mcp-agent MCP — Cas d'usage, Installer & Démo en direct

Pourquoi l'utiliser

Fonctionnalités clés

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

Démo en direct

Aperçu en pratique

mcp-agent.replay ▶ prêt

0/0

Installer

Choisissez votre client

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

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

Ouvrez Claude Desktop → Settings → Developer → Edit Config. Redémarrez après avoir enregistré.

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

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

Cursor utilise le même schéma mcpServers que Claude Desktop. La config projet l'emporte sur la globale.

VS Code → Cline → MCP Servers → Edit

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

Cliquez sur l'icône MCP Servers dans la barre latérale Cline, puis "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

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

Même format que Claude Desktop. Redémarrez Windsurf pour appliquer.

~/.continue/config.json

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

Continue utilise un tableau d'objets serveur plutôt qu'une map.

~/.config/zed/settings.json

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

Ajoutez dans context_servers. Zed recharge à chaud à la sauvegarde.

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

Une seule ligne. Vérifiez avec claude mcp list. Supprimez avec claude mcp remove.

Cas d'usage

Usages concrets : mcp-agent

Build an orchestrator-workers agent for research tasks

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

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

Prérequis

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

Déroulement

Define worker agents

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

→ Two Agent instances
Wire the orchestrator

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

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

→ 5 files generated with coherent content

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

Pièges

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

Combiner avec : mcp-use · fastmcp

Build an evaluator-optimizer agent for high-quality writing

👤 Teams shipping content pipelines ⏱ ~45 min advanced

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

Déroulement

Define the writer and evaluator

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

→ Two agents defined
Set the loop

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

→ 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?✓ Copié

→ Stats with outliers identified

Résultat : Consistent-quality output without human review in the loop.

Pièges

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

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

Prérequis

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

Déroulement

Annotate workflows

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

→ Workflow registered with Temporal
Switch the executor

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

→ 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.✓ Copié

→ No duplicate work, no lost state

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

Pièges

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

Combinaisons

Associez-le à d'autres MCPs pour un effet X10

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.✓ Copié

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.✓ Copié

Outils

Ce que ce MCP expose

Outil	Entrées	Quand appeler	Coût
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

Coût et limites

Coût d'exécution

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

Sécurité

Permissions, secrets, portée

Stockage des identifiants : env vars for LLM keys + per-MCP secrets

Sortie de données : LLM provider + each configured MCP server + Temporal (if enabled)

Dépannage

Erreurs courantes et correctifs

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 autres

Alternative	Quand l'utiliser	Compromis
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

Plus

Ressources

📖 Lire le README officiel sur GitHub

🐙 Voir les issues ouvertes

🔍 Parcourir les 400+ serveurs MCP et Skills