MCP, Function Calling, Tool Use : le guide complet

User → OpenAI API (with function definitions)
                    ↓
            Model chooses a function
                    ↓
            Returns structured JSON
                    ↓
        Your code executes the function
                    ↓
        Result sent back to the model
                    ↓
            Final response to the user

{
  "name": "get_weather",
  "description": "Retrieves the current weather for a given city",
  "parameters": {
    "type": "object",
    "properties": {
      "city": {
        "type": "string",
        "description": "The city name (e.g., Paris, London)"
      },
      "unit": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "description": "The temperature unit"
      }
    },
    "required": ["city"]
  }
}

import openai
import json

client = openai.OpenAI()

# Define available functions
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Retrieves the weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["city"]
            }
        }
    }
]

# Actual function (your logic)
def get_weather(city, unit="celsius"):
    # In production: call a weather API
    return {"city": city, "temperature": 18, "unit": unit, "condition": "cloudy"}

# Call the model
messages = [{"role": "user", "content": "What's the weather like in Paris?"}]
response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

# Check if the model wants to call a function
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)

        # Execute the function
        result = get_weather(**func_args)

        # Send the result back to the model
        messages.append(message)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result)
        })

    # Get the final response
    final = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=tools
    )
    print(final.choices[0].message.content)

# The model can return multiple tool_calls
for tool_call in message.tool_calls:
    # Process each call independently
    ...

User → Anthropic API (with tool definitions)
                    ↓
            Claude chooses a tool
                    ↓
            Returns a tool_use block in the content
                    ↓
        Your code executes the tool
                    ↓
        Result sent back via a tool_result message
                    ↓
            Final response to the user

{
  "name": "get_weather",
  "description": "Retrieves the current weather for a given city. Returns temperature and conditions.",
  "input_schema": {
    "type": "object",
    "properties": {
      "city": {
        "type": "string",
        "description": "The city name"
      },
      "unit": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "description": "The desired temperature unit"
      }
    },
    "required": ["city"]
  }
}

import anthropic
import json

client = anthropic.Anthropic()

# Define tools
tools = [
    {
        "name": "get_weather",
        "description": "Retrieves the weather for a given city",
        "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": "cloudy"}

# First call
messages = [{"role": "user", "content": "What's the weather like in Paris?"}]
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=messages
)

# Check the stop_reason
if response.stop_reason == "tool_use":
    # Extract the tool_use block
    tool_block = next(b for b in response.content if b.type == "tool_use")

    # Execute the tool
    result = get_weather(**tool_block.input)

    # Build the complete conversation
    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)
            }
        ]
    })

    # Get the final response
    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": "Error: city not found"
}

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

from mcp.server.fastmcp import FastMCP

# Create an MCP server
mcp = FastMCP("weather-server")

@mcp.tool()
def get_weather(city: str, unit: str = "celsius") -> dict:
    """Retrieves the current weather for a given city.

    Args:
        city: The city name (e.g., Paris, London)
        unit: The temperature unit (celsius or fahrenheit)
    """
    # In production: call a real API
    return {
        "city": city,
        "temperature": 18,
        "unit": unit,
        "condition": "cloudy"
    }

@mcp.resource("weather://current/{city}")
def current_weather(city: str) -> str:
    """Resource: current weather for a city."""
    data = get_weather(city)
    return f"{data['city']}: {data['temperature']}°C, {data['condition']}"

@mcp.prompt()
def weather_report(city: str) -> str:
    """Generates a prompt for a detailed weather report."""
    return f"Generate a comprehensive weather report for {city} including a 3-day forecast."

# Start the server
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",
  "Retrieves the weather for a city",
  {
    city: z.string().describe("City name"),
    unit: z.enum(["celsius", "fahrenheit"]).optional()
  },
  async ({ city, unit = "celsius" }) => {
    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          city,
          temperature: 18,
          unit,
          condition: "cloudy"
        })
      }]
    };
  }
);

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

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

# Pseudo-code: an agent that uses MCP internally
# but communicates via Function Calling or Tool Use

class UniversalAgent:
    def __init__(self, mcp_servers, llm_provider):
        self.mcp_client = MCPClient(mcp_servers)
        self.llm = llm_provider  # "openai" or "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)
        # Handle tool calls via MCP
        ...

# ❌ Bad
"description": "Search for stuff"

# ✅ Good
"description": "Searches articles in the database by keyword. Returns the 10 most recent results with title, date, and summary."

def execute_tool(name, params):
    # Always validate!
    if name == "delete_file":
        path = params.get("path", "")
        if ".." in path or path.startswith("/"):
            raise ValueError("Unauthorized path")
    # ...

try:
    result = execute_tool(name, params)
    return {"success": True, "data": result}
except Exception as e:
    return {"success": False, "error": str(e), "suggestion": "Check the parameters"}