Appel de fonctions OpenAI

Fonction d'appel OpenAI V2 Fonctionnalités

L'objectif principal de Function calling V2 est de donner aux modèles OpenAI la capacité d'interagir avec le monde extérieur, ce qui se reflète dans les deux fonctions principales suivantes :

1. Récupération de données - Mise en œuvre de l'appel de fonction de RAG.
   • Essentiellement RAG (Retrieval Augmented Generation). L'appel de fonctions constitue un mécanisme puissant pour mettre en œuvre la génération de l'amélioration de la récupération (RAG). Le modèle peut récupérer des informations actualisées et pertinentes à partir de sources de données externes (par exemple, bases de connaissances, API, etc.) en appelant des fonctions prédéfinies et en les incorporant dans les réponses qu'il génère.
   • Remédier au décalage de l'information et aux limites de la connaissance. La connaissance traditionnelle des grands modèles de langage est statique ; Function calling comble cette lacune en permettant aux modèles d'accéder à des informations en temps réel ou à des connaissances spécifiques à un domaine afin de générer des réponses plus précises et plus complètes.
   • Exemple de cas d'utilisation.
     • Demande d'informations en temps réel. Par exemple, vous pouvez obtenir les données météorologiques actuelles, les dernières informations, les cours de la bourse, etc.
     • Recherche dans la base de connaissances. Par exemple, l'interrogation de la base de connaissances interne de l'entreprise, de la documentation sur les produits, des FAQ, etc. pour fournir aux utilisateurs des réponses plus professionnelles.
     • Intégration des données API. Par exemple, obtenir des informations sur les produits, la dynamique des vols, la localisation géographique, etc. à partir d'API externes afin d'enrichir le contenu du dialogue.
   • Mise en œuvre. Fonctions définies par le développeur pour l'extraction de données (par ex. get_weather, search_knowledge_base), et en tools fournies au modèle dans les paramètres. Lorsque le modèle détermine que des informations externes sont nécessaires, il appelle ces fonctions et obtient les résultats, qui sont ensuite intégrés dans la réponse finale.
2. Passer à l'action - l'automatisation pilotée par le modèle.
   • Au-delà de la fourniture d'informations, les pratiques pratiques pratiques. L'appel de fonction ne se limite pas à la recherche d'informations, mais va plus loin en permettant au modèle de piloter des systèmes externes pour effectuer des opérations réelles, ce qui permet une automatisation plus poussée et des scénarios d'application.
   • Améliorer l'utilité et l'application des modèles. Cela permet aux modèles d'être plus que de simples partenaires de dialogue, ils peuvent être des assistants intelligents qui aident les utilisateurs dans toute une série de tâches.
   • Exemple de cas d'utilisation.
     • Flux de travail automatisés. Par exemple, la soumission de formulaires, la création d'événements dans le calendrier, l'envoi de courriels, la réservation de vols et d'hôtels, etc.
     • Contrôle de l'application. Les exemples incluent la modification de l'état d'une application (UI/front-end ou back-end), le contrôle des appareils domestiques intelligents, et plus encore.
     • Flux de travail agentique. Par exemple, en fonction du contenu de la conversation, celle-ci peut être transmise à un système de service à la clientèle plus spécialisé ou déclencher des processus automatisés plus complexes.
   • Mise en œuvre. Fonctions définies par le développeur pour effectuer des opérations spécifiques (par ex. send_email, create_calendar_event), et en tools fournies au modèle dans les paramètres. Le modèle peut appeler ces fonctions en fonction de l'intention de l'utilisateur et transmettre les paramètres appropriés pour déclencher une action.

Autres caractéristiques clés de Function calling V2 (support pour l'acquisition de données et les actions d'exécution).

• tools Paramètres et schéma des fonctions. Fournit un moyen structuré de définir et de gérer les fonctions qu'un modèle peut appeler, y compris les noms de fonctions, les descriptions et les définitions de paramètres, en veillant à ce que le modèle comprenne et appelle les fonctions avec précision.
• Mode strict. Améliorer la fiabilité et la précision des appels de fonction en veillant à ce que le modèle produise des appels de fonction strictement conformes à des modèles prédéfinis.
• Choix des outils et contrôle des appels de fonctions parallèles. Il offre un contrôle plus fin, permettant aux développeurs d'adapter le comportement des fonctions appelées modèles aux scénarios d'application, par exemple en forçant les appels à des fonctions spécifiques ou en limitant le nombre d'appels parallèles.
• Streaming. Améliorer l'expérience de l'utilisateur, vous pouvez montrer le processus de remplissage des paramètres de fonction en temps réel, afin que les utilisateurs puissent comprendre le processus de réflexion du modèle de manière plus intuitive.

Résumé.

La valeur fondamentale de la fonction d'appel V2 est qu'en Acquisition de données (mise en œuvre du RAG) répondre en chantant exécuter une action Ces deux caractéristiques élargissent considérablement les limites d'application des grands modèles de langage. Elles permettent non seulement au modèle d'accéder à des informations externes et de les utiliser pour générer des réponses plus intelligentes et plus pratiques, mais aussi aux systèmes externes d'effectuer des opérations et d'atteindre un niveau d'automatisation plus élevé, jetant ainsi les bases de la création d'applications d'IA plus puissantes. L'acquisition de données en tant que mise en œuvre de RAG est une capacité clé de Function calling V2 dans les applications à forte intensité de connaissances.

Voici la page officielle de l'OpenAI appel de fonction(Function calling) Nouvelle version de la description qui permet au modèle de récupérer des données et d'effectuer des opérations.

appel de fonction fournit un moyen puissant et flexible pour les modèles OpenAI d'interagir avec votre code ou des services externes, et a deux cas d'utilisation principaux :

Si vous voulez seulement faireGénération de modèles JSONVeuillez vous référer à la documentation d'OpenAI sur les sorties structurées pour vous assurer que le modèle génère toujours des sorties qui correspondent à celles que vous fournissez. Schéma JSON La réponse.

Obtenir la météo

Exemple d'appel de fonction utilisant la fonction get_weather

from openai import OpenAI
client = OpenAI()
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "获取给定位置的当前温度。",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "城市和国家，例如 Bogotá, Colombia"
}
},
"required": [
"location"
],
"additionalProperties": False
},
"strict": True
}
}]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "今天巴黎的天气怎么样？"}],
tools=tools
)
print(completion.choices[0].message.tool_calls)

exportations

[{
"id": "call_12345xyz",
"type": "function",
"function": {
"name": "get_weather",
"arguments": "{\"location\":\"Paris, France\"}"
}
}]

courrier

Exemple d'appel de fonction utilisant la fonction send_email

from openai import OpenAI
client = OpenAI()
tools = [{
"type": "function",
"function": {
"name": "send_email",
"description": "向给定的收件人发送包含主题和消息的电子邮件。",
"parameters": {
"type": "object",
"properties": {
"to": {
"type": "string",
"description": "收件人的电子邮件地址。"
},
"subject": {
"type": "string",
"description": "电子邮件主题行。"
},
"body": {
"type": "string",
"description": "电子邮件消息正文。"
}
},
"required": [
"to",
"subject",
"body"
],
"additionalProperties": False
},
"strict": True
}
}]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "你能给 ilan@example.com 和 katia@example.com 发送邮件说“hi”吗？"}],
tools=tools
)
print(completion.choices[0].message.tool_calls)

exportations

[
{
"id": "call_9876abc",
"type": "function",
"function": {
"name": "send_email",
"arguments": "{\"to\":\"ilan@example.com\",\"subject\":\"Hello!\",\"body\":\"Just wanted to say hi\"}"
}
},
{
"id": "call_9876abc",
"type": "function",
"function": {
"name": "send_email",
"arguments": "{\"to\":\"katia@example.com\",\"subject\":\"Hello!\",\"body\":\"Just wanted to say hi\"}"
}
}
]

Recherche dans la base de connaissances

Exemple d'appel de fonction utilisant la fonction search_knowledge_base

from openai import OpenAI
client = OpenAI()
tools = [{
"type": "function",
"function": {
"name": "search_knowledge_base",
"description": "查询知识库以检索关于某个主题的相关信息。",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "用户问题或搜索查询。"
},
"options": {
"type": "object",
"properties": {
"num_results": {
"type": "number",
"description": "要返回的排名靠前的结果数量。"
},
"domain_filter": {
"type": [
"string",
"null"
],
"description": "可选的域，用于缩小搜索范围（例如，“finance”，“medical”）。 如果不需要，则传递 null。"
},
"sort_by": {
"type": [
"string",
"null"
],
"enum": [
"relevance",
"date",
"popularity",
"alphabetical"
],
"description": "如何对结果进行排序。 如果不需要，则传递 null。"
}
},
"required": [
"num_results",
"domain_filter",
"sort_by"
],
"additionalProperties": False
}
},
"required": [
"query",
"options"
],
"additionalProperties": False
},
"strict": True
}
}]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "你能在 AI 知识库中找到关于 ChatGPT 的信息吗？"}],
tools=tools
)
print(completion.choices[0].message.tool_calls)

exportations

[{
"id": "call_4567xyz",
"type": "function",
"function": {
"name": "search_knowledge_base",
"arguments": "{\"query\":\"What is ChatGPT?\",\"options\":{\"num_results\":3,\"domain_filter\":null,\"sort_by\":\"relevance\"}}"
}
}]

esquissée

Vous pouvez rendre le modèle OpenAI accessible en lui donnant accès au fichier outils pour étendre ses fonctionnalités.outils Elle peut prendre deux formes :

Ce guide explique comment tirer le meilleur parti de l'application appel de fonction Donnez au modèle l'accès à vos propres fonctions. En fonction des invites et des messages du système, le modèle peut décider d'appeler ces fonctions - la fonctionAu lieu (ou en plus) de générer du texte ou de l'audio.

Ensuite, vous devez exécuter le code de la fonction, renvoyer les résultats, et le modèle intégrera les résultats dans sa réponse finale.

fonction d'échantillonnage (calcul)

Permettons au modèle d'utiliser le réel défini suivant get_weather Étapes de la fonction :

Exemple de fonction get_weather implémentée dans votre base de code

import requests
def get_weather(latitude, longitude):
response = requests.get(f"https://api.open-meteo.com/v1/forecast?latitude={latitude}&longitude={longitude}¤t=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m")
data = response.json()
return data['current']['temperature_2m']

Contrairement à l'organigramme précédent, cette fonction nécessite une latitude répondre en chantant longitudeet non générique localisation Paramètres. (Cependant, notre modèle peut déterminer automatiquement les coordonnées de nombreux lieux !)

appel de fonction étape

Utilisez le modèle d'appel de fonction défini, ainsi que les messages du système et de l'utilisateur.

Étape 1 : Appeler le modèle avec l'outil get_weather défini

from openai import OpenAI
import json
client = OpenAI()
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "获取给定坐标的当前温度，单位为摄氏度。",
"parameters": {
"type": "object",
"properties": {
"latitude": {"type": "number"},
"longitude": {"type": "number"}
},
"required": ["latitude", "longitude"],
"additionalProperties": False
},
"strict": True
}
}]
messages = [{"role": "user", "content": "今天巴黎的天气怎么样？"}]
completion = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools,
)

Étape 2 : Le modèle décide de la fonction à appeler - le modèle renvoie le nom et les paramètres d'entrée.

completion.choices[0].message.tool_calls

[{
"id": "call_12345xyz",
"type": "function",
"function": {
"name": "get_weather",
"arguments": "{\"latitude\":48.8566,\"longitude\":2.3522}"
}
}]

Étape 3 : Exécuter le code de la fonction - analyser la réponse du modèle et traiter l'appel de la fonction

Exécuter la fonction get_weather

tool_call = completion.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_weather(args["latitude"], args["longitude"])

Étape 4 : Fournir les résultats au modèle - afin que le modèle puisse intégrer les résultats dans sa réponse finale.

Fournir les résultats et rappeler le modèle

messages.append(completion.choices[0].message)  # append model's function call message
messages.append({                               # append result message
"role": "tool",
"tool_call_id": tool_call.id,
"content": str(result)
})
completion_2 = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools,
)

Étape 4 : Réponse du modèle - Intégrer les résultats dans la sortie du modèle.

completion_2.choices[0].message.content

"巴黎当前温度为 14°C (57.2°F)。"

Définition des fonctions

peut être ajoutée à la fonction outils dans le fichier fonction L'objet est défini sous la forme d'un objet.

Une fonction est définie par son schéma, qui informe le modèle de ce que fait la fonction et des paramètres d'entrée attendus. Il contient les champs suivants :

Exemples de modèles de fonctions

{
"type": "function",
"function": {
"name": "get_weather",
"description": "检索给定位置的当前天气。",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "城市和国家，例如 Bogotá, Colombia"
},
"units": {
"type": "string",
"enum": [
"celsius",
"fahrenheit"
],
"description": "温度将以什么单位返回。"
}
},
"required": [
"location",
"units"
],
"additionalProperties": False
},
"strict": True
}
}

en raison de paramètres défini par le schéma JSON, afin que vous puissiez tirer parti de ses nombreuses et riches fonctionnalités, telles que les types de propriétés, les énumérations, les descriptions, les objets imbriqués et les objets récursifs.

(Facultatif) Appels de fonctions avec pydantic et zod

Bien que nous vous encouragions à définir directement les modes de fonction, notre SDK fournit des aides qui peuvent être utilisées pour convertir les modes de fonction en modes de fonctionnement. pydantique répondre en chantant zod Les objets sont convertis en motifs. Tous les pydantique répondre en chantant zod Les fonctions sont prises en charge.

Définition d'objets pour représenter des modèles de fonction

from openai import OpenAI, pydantic_function_tool
from pydantic import BaseModel, Field
client = OpenAI()
class GetWeather(BaseModel):
location: str = Field(
...,
description="城市和国家，例如 Bogotá, Colombia"
)
tools = [pydantic_function_tool(GetWeather)]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "今天巴黎的天气怎么样？"}],
tools=tools
)
print(completion.choices[0].message.tool_calls)

Bonnes pratiques pour la définition des fonctions

Rédiger des noms de fonctions, des descriptions de paramètres et des instructions clairs et détaillés.

• Décrire clairement l'utilisation de la fonction et de chaque paramètre (et son format), et ce que représente la sortie.
• Utilisez les conseils du système pour décrire quand (et quand ne pas utiliser) chaque fonction. En général, il s'agit de dire au modèle exactement ce qu'il doit faire.
• Contient des exemples et des cas limites, en particulier pour corriger les défaillances récurrentes. (Attention : L'ajout d'exemples peut dégrader les performances du modèle d'inférence).
  Appliquer les meilleures pratiques en matière d'ingénierie logicielle.
  • Rendre les fonctions faciles à comprendre et intuitives. (Principe de moindre surprise)
  • Utiliser des énumérations et des structures d'objets pour rendre les états non valides irreprésentables. (Par exemple, les énumérations et les structures d'objets permettent de rendre les états non valides irreprésentables.toggle_light(on : bool, off : bool) (Les appels non valides sont autorisés)
  • Réussir le test du stagiaire. Le stagiaire/homme peut-il utiliser la fonction correctement avec seulement ce que vous avez donné au modèle ? (Si ce n'est pas le cas, quelles questions vous poseraient-ils ? Ajoutez la réponse à l'invite).

Minimiser la charge sur le modèle et utiliser le code dans la mesure du possible.

• Ne laissez pas le modèle remplir des paramètres que vous connaissez déjà. Par exemple, si vous avez déjà obtenu le menu sur la base de l'enquête précédente, il est préférable de ne pas laisser le modèle remplir les paramètres que vous connaissez déjà. order_idSi vous ne souhaitez pas définir le order_id Paramètres - au lieu de définir des paramètres submit_refund()et transmet le code order_id.
• Fusionner les fonctions qui sont toujours appelées de manière séquentielle. Par exemple, si vous appelez toujours les fonctions dans query_location() suivi d'un appel à mark_location()il suffit de déplacer la logique de marquage dans l'appel de la fonction de requête.Pour une plus grande précision, le nombre de fonctions doit être réduit.
  • Évaluez votre performance en utilisant un nombre différent de fonctions.
  • L'objectif est d'avoir moins de 20 fonctions en même temps, mais il ne s'agit que d'une recommandation prudente.

Exploiter les ressources de l'OpenAI.

• existent Terrain de jeux Générer et itérer des modèles de fonctions en
• Envisagez un réglage fin pour améliorer la précision des appels de fonction pour un grand nombre de fonctions ou pour des tâches difficiles.

Utilisation des jetons

Au niveau inférieur, les fonctions sont injectées dans les messages du système dans la syntaxe que le modèle a été formé à utiliser. Cela signifie que les fonctions sont prises en compte dans les contraintes contextuelles du modèle et sont utilisées comme entrées Jeton Frais. Si vous rencontrez une limite de jetons, nous vous recommandons de limiter le nombre de fonctions ou la longueur de la description que vous fournissez pour les arguments de la fonction.

Si de nombreuses fonctions sont définies dans la spécification de votre outil, vous pouvez également utiliser le réglage fin pour réduire le nombre de jetons utilisés.

Gestion des appels de fonction

Lorsqu'un modèle appelle une fonction, vous devez l'exécuter et renvoyer le résultat. Étant donné que la réponse du modèle peut contenir zéro, un ou plusieurs appels, la meilleure pratique consiste à supposer qu'il y a plusieurs appels.

La réponse contient un appels_outils chacun d'entre eux ayant un id(qui sera utilisé ultérieurement pour soumettre les résultats de la fonction) et un autre contenant un nom et le codage JSON arguments (utilisé comme expression nominale) fonction.

Exemple de réponse avec plusieurs appels de fonction

[
{
"id": "call_12345xyz",
"type": "function",
"function": {
"name": "get_weather",
"arguments": "{\"location\":\"Paris, France\"}"
}
},
{
"id": "call_67890abc",
"type": "function",
"function": {
"name": "get_weather",
"arguments": "{\"location\":\"Bogotá, Colombia\"}"
}
},
{
"id": "call_99999def",
"type": "function",
"function": {
"name": "send_email",
"arguments": "{\"to\":\"bob@email.com\",\"body\":\"Hi bob\"}"
}
}
]

Exécuter l'appel de fonction et ajouter le résultat

for tool_call in completion.choices[0].message.tool_calls:
name = tool_call.function.name
args = json.loads(tool_call.function.arguments)
result = call_function(name, args)
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": result
})

Dans l'exemple ci-dessus, nous avons une hypothétique call_function pour acheminer chaque appel. Il s'agit d'une implémentation possible :

Exécution d'un appel de fonction et ajout d'un résultat

def call_function(name, args):
if name == "get_weather":
return get_weather(**args)
if name == "send_email":
return send_email(**args)

Formatage des résultats

Le résultat doit être une chaîne, mais le format est libre (JSON, code d'erreur, texte brut, etc.). Le modèle interprétera la chaîne comme il se doit.

Si votre fonction n'a pas de valeur de retour (par ex. envoyer_mail), il suffit de renvoyer une chaîne de caractères pour indiquer le succès ou l'échec. (Par exemple "succès")

Intégrer les résultats dans les réponses

Joignez les résultats à votre messages Ensuite, vous pouvez les renvoyer au modèle pour une réponse finale.

Renvoyer les résultats au modèle

completion = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools,
)

réponse finale

"巴黎大约 15°C，Bogotá 大约 18°C，并且我已经向 Bob 发送了那封邮件。"

Configurations supplémentaires

Sélection des outils

Par défaut, le modèle détermine quand et combien d'outils doivent être utilisés. Vous pouvez utiliser le modèle choix de l'outil impose un comportement spécifique.

• Auto : (par défaut (réglage)) appelle zéro, une ou plusieurs fonctions. choix de l'outil : "auto"
• Obligatoire : Appeler une ou plusieurs fonctions. tool_choice : "required" (choix de l'outil)
• Fonction forcée : Appeler exactement une fonction spécifique. tool_choice : {"type" : "function", "function" : {"name" : "get_weather"}}

Vous pouvez également régler le choix de l'outil fixé à "aucun"pour simuler le comportement de la fonction qui ne passe pas.

appel de fonction parallèle

Le modèle peut choisir d'appeler plusieurs fonctions en une seule fois. Vous pouvez le faire en définissant l'option appels d'outils parallèles fixé à faux pour éviter cela, ce qui garantira qu'exactement zéro ou un outil est appelé.

Attention : Actuellement, si un modèle fait appel à plus d'une fonction au cours d'un tour, le modev strict désactive ces appels.

modèle strict

commandant en chef (militaire) stricte fixé à vrai s'assurera que les appels de fonction adhèrent de manière fiable au modèle de fonction, plutôt que de faire de leur mieux. Nous recommandons de toujours activer le mode strict.

En bas, le mode strict est mis en œuvre en utilisant notre fonction de sorties structurées, ce qui introduit plusieurs exigences :

• en ce qui concerne paramètres pour chaque objet dans lepropriétés supplémentaires doit être réglé sur faux.
• Tous les champs des propriétés doivent être étiquetés comme requis.

Vous pouvez le faire en ajoutant l'élément nul agir en tant que type pour indiquer les champs facultatifs (voir l'exemple ci-dessous).

Activer le mode strict

{
"type": "function",
"function": {
"name": "get_weather",
"description": "检索给定位置的当前天气。",
"strict": true,
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "城市和国家，例如 Bogotá, Colombia"
},
"units": {
"type": ["string", "null"],
"enum": ["celsius", "fahrenheit"],
"description": "温度将以什么单位返回。"
}
},
"required": ["location", "units"],
"additionalProperties": False
}
}
}

Désactiver le mode strict

{
"type": "function",
"function": {
"name": "get_weather",
"description": "检索给定位置的当前天气。",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "城市和国家，例如 Bogotá, Colombia"
},
"units": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "温度将以什么单位返回。"
}
},
"required": ["location"],
}
}
}

Tous les motifs générés dans la cour de récréation sont activés en mode strict.

Bien que nous vous recommandions d'activer le mode strict, celui-ci présente certaines limites :

• Certaines caractéristiques du schéma JSON ne sont pas prises en charge. (Voir les schémas pris en charge).
• Les modèles subissent un traitement supplémentaire lors de la première demande (et sont ensuite mis en cache). Si votre modèle varie d'une requête à l'autre, il peut en résulter une latence plus élevée.
• Les modèles sont mis en cache à des fins de performance et ne sont pas éligibles à la conservation zéro des données.

streaming

Le streaming peut être utilisé pour montrer la progression, en affichant les fonctions qui sont appelées au fur et à mesure que le modèle remplit ses paramètres, ou même en affichant les paramètres en temps réel.

La diffusion d'un appel de fonction est très similaire à la diffusion d'une réponse normale : vous devez flux fixé à vrai et obtenir les données avec la fonction delta Bloc d'objets.

Appels de fonctions en continu

from openai import OpenAI
client = OpenAI()
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "获取给定位置的当前温度。",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "城市和国家，例如 Bogotá, Colombia"
}
},
"required": ["location"],
"additionalProperties": False
},
"strict": True
}
}]
stream = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "今天巴黎的天气怎么样？"}],
tools=tools,
stream=True
)
for chunk in stream:
delta = chunk.choices[0].delta
print(delta.tool_calls)

Sortie delta.tool_calls

[{"index": 0, "id": "call_DdmO9pD3xa9XTPNJ32zg2hcA", "function": {"arguments": "", "name": "get_weather"}, "type": "function"}]
[{"index": 0, "id": null, "function": {"arguments": "{\"", "name": null}, "type": null}]
[{"index": 0, "id": null, "function": {"arguments": "location", "name": null}, "type": null}]
[{"index": 0, "id": null, "function": {"arguments": "\":\"", "name": null}, "type": null}]
[{"index": 0, "id": null, "function": {"arguments": "Paris", "name": null}, "type": null}]
[{"index": 0, "id": null, "function": {"arguments": ",", "name": null}, "type": null}]
[{"index": 0, "id": null, "function": {"arguments": " France", "name": null}, "type": null}]
[{"index": 0, "id": null, "function": {"arguments": "\"}", "name": null}, "type": null}]
null

Cependant, au lieu d'agréger les blocs en un seul contenu mais regroupe les blocs dans la chaîne de caractères encodée arguments Objet JSON.

Lorsque le modèle appelle une ou plusieurs fonctions, chacune des delta (utilisé comme expression nominale) appels_outils seront remplis. Chaque appel_outil Contient les champs suivants :

Nombre de ces champs ne sont disponibles que lors de la première invocation de l'outil. delta Fixé dans, par exemple id,fonction.nom répondre en chantant type.

Voici un extrait de code qui montre comment la fonction delta Agréger au final appels_outils dans l'objet.

Outil d'accumulation_call delta

final_tool_calls = {}
for chunk in stream:
for tool_call in chunk.choices[0].delta.tool_calls or []:
index = tool_call.index
if index not in final_tool_calls:
final_tool_calls[index] = tool_call
final_tool_calls[index].function.arguments += tool_call.function.arguments

Accumulé final_tool_calls[0]

{
"index": 0,
"id": "call_RzfkBpJgzeR0S242qfvjadNe",
"function": {
"name": "get_weather",
"arguments": "{\"location\":\"Paris, France\"}"
}
}