> ## Documentation Index
> Fetch the complete documentation index at: https://docs.venice.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Appel de fonctions

> Permettez aux modèles de chat Venice d'appeler les outils de votre application avec l'appel de fonctions compatible OpenAI et l'API de complétions de chat.

L'appel de fonctions permet au modèle de choisir des appels d'outils structurés que votre application peut exécuter. Le modèle n'exécute pas la fonction lui-même. Il retourne le nom de la fonction et ses arguments, votre code exécute la fonction, et vous renvoyez le résultat au modèle.

Utilisez l'appel de fonctions lorsque le modèle a besoin de données en direct, d'actions applicatives, de recherches en base de données ou de calculs déterministes.

## Définition d'outil de base

Définissez les outils avec le tableau `tools` compatible OpenAI :

<CodeGroup>
  ```python Python theme={"system"}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["VENICE_API_KEY"],
      base_url="https://api.venice.ai/api/v1",
  )

  tools = [
      {
          "type": "function",
          "function": {
              "name": "get_weather",
              "description": "Get the current weather in a location",
              "parameters": {
                  "type": "object",
                  "properties": {
                      "location": {
                          "type": "string",
                          "description": "City and state, such as San Francisco, CA",
                      }
                  },
                  "required": ["location"],
              },
          },
      }
  ]

  response = client.chat.completions.create(
      model="zai-org-glm-5",
      messages=[{"role": "user", "content": "What is the weather in San Francisco?"}],
      tools=tools,
  )

  print(response.choices[0].message.tool_calls)
  ```

  ```javascript Node.js theme={"system"}
  import OpenAI from "openai";

  const client = new OpenAI({
    apiKey: process.env.VENICE_API_KEY,
    baseURL: "https://api.venice.ai/api/v1",
  });

  const tools = [
    {
      type: "function",
      function: {
        name: "get_weather",
        description: "Get the current weather in a location",
        parameters: {
          type: "object",
          properties: {
            location: {
              type: "string",
              description: "City and state, such as San Francisco, CA",
            },
          },
          required: ["location"],
        },
      },
    },
  ];

  const response = await client.chat.completions.create({
    model: "zai-org-glm-5",
    messages: [{ role: "user", content: "What is the weather in San Francisco?" }],
    tools,
  });

  console.log(response.choices[0].message.tool_calls);
  ```

  ```bash cURL theme={"system"}
  curl https://api.venice.ai/api/v1/chat/completions \
    -H "Authorization: Bearer $VENICE_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "zai-org-glm-5",
      "messages": [
        {"role": "user", "content": "What is the weather in San Francisco?"}
      ],
      "tools": [
        {
          "type": "function",
          "function": {
            "name": "get_weather",
            "description": "Get the current weather in a location",
            "parameters": {
              "type": "object",
              "properties": {
                "location": {
                  "type": "string",
                  "description": "City and state, such as San Francisco, CA"
                }
              },
              "required": ["location"]
            }
          }
        }
      ]
    }'
  ```
</CodeGroup>

## Exécuter l'outil

Lorsque le modèle choisit un outil, inspectez `message.tool_calls`, analysez les arguments, exécutez la fonction de votre application, puis renvoyez le résultat sous forme de message `tool`.

```python Python theme={"system"}
import json

message = response.choices[0].message
tool_call = message.tool_calls[0]
arguments = json.loads(tool_call.function.arguments)

weather = get_weather(arguments["location"])

follow_up = client.chat.completions.create(
    model="zai-org-glm-5",
    messages=[
        {"role": "user", "content": "What is the weather in San Francisco?"},
        message.model_dump(),
        {
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(weather),
        },
    ],
    tools=tools,
)

print(follow_up.choices[0].message.content)
```

## Choisir un modèle

La prise en charge de l'appel de fonctions dépend du modèle. Consultez la page [Modèles de texte](/models/text) ou l'[API Models](/api-reference/endpoint/models/list) pour trouver les modèles avec `supportsFunctionCalling`.

<Warning>
  Traitez les arguments d'outil comme une entrée non fiable. Validez les arguments avant de les utiliser dans des requêtes de base de données, des commandes shell, des paiements ou d'autres opérations à effet de bord.
</Warning>

## Conseils de conception

* Gardez les noms et descriptions d'outils courts et littéraux.
* Utilisez JSON Schema pour faciliter la génération d'arguments valides par le modèle.
* Préférez des outils restreints avec des entrées claires à un outil unique et large avec de nombreux comportements optionnels.
* Retournez des résultats d'outils concis afin que la réponse finale ait suffisamment de contexte sans gaspiller de jetons.

## Ressources connexes

* [API Chat Completions](/api-reference/endpoint/chat/completions)
* [Modèles de texte](/models/text)
* [Guide des réponses structurées](/guides/features/structured-responses)
* [Intégration LangChain](/guides/integrations/langchain#function-calling-with-agents)