automcp

🚀 Overview

automcp allows you to easily convert tools, agents and orchestrators from existing agent frameworks into MCP servers, that can then be accessed by standardized interfaces via clients like Cursor and Claude Desktop.

We currently support deployment of agents, tools, and orchestrators as MCP servers for the following agent frameworks:

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

🔧 Installation

Install from PyPI:

# Basic installation
pip install naptha-automcp
UV
uv add naptha-automcp

Or install from source:

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

🧩 Quick Start

Create a new MCP server for your project:

Navigate to your project directory with your agent implementation:

cd your-project-directory

Generate the MCP server files via CLI with one of the following flags (crewai, langgraph, llamaindex, openai, pydantic, mcp_agent):

automcp init -f crewai

Edit the generated run_mcp.py file to configure your agent:

# Replace these imports with your actual agent classes
from your_module import YourCrewClass
Define the input schema
class InputSchema(BaseModel):
    parameter1: str
    parameter2: str
Set your agent details
name = "<YOUR_AGENT_NAME>"
description = "<YOUR_AGENT_DESCRIPTION>"
For CrewAI projects
mcp_crewai = create_crewai_adapter(
    orchestrator_instance=YourCrewClass().crew(),
    name=name,
    description=description,
    input_schema=InputSchema,
)

Install dependencies and run your MCP server:

automcp serve -t sse

📁 Generated Files

When you run automcp init -f <FRAMEWORK>, the following file is generated:

run_mcp.py

This is the main file that sets up and runs your MCP server. It contains:

- Server initialization code
- STDIO and SSE transport handlers
- A placeholder for your agent implementation
- Utilities to suppress warnings that might corrupt the STDIO protocol

You'll need to edit this file to:

- Import your agent/crew classes
- Define your input schema (the parameters your agent accepts)
- Configure the adapter with your agent

🔍 Examples

Running the examples

The repository includes examples for each supported framework:

# Clone the repository
git clone https://github.com/NapthaAI/automcp.git
cd automcp
Install automcp in development mode
pip install -e .
Navigate to an example directory
cd examples/crewai/marketing_agents
Generate the MCP server files (use the appropriate framework)
automcp init -f crewai
Edit the generated run_mcp.py file to import and configure the example agent
(See the specific example's README for details)
Add a .env file with necessary environmental variables
Install dependencies and run
automcp serve -t sse

Each example follows the same workflow as a regular project:

1. Run automcp init -f <FRAMEWORK> to generate the server files
2. Edit run_mcp.py to import and configure the example agent
3. Add a .env file with necessary environmental variables
4. Install dependencies and serve using automcp serve -t sse

CrewAI example

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 = "A crew that posts marketing posts to a social media platform"
Create an adapter for 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
)
Server entrypoints
def serve_sse():
    mcp.run(transport="sse")
def serve_stdio():

    # Redirect stderr to suppress warnings that bypass the filters

    import os

    import sys
class NullWriter:

        def write(self, args, kwargs):

            pass

        def flush(self, args, kwargs):

            pass
# Save the original stderr

    original_stderr = sys.stderr
# Replace stderr with our null writer to prevent warnings from corrupting STDIO

    sys.stderr = NullWriter()
# Set environment variable to ignore Python warnings

    os.environ["PYTHONWARNINGS"] = "ignore"
try:

        mcp.run(transport="stdio")

    finally:

        # Restore stderr for normal operation

        sys.stderr = original_stderr
if __name__ == "__main__":

    import sys

    if len(sys.argv) > 1 and sys.argv[1] == "sse":

        serve_sse()

    else:

        serve_stdio()

🔄 Running Your MCP Server

After setting up your files, you can run your server using one of these methods:

# Using the automcp CLI
automcp serve -t stdio    # STDIO transport
automcp serve -t sse      # SSE transport
Or run the Python file directly
python run_mcp.py       # STDIO transport
python run_mcp.py sse   # SSE transport
Or with uv run (if configured in pyproject.toml)
uv run serve_stdio
uv run serve_sse

Note about transport modes:
- STDIO: You don't need to run the server manually - it will be started by the client (Cursor)
- SSE: This is a two-step process:
1. Start the server separately: python run_mcp.py sse or automcp serve -t sse
2. Add the mcp.json configuration to connect to the running server

If you want to use the uv run commands, add the following to your pyproject.toml:

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

☁️ Deploying with Naptha's MCPaaS

Setup

First, make sure the run_mcp.py file generated by naptha-automcp is the root of your repository.

Second, make sure your pyproject.toml has the following configurations:

[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 = ["."]

If your agent is in a subdirectory / package of your repository:

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

Make sure that it's imported like this in run_mcp.py:

from my_agent.agent

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

🔌 Using with MCP Clients

Cursor

…