tools = [
    {
        "name": "get_weather",
        "description": "Obtenir la meteo actuelle d'une ville. Utiliser quand l'utilisateur demande la temperature, les conditions meteo ou les previsions.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Le nom de la ville (ex: Paris, Lyon, New York)"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Unite de temperature"
                }
            },
            "required": ["city"]
        }
    }
]

import anthropic
import json

client = anthropic.Anthropic()

# Definir les outils
tools = [{
    "name": "search_database",
    "description": "Recherche dans la base de donnees clients",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "Terme de recherche"},
            "limit": {"type": "integer", "description": "Nombre max de resultats"}
        },
        "required": ["query"]
    }
}]

# Fonction qui execute l'outil
def execute_tool(name, inputs):
    if name == "search_database":
        # Votre logique ici (requete DB, API call, etc.)
        return json.dumps({"results": [{"id": 1, "name": "Client A"}]})
    return json.dumps({"error": f"Outil inconnu: {name}"})

# Boucle conversationnelle avec outils
messages = [{"role": "user", "content": "Trouve le client A dans la base"}]

while True:
    response = client.messages.create(
        model="claude-sonnet-4-5-20250929",
        max_tokens=1024,
        tools=tools,
        messages=messages
    )

    # Si Claude a fini de repondre
    if response.stop_reason == "end_turn":
        print("Reponse:", response.content[0].text)
        break

    # Si Claude veut utiliser un outil
    if response.stop_reason == "tool_use":
        # Ajouter la reponse de Claude a l'historique
        messages.append({"role": "assistant", "content": response.content})

        # Executer chaque outil demande
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                print(f"Outil: {block.name}({block.input})")
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result
                })

        # Renvoyer les resultats a Claude
        messages.append({"role": "user", "content": tool_results})

# En cas d'erreur d'execution
tool_results.append({
    "type": "tool_result",
    "tool_use_id": block.id,
    "content": "Erreur: base de donnees indisponible",
    "is_error": True  # Claude saura que c'est une erreur
})

# La reponse de Claude peut contenir multiple tool_use blocks:
# response.content = [
#   TextBlock("Je vais chercher les deux..."),
#   ToolUseBlock(name="get_weather", input={"city": "Paris"}),
#   ToolUseBlock(name="get_weather", input={"city": "Lyon"})
# ]

# Vous DEVEZ renvoyer ALL tool_results:
tool_results = []
for block in response.content:
    if block.type == "tool_use":
        result = execute_tool(block.name, block.input)
        tool_results.append({
            "type": "tool_result",
            "tool_use_id": block.id,
            "content": result
        })

# Etape 1 : Router avec Haiku (rapide + pas cher)
router_response = client.messages.create(
    model="claude-haiku-4-5-20251001",
    max_tokens=50,
    system="Classifie la question: database, api, file, calculation. Reponds UNIQUEMENT le mot.",
    messages=[{"role": "user", "content": user_question}]
)
category = router_response.content[0].text.strip()

# Etape 2 : Selectionner les outils pertinents
tool_sets = {
    "database": [query_tool, schema_tool],
    "api": [http_get_tool, http_post_tool],
    "file": [read_file_tool, write_file_tool],
    "calculation": [calculator_tool, chart_tool]
}
selected_tools = tool_sets.get(category, all_tools)

# Etape 3 : Appeler Sonnet avec outils cibles
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=2048,
    tools=selected_tools,  # Seulement 2-3 outils
    messages=[{"role": "user", "content": user_question}]
)

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=4096,
    tools=[
        {
            "type": "computer_20241022",
            "name": "computer",
            "display_width_px": 1920,
            "display_height_px": 1080
        }
    ],
    messages=[{
        "role": "user",
        "content": "Ouvre le navigateur et va sur docs.anthropic.com"
    }]
)

# Claude repondra avec des actions:
# - screenshot: prendre une capture d'ecran
# - click: cliquer a des coordonnees (x, y)
# - type: taper du texte
# - key: appuyer sur une touche
# - scroll: scroller

1. INITIALIZATION
   Client ──► initialize(capabilities) ──► Server
   Client ◄── initialize_response     ◄── Server
   Client ──► initialized()           ──► Server

2. OPERATION (boucle)
   Client ──► tools/list             ──► Server
   Client ◄── tools: [...]           ◄── Server
   Client ──► tools/call(name, args) ──► Server
   Client ◄── result                 ◄── Server

3. SHUTDOWN
   Client ──► shutdown/close         ──► Server

{
  "jsonrpc": "2.0",
  "method": "initialize",
  "params": {
    "protocolVersion": "2024-11-05",
    "clientInfo": {
      "name": "claude-code",
      "version": "1.0.0"
    },
    "capabilities": {
      "sampling": {},
      "roots": { "listChanged": true }
    }
  }
}

# Installation du SDK
pip install mcp

# Ou avec les extras pour le serveur HTTP
pip install "mcp[cli]"

# Verifier l'installation
python -c "import mcp; print(mcp.__version__)"

from mcp.server.fastmcp import FastMCP

# Creer le serveur
mcp = FastMCP("mon-serveur")

# Definir un tool
@mcp.tool()
def calculer_prix(
    prix_ht: float,
    tva: float = 20.0
) -> str:
    """Calcule le prix TTC a partir du prix HT et du taux de TVA."""
    ttc = prix_ht * (1 + tva / 100)
    return f"Prix TTC : {ttc:.2f} EUR (TVA {tva}%)"

# Definir une resource
@mcp.resource("config://taux-tva")
def get_taux_tva() -> str:
    """Retourne les taux de TVA en vigueur."""
    return """
    Taux normal : 20%
    Taux intermediaire : 10%
    Taux reduit : 5.5%
    Taux super-reduit : 2.1%
    """

# Definir un prompt template
@mcp.prompt()
def analyser_facture(contenu: str) -> str:
    """Analyse une facture et extrait les informations cles."""
    return f"Analyse cette facture et extrait : montant HT, TVA, TTC, date, fournisseur.\n\nFacture:\n{contenu}"

# Lancer le serveur
if __name__ == "__main__":
    mcp.run(transport="stdio")

import json
from datetime import datetime

@mcp.resource("data://clients/{client_id}")
def get_client(client_id: str) -> str:
    """Recupere les informations d'un client par son ID."""
    # Simuler une base de donnees
    clients = {
        "C001": {"nom": "Acme Corp", "ca": 150000},
        "C002": {"nom": "TechStart", "ca": 45000},
    }
    client = clients.get(client_id, {"error": "Client non trouve"})
    return json.dumps(client, ensure_ascii=False, indent=2)

@mcp.resource("data://stats/today")
def get_stats_today() -> str:
    """Statistiques du jour."""
    return json.dumps({
        "date": datetime.now().isoformat(),
        "commandes": 42,
        "ca_jour": 12500.00
    }, indent=2)

{
  "mcpServers": {
    "mon-serveur": {
      "command": "python",
      "args": ["chemin/vers/serveur.py"],
      "env": {
        "API_KEY": "votre-cle"
      }
    }
  }
}

# Lancer l'Inspector
npx @modelcontextprotocol/inspector python serveur.py

# Ouvre un navigateur a http://localhost:5173
# Vous pouvez tester tools, resources et prompts visuellement

# Initialiser le projet
mkdir mon-mcp-server && cd mon-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node

# tsconfig.json
npx tsc --init --target es2022 --module nodenext \
  --moduleResolution nodenext --outDir dist

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// Creer le serveur
const server = new McpServer({
  name: "analyse-code",
  version: "1.0.0",
});

// Definir un tool avec schema Zod
server.tool(
  "analyser_complexite",
  "Analyse la complexite cyclomatique d'un fichier",
  {
    code: z.string().describe("Le code source a analyser"),
    langage: z.enum(["python", "javascript", "typescript"])
      .describe("Le langage du code"),
  },
  async ({ code, langage }) => {
    // Compter les points de decision
    const patterns = {
      python: /\b(if|elif|for|while|except|and|or)\b/g,
      javascript: /\b(if|else if|for|while|catch|&&|\|\|)\b/g,
      typescript: /\b(if|else if|for|while|catch|&&|\|\|)\b/g,
    };
    const matches = code.match(patterns[langage]) || [];
    const complexity = matches.length + 1;

    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          complexite: complexity,
          niveau: complexity <= 5 ? "Simple" :
                  complexity <= 10 ? "Moderee" : "Elevee",
          points_decision: matches.length,
        }, null, 2),
      }],
    };
  }
);

// Definir une resource
server.resource(
  "docs://bonnes-pratiques",
  "bonnes-pratiques://guide",
  async (uri) => ({
    contents: [{
      uri: uri.href,
      mimeType: "text/markdown",
      text: "# Bonnes pratiques\n- Max 10 de complexite\n..."
    }],
  })
);

// Lancer avec transport stdio
const transport = new StdioServerTransport();
await server.connect(transport);

// Dans .claude/settings.json ou via CLI
{
  "mcpServers": {
    "analyse-code": {
      "command": "node",
      "args": ["dist/index.js"],
      "cwd": "/chemin/vers/projet"
    }
  }
}

# Serveur GitHub via npx (aucune installation permanente)
npx -y @modelcontextprotocol/server-github

# Serveur Filesystem
npx -y @modelcontextprotocol/server-filesystem /chemin/autorise

# Serveur PostgreSQL
npx -y @modelcontextprotocol/server-postgres \
  "postgresql://user:pass@localhost/mydb"

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem",
               "/Users/dev/projects"],
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "ghp_xxx" }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://user:pass@localhost/analytics"]
    }
  }
}

# Methode 1 : via la commande claude
claude mcp add mon-serveur -- python serveur.py
claude mcp add github -- npx -y @modelcontextprotocol/server-github

# Methode 2 : via le fichier de configuration
# Editer .claude/settings.json

# Lister les serveurs configures
claude mcp list

# Tester un serveur
claude mcp test mon-serveur

{
  "mcpServers": {
    "project-db": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://localhost/monprojet"],
      "env": {}
    },
    "project-files": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
      "env": {}
    }
  }
}

$ claude

> Montre-moi les tables de la base de donnees
  # Claude utilise automatiquement le tool MCP "query" du serveur postgres
  # Resultat : liste des tables avec schemas

> Quelles sont les issues ouvertes sur ce repo ?
  # Claude utilise le tool MCP "list_issues" du serveur GitHub
  # Resultat : liste des issues

> Cree une migration SQL pour ajouter un champ email a la table users
  # Claude combine : lecture schema (MCP postgres) + ecriture fichier (natif)
  # Resultat : fichier migration cree

# Voir les logs de connexion MCP
claude --mcp-debug

# Tester la connexion a un serveur specifique
claude mcp test mon-serveur

# Inspector pour debug detaille
npx @modelcontextprotocol/inspector python serveur.py

# Installation globale
npm install -g @anthropic-ai/claude-code

# Verifier l'installation
claude --version

# Premier lancement (authentification requise)
claude

# Lancer en mode non-interactif
claude -p "Explique ce projet"

# Mon Projet

## Stack technique
- Frontend : React 18 + TypeScript
- Backend : FastAPI + PostgreSQL
- Tests : pytest + vitest

## Conventions
- Utiliser snake_case pour Python, camelCase pour TypeScript
- Toujours ecrire des tests pour les nouvelles fonctionnalites
- Commits en francais au format : "type: description"

## Architecture
- /src/api : Routes FastAPI
- /src/models : Models SQLAlchemy
- /src/frontend : Application React
- /tests : Tests unitaires et integration

## Commandes utiles
- `make test` : Lancer les tests
- `make lint` : Verifier le code
- `make dev` : Lancer en developpement

Vous : "Refactore le module auth et mets a jour les tests"

Claude Code (agent principal) :
├── Lance Explore agent : "Trouve tous les fichiers auth"
├── Lance Explore agent : "Trouve tous les tests lies a auth"
│   (ces 2 agents s'executent en PARALLELE)
│
├── Recoit les resultats des 2 agents
├── Planifie les modifications
│
├── Edite les fichiers auth (sequentiellement)
├── Edite les fichiers tests (sequentiellement)
│
├── Lance Bash agent : "npm test" (verification)
└── Presente le resultat

$ claude

> Ajoute l'authentification JWT a l'API

Claude entre en mode plan...
  - Explore la structure du projet
  - Identifie les fichiers de routes existants
  - Analyse les dependances actuelles

Plan propose :
  1. Installer pyjwt et python-dotenv
  2. Creer src/auth/jwt_handler.py
  3. Creer src/auth/middleware.py
  4. Modifier src/api/routes.py pour proteger les endpoints
  5. Ajouter les tests dans tests/test_auth.py
  6. Mettre a jour .env.example

Approuvez-vous ce plan ? [Y/n]

{
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm test)",
      "Bash(npm run lint)",
      "Bash(git status)",
      "Bash(git diff)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(git push --force)",
      "Bash(docker rm)"
    ]
  }
}

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "echo 'Modification de fichier detectee'"
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "npm run lint --fix $(cat $CLAUDE_TOOL_INPUT | jq -r '.file_path')"
      }
    ],
    "Notification": [
      {
        "matcher": "",
        "command": "notify-send 'Claude Code' '$CLAUDE_NOTIFICATION'"
      }
    ]
  }
}

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # Budget pour la reflexion
    },
    messages=[{
        "role": "user",
        "content": "Analyse cette architecture microservices et identifie "
                   "les points de defaillance potentiels..."
    }]
)

# La reponse contient 2 types de blocs
for block in response.content:
    if block.type == "thinking":
        print("REFLEXION:", block.thinking)  # Processus interne
    elif block.type == "text":
        print("REPONSE:", block.text)        # Reponse finale

import anthropic

client = anthropic.Anthropic()

# Niveau bas : verification rapide
response_quick = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=8000,
    thinking={
        "type": "enabled",
        "budget_tokens": 2000  # ~low
    },
    messages=[{"role": "user", "content": "Ce code a-t-il un bug ?"}]
)

# Niveau haut : analyse approfondie
response_deep = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 25000  # ~high
    },
    messages=[{"role": "user", "content": "Concois une architecture de cache distribue..."}]
)

def get_thinking_budget(task_type: str, complexity: str) -> int:
    """Determine le budget de thinking optimal."""
    budgets = {
        ("chat", "simple"): 0,       # Pas de thinking
        ("chat", "complex"): 3000,    # Low
        ("code", "simple"): 2000,     # Low
        ("code", "complex"): 10000,   # Medium-High
        ("architecture", "simple"): 5000,   # Medium
        ("architecture", "complex"): 25000, # High
        ("math", "simple"): 5000,     # Medium
        ("math", "complex"): 50000,   # Max
    }
    return budgets.get((task_type, complexity), 5000)

# Usage
budget = get_thinking_budget("architecture", "complex")
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": budget},
    messages=[{"role": "user", "content": prompt}]
)

# Mode rapide (thinking reduit)
# Commande /fast dans la session Claude Code

# Mode par defaut (thinking adaptatif)
claude

# Choix du modele pour plus de reflexion
# /model opus dans la session pour utiliser Opus 4.6

import anthropic

client = anthropic.Anthropic()

# Definir le Think Tool
think_tool = {
    "name": "think",
    "description": (
        "Utilisez cet outil pour reflechir sur un probleme. "
        "Appelez-le quand vous devez analyser des informations "
        "recueillies, planifier vos prochaines actions, ou "
        "verifier votre raisonnement. Le contenu n'est pas "
        "visible par l'utilisateur."
    ),
    "input_schema": {
        "type": "object",
        "properties": {
            "thought": {
                "type": "string",
                "description": "Votre reflexion interne"
            }
        },
        "required": ["thought"]
    }
}

# Boucle agentique avec Think Tool
def agent_loop(user_query, other_tools):
    tools = [think_tool] + other_tools
    messages = [{"role": "user", "content": user_query}]

    while True:
        response = client.messages.create(
            model="claude-sonnet-4-5-20250929",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

        if response.stop_reason == "end_turn":
            # Claude a termine, extraire la reponse finale
            return [b.text for b in response.content if b.type == "text"]

        # Traiter les appels d'outils
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                if block.name == "think":
                    # Think Tool : pas d'execution, juste retourner OK
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": "Reflexion enregistree."
                    })
                else:
                    # Executer les vrais outils
                    result = execute_tool(block.name, block.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result
                    })

        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": tool_results})

Agent recoit : "Trouve et corrige le bug dans le module de paiement"

  1. tool_use: search_files("paiement")
     → Resultat : 5 fichiers trouves

  2. tool_use: think({
       thought: "J'ai trouve 5 fichiers lies au paiement :
       payment.py, payment_api.py, payment_test.py,
       payment_models.py, payment_utils.py.
       Les bugs sont souvent dans la logique metier
       (payment.py) ou les appels API (payment_api.py).
       Je vais commencer par lire ces deux fichiers."
     })

  3. tool_use: read_file("payment.py")
  4. tool_use: read_file("payment_api.py")
     → Resultats recus

  5. tool_use: think({
       thought: "J'ai identifie le probleme dans payment.py
       ligne 42 : la conversion de devise utilise une
       division au lieu d'une multiplication. Cela
       explique les montants incorrects signales.
       Je vais corriger et verifier avec un test."
     })

  6. tool_use: edit_file("payment.py", ...)
  7. tool_use: run_tests("payment_test.py")