你的数据分析师不需要 SQL：将 Elastic Agent Builder 接入 AWS AgentCore，实现自然语言 Elasticsearch 查询

作者：来自 Elastic Someshwaran Mohankumar

使用 Elastic Agent Builder MCP、AWS Bedrock AgentCore 和 Strands SDK，将纯英文问题连接到你的 Elasticsearch 数据。包含 Python 代码。

Agent Builder 现已正式发布。立即开始使用 Elastic Cloud Trial，并查看 Agent Builder 的文档 Agent Builder Documentation。

---

如果你的用户不再写 queries，而是开始直接提问，会发生什么？大多数数据分析仍然像翻译工作。你从一个简单问题开始，比如：为什么这些 URLs 上周出现了 5xx error spike？ 或 哪些 product categories 在驱动 revenue？ 但要得到答案通常意味着写 queries、做 tables join、检查 dashboards、验证 assumptions，然后不断重复这个过程。这个从 curiosity 到 insight 的 gap 是大多数团队浪费时间的地方。

本文介绍一个可运行的 agent：它可以接收纯英文问题，通过 Elastic 的 Model Context Protocol（MCP）server 对你的 Elasticsearch 数据执行 ElasticsearchQuery Language (ES|QL) 和 index search，并返回可审计的完整答案。技术栈包括：用于 tools 的 Elastic Agent Builder、用于 reasoning 的 AWS Bedrock、用于 managed memory 的 AgentCore，以及用于整体编排的 Strands Agents SDK。完整代码在 GitHub repository。

2025年9月的 Elasticsearch Labs 文章展示了 self-managed MCP server 如何连接 Bedrock AgentCore Runtime。本示例通过使用 Elastic 的 hosted MCP（在 Kibana 中提供），并结合 Strands Agents SDK 和 AgentCore Memories，使实现更加简化。

Elasticsearch agent loop 如何工作

来源致谢：Strands Agents Concepts – Agent Loop

Agent 是一个持续循环。它不是线性的 input-to-output 流程，而是在一个 cycle 中运行：不断评估自己是否接近目标。它进行 reasoning、执行 actions、观察结果，然后重复这个 cycle，直到任务完成。

要在实践中实现这个 loop，我们需要三个核心层：

层	组件	作用
Memory + Tool Execution	Elastic Cloud (Elasticsearch + Kibana)	可搜索的 memory，以及通过 Agent Builder 实现的 MCP tool 执行
Reasoning + Infra	AWS Bedrock + AgentCore	LLM reasoning、托管 runtime、session memory
Orchestration	Strands Agents SDK (v1.29.0)	连接 LLM、tools 和 memory，构建 agent loop

Elastic（memory layer 和 tool execution）： 一个 Elastic Cloud project（Elasticsearch Serverless 是非常自然的选择），提供 agent loop 的 searchable memory layer，同时通过 Elastic MCP 驱动 tool selection 和 execution。本文使用常见的 sample web logs 和 sample ecommerce datasets 作为示例数据。

AWS（reasoning 和 infra layer）： 一个启用了 Amazon Bedrock 的 account，并为计划使用的 foundation models（例如 Anthropic Claude）开放 model access，同时具备 Bedrock 和 Bedrock AgentCore 的 IAM permissions。这一层负责 reasoning、runtime 和 managed agent infrastructure，为 agent loop 提供运行能力。

Agent SDK（orchestration layer）： Strands Agents SDK (v1.29.0)，作为 agent loop 的 orchestration layer，管理 elasticstack.blog.csdn.net/article/det…、tools 和 memory 之间的交互。它原生支持 AWS services。

如何将 Elastic Agent Builder MCP 连接到 AI agent

Agent Builder 在 Kibana 中暴露 tools，用于执行诸如运行 ES|QL、搜索 indices、以及检查 mappings 等操作。虽然 built-in tools reference 列出了客户端可以开箱即用调用的内容，但你也可以 custom tools 创建并管理自定义 tools，从而扩展 agent 的能力，使其能够通过 MCP server 与外部 API 或特定的内部业务逻辑进行交互。

MCP 是一个基于 JSON-RPC 2.0 构建的双向 open protocol，它允许 agents 通过 structured interface 发现并执行 tools。它不是通过 hard-coding integrations，而是让 clients 直接连接到 MCP servers，检查可用 capabilities，并通过 structured request 和 response 来调用 tools。Elastic 通过 Agent Builder in Kibana 暴露了一个 hosted MCP server。在实际使用中，你的 agent 会连接到 Kibana 中的以下 HTTPS endpoint：

`{KIBANA_URL}/api/agent_builder/mcp`AI写代码

它使用 API key 进行认证，该 API key 具有正确的 cluster、specific role-based index privileges，以及 Kibana application privileges（包括对 Agent Builder 的访问）。

`

1.  POST /_security/api_key
2.  {
3.    "name": "my-mcp-api-key",
4.    "expiration": "30d",
5.    "role_descriptors": {
6.      "mcp-access": {
7.        "cluster": ["monitor_inference"],
8.        "indices": [
9.          {
10.            "names": ["logs-*", "metrics-*"],
11.            "privileges": ["read", "view_index_metadata"]
12.          }
13.        ],
14.        "applications": [
15.          {
16.            "application": "kibana-.kibana",
17.            "privileges": ["feature_agentBuilder.read", "feature_actions.read"],
18.            "resources": ["space:default"]
19.          }
20.        ]
21.      }
22.    }
23.  }

`AI写代码![](https://csdnimg.cn/release/blogv2/dist/pc/img/runCode/icon-arrowwhite.png)

请注意：如果没有 feature_agentBuilder.read 这个 application privilege，在尝试连接 MCP endpoint 时会返回 403 Forbidden 错误。

这里的 hosted path 意味着 MCP server 是作为你 deployment 的一部分运行的，而不是你单独构建并部署的一个独立 server。它仍然提供与之前 Elasticsearch Labs 文章中相同的 tool-calling 模型——当时使用的是在 Amazon Elastic Container Registry（ECR）和 AgentCore Runtime 上运行的 containerized MCP server。这两种方式都是有效的实现路径。

Amazon Bedrock AgentCore：Elasticsearch agents 的托管 runtime 和 memory

Amazon Bedrock AgentCore 是 AWS 用于在生产环境中运行和管理 agents 的托管层。这个架构中最关键的几个组件如下表所示。

Capability	Role
Hosting	在 invocation API 后面托管你的 agent，并提供生产级 workload 的扩展与隔离能力。
Memory	存储短期对话 context，并运行长期信息提取策略（summaries、user preferences、semantic facts），使行为可以跨 session 改进。
Identity	与 IAM policies 集成的身份认证能力。
Observability	用于在 AWS 中对 agent 行为进行 tracing 和 monitoring。

AgentCore 的价值在于：你不需要为每个 demo 或 product 重复造 session isolation、memory lifecycle 和 deployment 体系。Strands SDK 可以直接集成 AgentCore Memory，并根据用户与 agent 的交互进行处理。它会异步提取并存储 memory（采用相应的策略）。更多细节可参考 AWS 文档中的 Use AgentCore Memory with the Strands SDK。

Strands Agents SDK：在 Python 中编排 agent loop

Strands Agents SDK 是一个 agent framework，由四个组件组成，用于帮助我们在 AgentCore 和 Elasticsearch 之间建立连接：

• system prompt

• tools

• 一个 session manager（当启用 AgentCore Memory 时会接入）

• model provider

当你创建 agent 而没有传入自定义 model 时，Strands 会使用 Amazon Bedrock 的默认模型配置。默认值与 override 机制可以参考 Amazon Bedrock model provider documentation。

请参考 BedrockModel._get_default_model_with_warning：为什么同时存在 DEFAULT_BEDROCK_MODEL_ID 和 _DEFAULT_BEDROCK_MODEL_ID？本质原因是：前者是可覆盖的 default（DEFAULT_BEDROCK_MODEL_ID），后者是 private template（_DEFAULT_BEDROCK_MODEL_ID），用于在没有 override 时生成 region-correct 的 model ID。这也是为什么你会在 prefix 里看到 { } 占位符。Strands 通过对比这两者来区分不同情况。

``

1.  # src/strands/models/bedrock.py# See: `BedrockModel._get_default_model_with_warning` for why we need both
2.  DEFAULT_BEDROCK_MODEL_ID = "us.anthropic.claude-sonnet-4-20250514-v1:0"
3.  _DEFAULT_BEDROCK_MODEL_ID = "{}.anthropic.claude-sonnet-4-20250514-v1:0"
4.  DEFAULT_BEDROCK_REGION = "us-west-2"

6.  ......
7.  @staticmethod
8.  def _get_default_model_with_warning(
9.      region_name: str,
10.      model_config: BedrockConfig | None = None,
11.  ) -> str:
12.      ...
13.      model_config = model_config or {}
14.      if model_config.get("model_id"):
15.          return model_config["model_id"]

17.      # Some inference endpoints can be a bit different than the region prefix.
18.      prefix_inference_map = {"ap": "apac"}

20.      # Handles `us-east-1` or `us-gov-east-1`.
21.      prefix = "-".join(region_name.split("-")[:-2]).lower()
22.      ...

24.      return _DEFAULT_BEDROCK_MODEL_ID.format(prefix_inference_map.get(prefix, prefix))

``AI写代码![](https://csdnimg.cn/release/blogv2/dist/pc/img/runCode/icon-arrowwhite.png)

一个典型的代码流程如下：

1. 构建 tool list：至少包含一个指向 Elastic 托管 MCP 的 MCP client，它会暴露所有 tools。参见 MCP tools in Strands。

2. 添加 Strands tools，用于在 Elasticsearch 中对 memory documents 进行 index 和 search（store_memory、recall_memories），这些能力由 agent-memory index 上的一个 semantic text 字段来支持。

`

1.  @tool
2.  def store_memory(content: str, tags: list[str] | None = None, user_id: str = "default-analyst") -> str:
3.      """Store a piece of knowledge or insight into long-term memory.
4.      ...
5.      """
6.      doc = {
7.          "content": content,
8.          "tags": tags or [],
9.          "user_id": user_id,
10.          "timestamp": datetime.now(timezone.utc).isoformat(),
11.      }
12.      result = _get_client().index(index=ES_MEMORY_INDEX, document=doc)
13.      return f"Memory stored (id={result['_id']}): {content}"

18.  @tool
19.  def recall_memories(query: str, top_k: int = 5, user_id: str = "default-analyst") -> str:
20.      """Search long-term memory for relevant past knowledge and user preferences.
21.      ...
22.      """
23.      body = {
24.          "size": top_k,
25.          "query": {
26.              "bool": {
27.                  "must": {"semantic": {"field": "content", "query": query}},
28.                  "filter": {"term": {"user_id": user_id}},
29.              }
30.          },
31.      }
32.      resp = _get_client().search(index=ES_MEMORY_INDEX, body=body)
33.      ...

`AI写代码![](https://csdnimg.cn/release/blogv2/dist/pc/img/runCode/icon-arrowwhite.png)

3. 在使用 AgentCore Memory 时，附加 AgentCoreMemorySessionManager，并传入你的 memory ID、actor（user）以及 session identifiers。它用于保存 session context。

`

1.  from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig
2.  from bedrock_agentcore.memory.integrations.strands.session_manager import (   AgentCoreMemorySessionManager)

5.  def create_session_manager(
6.      user_id: str,
7.      memory_id: str,
8.      aws_region: str,
9.      session_id: str | None = None,
10.  ) -> AgentCoreMemorySessionManager:
11.      session_id = session_id or f"session-{datetime.now().strftime('%Y%m%d-%H%M%S')}"

13.      config = AgentCoreMemoryConfig(
14.          memory_id=memory_id,
15.          session_id=session_id,
16.          actor_id=user_id,
17.      )

19.      return AgentCoreMemorySessionManager(
20.          agentcore_memory_config=config,
21.          region_name=aws_region,
22.     )

`AI写代码![](https://csdnimg.cn/release/blogv2/dist/pc/img/runCode/icon-arrowwhite.png)

4. 将同一个 agent 通过 BedrockAgentCoreApp 暴露到 AgentCore Runtime 后端，或者从任意 UI layer 调用它进行交互。

在部署到 AgentCore Runtime 时，请参考将 Python agent 部署到 Amazon Bedrock AgentCore Runtime。关于进入 production 时的权限（IAM policies）细节，请参见 AgentCore Runtime permissions。

Elastic 托管 MCP 如何连接到 AI agent？

LLM 并不会直接登录 Elasticsearch。它只会发出 tool calls，而由 Strands 来执行这些调用。

根据这个概念，client 会使用 HTTP transport、ApiKey authorization，以及 Kibana 要求的 kbn-xsrf header 来建立到 Kibana 的 MCP connection。Strands 的 MCPClient 会封装这个 streamable HTTP session，使得每一个 Agent Builder tool 都以可调用 function 的形式暴露给 model（通常会带有 elastic- 前缀，这是一个 best practice，用于帮助模型更容易进行 tool selection 和 invocation）。

模型可能会调用某个 tool 来 list indices、运行 ES|QL 或执行 search。Elastic 会在你的 cluster 上执行这些操作，并使用 API key 中所定义的 privileges。

这就是 natural language 如何变成受约束、可审计的对真实数据的 actions，并且完全基于与你的人类 analyst 相同的 security model。

`

1.  # elastic_mcp.py
2.  from mcp.client.streamable_http import streamablehttp_client
3.  from strands.tools.mcp import MCPClient

5.  from .config import ELASTIC_API_KEY, KIBANA_URL

8.  def create_elastic_mcp_client() -> MCPClient:
9.      """Connect to the Elastic Agent Builder hosted MCP endpoint.

11.      The endpoint is built into Elastic Cloud Serverless (9.2+) and
12.      Elastic Stack 9.3+.  No Docker container or ECR deployment needed.

14.      The hosted MCP exposes all built-in Agent Builder tools:
15.        - ES|QL queries
16.        - Index search
17.        - Index mappings / shard info
18.        - Plus any custom tools defined in Kibana → Agent Builder → Tools
19.      """
20.      mcp_url = f"{KIBANA_URL}/api/agent_builder/mcp"

22.      return MCPClient(
23.          lambda: streamablehttp_client(
24.              url=mcp_url,
25.              headers={
26.                  "Authorization": f"ApiKey {ELASTIC_API_KEY}",
27.                  "kbn-xsrf": "true",
28.              },
29.          ),
30.          prefix="elastic",
31.      )

`AI写代码![](https://csdnimg.cn/release/blogv2/dist/pc/img/runCode/icon-arrowwhite.png)

双层 memory：AgentCore session context 与 Elasticsearch semantic search

AgentCore Memory

通过 AgentCore Memory，每一次 conversation turn 都可以被记录在 session memory 中。长期策略（summary、user preference、semantic memory 等你配置的策略）会随着时间抽取出持久化记录。这为你处理 personalization 和 continuity 提供能力，而无需手动实现 extraction pipeline。

从运维与 data-governance 的角度来看，AgentCore Memory 是一个 managed service。你可以通过 AWS console 和 API 对其进行检查（例如列出某个 memory resource、session 或 actor 的 memory records）。如前所述，Strands 的 session manager 会把这些 wiring 抽象掉，因此你只需要用 prompt 调用 agent 即可。

`

1.  #Example (passing the session_manager directly to the Agent for context management)

3.  agent_kwargs = {
4.      "system_prompt": SYSTEM_PROMPT,
5.      "tools": tools,
6.  }

8.  if session_manager is not None:
9.      agent_kwargs["session_manager"] = session_manager

11.  agent = Agent(**agent_kwargs)

`AI写代码![](https://csdnimg.cn/release/blogv2/dist/pc/img/runCode/icon-arrowwhite.png)

为什么还要在 Elasticsearch 中存储 memory？

AgentCore Memory 和 Elasticsearch 解决的是不同的 visibility 问题：

• AgentCore 优化的是 managed retention、extraction strategies，以及与 AWS 上 agent runtime 的紧密集成。

• Elasticsearch 优化的是 search、dashboards，以及 ad hoc analytics。这些能力与你们团队已经用于 logs 和 revenue data 的能力是相同的。

通过让 agent 使用 tools 将 memory documents 写入 agent-memory index（其中包含用于 natural-language recall 的 semantic text 字段，以及用于 user 和 tags 的 keyword fields），你可以获得：

• 对已存储内容进行 discover 和 ES|QL 分析（包括它何时被存储、为哪个 user 存储）。

• 对 memory text 进行 semantic search，在它混淆用户之前发现 contradictions、duplicates 或 gaps。

• 可以回答类似 “模型刚刚说的内容是否与我们存储的数据一致？” 的问题，从而支持 quality review 以及 prompt 或 model tuning。

这个 Elasticsearch memory plane 与你日常操作的 logs 和 analytics indices 处于同一个 cluster 中。AgentCore Memory 继续负责 session semantics 和 AWS 侧的 long-term extraction，而 agent-memory index 则让 agent-curated facts 和 preferences 成为可搜索、可观测的 first-class data。

Elastic Agent Builder + AWS AgentCore：端到端架构

Elastic Agent Builder + AWS AgentCore：端到端架构

从 diagram 来看：用户（或 client）通过 Streamlit 或 AgentCore Runtime 本地调用 Strands agent。agent 会调用 Amazon Bedrock 进行 reasoning，通过 AgentCore Memory 获取基于 session 的 context，通过 Kibana-hosted MCP 在 Agent Builder tools 上运行工具（针对 analytics indices），并通过 Strands tools 直接调用 Elasticsearch client API，将数据写入和读取 agent-memory。

获取代码：GitHub repo 与 Codespaces 快速启动

查看完整示例： github.com/Som23Git/el….。可以 clone repo，或者使用 GitHub Codespaces 进行快速启动。

结论：这个 Elasticsearch agent 架构在生产中提供了什么

通过将 Elasticsearch、AWS Bedrock 与 AgentCore，以及 Strands Agents SDK 组合起来，你从线性 scripts 进入了真正的 agent loop。这个架构提供了一条可用于 production 的路径：Elastic 通过 MCP 管理你的 data 和 custom tools，AWS 提供 managed reasoning engine 和基于策略的 memory，而 Strands 负责以可观测的方式编排整个 cycle。

因为 agent 的“thoughts”和“actions”都会被重新写入 Elasticsearch，你得到一个实际收益：你可以像搜索 application logs 一样搜索、dashboard 并审计 agent 的 reasoning。

下一步扩展 loop：

Security：为 MCP connections 实现 least-privilege API keys 和安全 secrets 管理。

Governance：为 agent-memory indices 定义 retention policies 来控制数据增长。

Evaluation：使用自动化评估框架定期评估 tool-call accuracy 和 LLM reasoning。

Full-stack observability：使用 Elastic 和 AWS monitoring 跟踪 agent 做了什么、选择了哪个 tool，以及为什么，从而确保 loop 保持高效与可靠。

延伸阅读

完整应用

• github.com/Som23Git/el…

Elasticsearch

• Agent Builder MCP server

• Agent Builder built-in tools reference

• semantic text field type

• Elastic MCP server on AgentCore Runtime

AWS

• What is Amazon Bedrock

• Model access

• What is Amazon AgentCore

• AgentCore Memory getting started

• Use AgentCore Memory with Strands SDK

• AgentCore Runtime permissions

Strands Agents SDK

• Deploy Python agent to AgentCore Runtime

• MCP tools

• Amazon Bedrock model provider

常见问题

Q1：什么是 Elastic Agent Builder MCP？
A1：Elastic Agent Builder 通过 Kibana 暴露 hosted Model Context Protocol。它允许 external agents 通过标准 JSON-RPC 2.0 interface 发现并调用 Elasticsearch tools，例如 ES|QL 查询、index search，以及 custom business logic。

Q2：如何认证 Elastic MCP endpoint？
A2：创建一个 API key，需要 cluster privilege monitor_inference、数据 index read privileges，以及 Kibana application privileges feature_agentBuilder.read 和 feature_actions.read，并通过 ApiKey header 携带，同时加上 kbn-xsrf: true。

Q3：AgentCore Memory 和 Elasticsearch agent memory 的区别？
A3：AgentCore Memory 是 AWS 托管的，用于 session context、summaries 和 user preference extraction。Elasticsearch agent memory 将数据存入可搜索 index（带 semantic_text），可以做 dashboards、ES|QL 和 semantic search，并支持 RAG 和 knowledge base。

Q4：需要哪个 Python SDK 版本？
A4：使用 Strands Agents SDK v1.29.0，同时需要 bedrock-agentcore-memory package 来支持 AgentCoreMemorySessionManager。

Q5：可以自定义 Elastic MCP tools 吗？
A5：可以。在 Kibana 的 Agent Builder > Tools 中，可以创建 custom tools，将外部 API 或内部业务逻辑暴露给 MCP server。

原文：Elastic Agent Builder MCP and AWS AgentCore: Python tutorial - Elasticsearch Labs