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 :

Python

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)

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);

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"]
          }
        }
      }
    ]
  }'

​

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

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 ou l’API Models pour trouver les modèles avec supportsFunctionCalling.

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.

​

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
• Modèles de texte
• Guide des réponses structurées
• Intégration LangChain