automcp

🚀 概述

automcp 使您可以轻松地将现有代理框架中的工具、代理和编排器转换为 MCP 服务器，然后可以通过 Cursor 和 Claude Desktop 等客户端通过标准化接口访问这些服务器。

我们目前支持将代理、工具和编排器部署为以下代理框架的 MCP 服务器：

1. CrewAI
2. LangGraph
3. Llama Index
4. OpenAI Agents SDK
5. Pydantic AI
6. mcp-agent

🔧 安装

从 PyPI 安装：

# 基本安装
pip install naptha-automcp

# UV
uv add naptha-automcp

或者从源代码安装：

git clone https://github.com/napthaai/automcp.git
cd automcp
uv venv 
source .venv/bin/activate
pip install -e .

🧩 快速开始

为您的项目创建一个新的 MCP 服务器：

使用您的代理实现导航到您的项目目录：

cd your-project-directory

通过 CLI 使用以下标志之一（crewai、langgraph、llamaindex、openai、pydantic、mcp_agent）生成 MCP 服务器文件：

automcp init -f crewai

编辑生成的 run_mcp.py 文件以配置您的代理：

# 将这些导入替换为您实际的代理类
from your_module import YourCrewClass

# 定义输入模式
class InputSchema(BaseModel):
    parameter1: str
    parameter2: str

# 设置您的代理详细信息
name = "<YOUR_AGENT_NAME>"
description = "<YOUR_AGENT_DESCRIPTION>"

# 对于 CrewAI 项目
mcp_crewai = create_crewai_adapter(
    orchestrator_instance=YourCrewClass().crew(),
    name=name,
    description=description,
    input_schema=InputSchema,
)

安装依赖项并运行您的 MCP 服务器：

automcp serve -t sse

📁 生成的文件

当您运行 automcp init -f <FRAMEWORK> 时，将生成以下文件：

run_mcp.py

这是设置和运行您的 MCP 服务器的主文件。它包含：

• 服务器初始化代码
• STDIO 和 SSE 传输处理程序
• 您的代理实现的占位符
• 用于抑制可能破坏 STDIO 协议的警告的实用程序

您需要编辑此文件以：

• 导入您的代理/团队类
• 定义您的输入模式（您的代理接受的参数）
• 使用您的代理配置适配器

🔍 示例

运行示例

该存储库包含每个受支持框架的示例：

# 克隆存储库
git clone https://github.com/NapthaAI/automcp.git
cd automcp

# 以开发模式安装 automcp
pip install -e .

# 导航到示例目录
cd examples/crewai/marketing_agents

# 生成 MCP 服务器文件（使用适当的框架）
automcp init -f crewai

# 编辑生成的 run_mcp.py 文件以导入和配置示例代理
# （有关详细信息，请参阅特定示例的 README）

# 添加一个包含必要环境变量的 .env 文件

# 安装依赖项并运行
automcp serve -t sse

每个示例都遵循与常规项目相同的工作流程：

1. 运行 automcp init -f <FRAMEWORK> 以生成服务器文件
2. 编辑 run_mcp.py 以导入和配置示例代理
3. 添加一个包含必要环境变量的 .env 文件
4. 使用 automcp serve -t sse 安装依赖项并提供服务

CrewAI 示例

以下是 CrewAI 示例的典型配置的 run_mcp.py 的外观：

import warnings
from typing import Any
from automcp.adapters.crewai import create_crewai_adapter
from pydantic import BaseModel
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("MCP Server")

warnings.filterwarnings("ignore")

from crew import MarketingPostsCrew

class InputSchema(BaseModel):
    project_description: str
    customer_domain: str

name = "marketing_posts_crew"
description = "一个将营销帖子发布到社交媒体平台的团队"

# 为 crewai 创建一个适配器
mcp_crewai = create_crewai_adapter(
    orchestrator_instance=MarketingPostsCrew().crew(),
    name=name,
    description=description,
    input_schema=InputSchema,
)
mcp.add_tool(
    mcp_crewai,
    name=name,
    description=description
)

# 服务器入口点
def serve_sse():
    mcp.run(transport="sse")

def serve_stdio():
    # 重定向 stderr 以抑制绕过过滤器的警告
    import os
    import sys

    class NullWriter:
        def write(self, *args, **kwargs):
            pass
        def flush(self, *args, **kwargs):
            pass

    # 保存原始 stderr
    original_stderr = sys.stderr

    # 将 stderr 替换为我们的 null writer 以防止警告破坏 STDIO
    sys.stderr = NullWriter()

    # 设置环境变量以忽略 Python 警告
    os.environ["PYTHONWARNINGS"] = "ignore"

    try:
        mcp.run(transport="stdio")
    finally:
        # 恢复 stderr 以进行正常操作
        sys.stderr = original_stderr

if __name__ == "__main__":
    import sys
    if len(sys.argv) > 1 and sys.argv[1] == "sse":
        serve_sse()
    else:
        serve_stdio()

🔄 运行您的 MCP 服务器

设置好文件后，您可以使用以下方法之一运行您的服务器：

# 使用 automcp CLI
automcp serve -t stdio    # STDIO 传输
automcp serve -t sse      # SSE 传输

# 或者直接运行 Python 文件
python run_mcp.py       # STDIO 传输
python run_mcp.py sse   # SSE 传输

# 或者使用 uv 运行（如果在 pyproject.toml 中配置）
uv run serve_stdio
uv run serve_sse

关于传输模式的说明：

• STDIO：您不需要手动运行服务器 - 它将由客户端（Cursor）启动
• SSE：这是一个两步过程：
  1. 单独启动服务器：python run_mcp.py sse 或 automcp serve -t sse
  2. 添加 mcp.json 配置以连接到正在运行的服务器

如果您想使用 uv run 命令，请将以下内容添加到您的 pyproject.toml：

[tool.uv.scripts]
serve_stdio = "python run_mcp.py"
serve_sse = "python run_mcp.py sse"

☁️ 使用 Naptha 的 MCPaaS 部署

Naptha 支持将您新创建的 MCP 服务器部署到我们的 MCP 服务器即服务平台！ 入门很容易。

设置

Naptha 的 MCPaaS 平台要求您的存储库使用 uv 进行设置。 这意味着您需要在 pyproject.toml 中进行一些配置。

首先，确保由 naptha-automcp 生成的 run_mcp.py 文件是您存储库的根目录。

其次，确保您的 pyproject.toml 具有以下配置：

[build-system]
requires = [ "hatchling",]
build-backend = "hatchling.build"

[project.scripts]
serve_stdio = "run_mcp:serve_stdio"
serve_sse = "run_mcp:serve_sse"

[tool.hatch.metadata]
allow-direct-references = true

[tool.hatch.build.targets.wheel]
include = [ "run_mcp.py",]
exclude = [ "__pycache__", "*.pyc",]
sources = [ ".",]
packages = ["."]

如果您的代理位于存储库的子目录/包中：

pyproject.toml
run_mcp.py
my_agent/
|---| __init__.py
    | agent.py

确保它在 run_mcp.py 中像这样导入：

from my_agent.agent

不要像下面这样，因为这会导致构建失败：

from .my_agent.agent

配置完所有内容后，提交并将您的代码（但不是您的环境变量！）推送到 github。 然后，您可以对其进行测试以确保您正确设置了所有内容：

uvx --from https://github.com/your-username/your-repo serve_sse

如果这导致您的 MCP 服务器成功在端口 8000 上启动，那么您就可以开始了！

启动您的服务器

1. 转到 labs.naptha.ai
2. 使用您的 github 帐户登录
3. 从您的存储库列表中选择您编辑的存储库 - 我们会自动发现您的 github 存储库。
4. 添加您的环境变量，例如 OPENAI_API_KEY 等。
5. 单击启动。
6. 复制 SSE URL，并将其粘贴到您的 MCP 客户端中：

🔌 与 MCP 客户端一起使用

Cursor

要与 Cursor IDE 集成，请在您的项目根目录中创建一个 .cursor 文件夹，并添加一个包含以下配置的 mcp.json 文件：

{
    "mcpServers": {
        "crew-name-stdio": {
            "type": "stdio",
            "command": "/absolute/path/to/your/.venv/bin/uv",
            "args": [
                "--directory",
                "/absolute/path/to/your/project_dir",
                "run",
                "serve_stdio"
            ],
            "env": {
                "OPENAI_API_KEY": "sk-",
                "SERPER_API_KEY": ""
            }
        },
        
        "crew-name-python": {
            "type": "stdio",
            "command": "/absolute/path/to/your/.venv/bin/python",
            "args": [
                "/absolute/path/to/your/project_dir/run_mcp.py"
            ],
            "env": {
                "OPENAI_API_KEY": "sk-",
                "SERPER_API_KEY": ""
            }
        },
        
        "crew-name-automcp": {
            "type": "stdio",
            "command": "/absolute/path/to/your/.venv/bin/automcp",
            "args": [
                "serve",
                "-t",
                "stdio"
            ],
            "cwd": "/absolute/path/to/your/project_dir",
            "env": {
                "OPENAI_API_KEY": "sk-",
                "SERPER_API_KEY": ""
            }
        },
        
        "crew-name-sse": {
            "type": "sse",
            "url": "http://localhost:8000/sse"
        }
    }
}

注意： 确保将所有占位符路径替换为指向您的实际文件和目录的绝对路径。

直接 GitHub 执行

将您的项目推送到 GitHub 并使用：

{
   "mcpServers": {
       "My Agent": {
           "command": "uvx",
           "args": [
               "--from",
               "git+https://github.com/your-username/your-repo",
               "serve_stdio"
           ],
           "env": {
               "OPENAI_API_KEY": "your-key-here"
           }
       }
   }
}

🛠️ 创建新的适配器

想要添加对新代理框架的支持吗？ 方法如下：

1. 在 automcp/adapters/ 中创建一个新的适配器文件（或添加到现有的框架文件中）：

# automcp/adapters/framework.py
import json
import contextlib
import io
from typing import Any, Callable, Type
from pydantic import BaseModel

def create_framework_adapter(
    agent_instance: Any,
    name: str,
    description: str,
    input_schema: Type[BaseModel],
) -> Callable:
    """Doc string for your function"""
    
    # Get the field names and types from the input schema
    schema_fields = input_schema.model_fields

    # Create the parameter string for the function signature
    params_str = ", ".join(
        f"{field_name}: {field_info.annotation.__name__}"
        for field_name, field_info in schema_fields.items()
    )

    # Create the function body that constructs the input schema
    # Note: You may need to adjust the method calls (kickoff, model_dump_json)
    # to match your framework's specific API
    body_str = f"""def run_agent({params_str}):
        inputs = input_schema({', '.join(f'{name}={name}' for name in schema_fields)})
        with contextlib.redirect_stdout(io.StringIO()):
            result = agent_instance.framework_specific_run(inputs=inputs.model_dump())
        return result.framework_specific_result()
    """

    # Create a namespace for the function
    namespace = {
        "input_schema": input_schema,
        "agent_instance": agent_instance,
        "json": json,
        "contextlib": contextlib,
        "io": io,
    }

    # Execute the function definition in the namespace
    exec(body_str, namespace)

    # Get the created function
    run_agent = namespace["run_agent"]

    # Add proper function metadata
    run_agent.__name__ = name
    run_agent.__doc__ = description

    return run_agent

2. 在 examples/your_framework/ 中创建一个示例

📝 笔记

• 使用 STDIO 传输时，请注意代理代码中的 print 语句，因为它们可能会破坏协议
• MCP Inspector 可用于调试：npx @modelcontextprotocol/inspector
• 请记住，对于 STDIO 模式，客户端（如 Cursor）将为您启动服务器
• 对于 SSE 模式，您需要手动启动服务器，然后配置客户端以连接到它