MCP100 verdict
Not currently recommended. MCP-native Python framework for building composable agents and workflows, including MCP client/server support and optional durable execution. Capabilities: Manage MCP server connections; Build agents with composable workflow patterns; Create MCP servers and expose agents as servers; Use optional Temporal-backed durable execution; Use OAuth, sampling, elicitation, roots and other MCP capabilities documented by the framework
MCP100 Assessment
Editorial verdict
Reviewed September 13, 2026
Task Fit
Mapped
Specialized workflows
Trust
Status warning
maintenance_source_health; install_supply_chain; advisory_freshness; adoption_evidence_presence; resource_type_requirements
Maintenance
Recheck needed
The source snapshot needs another refresh before maintenance can be interpreted.
Popularity
Signals unavailable
No independently comparable adoption metric is currently stored.
Evidence scope
No MCP-specific repository metric is stored
No MCP-specific package metric is stored
Stars observation date unavailable · Downloads observation date unavailable
Exact implementation repository metric.
Exact package is documented; download evidence is unavailable.
Publisher activity observed September 13, 2026
Stale source snapshot - recheck needed
Source relationship: First-party MCP
Reviewed September 13, 2026
Evidence-backed setup
This profile has type-appropriate, source-backed setup rather than an MCP-server client connector configuration.
Capability
MCP-native Python framework for building composable agents and workflows, including MCP client/server support and optional durable execution. Capabilities: Manage MCP server connections; Build agents with composable workflow patterns; Create MCP servers and expose agents as servers; Use optional Temporal-backed durable execution; Use OAuth, sampling, elicitation, roots and other MCP capabilities documented by the framework
Not measured yet
Estimated token footprint of the MCP tool schemas exposed to the agent.
Reviewed access
Review the exact access boundary before connecting this MCP to accounts, credentials, or sensitive data.
Related reviewed MCPs
MCP server for Chrome DevTools
Choose this instead if
Choose Chrome DevTools MCP instead if inspecting pages, console and network activity, automating browser actions, and collecting performance evidence in Chrome.
Recommended for browser debugging and performance investigation when Chrome runs with an isolated, non-sensitive profile.
Provide a structured tool for iterative problem-solving steps.
Choose this instead if
Choose Sequential Thinking MCP instead if complex planning and debugging that benefits from revisions and branches.
Provide a structured tool for iterative problem-solving steps.
⚡ Fully automated MCP server + JADX plugin built to communicate with LLM through MCP to analyze Android APKs using LLMs like Claude — uncover vulnerabilities, analyze APK, and reverse engineer effortlessly.
Choose this instead if
Choose JADX-AI-MCP (Part of Zin MCP Suite) instead if navigating JADX decompilation, searching APK code, and accelerating reverse-engineering or security-analysis hypotheses.
Recommended for authorized Android APK triage in an isolated lab, with findings confirmed manually in JADX and the underlying code.
github:lastmile-ai is listed as First-party MCP in MCP100’s current evidence.
Current official resources:
Original product, capability, tool, and usage documentation from the MCP publisher. Installation sections appear under Install & Agents.
mcp-agent is a simple, composable framework to build effective agents using Model Context Protocol.
[!Note] mcp-agent's vision is that MCP is all you need to build agents, and that simple patterns are more robust than complex architectures for shipping high-quality agents.
mcp-agent gives you the following:
Altogether, this is the simplest and easiest way to build robust agent applications.
We welcome all kinds of contributions, feedback and your help in improving this project.
Minimal example
import asyncio
from mcp_agent.app import MCPApp
from mcp_agent.agents.agent import Agent
from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
app = MCPApp(name="hello_world")
async def main():
async with app.run():
agent = Agent(
name="finder",
instruction="Use filesystem and fetch to answer questions.",
server_names=["filesystem", "fetch"],
)
async with agent:
llm = await agent.attach_llm(OpenAIAugmentedLLM)
answer = await llm.generate_str("Summarize README.md in two sentences.")
print(answer)
if __name__ == "__main__":
asyncio.run(main())
# Add your LLM API key to `mcp_agent.secrets.yaml` or set it in env.
# The [Getting Started guide](https://docs.mcp-agent.com/get-started/overview) walks through configuration and secrets in detail.
mcp-agent's complete documentation is available at docs.mcp-agent.com, including full SDK guides, CLI reference, and advanced patterns. This readme gives a high-level overview to get you started.
llms-full.txt: contains entire documentation.llms.txt: sitemap listing key pages in the docs.[!TIP] The CLI is available via
uvx mcp-agent. To get up and running, scaffold a project withuvx mcp-agent initand deploy withuvx mcp-agent deploy my-agent.You can get up and running in 2 minutes by running these commands:
mkdir hello-mcp-agent && cd hello-mcp-agent uvx mcp-agent init uv init uv add "mcp-agent[openai]" # Add openai API key to `mcp_agent.secrets.yaml` or set `OPENAI_API_KEY` uv run main.py
mcp-agent?There are too many AI frameworks out there already. But mcp-agent is the only one that is purpose-built for a shared protocol - MCP.mcp-agent pairs Anthropic’s Building Effective Agents patterns with a batteries-included MCP runtime so you can focus on behaviour, not boilerplate. Teams pick it because it is:
Docs: Welcome to mcp-agent • Effective patterns overview.
Every project revolves around a single MCPApp runtime that loads configuration, registers agents and MCP servers, and exposes tools/workflows. The Core Components guide walks through these building blocks.
Initialises configuration, logging, tracing, and the execution engine so everything shares one context.
from mcp_agent.app import MCPApp
app = MCPApp(name="finder_app")
async def main():
async with app.run() as running_app:
logger = running_app.logger
logger.info("App ready", data={"servers": list(running_app.context.server_registry.registry)})
Docs: MCPApp • Example: examples/basic/mcp_basic_agent.
Agents couple instructions with the MCP servers (and optional functions) they may call. AgentSpec definitions can be loaded from disk and turned into agents or Augmented LLMs with the factory helpers.
from pathlib import Path
from mcp_agent.agents.agent import Agent
from mcp_agent.workflows.factory import load_agent_specs_from_file
agent = Agent(
name="researcher",
instruction="Research topics using web and filesystem access",
server_names=["fetch", "filesystem"],
)
async with agent:
tools = await agent.list_tools()
async with app.run() as running_app:
specs = load_agent_specs_from_file(
str(Path("examples/basic/agent_factory/agents.yaml")),
context=running_app.context,
)
Docs: Agents • Agent factory helpers • Examples: examples/basic/agent_factory.
Augmented LLMs wrap provider SDKs with the agent’s tools, memory, and structured output helpers. Attach one to an agent to unlock generate, generate_str, and generate_structured.
from pydantic import BaseModel
from mcp_agent.workflows.llm.augmented_llm import RequestParams
from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
class Summary(BaseModel):
title: str
verdict: str
async with agent:
llm = await agent.attach_llm(OpenAIAugmentedLLM)
report = await llm.generate_str(
message="Draft a 3-sentence release note from CHANGELOG.md",
request_params=RequestParams(maxTokens=400, temperature=0.2),
)
structured = await llm.generate_structured(
message="Return a JSON object with `title` and `verdict` summarising the README.",
response_model=Summary,
)
Docs: Augmented LLMs • Examples: examples/basic/mcp_basic_agent and the workflow projects listed in gallery.md.
MCPApp decorators convert coroutines into durable workflows and tools. The same annotations work for both asyncio and Temporal execution.
from datetime import timedelta
from mcp_agent.executor.workflow import Workflow, WorkflowResult
@app.workflow
class PublishArticle(Workflow[WorkflowResult[str]]):
@app.workflow_task(schedule_to_close_timeout=timedelta(minutes=5))
async def draft(self, topic: str) -> str:
return f"- intro to {topic}\n- highlights\n- next steps"
@app.workflow_run
async def run(self, topic: str) -> WorkflowResult[str]:
outline = await self.draft(topic)
return WorkflowResult(value=outline)
Docs: Decorator reference • Examples: examples/workflows.
Settings load from mcp_agent.config.yaml, mcp_agent.secrets.yaml, environment variables, and optional preload strings. Keep secrets out of source control.
# mcp_agent.config.yaml
execution_engine: asyncio
mcp:
servers:
fetch:
command: "uvx"
args: ["mcp-server-fetch"]
filesystem:
command: "npx"
args: ["-y", "@modelcontextprotocol/server-filesystem"]
openai:
default_model: gpt-4o-mini
# mcp_agent.secrets.yaml (gitignored)
openai:
api_key: "${OPENAI_API_KEY}"
Docs: Configuration reference • Specify secrets.
Connect to existing MCP servers programmatically or aggregate several into one façade.
from mcp_agent.mcp.gen_client import gen_client
async with app.run():
async with gen_client("filesystem", app.server_registry, context=app.context) as client:
resources = await client.list_resources()
app.logger.info("Filesystem resources", data={"uris": [r.uri for r in resources.resources]})
Docs: MCP integration overview • Examples: examples/mcp.
Key agent patterns are implemented as an AugmentedLLM. Use factory helpers to wire them up or inspect the runnable projects listed in gallery.md.
| Pattern | Helper | Summary | Docs |
|---|---|---|---|
| Parallel (Map-Reduce) | create_parallel_llm(...) | Fan-out specialists and fan-in aggregated reports. | Parallel |
| Router | create_router_llm(...) / create_router_embedding(...) | Route requests to the best agent, server, or function. | Router |
| Intent classifier | create_intent_classifier_llm(...) / create_intent_classifier_embedding(...) | Bucket user input into intents before automation. | Intent classifier |
| Orchestrator-workers | create_orchestrator(...) |
Switch execution_engine to temporal for pause/resume, retries, human input, and durable history—without changing workflow code. Run a worker alongside your app to host activities.
from mcp_agent.executor.temporal import create_temporal_worker_for_app
async with create_temporal_worker_for_app(app) as worker:
await worker.run()
Docs: Durable agents • Temporal backend • Examples: examples/temporal.
Expose an MCPApp as a standard MCP server so Claude Desktop, Cursor, or custom clients can call your tools and workflows.
from mcp_agent.server import create_mcp_server_for_app
@app.tool
def grade_story(story: str) -> str:
return "Report..."
if __name__ == "__main__":
server = create_mcp_server_for_app(app)
server.run_stdio()
Docs: Agent servers • Examples: examples/mcp_agent_server.
uvx mcp-agent scaffolds projects, manages secrets, inspects workflows, and deploys to Cloud.
uvx mcp-agent init --template basic # Scaffold a new project
uvx mcp-agent deploy my-agent # Deploy to mcp-agent Cloud
Docs: CLI reference • Getting started guides.
Load API keys from secrets files or use the built-in OAuth client to fetch and persist tokens for MCP servers.
# mcp_agent.config.yaml excerpt
oauth:
providers:
github:
client_id: "${GITHUB_CLIENT_ID}"
client_secret: "${GITHUB_CLIENT_SECRET}"
scopes: ["repo", "user"]
Docs: Advanced authentication • Server authentication • Examples: examples/basic/oauth_basic_agent.
Enable structured logging and OpenTelemetry via configuration, and track token usage programmatically.
# mcp_agent.config.yaml
logger:
transports: [console]
level: info
otel:
enabled: true
exporters:
- console
TokenCounter tracks token usage for agents, workflows, and LLM nodes. Attach watchers to stream updates or trigger alerts.
# Inside `async with app.run() as running_app:`
# token_counter lives on the running app context when tracing is enabled.
token_counter = running_app.context.token_counter
class TokenMonitor:
async def on_token_update(self, node, usage):
print(f"[{node.name}] total={usage.total_tokens}")
monitor = TokenMonitor()
watch_id = await token_counter.watch(
callback=monitor.on_token_update,
node_type="llm",
threshold=1_000,
include_subtree=True,
)
await token_counter.unwatch(watch_id)
Docs: Observability • Examples: examples/tracing.
Mix and match AgentSpecs to build higher-level workflows using the factory helpers—routers, parallel pipelines, orchestrators, and more.
from mcp_agent.workflows.factory import create_router_llm
# specs are loaded via load_agent_specs_from_file as shown above.
async with app.run() as running_app:
router = await create_router_llm(
agents=specs,
provider="openai",
context=running_app.context,
)
Docs: Workflow composition • Examples: examples/basic/agent_factory.
Pause workflows for approvals or extra data. Temporal stores state durably until an operator resumes the run.
from mcp_agent.human_input.types import HumanInputRequest
response = await self.context.request_human_input(
HumanInputRequest(
prompt="Approve the draft?",
required=True,
metadata={"workflow_id": self.context.workflow_id},
)
)
Resume with mcp-agent cloud workflows resume … --payload '{"content": "approve"}'. Docs: Deploy agents – human input • Examples: examples/human_input/temporal.
Build Settings objects programmatically when you need dynamic config (tests, multi-tenant hosts) instead of YAML files.
from mcp_agent.config import Settings, MCPSettings, MCPServerSettings
settings = Settings(
execution_engine="asyncio",
mcp=MCPSettings(
servers={
"fetch": MCPServerSettings(command="uvx", args=["mcp-server-fetch"]),
}
),
)
app = MCPApp(name="configured_app", settings=settings)
Docs: Configuring your application.
Add icons to agents and tools so MCP clients that support imagery (Claude Desktop, Cursor) render richer UIs.
from base64 import standard_b64encode
from pathlib import Path
from mcp_agent.icons import Icon
icon_data = standard_b64encode(Path("my-icon.png").read_bytes()).decode()
icon = Icon(src=f"data:image/png;base64,{icon_data}", mimeType="image/png", sizes=["64x64"])
app = MCPApp(name="my_app_with_icon", icons=[icon])
@app.tool(icons=[icon])
async def my_tool() -> str:
return "Hello with style"
Docs: MCPApp icons • Examples: examples/mcp_agent_server/asyncio.
Use MCPAggregator or gen_client to manage MCP server connections and expose combined tool sets.
from mcp_agent.mcp.mcp_aggregator import MCPAggregator
async with MCPAggregator.create(server_names=["fetch", "filesystem"]) as aggregator:
tools = await aggregator.list_tools()
Docs: Connecting to MCP servers • Examples: examples/basic/mcp_server_aggregator.
Deploy to mcp-agent Cloud for managed Temporal execution, secrets, and HTTPS MCP endpoints.
uvx mcp-agent login
uvx mcp-agent deploy my-agent
uvx mcp-agent cloud apps list
Docs: Cloud overview • Deployment quickstart • Examples: examples/cloud.
Browse gallery.md for runnable examples, demo videos, and community projects grouped by concept. Every entry cites the docs page and command you need to run it locally.
mcp-agent provides a streamlined approach to building AI agents using capabilities exposed by MCP (Model Context Protocol) servers.
MCP is quite low-level, and this framework handles the mechanics of connecting to servers, working with LLMs, handling external signals (like human input) and supporting persistent state via durable execution. That lets you, the developer, focus on the core business logic of your AI application.
Core benefits:
if statements. For cycles, use while loops.No, you can use mcp-agent anywhere, since it handles MCPClient creation for you. This allows you to leverage MCP servers outside of MCP hosts like Claude Desktop.
Here's all the ways you can set up your mcp-agent application:
You can expose mcp-agent applications as MCP servers themselves (see example), allowing MCP clients to interface with sophisticated AI workflows using the standard tools API of MCP servers. This is effectively a server-of-servers.
You can embed mcp-agent in an MCP client directly to manage the orchestration across multiple MCP servers.
You can use mcp-agent applications in a standalone fashion (i.e. they aren't part of an MCP client). The examples are all standalone applications.
Run uvx mcp-agent deploy <app-name> after logging in with uvx mcp-agent login. The CLI packages your project, provisions secrets, and exposes an MCP endpoint backed by a durable Temporal runtime. See the [Cloud quickstart](https://docs.mcp-agent.com/get-started/
cloud) for step-by-step screenshots and CLI output.
Every class, decorator, and CLI command is documented on docs.mcp-agent.com. The API reference and the llms-full.txt are designed so LLMs (or you) can ingest the whole surface area easily.
I debated naming this project silsila (سلسلہ), which means chain of events in Urdu. mcp-agent is more matter-of-fact, but there's still an easter egg in the project paying homage to silsila.
We welcome contributions of every size—bug fixes, new examples, docs, or feature requests. Start with CONTRIBUTING.md, open a discussion, or drop by Discord.
mcp-agent would not be possible without the tireless efforts of the many open source contributors. Thank you!
| Generate plans and coordinate worker agents. |
| Planner |
| Deep research | create_deep_orchestrator(...) | Long-horizon research with knowledge extraction and policy checks. | Deep research |
| Evaluator-optimizer | create_evaluator_optimizer_llm(...) | Iterate until an evaluator approves the result. | Evaluator-optimizer |
| Swarm | create_swarm(...) | Multi-agent handoffs compatible with OpenAI Swarm. | Swarm |