Model Context Protocol est le standard ouvert publie par Anthropic en novembre 2024 pour unifier la decouverte et l invocation des capacites externes par les clients IA. L idee : un Server, connexion depuis Claude Desktop, Cursor ou tout client MCP — changer de LLM sans reecrire la couche outils.

┌────────────────────┐         ┌─────────────────────┐
│   MCP Client       │ ◄─────► │   MCP Server        │
│  (Claude / Cursor) │  JSON   │  (vous construisez) │
│                    │  -RPC   │                     │
└────────────────────┘         └─────────────────────┘
                                        │
                          ┌─────────────┼─────────────┐
                          ▼             ▼             ▼
                       Tools       Resources      Prompts
                    (actions)     (lecture data) (modeles)

Format wire : JSON-RPC 2.0. Cycle de vie : handshake initialize → negociation des capacites → boucle request/response → arret propre. Deux modes de transport dominent : stdio (sous-processus local, zero dependance reseau) et HTTP + SSE (distant, multi-client, partage en equipe).

Un MCP Server operationnel en moins de dix minutes. Python avec FastMCP est le parcours recommande ; TypeScript reflete les memes concepts avec @modelcontextprotocol/sdk.

python -m venv .venv
source .venv/bin/activate
pip install mcp

npm init -y
npm install @modelcontextprotocol/sdk

Structure de projet recommandee :

my-mcp-server/
├── server.py
├── tools/
│   ├── calculator.py
│   └── web_search.py
├── resources/
│   └── file_reader.py
├── prompts/
│   └── templates.py
├── tests/
│   └── test_tools.py
└── pyproject.toml

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-first-server")

@mcp.tool()
def say_hello(name: str) -> str:
    return f"Hello, {name}! This is your first MCP tool."

if __name__ == "__main__":
    mcp.run()

Lancer et verifier avec le MCP Inspector officiel :

python server.py
npx @modelcontextprotocol/inspector python server.py

Connexion clients : ajouter la commande de lancement dans Claude Desktop claude_desktop_config.json ou pointer Cursor mcp.json vers la meme commande. Apres redemarrage, confirmer l outil dans la liste et tester un appel.

Un Server de production enregistre des Tools pour les actions, des Resources pour les donnees lisibles et des Prompts pour les modeles reutilisables. Signatures et docstrings deviennent la documentation IA — pas besoin d OpenAPI separe.

Structure Tool : nom depuis la fonction, parametres depuis les type hints, description depuis la docstring. Modeles Pydantic pour inputs complexes :

from pydantic import BaseModel, Field

class SearchInput(BaseModel):
    query: str = Field(description="Search keywords")
    max_results: int = Field(default=5, description="Max results")
    language: str = Field(default="en", description="Result language")

@mcp.tool()
def web_search(input: SearchInput) -> list[dict]:
    ...

import httpx

@mcp.tool()
async def fetch_url(url: str) -> str:
    async with httpx.AsyncClient(timeout=30.0) as client:
        response = await client.get(url)
        response.raise_for_status()
        return response.text

Gestion des erreurs : dicts d erreur structures pour echecs recoverable ; raise seulement pour etats irrecoverable. Timeouts sur les outils I/O. Valider les permissions avant filesystem ou base de donnees.

Resources different des Tools : Resources fournissent des donnees via URI, Tools executent des actions. Resources statiques avec URIs fixes ; dynamiques avec parametres de chemin.

@mcp.resource("config://app-settings")
def get_app_settings() -> str:
    return json.dumps({"version": "1.0", "env": "production"})

@mcp.resource("user://{user_id}/profile")
def get_user_profile(user_id: str) -> str:
    user = db.query_user(user_id)
    return json.dumps(user)

Un Server Resource filesystem liste repertoires, lit fichiers et peut s abonner aux changements. Prompts fournissent des modeles de conversation avec injection dynamique de parametres :

from mcp.types import PromptMessage, TextContent

@mcp.prompt()
def code_review_prompt(language: str, code: str) -> list[PromptMessage]:
    return [
        PromptMessage(
            role="user",
            content=TextContent(
                type="text",
                text=f"Review this {language} code for bugs, security, and performance:\n```{language}\n{code}\n```"
            )
        )
    ]

Les Prompts multi-tours melangent roles user et assistant — utiles pour simulations d interview, walkthroughs debug et onboarding avec structure constante.

STDIO local couvre le dev ; deployments partages ou SaaS exigent HTTP + SSE. FastMCP supporte streamable-http avec changement minimal.

mcp = FastMCP("remote-server", transport="streamable-http")

if __name__ == "__main__":
    mcp.run(host="0.0.0.0", port=8000)

Servers HTTP production exigent auth et garde-fous : middleware Bearer Token ou API Key, CORS restreint aux origines clients connues, rate limiting sur endpoints outils touchant APIs externes ou bases de donnees. Equipes UE : evaluer le flux de donnees vers les serveurs cloud.

MCP Inspector reste l UI de debug principale : lancer contre la commande Server, appeler Tools interactivement, inspecter paires JSON-RPC request/response, simuler chemins d erreur avant connexion client.

import pytest
from mcp.client.session import ClientSession
from mcp.client.stdio import StdioServerParameters, stdio_client

@pytest.mark.asyncio
async def test_calculator_tool():
    server_params = StdioServerParameters(
        command="python",
        args=["server.py"]
    )
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            result = await session.call_tool("calculate", {"expression": "2 + 2"})
            assert result.content[0].text == "4"

Passer de Hello World a la production : containerisation, observabilite, negociation de version et projet reference qui demontre la valeur. Capstone : MCP Server base de connaissances personnelle — recherche semantique sur notes Markdown locales dans Cursor.

Options de deploiement : Docker isole les deps Python. Railway et Render offrent deploys one-click. AWS Lambda et Google Cloud Run pour workloads serverless burst. VPS self-hosted plus Nginx reverse proxy pour equipes avec infra existante. Logging structure, metriques Prometheus sur appels outils, Sentry pour alertes, endpoint /health. Declarer version protocole MCP et negocier capacites au handshake pour degradation gracieuse.

Projet base de connaissances : indexer Markdown local avec ChromaDB ou Qdrant, embed avec text-embedding-3-small, surveiller changements via watchfiles. Trois Tools — indexer notes, recherche semantique, ecrire/updater note — plus Resource listant fichiers indexes. Dans Cursor, demander « Qu ai-je ecrit sur MCP la semaine derniere ? » — l Agent appelle votre outil search.

En 2026 tous les grands clients IA livrent le support MCP natif. Les marketplaces listent des milliers de Servers ; l adoption entreprise pousse OAuth 2.0 et audits de securite. Prochaines etapes : spec complete sur modelcontextprotocol.io, publier votre premier Server, combiner MCP avec Agent Skills.

Comparer les alternatives honnementement. HTTP+SSE sur MacBook principal casse a la fermeture du capot et aux mises a jour OS. Serverless sans affinite session perd le contexte Agent multi-etapes. Endpoints MCP sans auth invitent injection de prompt et appels outils non autorises — environ 1 000 Servers non proteges indexes en audits 2026. Pour equipes avec Apple Silicon, disponibilite 24/7 et isolation entre MCP Server, iOS CI et Agent Gateway, louer un Mac Mini M4 ou M4 Pro KVMNODE dedie est souvent la meilleure reponse : tarifs jour/week/mois flexibles, processus launchd, rollback snapshot. Comparez sur la page tarifs, details dans le centre d aide, provisionnement via commander quand votre stack MCP a besoin d un host qui reste en ligne apres fermeture du laptop.