MCP, Function Calling, Tool Use : le guide complet

Utilisateur → API OpenAI (avec définitions de fonctions)
                    ↓
            Le modèle choisit une fonction
                    ↓
            Retourne un JSON structuré
                    ↓
        Votre code exécute la fonction
                    ↓
        Résultat renvoyé au modèle
                    ↓
            Réponse finale à l'utilisateur

{
  "name": "get_weather",
  "description": "Récupère la météo actuelle pour une ville donnée",
  "parameters": {
    "type": "object",
    "properties": {
      "city": {
        "type": "string",
        "description": "Le nom de la ville (ex: Paris, Lyon)"
      },
      "unit": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "description": "L'unité de température"
      }
    },
    "required": ["city"]
  }
}

import openai
import json

client = openai.OpenAI()

# Définir les fonctions disponibles
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Récupère la météo pour une ville",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["city"]
            }
        }
    }
]

# Fonction réelle (votre logique)
def get_weather(city, unit="celsius"):
    # En production : appel à une API météo
    return {"city": city, "temperature": 18, "unit": unit, "condition": "nuageux"}

# Appel au modèle
messages = [{"role": "user", "content": "Quel temps fait-il à Paris ?"}]
response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

# Vérifier si le modèle veut appeler une fonction
message = response.choices[0].message
if message.tool_calls:
    for tool_call in message.tool_calls:
        func_name = tool_call.function.name
        func_args = json.loads(tool_call.function.arguments)

        # Exécuter la fonction
        result = get_weather(**func_args)

        # Renvoyer le résultat au modèle
        messages.append(message)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result)
        })

    # Obtenir la réponse finale
    final = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=tools
    )
    print(final.choices[0].message.content)

# Le modèle peut retourner plusieurs tool_calls
for tool_call in message.tool_calls:
    # Traiter chaque appel indépendamment
    ...

Utilisateur → API Anthropic (avec définitions d'outils)
                    ↓
            Claude choisit un outil
                    ↓
            Retourne un bloc tool_use dans le contenu
                    ↓
        Votre code exécute l'outil
                    ↓
        Résultat renvoyé via un message tool_result
                    ↓
            Réponse finale à l'utilisateur

{
  "name": "get_weather",
  "description": "Récupère la météo actuelle pour une ville donnée. Retourne la température et les conditions.",
  "input_schema": {
    "type": "object",
    "properties": {
      "city": {
        "type": "string",
        "description": "Le nom de la ville"
      },
      "unit": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "description": "L'unité de température souhaitée"
      }
    },
    "required": ["city"]
  }
}

import anthropic
import json

client = anthropic.Anthropic()

# Définir les outils
tools = [
    {
        "name": "get_weather",
        "description": "Récupère la météo pour une ville donnée",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
            },
            "required": ["city"]
        }
    }
]

def get_weather(city, unit="celsius"):
    return {"city": city, "temperature": 18, "unit": unit, "condition": "nuageux"}

# Premier appel
messages = [{"role": "user", "content": "Quel temps fait-il à Paris ?"}]
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=messages
)

# Vérifier le stop_reason
if response.stop_reason == "tool_use":
    # Extraire le bloc tool_use
    tool_block = next(b for b in response.content if b.type == "tool_use")

    # Exécuter l'outil
    result = get_weather(**tool_block.input)

    # Construire la conversation complète
    messages.append({"role": "assistant", "content": response.content})
    messages.append({
        "role": "user",
        "content": [
            {
                "type": "tool_result",
                "tool_use_id": tool_block.id,
                "content": json.dumps(result)
            }
        ]
    })

    # Obtenir la réponse finale
    final = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        tools=tools,
        messages=messages
    )
    print(final.content[0].text)

{
    "type": "tool_result",
    "tool_use_id": "toolu_abc123",
    "is_error": True,
    "content": "Erreur : ville non trouvée"
}

┌─────────────────────────────────┐
│          Application hôte        │
│  (Claude Desktop, IDE, Agent)    │
│                                  │
│  ┌──────────┐  ┌──────────┐     │
│  │ Client   │  │ Client   │     │
│  │ MCP #1   │  │ MCP #2   │     │
│  └────┬─────┘  └────┬─────┘     │
└───────┼──────────────┼───────────┘
        │              │
   ┌────▼─────┐  ┌────▼─────┐
   │ Serveur  │  │ Serveur  │
   │ MCP      │  │ MCP      │
   │ (Files)  │  │ (GitHub) │
   └──────────┘  └──────────┘

from mcp.server.fastmcp import FastMCP

# Créer un serveur MCP
mcp = FastMCP("weather-server")

@mcp.tool()
def get_weather(city: str, unit: str = "celsius") -> dict:
    """Récupère la météo actuelle pour une ville donnée.

    Args:
        city: Le nom de la ville (ex: Paris, Lyon)
        unit: L'unité de température (celsius ou fahrenheit)
    """
    # En production : appel à une vraie API
    return {
        "city": city,
        "temperature": 18,
        "unit": unit,
        "condition": "nuageux"
    }

@mcp.resource("weather://current/{city}")
def current_weather(city: str) -> str:
    """Ressource : météo actuelle d'une ville."""
    data = get_weather(city)
    return f"{data['city']}: {data['temperature']}°C, {data['condition']}"

@mcp.prompt()
def weather_report(city: str) -> str:
    """Génère un prompt pour un rapport météo détaillé."""
    return f"Génère un rapport météo complet pour {city} en incluant les prévisions sur 3 jours."

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

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

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

server.tool(
  "get_weather",
  "Récupère la météo pour une ville",
  {
    city: z.string().describe("Nom de la ville"),
    unit: z.enum(["celsius", "fahrenheit"]).optional()
  },
  async ({ city, unit = "celsius" }) => {
    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          city,
          temperature: 18,
          unit,
          condition: "nuageux"
        })
      }]
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

{
  "mcpServers": {
    "weather": {
      "command": "python",
      "args": ["/chemin/vers/weather_server.py"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxx"
      }
    }
  }
}

# Pseudo-code : un agent qui utilise MCP en interne
# mais communique via Function Calling ou Tool Use

class UniversalAgent:
    def __init__(self, mcp_servers, llm_provider):
        self.mcp_client = MCPClient(mcp_servers)
        self.llm = llm_provider  # "openai" ou "anthropic"

    def get_tools_for_llm(self):
        mcp_tools = self.mcp_client.list_tools()
        if self.llm == "openai":
            return convert_to_function_calling(mcp_tools)
        elif self.llm == "anthropic":
            return convert_to_tool_use(mcp_tools)

    async def run(self, user_message):
        tools = self.get_tools_for_llm()
        response = await self.llm.complete(user_message, tools)
        # Gérer les appels d'outils via MCP
        ...

# ❌ Mauvais
"description": "Cherche des trucs"

# ✅ Bon
"description": "Recherche des articles dans la base de données par mot-clé. Retourne les 10 résultats les plus récents avec titre, date et résumé."

def execute_tool(name, params):
    # Toujours valider !
    if name == "delete_file":
        path = params.get("path", "")
        if ".." in path or path.startswith("/"):
            raise ValueError("Chemin non autorisé")
    # ...

try:
    result = execute_tool(name, params)
    return {"success": True, "data": result}
except Exception as e:
    return {"success": False, "error": str(e), "suggestion": "Vérifiez les paramètres"}