Documentation/Appel de fonctions (Function Calling)

Appel de fonctions (Function Calling)

L'appel de fonctions permet au modèle de sélectionner et d'appeler automatiquement les fonctions outils que vous avez prédéfinies selon les besoins de l'utilisateur, afin de réaliser des requêtes de données, des appels d'API, l'exécution de tâches, etc.

Concepts de base#

Le flux complet de l'appel de fonctions :

Définir les outils — décrire les fonctions et paramètres disponibles dans la requête
Décision du modèle — le modèle détermine s'il faut appeler un outil
Retour de l'appel — le modèle renvoie le nom de la fonction et les paramètres
Exécuter la fonction — vous exécutez la fonction et récupérez le résultat
Poursuivre la conversation — renvoyer le résultat au modèle pour générer la réponse finale

Protocole OpenAI#

Python

Code

from openai import OpenAI
import json
 
client = OpenAI(
    base_url="https://as.apinoma.com/v1",
    api_key="<votre APINOMA_API_KEY>"
)
 
# 1. Définir les outils
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Obtenir la météo en temps réel d'une ville donnée",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Nom de la ville, ex. : Pékin, Shanghai"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Unité de température"
                }
            },
            "required": ["city"]
        }
    }
}]
 
# 2. Envoyer la requête
messages = [{"role": "user", "content": "Quel temps fait-il à Pékin aujourd'hui ?"}]
 
response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)
 
message = response.choices[0].message
 
# 3. Traiter l'appel d'outil
if message.tool_calls:
    for tool_call in message.tool_calls:
        args = json.loads(tool_call.function.arguments)
 
        # 4. Exécuter votre fonction
        result = get_weather(args["city"])  # Votre propre implémentation
 
        # 5. 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="openai/gpt-4o",
        messages=messages,
        tools=tools
    )
    print(final.choices[0].message.content)

TypeScript

Protocole Anthropic#

Anthropic utilise le paramètre `tools`, avec un format légèrement différent :

Code

import anthropic
 
client = anthropic.Anthropic(
    base_url="https://as.apinoma.com/anthropic",
    api_key="<votre APINOMA_API_KEY>"
)
 
response = client.messages.create(
    model="anthropic/claude-sonnet-4.6",
    max_tokens=1024,
    tools=[{
        "name": "get_weather",
        "description": "Obtenir la météo en temps réel d'une ville donnée",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "Nom de la ville"}
            },
            "required": ["city"]
        }
    }],
    messages=[{"role": "user", "content": "Quel temps fait-il à Pékin aujourd'hui ?"}]
)
 
# Traiter le content block tool_use
for block in response.content:
    if block.type == "tool_use":
        print(f"Appel d'outil : {block.name}, paramètres : {block.input}")

Appels de fonctions parallèles#

Le modèle peut renvoyer plusieurs appels d'outils dans une seule réponse ; vous devez les exécuter en parallèle :

Code

# Le modèle peut demander plusieurs appels d'outils simultanément
if message.tool_calls:
    # Exécuter tous les appels d'outils en parallèle
    import asyncio
 
    async def execute_tools(tool_calls):
        tasks = []
        for tc in tool_calls:
            args = json.loads(tc.function.arguments)
            tasks.append(execute_function(tc.function.name, args))
        return await asyncio.gather(*tasks)

Paramètre tool_choice#

Valeur

Description

`"auto"`

Le modèle décide automatiquement s'il faut appeler un outil (par défaut)

`"none"`

Interdire l'appel d'outils

`"required"`

Forcer l'appel d'un outil

`{"type": "function", "function": {"name": "xxx"}}`

Forcer l'appel d'un outil spécifié

Modèles pris en charge#

Les modèles suivants prennent en charge Function Calling :

OpenAI: `gpt-4o`、`gpt-4o-mini`、`o1`、`o3-mini`
Anthropic: `claude-opus-4`、`claude-sonnet-4`、`claude-3-5-haiku`
Google: `gemini-pro-compatible-pro-preview`、`gemini-pro-compatible-flash-lite-preview`、`gemini-3-pro-preview`
Modèles nationaux : `deepseek-chat`、`qwen-max`、`glm-4`

Dernière mise à jour le 23 juin 2026