mcp-agent MCP — Anwendungsfälle, Installieren & Live-Demo

Warum nutzen

Hauptfunktionen

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

In der Praxis

mcp-agent.replay ▶ bereit

0/0

Installieren

Wählen Sie Ihren Client

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

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

Öffne Claude Desktop → Settings → Developer → Edit Config. Nach dem Speichern neu starten.

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

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

Cursor nutzt das gleiche mcpServers-Schema wie Claude Desktop. Projektkonfiguration schlägt die globale.

VS Code → Cline → MCP Servers → Edit

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

Klicken Sie auf das MCP-Servers-Symbol in der Cline-Seitenleiste, dann "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

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

Gleiche Struktur wie Claude Desktop. Windsurf neu starten zum Übernehmen.

~/.continue/config.json

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

Continue nutzt ein Array von Serverobjekten statt einer Map.

~/.config/zed/settings.json

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

In context_servers hinzufügen. Zed lädt beim Speichern neu.

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

Einzeiler. Prüfen mit claude mcp list. Entfernen mit claude mcp remove.

Anwendungsfälle

Praxisnahe Nutzung: mcp-agent

Build an orchestrator-workers agent for research tasks

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

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

Voraussetzungen

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

Ablauf

Define worker agents

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

→ Two Agent instances
Wire the orchestrator

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

→ 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.'✓ Kopiert

→ 5 files generated with coherent content

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

Fallstricke

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

Kombinieren mit: mcp-use · fastmcp

Build an evaluator-optimizer agent for high-quality writing

👤 Teams shipping content pipelines ⏱ ~45 min advanced

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

Ablauf

Define the writer and evaluator

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

→ Two agents defined
Set the loop

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

→ 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?✓ Kopiert

→ Stats with outliers identified

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

Fallstricke

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

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

Voraussetzungen

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

Ablauf

Annotate workflows

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

→ Workflow registered with Temporal
Switch the executor

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

→ 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.✓ Kopiert

→ No duplicate work, no lost state

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

Fallstricke

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

Kombinationen

Mit anderen MCPs für 10-fache Wirkung

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.✓ Kopiert

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.✓ Kopiert

Werkzeuge

Was dieses MCP bereitstellt

Werkzeug	Eingaben	Wann aufrufen	Kosten
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

Kosten & Limits

Was der Betrieb kostet

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

Sicherheit

Rechte, Secrets, Reichweite

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

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

Fehlerbehebung

Häufige Fehler und Lösungen

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.

Alternativen

mcp-agent vs. andere

Alternative	Wann stattdessen	Kompromiss
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

Mehr

Ressourcen

📖 Offizielle README auf GitHub lesen

🐙 Offene Issues ansehen

🔍 Alle 400+ MCP-Server und Skills durchsuchen