mcp-agent MCP — Use Cases, Install & Live Demo

Why use it

Key features

Pattern library: Orchestrator, Router, Evaluator, Swarm, Parallel, Deep Research
Durable workflows via Temporal (same code, just change executor)
MCPApp lifecycle manages server connections cleanly
Decorators: @app.workflow, @app.tool, @app.workflow_task

Live Demo

What it looks like in practice

mcp-agent.replay ▶ ready

0/0

Install

Pick your client

~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "mcp-agent": {
      "command": "uvx",
      "args": [
        "mcp-agent"
      ]
    }
  }
}

Open Claude Desktop → Settings → Developer → Edit Config. Restart after saving.

~/.cursor/mcp.json · .cursor/mcp.json

{
  "mcpServers": {
    "mcp-agent": {
      "command": "uvx",
      "args": [
        "mcp-agent"
      ]
    }
  }
}

Cursor uses the same mcpServers schema as Claude Desktop. Project config wins over global.

VS Code → Cline → MCP Servers → Edit

{
  "mcpServers": {
    "mcp-agent": {
      "command": "uvx",
      "args": [
        "mcp-agent"
      ]
    }
  }
}

Click the MCP Servers icon in the Cline sidebar, then "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "mcp-agent": {
      "command": "uvx",
      "args": [
        "mcp-agent"
      ]
    }
  }
}

Same shape as Claude Desktop. Restart Windsurf to pick up changes.

~/.continue/config.json

{
  "mcpServers": [
    {
      "name": "mcp-agent",
      "command": "uvx",
      "args": [
        "mcp-agent"
      ]
    }
  ]
}

Continue uses an array of server objects rather than a map.

~/.config/zed/settings.json

{
  "context_servers": {
    "mcp-agent": {
      "command": {
        "path": "uvx",
        "args": [
          "mcp-agent"
        ]
      }
    }
  }
}

Add to context_servers. Zed hot-reloads on save.

claude mcp add mcp-agent -- uvx mcp-agent

One-liner. Verify with claude mcp list. Remove with claude mcp remove.

Use Cases

Real-world ways to use mcp-agent

Build an orchestrator-workers agent for research tasks

👤 Python devs building multi-step agents ⏱ ~60 min advanced

When to use: The task is too big for one LLM pass but decomposes into parallel subtasks (e.g., research 10 competitors).

Prerequisites

Python 3.10+ — standard
MCP servers you want the agent to use — List them in the mcp-agent config

Flow

Define worker agents

Create 2 Agents — scraper with the firecrawl server, writer with filesystem. Give each a focused instruction set.✓ Copied

→ Two Agent instances
Wire the orchestrator

Wrap them with create_orchestrator(planner_llm=..., workers=[scraper, writer]). Max iterations = 10.✓ Copied

→ Orchestrator returns plan + execution handle
Run a real task

Run: 'Research the 5 top-rated Postgres MCPs on GitHub. For each, write a 1-page summary to ./reports/<slug>.md.'✓ Copied

→ 5 files generated with coherent content

Outcome: A parallelized agent that completes what would be 30 min of manual multi-step work in 3-5 min.

Pitfalls

Orchestrator creates too many or too few subtasks — Give the planner LLM explicit guidance: 'break into 3-7 subtasks, each <5 minutes of work'
Workers re-fetch the same data — Share a cache via the app state or pass results explicitly through the plan

Combine with: mcp-use · fastmcp

Build an evaluator-optimizer agent for high-quality writing

👤 Teams shipping content pipelines ⏱ ~45 min advanced

When to use: First-draft LLM output is too sloppy for production. You need an automatic 'keep iterating until it passes' loop.

Flow

Define the writer and evaluator

Writer: produces a draft given a brief. Evaluator: scores on [accuracy, clarity, tone] 1-5, with rationale.✓ Copied

→ Two agents defined
Set the loop

Use EvaluatorOptimizer with min_rating=4 across all criteria, max_iterations=5. Pass brief as input.✓ Copied

→ Loop runs, iterations visible in logs
Observe convergence

For 10 diverse briefs, log: initial score, final score, iterations needed. Are there briefs that never converge?✓ Copied

→ Stats with outliers identified

Outcome: Consistent-quality output without human review in the loop.

Pitfalls

Evaluator is lenient, loop exits on iter 1 with mediocre output — Calibrate the evaluator — give it 3 example inputs with expected scores in the system prompt
Budget blows up when max_iterations is high — Cap at 3-4; if it doesn't converge by then, the brief is the problem, not the model

Make an agent workflow durable with Temporal

👤 Platform engineers running agents in production ⏱ ~90 min advanced

When to use: Your agent flow is long-running (minutes to hours), can't afford to restart from zero if a node dies.

Prerequisites

Running Temporal cluster — temporal server start-dev for local, Temporal Cloud or self-hosted for prod

Flow

Annotate workflows

Decorate my existing orchestrator function with @app.workflow and individual steps with @app.workflow_task.✓ Copied

→ Workflow registered with Temporal
Switch the executor

Change the app config executor: 'temporal'. Register the worker. Start a workflow.✓ Copied

→ Temporal UI shows the running workflow
Verify crash recovery

Kill the Python worker mid-workflow. Restart it. Confirm the workflow resumes from the last completed activity.✓ Copied

→ No duplicate work, no lost state

Outcome: Agent workflows survive process restarts, deploys, and OOMs — critical for hour-long research tasks.

Pitfalls

Activities aren't idempotent and resume causes double-writes — Every activity must be safe to retry — use idempotency keys on external writes

Combinations

Pair with other MCPs for X10 leverage

mcp-agent + mcp-use

mcp-use for client plumbing + mcp-agent for workflow patterns

Use mcp-use to connect filesystem + git. Wrap with mcp-agent's Orchestrator to plan a multi-repo refactor.✓ Copied

mcp-agent + fastmcp

Build custom MCPs with FastMCP that your mcp-agent workflows consume

Expose our internal ranking API via FastMCP, then use it in an mcp-agent Router that classifies customer questions.✓ Copied

Tools

What this MCP exposes

Tool	Inputs	When to call	Cost
MCPApp	config_path or config object	Top-level — one per process	free
Agent(name, instruction, server_names)	configured with which MCP servers it can use	Define each worker/role	free
AugmentedLLM.generate / generate_str / generate_structured	messages, optional schema	Direct LLM call with MCP tools wired	LLM tokens
create_parallel_llm / create_router_llm / create_orchestrator	agents + planner LLM	Instantiate one of the built-in patterns	LLM tokens × pattern fan-out
@app.workflow / @app.workflow_task	decorator on async function	When using Temporal executor	free
EvaluatorOptimizer	writer_agent, evaluator_agent, min_rating, max_iterations	Quality-critical outputs	expensive — cap max_iterations

Cost & Limits

What this costs to run

API quota: None from mcp-agent; LLM + MCP costs passthrough
Tokens per call: Patterns amplify — a Parallel with 5 workers is 5× the tokens of a single LLM call
Monetary: Free library; LLM + optional Temporal infra are real costs
Tip: Patterns like Orchestrator fan out — put an explicit token budget check in the planner LLM's system prompt

Security

Permissions, secrets, blast radius

Credential storage: env vars for LLM keys + per-MCP secrets

Data egress: LLM provider + each configured MCP server + Temporal (if enabled)

Troubleshooting

Common errors and fixes

Workflow hangs at start with no logs

MCP server failed to spawn. Enable debug logging: logger: {level: 'DEBUG'} in config. Usually a bad command/env in the server entry.

Orchestrator returns plan but no execution

You called .plan() instead of .generate(). Use the full method to execute the plan.

Temporal workflow fails with serialization error

Your activity returns a non-serializable object (e.g., an MCP client handle). Activities must return JSON-serializable values.

LLM ignores available tools and hallucinates

The system prompt is likely truncated or missing tool list. Upgrade to a tool-use-strong model (Sonnet, GPT-4o) and verify tools in list_tools before running.

Alternatives

mcp-agent vs others

Alternative	When to use it instead	Tradeoff
mcp-use	You want lighter client plumbing without the pattern library	Write orchestration code yourself
LangGraph	You want stateful graphs with time-travel debugging	More LangChain-centric; MCP is bolted on
CrewAI	You want opinionated role-based agent crews	Different mental model; MCP support is secondary

More

Resources

📖 Read the official README on GitHub

🐙 Browse open issues

🔍 Browse all 400+ MCP servers and Skills