Cheatsheet Phase 2 - Outils Avances & MCP

{
  "name": "get_weather",
  "description": "Obtenir la meteo d'une ville",
  "input_schema": {
    "type": "object",
    "properties": {
      "city": {
        "type": "string",
        "description": "Nom de la ville"
      }
    },
    "required": ["city"]
  }
}

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    tools=[weather_tool],  # Liste d'outils
    messages=[{"role": "user",
      "content": "Meteo a Paris?"}]
)

# Claude repond avec stop_reason="tool_use"
# content[0].type == "tool_use"
# content[0].name == "get_weather"
# content[0].input == {"city": "Paris"}

# 1. User question
# 2. Claude → tool_use (veut appeler un outil)
# 3. Vous executez l'outil
# 4. Vous renvoyez tool_result
# 5. Claude genere la reponse finale

messages.append({"role": "assistant",
  "content": response.content})
messages.append({"role": "user",
  "content": [{
    "type": "tool_result",
    "tool_use_id": tool_block.id,
    "content": "22°C, ensoleille"
  }]
})

Claude peut appeler plusieurs outils en parallele dans une seule reponse :

# response.content peut contenir :
[
  {"type": "tool_use", "name": "get_weather",
   "input": {"city": "Paris"}},
  {"type": "tool_use", "name": "get_weather",
   "input": {"city": "Lyon"}}
]
# Renvoyez TOUS les tool_results

Claude peut controler un ordinateur : ecran, clavier, souris.

tools=[
  {"type": "computer_20241022",
   "name": "computer",
   "display_width_px": 1920,
   "display_height_px": 1080}
]
# Actions: click, type, screenshot,
# scroll, key, cursor_position

┌──────────┐    ┌──────────┐    ┌──────────┐
│  Claude   │    │   MCP    │    │ External │
│  (Client) │◄──►│  Server  │◄──►│ Service  │
└──────────┘    └──────────┘    └──────────┘
  JSON-RPC       Resources       Database
  stdio/HTTP     Tools           API
                 Prompts         Files

3 primitives MCP: Resources (donnees), Tools (actions), Prompts (templates)

from mcp.server import Server
from mcp.types import Tool

app = Server("my-server")

@app.tool()
async def query_db(sql: str) -> str:
    """Execute une requete SQL"""
    result = await db.execute(sql)
    return str(result)

@app.resource("schema://tables")
async def get_schema() -> str:
    """Retourne le schema DB"""
    return schema_text

# Lancer: python server.py

import { Server } from "@modelcontextprotocol/sdk/server";

const server = new Server({
  name: "my-server",
  version: "1.0.0"
});

server.setRequestHandler(
  ListToolsRequestSchema,
  async () => ({
    tools: [{
      name: "search",
      description: "Search docs",
      inputSchema: { /* JSON Schema */ }
    }]
  })
);

// .mcp.json (racine du projet)
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost/mydb"
      ]
    },
    "github": {
      "command": "npx",
      "args": [
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_TOKEN": "ghp_..."
      }
    }
  }
}

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

# Lancer dans un projet
claude

# Commandes slash
/help          # Aide
/clear         # Effacer contexte
/compact       # Compresser contexte
/cost          # Voir les couts
/model         # Changer modele
/permissions   # Gerer permissions
/mcp           # Gerer serveurs MCP

# Mode non-interactif
claude -p "Explique ce code" file.py
echo "Fix le bug" | claude

# .claude/CLAUDE.md (racine projet)

# Instructions Projet

## Regles
- Utiliser TypeScript strict
- Tests pour chaque fonction
- Pas de console.log en production

## Architecture
- /src/controllers - API routes
- /src/services - Business logic
- /src/models - Data models

## Conventions
- camelCase pour variables
- PascalCase pour classes
- kebab-case pour fichiers

Claude Code lance des sous-agents pour paralleliser :

• Task tool - Lance un agent pour une tache
• 7 agents max en parallele
• Types: Bash, Explore, Plan, general-purpose

# Claude Code decide automatiquement
# d'utiliser des subagents quand:
# - Recherche multi-fichiers
# - Taches independantes
# - Exploration large codebase

// .claude/settings.json
{
  "hooks": {
    "pre-tool-use": [
      {"command": "lint-check.sh",
       "tools": ["Write", "Edit"]}
    ],
    "post-tool-use": [
      {"command": "format.sh",
       "tools": ["Write"]}
    ]
  }
}

Events: pre-tool-use, post-tool-use, notification, stop

response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    messages=[{"role": "user",
      "content": "Probleme complexe..."}]
)

# response.content peut contenir:
# [{"type":"thinking","thinking":"..."},
#  {"type":"text","text":"..."}]

thinking={
    "type": "enabled",
    "budget_tokens": 5000  # ou adaptive
}

Outil special pour les boucles agentiques :

tools=[
  {"name": "think",
   "description": "Reflechir avant d'agir",
   "input_schema": {
     "type": "object",
     "properties": {
       "thought": {"type": "string"}
     }
   }}
]
# Claude "reflechit" dans un outil
# avant de choisir le prochain outil

while True:
    response = client.messages.create(
        model=model, max_tokens=4096,
        tools=tools, messages=messages)

    if response.stop_reason == "end_turn":
        break  # Fini

    # Executer les outils demandes
    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
            })

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

# Lancer en mode auto-edit
claude --allowedTools "Edit,Write,Glob,Grep,Read"

# Mode full-auto (dangereux)
claude --dangerously-skip-permissions