Agentic observability with Amazon OpenSearch Service MCP Apps

Observability brokers are quick. They question alerts, correlate logs with traces, and produce a root trigger speculation in minutes. The half that also takes time is verification. You learn the agent’s textual content abstract, open your observability instruments in a browser, navigate to the hint waterfall, test the service map to scope affect, and cross-reference what the agent advised you in opposition to what you see on display screen. The agent saved you the question time. It didn’t prevent the tab-switching, context-carrying, manual-verification time. That’s nonetheless your job.

Amazon OpenSearch Service MCP Apps shut that hole. MCP Apps lengthen the Mannequin Context Protocol so that every software name responds with an interactive visualization — a hint waterfall, a service topology, a log sample view — rendered instantly in your AI assistant’s chat window alongside the textual content response. You ask the agent to research. The agent queries Amazon OpenSearch Service. The response arrives with each a textual content rationalization and the related dashboard widget. You confirm in the identical thread the place you requested the query, with out opening a separate browser tab or re-running a question.

On this submit, we clarify how MCP Apps change your observability workflow and stroll by way of setup step-by-step.

The issue: Verification nonetheless requires leaving the agent loop

The everyday investigation loop proceeds as follows. First, the engineer asks the agent and will get a text-based root trigger speculation. Subsequent, they go away the IDE to open a browser and log in to a separate observability UI. They then re-run queries manually to breed what the agent discovered, in a special software. After verifying visually by evaluating the agent’s textual content output in opposition to precise dashboards, they return to the agent and resume the dialog, having misplaced their place within the investigation.

The agent generates a response in seconds, however you need to go away the agent’s atmosphere to confirm. This implies logging in to a separate observability expertise and navigating dashboards manually. This exterior verification loop is the bottleneck. It forces you right into a tool-switching position that undermines the velocity benefit of agentic automation.

Organizations working agentic observability regionally selected management and value effectivity over vendor-provided AI. However this selection has traditionally include a trade-off: native agentic setups sacrifice ease of use and generally agent efficiency in comparison with vendor-hosted options that tightly couple AI with their providers. For these groups, the verification hole is the first operational burden. They optimized for autonomy, but verification nonetheless occurs at human velocity, in a separate observability software.

The answer: MCP Apps convey an observability UI into your IDE

Amazon OpenSearch Service now helps MCP Apps, a functionality that extends MCP with a twin response sample.

When your AI agent calls an MCP App software, the response accommodates two elements. The primary is a textual content abstract with concise, structured information. The second is an interactive visualization rendered in the identical dialog thread so that you can assessment. OpenSearch MCP App generates the visualization by executing code in opposition to the identical information sources that energy your dashboards. Due to this, the outcomes are deterministic. You’re not trusting the AI’s interpretation. You’re seeing the precise question end result rendered as an interactive chart, hint waterfall, or service map.

Determine 1: MCP App rendering an observability report contained in the agentic IDE, exhibiting error counts by service alongside AI-generated root trigger evaluation

The way it works

The MCP Apps functionality consists of a neighborhood MCP server, your IDE, and your OpenSearch UI utility working collectively. This part explains the structure, the protocol extension mechanism, and the end-to-end circulation of a single software name.

Structure

A native MCP server runs in your machine. It acts as a safe bridge between your agentic IDE and your OpenSearch UI utility. The server exposes observability instruments that your AI agent can name. Every software name goes by way of the MCP server to your OpenSearch UI endpoint, executes the question, and returns the twin response again to your IDE. OpenSearch UI is the serverless interface for unified observability that works with OpenSearch domains, serverless collections, CloudWatch, and Amazon Managed Service for Prometheus (study extra about OpenSearch UI).

The next diagram reveals the request circulation:

Your IDE or AI desktop shopper (Claude, VS Code, Cursor, and many others.)
  ↓ software name
Native MCP server (runs in your machine)
  ↓ authenticated question
OpenSearch UI utility (linked together with your information sources)
  ↓ twin response
Your IDE ← textual content abstract + interactive MCP App visualization

You keep full management. The MCP server runs regionally. Your information stays in your AWS account. Your credentials, your insurance policies, your domains.

How MCP Apps lengthen the MCP protocol

Commonplace MCP software calls return text-only responses. The agent sends a JSON-RPC request specifying the software identify and parameters, and the server returns a textual content end result that the agent incorporates into its reasoning. MCP Apps lengthen this sample by including a second response channel: a visualization payload that the IDE renders as an interactive widget alongside the textual content.

When the native MCP server receives a software name, it authenticates utilizing your configured AWS credentials and forwards the request to your OpenSearch UI utility endpoint as an HTTP API name. OpenSearch UI executes the question in opposition to your linked information sources and returns each a structured textual content abstract and a rendered visualization artifact. Supported information sources embrace OpenSearch domains, serverless collections, and Amazon Managed Service for Prometheus. The MCP server packages these right into a single MCP response containing the textual content content material for the agent and the visualization content material for the IDE host to render.

The IDE host detects the visualization payload and renders it as an interactive widget within the dialog thread. OpenSearch MCP App generates the visualization server-side by executing code in opposition to your precise information. Due to this fact, the rendered output is deterministic and matches what you’ll see in your OpenSearch dashboards.

A software name end-to-end

For example the twin response sample in follow, think about a hint investigation. The next walkthrough reveals what occurs when your agent calls the hint investigation MCP App software.

What the agent sends. Your agent points a software name to the hint investigation MCP App, passing parameters such because the hint ID or a filter like service identify and time vary. This name travels out of your IDE to the native MCP server over the usual MCP protocol.

How the server executes it. The native MCP server receives the software name, authenticates in opposition to your AWS credentials, and forwards the request to your OpenSearch UI utility endpoint. OpenSearch UI executes the hint question in opposition to your linked information sources, retrieves the matching spans, and assembles the response.

What the twin response accommodates. The MCP server returns two outputs in a single response. The textual content portion accommodates a structured abstract. It consists of the hint ID, whole length, span depend, the important path, and an evaluation of the place the failure originated. The visualization portion accommodates an interactive hint waterfall rendered as an MCP App inside your IDE, exhibiting the span hierarchy, timing, and error annotations.

How the agent and human every eat it. From the textual content abstract, your agent extracts context for its subsequent reasoning step, for instance correlating the failing span with associated log entries. In the meantime, you see the interactive hint waterfall in the identical dialog thread. You may increase particular person spans, examine attributes, and make sure the foundation trigger visually, with out opening a separate browser tab.

Obtainable MCP Apps

The MCP Apps help observability investigation throughout the lifecycle, with instruments that chain collectively throughout investigation phases.

Core investigation instruments

A typical investigation begins with triage and response instruments, which floor energetic alerts, correlate associated alerts throughout information sources, and current severity breakdowns so your agent can prioritize the difficulty. After the agent identifies the affected service, log investigation instruments seek for error patterns and cluster comparable log entries to isolate the failure signature. From there, hint investigation instruments find the precise distributed hint, show the span hierarchy and latency breakdown, and pinpoint the place the failure originated.

Context and visualization instruments

To quantify the affect, metric investigation instruments execute PromQL queries and carry out threshold evaluation, whereas service efficiency instruments present RED metrics (price, errors, length) on the service stage. Topology instruments render the service map as a dependency graph. The graph reveals name quantity and error charges throughout edges so you’ll be able to scope the affect. All through the investigation, dynamic visualization instruments generate line, bar, space, and metric charts from queries you specify, and datasets and correlations instruments help cross-signal joins and information summaries.

Specialised instruments

Specialised instruments tackle rising wants. AI and agent observability instruments hint massive language mannequin (LLM) calls and render agent hint maps for groups constructing their very own AI workflows. Stack well being instruments report cluster standing and shard allocation. Instrumentation scoring instruments detect telemetry high quality gaps so groups can enhance their observability protection.

Determine 2: Hint investigation MCP App exhibiting span hierarchy, timeline, and failure origin evaluation contained in the IDE

Revisiting the on-call situation

With MCP Apps, the identical on-call investigation now appears to be like like this.

The engineer asks the agent: “What’s inflicting the spike in checkout errors?” The agent investigates by querying logs, correlating with traces, and checking the service map. A twin response arrives containing each a textual content abstract and interactive visualizations (alert view, hint waterfall, and repair map) rendered in the identical thread. The engineer opinions inline by scrolling by way of the MCP App visualizations and choosing span particulars to verify the scope of affect, with out leaving the IDE. Lastly, they instruct the agent to draft the difficulty abstract or set off a remediation.

The engineer by no means leaves the IDE. Investigation, verification, and determination occur in a single dialog thread. For on-call engineers, this implies sooner decision and a extra simple expertise to collaborate with AI brokers.

Determine 3: Service map MCP App exhibiting dependency graph with error price colour coding and name quantity edge widths

Getting began: Arrange the MCP server

Comply with these steps to attach your agentic IDE to your OpenSearch UI utility.

Conditions

Earlier than you start, test that you’ve the next:

• An OpenSearch UI utility with an Observability workspace linked to a minimum of one information supply (Amazon OpenSearch Service domains, serverless collections, or Amazon Managed Service for Prometheus).
• A suitable agentic IDE (Claude Desktop, VS Code GitHub Copilot, Goose, ChatGPT, or Cursor).
• Node.js 22 or later put in regionally.
• AWS credentials configured with es:ESHttpGet and es:ESHttpPost permissions.

Step-by-step setup

The next process walks by way of downloading the server, configuring your IDE, and verifying the connection.

Step 1: Obtain and extract the MCP server

Obtain and put together the MCP server package deal:

1. Navigate to the OpenSearch observability MCP server obtain web page.
2. Obtain the MCP server .zip file.
3. Extract the archive. The extracted listing accommodates a server/server.js file. Word the complete path to this file.

Step 2: Add the MCP server to your IDE

Every supported IDE has an MCP configuration file. The next checklist reveals the place to search out it:

• Claude Desktop: Settings → Developer → Edit Config.
• VS Code GitHub Copilot: .vscode/mcp.json in your workspace, or Consumer Settings → MCP Servers.
• Cursor: Settings → MCP → Add Server.
• Goose: ~/.config/goose/mcp.json (by way of extensions).
• ChatGPT: Settings → MCP Plugins → Add.

Open the configuration to your IDE and add the next:

{
  "mcpServers": {
    "opensearch-observability-stack-mcp": {
      "command": "node",
      "args": ["/path/to/opensearch-observability-stack-mcp/server/server.js"],
      "env": {
        "OS_UI_ENDPOINT": "application-foo-bar.us-west-2.opensearch.amazonaws.com",
        "AWS_REGION": "us-west-2",
        "AWS_PROFILE": "my-profile"
      }
    }
  }
}

Substitute the placeholder values together with your OpenSearch UI endpoint, AWS Area, and profile.

To seek out your OpenSearch UI endpoint:

1. Open the Amazon OpenSearch Service console.
2. Within the navigation pane, select Functions.
3. Choose your OpenSearch UI utility.
4. Copy the Utility URL (for instance, application-abc123.us-west-2.opensearch.amazonaws.com).

Step 3: Confirm the connection

After saving the configuration, restart your IDE or reload the MCP server checklist. Then enter the next immediate in your IDE:

“Record out there observability information sources”

If the agent returns your linked information sources (Amazon OpenSearch Service domains, serverless collections, or Amazon Managed Service for Prometheus workspaces), the MCP server is configured accurately.

In case you obtain an error, test that your AWS credentials are energetic and that your AWS Identification and Entry Administration (IAM) coverage consists of the es:ESHttpGet and es:ESHttpPost actions to your OpenSearch UI utility ARN.

Tip: To check with out manufacturing information, deploy the OpenTelemetry Demo utility to generate pattern traces, logs, and metrics in your Amazon OpenSearch Service area.

Clear up

To take away the MCP server configuration, open your IDE’s MCP settings and delete the opensearch-observability-stack-mcp entry. Then delete the extracted MCP server listing out of your native machine. This setup provisions no cloud sources, so that you don’t want AWS aspect cleanup.

Why this issues

The next desk summarizes how MCP Apps change the on-call workflow:

Conclusion

With MCP Apps, Amazon OpenSearch Service closes the verification hole in agentic observability. Your AI agent investigates, and the interactive proof arrives in the identical thread: no context-switching, no separate logins, no re-running queries. For on-call engineers, this may imply sooner decision. For organizations working agentic observability regionally, this supplies the operational simplicity you needed with out sacrificing accuracy.

Get began as we speak: For setup directions, see Agentic observability with MCP Apps within the Amazon OpenSearch Service Developer Information.

In regards to the authors