关于 Run Model Context Protocol (MCP) servers with AWS Lambda
本项目可将现有的 MCP stdio 服务封装为 AWS Lambda 函数，由 Lambda 负责每次调用时的启动、初始化与关闭。适合需要在云端或分布式系统中调用 MCP 服务的开发者，不必在本地运行子进程。
主要功能
- 01将 stdio MCP 服务封装为 Lambda 函数
- 02每次调用时启动并关闭服务子进程
- 03支持 API Gateway 与 Bedrock AgentCore Gateway
- 04支持 Lambda 函数 URL（SigV4）与直接 Invoke 调用
- 05示例可从 Secrets Manager 读取密钥
适用场景
- 01在云端分布式系统中调用本地风格的 MCP 服务
- 02通过 API Gateway 为多个 MCP 客户端提供远程服务
- 03借助 AgentCore Gateway 为 MCP 服务配置 OAuth 认证
MCP 相关
该项目把 stdio 形式的 MCP 服务部署为可通过 Streamable HTTP 或 Lambda 调用访问的远程服务，供 MCP 客户端通过 HTTPS 连接。
配置
本地服务的配置在各客户端中通用，复制后粘贴到客户端的 MCP 配置文件即可。
暂未收录安装方式
我们还没有获取到这个服务的安装包或远程地址，请按项目 README 中的说明安装。
工具
还没有获取到工具列表
本地服务需要在你的电脑上运行后才能读取工具，维护者暂未提供工具列表。
详细介绍
使用 AWS Lambda 运行 Model Context Protocol（MCP）服务
本项目可让你在 AWS Lambda 函数中运行基于 stdio 的 Model Context Protocol 服务。
目前，大多数 MCP 服务和客户端的实现都完全运行在单台计算机本地。 IDE 或 Claude Desktop 等桌面应用会在本地以子进程的形式启动 MCP 服务， 并通过长连接 stdio 流与每个服务通信。
flowchart LR
subgraph "Your Laptop"
Host["Desktop Application<br>with MCP Clients"]
S1["MCP Server A<br>(child process)"]
S2["MCP Server B<br>(child process)"]
Host <-->|"MCP Protocol<br>(over stdio stream)"| S1
Host <-->|"MCP Protocol<br>(over stdio stream)"| S2
end
此库可帮助你将现有的 stdio MCP 服务封装到 Lambda 函数中。 你的应用可以通过短连接 HTTPS，使用 MCP 协议调用这些基于函数的 MCP 服务。 你的应用可以是桌面应用、在云端运行的分布式系统， 也可以采用其他任何架构。
flowchart LR
subgraph "Distributed System"
App["Your Application<br>with MCP Clients"]
S3["MCP Server A<br>(Lambda function)"]
S4["MCP Server B<br>(Lambda function)"]
App <-->|"MCP Protocol<br>(over HTTPS connection)"| S3
App <-->|"MCP Protocol<br>(over HTTPS connection)"| S4
end
使用此库时，Lambda 函数会管理 stdio MCP 服务的生命周期。 每次调用 Lambda 函数时，都会：
- 将 stdio MCP 服务作为子进程启动
- 初始化 MCP 服务
- 将传入请求转发到本地服务
- 将服务的响应返回给函数调用方
- 关闭 MCP 服务子进程
此库支持通过以下四种方式连接到基于 Lambda 的 MCP 服务：
- 使用 Amazon API Gateway 的 MCP Streamable HTTP 传输方式。通常使用 OAuth 进行身份验证。
- 使用 Amazon Bedrock AgentCore Gateway 的 MCP Streamable HTTP 传输方式。使用 OAuth 进行身份验证。
- 支持 SigV4 的自定义 Streamable HTTP 传输方式，使用 Lambda 函数 URL。使用 AWS IAM 进行身份验证。
- 自定义 Lambda 调用传输方式，直接使用 Lambda Invoke API。使用 AWS IAM 进行身份验证。
确定服务参数
许多基于 stdio 的 MCP 服务文档建议使用按需下载并运行服务的工具。
例如，uvx my-mcp-server 或 npx my-mcp-server。
这些工具通常未预装在 Lambda 环境中，而且每次调用 Lambda 都重新下载服务会降低效率。
相反，本仓库中的示例展示了如何将 MCP 服务与 Lambda 函数代码一起打包，
然后直接使用 python 或 node（或 npx --offline）启动服务。
你需要根据 MCP 服务所用的包确定合适的参数。 由于 MCP 服务的打包方式各不相同，这通常需要在本地反复尝试。
Python 服务示例
基本示例：
from mcp.client.stdio import StdioServerParameters
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-m",
"my_mcp_server_python_module",
"--my-server-command-line-parameter",
"some_value",
],
)
在本地，你可以通过以下方式运行此模块：
python -m my_mcp_server_python_module --my-server-command-line-parameter some_value
其他示例：
python -m mcpdoc.cli # Note the sub-module
python -c "from mcp_openapi_proxy import main; main()"
python -c "import asyncio; from postgres_mcp.server import main; asyncio.run(main())"
如果使用 Lambda layers，还需要为 python 子进程设置 PYTHONPATH：
lambda_paths = ["/opt/python"] + sys.path
env_config = {"PYTHONPATH": ":".join(lambda_paths)}
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-c",
"from mcp_openapi_proxy import main; main()",
],
env=env_config,
)
Typescript 服务示例
基本示例：
const serverParams = {
command: "npx",
args: [
"--offline",
"my-mcp-server-typescript-module",
"--my-server-command-line-parameter",
"some_value",
],
};
在本地，你可以通过以下方式运行此模块：
npx --offline my-mcp-server-typescript-module --my-server-command-line-parameter some_value
其他示例：
node /var/task/node_modules/@ivotoby/openapi-mcp-server/bin/mcp-server.js
此库不提供开箱即用的机制来管理封装的 MCP 服务所需的任何机密。例如，GitHub MCP 服务 和 Brave 搜索 MCP 服务 需要 API 密钥才能向第三方 API 发出请求。 你可以在 Lambda 函数的配置中将这些 API 密钥设置为 加密的环境变量， 也可以在 Lambda 函数代码中从 Secrets Manager 检索它们（示例如下）。 不过请注意，任何有权限调用 Lambda 函数的人 都能通过调用该函数，使用你的 API 密钥访问第三方 API。 我们建议使用 最小权限 IAM 策略 限制对 Lambda 函数的访问。 如果你使用 OAuth 等基于身份的身份验证机制，也可以按用户存储和检索 API 密钥，但此仓库中没有实现示例。
从 Secrets Manager 检索 API 密钥的 Python 服务示例
import sys
import boto3
from mcp.client.stdio import StdioServerParameters
# Retrieve API key from Secrets Manager
secrets_client = boto3.client("secretsmanager")
api_key = secrets_client.get_secret_value(SecretId="my-api-key-secret")["SecretString"]
server_params = StdioServerParameters(
command=sys.executable,
args=["-m", "my_mcp_server"],
env={
"API_KEY": api_key,
},
)
从 Secrets Manager 检索 API 密钥的 Typescript 服务示例
import { SecretsManagerClient, GetSecretValueCommand } from "@aws-sdk/client-secrets-manager";
const secretsClient = new SecretsManagerClient({});
const secret = await secretsClient.send(
new GetSecretValueCommand({ SecretId: "my-api-key-secret" })
);
const apiKey = secret.SecretString;
const serverParams = {
command: "npx",
args: ["--offline", "my-mcp-server"],
env: {
API_KEY: apiKey,
},
};
如果你的 MCP 服务需要调用 AWS API（例如 AWS 的 MCP 服务）， 你可以通过环境变量将 Lambda 函数的 AWS 凭据传递给封装的 MCP 服务。 封装的 MCP 服务子进程不会自动继承 Lambda 执行角色的凭据。 再次提醒，任何有权限调用 Lambda 函数的人 都能通过调用该函数，使用函数的 AWS 凭据访问 AWS API。 我们建议使用 最小权限 IAM 策略 限制对 Lambda 函数的访问。
通过环境变量使用 AWS 凭据的 Python 服务示例
import os
import sys
import boto3
from mcp.client.stdio import StdioServerParameters
# Get AWS credentials from Lambda execution role to pass to subprocess
session = boto3.Session()
credentials = session.get_credentials()
if credentials is None:
raise RuntimeError("Unable to retrieve AWS credentials from the execution environment")
resolved = credentials.get_frozen_credentials()
server_params = StdioServerParameters(
command=sys.executable,
args=["-m", "my_mcp_server"],
env={
"AWS_REGION": os.environ.get("AWS_REGION", "us-west-2"),
"AWS_DEFAULT_REGION": os.environ.get("AWS_REGION", "us-west-2"),
"AWS_ACCESS_KEY_ID": resolved.access_key,
"AWS_SECRET_ACCESS_KEY": resolved.secret_key,
"AWS_SESSION_TOKEN": resolved.token or "",
},
)
通过凭据文件使用 AWS 凭据的 Python 服务示例
某些 MCP 服务需要 AWS 配置文件，不支持通过环境变量传递凭据。 在这种情况下，你可以将凭据写入文件，并将该文件路径提供给 MCP 服务。
import os
import sys
import boto3
from mcp.client.stdio import StdioServerParameters
# Get AWS credentials from Lambda execution role to pass to subprocess
session = boto3.Session()
credentials = session.get_credentials()
if credentials is None:
raise RuntimeError("Unable to retrieve AWS credentials from the execution environment")
resolved = credentials.get_frozen_credentials()
# Write credentials to disk as default profile
aws_dir = "/tmp/.aws"
os.makedirs(aws_dir, exist_ok=True)
with open(f"{aws_dir}/credentials", "w") as f:
f.write("[default]\n")
f.write(f"aws_access_key_id = {resolved.access_key}\n")
f.write(f"aws_secret_access_key = {resolved.secret_key}\n")
if resolved.token:
f.write(f"aws_session_token = {resolved.token}\n")
server_params = StdioServerParameters(
command=sys.executable,
args=["-m", "my_mcp_server"],
env={
"AWS_REGION": os.environ.get("AWS_REGION", "us-west-2"),
"AWS_DEFAULT_REGION": os.environ.get("AWS_REGION", "us-west-2"),
"AWS_SHARED_CREDENTIALS_FILE": f"{aws_dir}/credentials",
},
)
完整且可部署的示例请见此处。
使用 API Gateway
flowchart LR
App["MCP Client"]
T1["MCP Server<br>(Lambda function)"]
T2["API Gateway"]
T3["OAuth Server<br>(Cognito or similar)"]
App -->|"MCP Streamable<br>HTTP Transport"| T2
T2 -->|"Invoke"| T1
T2 -->|"Authorize"| T3
此解决方案兼容大多数支持可流式 HTTP 传输的 MCP 客户端。 使用此架构部署的 MCP 服务通常可以与 Cursor、Cline、Claude Desktop 等现成的 MCP 兼容应用配合使用。
你可以为此解决方案选择所需的 OAuth 服务提供商。此仓库中的示例使用 Amazon Cognito；你也可以通过 API Gateway 自定义授权， 使用 Okta 或 Auth0 等第三方提供商。
Python 服务示例
import sys
from mcp.client.stdio import StdioServerParameters
from mcp_lambda import APIGatewayProxyEventHandler, StdioServerAdapterRequestHandler
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-m",
"my_mcp_server_python_module",
"--my-server-command-line-parameter",
"some_value",
],
)
request_handler = StdioServerAdapterRequestHandler(server_params)
event_handler = APIGatewayProxyEventHandler(request_handler)
def handler(event, context):
return event_handler.handle(event, context)
完整且可部署的示例请见此处。
Typescript 服务示例
import {
Handler,
Context,
APIGatewayProxyWithCognitoAuthorizerEvent,
APIGatewayProxyResult,
} from "aws-lambda";
import {
APIGatewayProxyEventHandler,
StdioServerAdapterRequestHandler,
} from "@aws/run-mcp-servers-with-aws-lambda";
const serverParams = {
command: "npx",
args: [
"--offline",
"my-mcp-server-typescript-module",
"--my-server-command-line-parameter",
"some_value",
],
};
const requestHandler = new APIGatewayProxyEventHandler(
new StdioServerAdapterRequestHandler(serverParams)
);
export const handler: Handler = async (
event: APIGatewayProxyWithCognitoAuthorizerEvent,
context: Context
): Promise<APIGatewayProxyResult> => {
return requestHandler.handle(event, context);
};
完整且可部署的示例请见此处。
Python 客户端示例
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
# Create OAuth client provider here
async with streamablehttp_client(
url="https://abc123.execute-api.us-west-2.amazonaws.com/prod/mcp",
auth=oauth_client_provider,
) as (
read_stream,
write_stream,
_,
):
async with ClientSession(read_stream, write_stream) as session:
await session.initialize()
tool_result = await session.call_tool("echo", {"message": "hello"})
完整示例请参见此处，该示例属于示例聊天机器人。
Typescript 客户端示例
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
const client = new Client(
{
name: "my-client",
version: "0.0.1",
},
{
capabilities: {
sampling: {},
},
}
);
// Create OAuth client provider here
const transport = new StreamableHTTPClientTransport(
"https://abc123.execute-api.us-west-2.amazonaws.com/prod/mcp",
{
authProvider: oauthProvider,
}
);
await client.connect(transport);
完整示例请参见此处，该示例属于示例聊天机器人。
flowchart LR
App["MCP Client"]
T1["MCP Server<br>(Lambda function)"]
T2["Bedrock AgentCore Gateway"]
T3["OAuth Server<br>(Cognito or similar)"]
App -->|"MCP Streamable<br>HTTP Transport"| T2
T2 -->|"Invoke"| T1
T2 -->|"Authorize"| T3
此解决方案兼容大多数支持可流式 HTTP 传输的 MCP 客户端。 采用此架构部署的 MCP 服务通常可与 Cursor、Cline、Claude Desktop 等现成的兼容 MCP 的应用程序配合使用。
使用 Bedrock AgentCore Gateway 时，你可以选择所需的 OAuth 服务提供商， 例如 Amazon Cognito、Okta 或 Auth0。
要在基于 stdio 的 MCP 服务前使用 Bedrock AgentCore Gateway，需要先获取 MCP 服务的工具架构，并将其提供给 AgentCore Gateway Lambda 目标配置。 随后，AgentCore Gateway 可以向 HTTP 客户端公布该架构，并验证请求输入和输出。
若要获取基于 stdio 的 MCP 服务的工具架构并保存到文件，请运行：
npx @modelcontextprotocol/inspector --cli --method tools/list <your MCP server command and arguments> > tool-schema.json
# For example:
npx @modelcontextprotocol/inspector --cli --method tools/list uvx mcp-server-time > tool-schema.json
有些 MCP 服务会生成 AgentCore Gateway 在严格验证时拒绝的工具架构，例如 "items": {}、"default": null 或包含 {"type": "null"} 的 anyOf。
使用前可能需要清理架构：
python3 scripts/clean-tool-schema.py tool-schema.json
Python 服务示例
import sys
from mcp.client.stdio import StdioServerParameters
from mcp_lambda import BedrockAgentCoreGatewayTargetHandler, StdioServerAdapterRequestHandler
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-m",
"my_mcp_server_python_module",
"--my-server-command-line-parameter",
"some_value",
],
)
request_handler = StdioServerAdapterRequestHandler(server_params)
event_handler = BedrockAgentCoreGatewayTargetHandler(request_handler)
def handler(event, context):
return event_handler.handle(event, context)
完整的可部署示例请见此处。
Typescript 服务示例
import { Handler, Context } from "aws-lambda";
import {
BedrockAgentCoreGatewayTargetHandler,
StdioServerAdapterRequestHandler,
} from "@aws/run-mcp-servers-with-aws-lambda";
const serverParams = {
command: "npx",
args: [
"--offline",
"my-mcp-server-typescript-module",
"--my-server-command-line-parameter",
"some_value",
],
};
const requestHandler = new BedrockAgentCoreGatewayTargetHandler(
new StdioServerAdapterRequestHandler(serverParams)
);
export const handler: Handler = async (
event: Record<string, unknown>,
context: Context
): Promise<Record<string, unknown>> => {
return requestHandler.handle(event, context);
};
完整的可部署示例请见此处。
Python 客户端示例
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
# Create OAuth client provider here
async with streamablehttp_client(
url="https://abc123.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp",
auth=oauth_client_provider,
) as (
read_stream,
write_stream,
_,
):
async with ClientSession(read_stream, write_stream) as session:
await session.initialize()
tool_result = await session.call_tool("echo", {"message": "hello"})
完整示例可在此处查看，该示例是示例聊天机器人的一部分。
Typescript 客户端示例
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
const client = new Client(
{
name: "my-client",
version: "0.0.1",
},
{
capabilities: {
sampling: {},
},
}
);
// Create OAuth client provider here
const transport = new StreamableHTTPClientTransport(
"https://abc123.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp",
{
authProvider: oauthProvider,
}
);
await client.connect(transport);
完整示例可在此处查看，该示例是示例聊天机器人的一部分。
使用 Lambda 函数 URL
flowchart LR
App["MCP Client"]
T1["MCP Server<br>(Lambda function)"]
T2["Lambda function URL"]
App -->|"Custom Streamable HTTP<br>Transport with AWS Auth"| T2
T2 -->|"Invoke"| T1
此解决方案使用 AWS IAM 进行身份验证，并依靠向你的 IAM 用户和角色授予 Lambda InvokeFunctionUrl 权限，以允许访问 MCP 服务。客户端必须使用 MCP 可流式 HTTP 传输的扩展，通过 AWS SigV4 对请求进行签名。 现成的兼容 MCP 的应用程序不太可能支持这种自定义传输， 因此，此解决方案更适用于服务间通信，而非面向最终用户。
Python 服务示例
import sys
from mcp.client.stdio import StdioServerParameters
from mcp_lambda import LambdaFunctionURLEventHandler, StdioServerAdapterRequestHandler
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-m",
"my_mcp_server_python_module",
"--my-server-command-line-parameter",
"some_value",
],
)
request_handler = StdioServerAdapterRequestHandler(server_params)
event_handler = LambdaFunctionURLEventHandler(request_handler)
def handler(event, context):
return event_handler.handle(event, context)
完整的可部署示例请见此处。
Typescript 服务示例
import {
Handler,
Context,
APIGatewayProxyEventV2WithIAMAuthorizer,
APIGatewayProxyResultV2,
} from "aws-lambda";
import {
LambdaFunctionURLEventHandler,
StdioServerAdapterRequestHandler,
} from "@aws/run-mcp-servers-with-aws-lambda";
const serverParams = {
command: "npx",
args: [
"--offline",
"my-mcp-server-typescript-module",
"--my-server-command-line-parameter",
"some_value",
],
};
const requestHandler = new LambdaFunctionURLEventHandler(
new StdioServerAdapterRequestHandler(serverParams)
);
export const handler: Handler = async (
event: APIGatewayProxyEventV2WithIAMAuthorizer,
context: Context
): Promise<APIGatewayProxyResultV2> => {
return requestHandler.handle(event, context);
};
完整的可部署示例请见此处。
Python 客户端示例
from mcp import ClientSession
from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client
async with aws_iam_streamablehttp_client(
endpoint="https://url-id-12345.lambda-url.us-west-2.on.aws",
aws_service="lambda",
aws_region="us-west-2",
) as (
read_stream,
write_stream,
_,
):
async with ClientSession(read_stream, write_stream) as session:
await session.initialize()
tool_result = await session.call_tool("echo", {"message": "hello"})
完整示例可在此处查看，该示例是示例聊天机器人的一部分。
Typescript 客户端示例
import { StreamableHTTPClientWithSigV4Transport } from "@aws/run-mcp-servers-with-aws-lambda";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
const client = new Client(
{
name: "my-client",
version: "0.0.1",
},
{
capabilities: {
sampling: {},
},
}
);
const transport = new StreamableHTTPClientWithSigV4Transport(
new URL("https://url-id-12345.lambda-url.us-west-2.on.aws"),
{
service: "lambda",
region: "us-west-2",
}
);
await client.connect(transport);
完整示例可在此处查看，该示例是示例聊天机器人的一部分。
flowchart LR
App["MCP Client"]
T1["MCP Server<br>(Lambda function)"]
App -->|"Custom MCP Transport<br>(Lambda Invoke API)"| T1
与 Lambda 函数 URL 方案类似，此方案使用 AWS IAM 进行身份验证。 它依赖于向 IAM 用户和角色授予 Lambda InvokeFunction 权限， 以允许访问 MCP 服务。 客户端必须使用直接调用 Lambda Invoke API 的自定义 MCP 传输方式。 现成的兼容 MCP 应用不太可能支持这种自定义传输方式， 因此，此方案更适用于服务间通信，而非面向终端用户。
Python 服务端示例
import sys
from mcp.client.stdio import StdioServerParameters
from mcp_lambda import stdio_server_adapter
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-m",
"my_mcp_server_python_module",
"--my-server-command-line-parameter",
"some_value",
],
)
def handler(event, context):
return stdio_server_adapter(server_params, event, context)
此处提供了完整且可部署的示例。
Typescript 服务端示例
import { Handler, Context } from "aws-lambda";
import { stdioServerAdapter } from "@aws/run-mcp-servers-with-aws-lambda";
const serverParams = {
command: "npx",
args: [
"--offline",
"my-mcp-server-typescript-module",
"--my-server-command-line-parameter",
"some_value",
],
};
export const handler: Handler = async (event, context: Context) => {
return await stdioServerAdapter(serverParams, event, context);
};
此处提供了完整且可部署的示例。
Python 客户端示例
from mcp import ClientSession
from mcp_lambda import LambdaFunctionParameters, lambda_function_client
server_params = LambdaFunctionParameters(
function_name="my-mcp-server-function",
region_name="us-west-2",
)
async with lambda_function_client(server_params) as (
read_stream,
write_stream,
):
async with ClientSession(read_stream, write_stream) as session:
await session.initialize()
tool_result = await session.call_tool("echo", {"message": "hello"})
此处提供了示例聊天机器人的完整示例。
Typescript 客户端示例
import {
LambdaFunctionParameters,
LambdaFunctionClientTransport,
} from "@aws/run-mcp-servers-with-aws-lambda";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
const serverParams: LambdaFunctionParameters = {
functionName: "my-mcp-server-function",
regionName: "us-west-2",
};
const client = new Client(
{
name: "my-client",
version: "0.0.1",
},
{
capabilities: {
sampling: {},
},
}
);
const transport = new LambdaFunctionClientTransport(serverParams);
await client.connect(transport);
此处提供了示例聊天机器人的完整示例。
相关项目
- 如需在 Lambda 函数中编写自定义 MCP 服务端， 请参阅 MCP Lambda Handler 项目。
- 如需通过 stdio MCP 服务将现有 Lambda 函数作为工具调用， 请参阅 AWS Lambda Tool MCP Server 项目。
注意事项
- 此库目前支持使用 Python 和 Typescript 编写的 MCP 服务端和客户端。 不支持 Kotlin 等其他语言。
- 此库仅为 Lambda 适配 stdio MCP 服务端，不支持为 SSE 等其他协议编写的服务端。
- 此库不会在 Lambda 函数调用之间维护任何 MCP 服务端状态或会话。 只有无状态 MCP 服务端适合使用此库。例如，调用无状态工具（如 time MCP server） 或发出无状态 Web 请求（如 fetch MCP server）的 MCP 服务端。 有状态 MCP 服务端不适合使用此库，因为它们会在每次请求时丢失状态。 例如，管理磁盘或内存中数据的 MCP 服务端，包括 sqlite MCP server、 filesystem MCP server 和 git MCP server。
部署和运行示例
请参阅开发指南，了解如何部署和运行此仓库中的示例。
安全
如需了解更多信息，请参阅 CONTRIBUTING。
许可证
本项目采用 Apache-2.0 许可证。
评论
支持 Markdown
一个开放协议，规定了 AI 应用如何以统一方式连接外部工具与数据源。客户端负责与模型对话，MCP 服务负责提供工具、资源和提示模板，两者通过标准消息通信，同一个服务可以被不同客户端复用。