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\u2019s textual content abstract, open your observability instruments in a browser, navigate to the hint waterfall, verify the service map to scope influence, and cross-reference what the agent instructed 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.<\/p>\n
Amazon OpenSearch Service MCP Apps shut that hole. MCP Apps prolong the Mannequin Context Protocol so that every software name responds with an interactive visualization \u2014 a hint waterfall, a service topology, a log sample view \u2014 rendered straight in your AI assistant\u2019s 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.<\/p>\n
On this submit, we clarify how MCP Apps change your observability workflow and stroll by means of setup step-by-step.<\/p>\n
The issue: Verification nonetheless requires leaving the agent loop<\/h2>\n
The standard 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 distinct software. After verifying visually by evaluating the agent\u2019s textual content output in opposition to precise dashboards, they return to the agent and resume the dialog, having misplaced their place within the investigation.<\/p>\n
The agent generates a response in seconds, however you should go away the agent\u2019s 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 function that undermines the pace benefit of agentic automation.<\/p>\n
Organizations working agentic observability regionally selected management and value effectivity over vendor-provided AI. However this alternative 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 pace, in a separate observability software.<\/p>\n
The answer: MCP Apps carry an observability UI into your IDE<\/h2>\n
Amazon OpenSearch Service now helps MCP Apps, a functionality that extends MCP with a twin response sample.<\/p>\n
When your AI agent calls an MCP App software, the response incorporates two components. 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\u2019re not trusting the AI\u2019s interpretation. You\u2019re seeing the precise question consequence rendered as an interactive chart, hint waterfall, or service map.<\/p>\n
![\"MCP](\"https:\/\/d2908q01vomqb2.cloudfront.net\/f1f836cb4ea6efb2a0b1b99f41ad8b103eff4b59\/2026\/08\/04\/ML-21227-1-2.png\")
<\/p>\nDetermine 1: MCP App rendering an observability report contained in the agentic IDE, exhibiting error counts by service alongside AI-generated root trigger evaluation<\/p>\n<\/p><\/div>\n
The way it works<\/h2>\n
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 movement of a single software name.<\/p>\n
Structure<\/h3>\n
An area 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 means 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 (be taught extra about OpenSearch UI).<\/p>\n
The next diagram exhibits the request movement:<\/p>\n
Your IDE or AI desktop shopper (Claude, VS Code, Cursor, and so on.)
\n \u2193 software name
\nNative MCP server (runs in your machine)
\n \u2193 authenticated question
\nOpenSearch UI utility (linked along with your information sources)
\n \u2193 twin response
\nYour IDE \u2190 textual content abstract + interactive MCP App visualization<\/p>\n
You preserve full management. The MCP server runs regionally. Your information stays in your AWS account. Your credentials, your insurance policies, your domains.<\/p>\n
How MCP Apps prolong the MCP protocol<\/h3>\n
Customary 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 consequence that the agent incorporates into its reasoning. MCP Apps prolong this sample by including a second response channel: a visualization payload that the IDE renders as an interactive widget alongside the textual content.<\/p>\n
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 embody 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.<\/p>\n
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.<\/p>\n
A software name end-to-end<\/h3>\n
As an instance the twin response sample in observe, take into account a hint investigation. The next walkthrough exhibits what occurs when your agent calls the hint investigation MCP App software.<\/p>\n
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.<\/p>\n
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.<\/p>\n
What the twin response incorporates. The MCP server returns two outputs in a single response. The textual content portion incorporates a structured abstract. It contains the hint ID, whole period, span rely, the crucial path, and an evaluation of the place the failure originated. The visualization portion incorporates an interactive hint waterfall rendered as an MCP App inside your IDE, exhibiting the span hierarchy, timing, and error annotations.<\/p>\n
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 develop particular person spans, examine attributes, and ensure the basis trigger visually, with out opening a separate browser tab.<\/p>\n
Accessible MCP Apps<\/h3>\n
The MCP Apps assist observability investigation throughout the lifecycle, with instruments that chain collectively throughout investigation phases.<\/p>\n
Core investigation instruments<\/h4>\n
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 problem. 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 particular distributed hint, show the span hierarchy and latency breakdown, and pinpoint the place the failure originated.<\/p>\n
Context and visualization instruments<\/h4>\n
To quantify the influence, metric investigation instruments execute PromQL queries and carry out threshold evaluation, whereas service efficiency instruments present RED metrics (fee, errors, period) on the service degree. Topology instruments render the service map as a dependency graph. The graph exhibits name quantity and error charges throughout edges so you may scope the influence. All through the investigation, dynamic visualization instruments generate line, bar, space, and metric charts from queries you specify, and datasets and correlations instruments assist cross-signal joins and information summaries.<\/p>\n
Specialised instruments<\/h4>\n
Specialised instruments deal with 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.<\/p>\n
![\"MCP](\"https:\/\/d2908q01vomqb2.cloudfront.net\/f1f836cb4ea6efb2a0b1b99f41ad8b103eff4b59\/2026\/08\/04\/ML-21227-2-2.png\")
<\/p>\nDetermine 2: Hint investigation MCP App exhibiting span hierarchy, timeline, and failure origin evaluation contained in the IDE<\/p>\n<\/p><\/div>\n
Revisiting the on-call state of affairs<\/h2>\n
With MCP Apps, the identical on-call investigation now appears to be like like this.<\/p>\n
The engineer asks the agent: \u201cWhat\u2019s inflicting the spike in checkout errors?\u201d 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 means of the MCP App visualizations and deciding on span particulars to verify the scope of influence, with out leaving the IDE. Lastly, they instruct the agent to draft the problem abstract or set off a remediation.<\/p>\n
The engineer by no means leaves the IDE. Investigation, verification, and backbone occur in a single dialog thread. For on-call engineers, this implies quicker decision and a extra easy expertise to collaborate with AI brokers.<\/p>\n
![\"MCP](\"https:\/\/d2908q01vomqb2.cloudfront.net\/f1f836cb4ea6efb2a0b1b99f41ad8b103eff4b59\/2026\/08\/04\/ML-21227-3-2.png\")
<\/p>\nDetermine 3: Service map MCP App exhibiting dependency graph with error fee coloration coding and name quantity edge widths<\/p>\n<\/p><\/div>\n
Getting began: Arrange the MCP server<\/h2>\n
Comply with these steps to attach your agentic IDE to your OpenSearch UI utility.<\/p>\n
Conditions<\/h3>\n
Earlier than you start, verify that you’ve got the next:<\/p>\n
An OpenSearch UI utility with an Observability workspace linked to not less than one information supply (Amazon OpenSearch Service domains, serverless collections, or Amazon Managed Service for Prometheus).
\n A appropriate agentic IDE (Claude Desktop, VS Code GitHub Copilot, Goose, ChatGPT, or Cursor).
\n Node.js 22 or later put in regionally.
\n AWS credentials configured with es:ESHttpGet and es:ESHttpPost permissions.<\/p>\n
Step-by-step setup<\/h3>\n
The next process walks by means of downloading the server, configuring your IDE, and verifying the connection.<\/p>\n
Step 1: Obtain and extract the MCP server<\/p>\n
Obtain and put together the MCP server bundle:<\/p>\n
Navigate to the OpenSearch observability MCP server obtain web page.
\n Obtain the MCP server .zip file.
\n Extract the archive. The extracted listing incorporates a server\/server.js file. Notice the total path to this file.<\/p>\n
Step 2: Add the MCP server to your IDE<\/p>\n
Every supported IDE has an MCP configuration file. The next record exhibits the place to search out it:<\/p>\n
Claude Desktop: Settings \u2192 Developer \u2192 Edit Config.
\n VS Code GitHub Copilot: .vscode\/mcp.json in your workspace, or Person Settings \u2192 MCP Servers.
\n Cursor: Settings \u2192 MCP \u2192 Add Server.
\n Goose: ~\/.config\/goose\/mcp.json (by means of extensions).
\n ChatGPT: Settings \u2192 MCP Plugins \u2192 Add.<\/p>\n
Open the configuration to your IDE and add the next:<\/p>\n
\n “mcpServers”: {
\n “opensearch-observability-stack-mcp”: {
\n “command”: “node”,
\n “args”: [“\/path\/to\/opensearch-observability-stack-mcp\/server\/server.js”],
\n “env”: {
\n “OS_UI_ENDPOINT”: “application-foo-bar.us-west-2.opensearch.amazonaws.com”,
\n “AWS_REGION”: “us-west-2”,
\n “AWS_PROFILE”: “my-profile”
\n }
\n }
\n }
\n}\n <\/div>\n
Substitute the placeholder values along with your OpenSearch UI endpoint, AWS Area, and profile.<\/p>\n
To search out your OpenSearch UI endpoint:<\/p>\n
Open the Amazon OpenSearch Service console.
\n Within the navigation pane, select Functions.
\n Choose your OpenSearch UI utility.
\n Copy the Utility URL (for instance, application-abc123.us-west-2.opensearch.amazonaws.com).<\/p>\n
Step 3: Confirm the connection<\/p>\n
After saving the configuration, restart your IDE or reload the MCP server record. Then enter the next immediate in your IDE:<\/p>\n
\u201cListing obtainable observability information sources\u201d<\/p>\n
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.<\/p>\n
If you happen to obtain an error, verify that your AWS credentials are energetic and that your AWS Identification and Entry Administration (IAM) coverage contains the es:ESHttpGet and es:ESHttpPost actions to your OpenSearch UI utility ARN.<\/p>\n
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.<\/p>\n
Clear up<\/h2>\n
To take away the MCP server configuration, open your IDE\u2019s 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\u2019t want AWS facet cleanup.<\/p>\n
Why this issues<\/h2>\n
The next desk summarizes how MCP Apps change the on-call workflow:<\/p>\n
With out MCP Apps
\n With MCP Apps<\/p>\n
Agent returns textual content \u2192 open browser \u2192 log in \u2192 navigate \u2192 confirm manually
\n Agent returns textual content + interactive visualization \u2192 assessment inline<\/p>\n
You can not see the underlying information in AI output
\n MCP App outcomes are deterministic (OpenSearch MCP App executes code)<\/p>\n
Context-switching between IDE and dashboard tabs
\n Single dialog thread in your IDE<\/p>\n
Agent causes solely by itself output
\n Agent reads MCP App outcomes as extra structured context<\/p>\n
Human verification takes minutes throughout exterior platforms
\n Verification compressed to seconds, inline with the agent<\/p>\n
Conclusion<\/h2>\n
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 quicker decision. For organizations working agentic observability regionally, this gives the operational simplicity you needed with out sacrificing accuracy.<\/p>\n
Get began right this moment: For setup directions, see Agentic observability with MCP Apps within the Amazon OpenSearch Service Developer Information.<\/p>\n
![\"Arthur](\"https:\/\/d2908q01vomqb2.cloudfront.net\/f1f836cb4ea6efb2a0b1b99f41ad8b103eff4b59\/2026\/08\/04\/ML-21227-4-2.png\")
<\/p>\n<\/p><\/div>\n![\"Joshua](\"https:\/\/d2908q01vomqb2.cloudfront.net\/f1f836cb4ea6efb2a0b1b99f41ad8b103eff4b59\/2026\/08\/04\/ML-21227-5-2.png\")
<\/p>\n<\/p><\/div>\n![\"Shenoy](\"https:\/\/d2908q01vomqb2.cloudfront.net\/f1f836cb4ea6efb2a0b1b99f41ad8b103eff4b59\/2026\/08\/04\/ML-21227-6-2.png\")
<\/p>\n<\/p><\/div>\n