Chamada de função OpenAI

Recursos do OpenAI Function calling V2

O objetivo principal da Chamada de função V2 é dar aos modelos da OpenAI a capacidade de interagir com o mundo externo, o que se reflete nas duas funções principais a seguir:

1. Obtenção de dados - implementação da chamada de função do RAG.
   • Essencialmente RAG (Retrieval Augmented Generation). A chamada de função oferece um mecanismo avançado para implementar a geração de aprimoramento de recuperação (RAG). O modelo pode recuperar informações atualizadas e relevantes de fontes de dados externas (por exemplo, bases de conhecimento, APIs etc.) chamando funções predefinidas e incorporando-as às suas próprias respostas geradas.
   • Abordar a defasagem de informações e as limitações de conhecimento. O conhecimento tradicional de grandes modelos de linguagem é estático; a chamada de função preenche essa lacuna, permitindo que os modelos acessem informações em tempo real ou conhecimento específico do domínio para gerar respostas mais precisas e abrangentes.
   • Exemplo de caso de uso.
     • Consulta de informações em tempo real. Por exemplo, obtenha dados meteorológicos atuais, informações sobre as últimas notícias, preços de ações, etc.
     • Pesquisa na base de conhecimento. Por exemplo, consultar a base de conhecimento interna da empresa, a documentação do produto, as perguntas frequentes, etc., para fornecer aos usuários respostas mais profissionais.
     • Integração de dados de API. Por exemplo, obtenha informações sobre produtos, dinâmica de voo, informações sobre localização geográfica etc. de APIs externas para enriquecer o conteúdo do diálogo.
   • Implementação. Funções definidas pelo desenvolvedor para recuperação de dados (por exemplo get_weather, search_knowledge_base), e em tools fornecidos ao modelo nos parâmetros. Quando o modelo determina que são necessárias informações externas, ele chama essas funções e obtém os resultados, que são então integrados à resposta final.
2. Tomando medidas - automação orientada por modelos.
   • Além do fornecimento de informações, a condução de práticas práticas. A chamada de função não se limita à recuperação de informações, mas vai além, permitindo que o modelo acione sistemas externos para realizar operações reais, possibilitando cenários de automação e aplicativos mais profundos.
   • Aprimorando a utilidade e a aplicação de modelos. Isso permite que os modelos sejam mais do que simples parceiros de diálogo, mas também assistentes inteligentes que ajudam os usuários com uma variedade de tarefas.
   • Exemplo de caso de uso.
     • Fluxos de trabalho automatizados. Por exemplo, o envio de formulários, a criação de eventos de calendário, o envio de e-mails, a reserva de voos e hotéis e assim por diante.
     • Controle de aplicativos. Os exemplos incluem a modificação do estado de um aplicativo (UI/front-end ou back-end), o controle de dispositivos domésticos inteligentes e muito mais.
     • Fluxo de trabalho agêntico. Por exemplo, dependendo do conteúdo da conversa, ela pode ser transferida para um sistema de atendimento ao cliente mais especializado ou acionar processos automatizados mais complexos.
   • Implementação. Funções definidas pelo desenvolvedor para realizar operações específicas (por exemplo send_email, create_calendar_event), e em tools fornecidos ao modelo nos parâmetros. O modelo pode chamar essas funções com base na intenção do usuário e passar os parâmetros apropriados para acionar uma ação.

Outros recursos importantes da Chamada de função V2 (suporte para aquisição de dados e ações de execução).

• tools Parâmetros e esquema de funções. Fornece uma maneira estruturada de definir e gerenciar as funções que um modelo pode chamar, incluindo nomes de funções, descrições e definições de parâmetros, garantindo que o modelo compreenda e chame as funções com precisão.
• Modo estrito. Melhorar a confiabilidade e a precisão das chamadas de função para garantir que o modelo produza chamadas de função que estejam estritamente em conformidade com padrões predefinidos.
• Escolha de ferramentas e controle de chamadas de funções paralelas. Fornece controle mais refinado, permitindo que os desenvolvedores adaptem o comportamento das funções chamadas de modelo aos cenários de aplicativos, como forçar chamadas a funções específicas ou limitar o número de chamadas paralelas.
• Transmissão. Melhore a experiência do usuário, você pode mostrar o processo de preenchimento dos parâmetros da função em tempo real, para que os usuários possam entender o processo de raciocínio do modelo de forma mais intuitiva.

Resumo.

O valor central da Chamada de função V2 é que, ao Aquisição de dados (implementação do RAG) responder cantando executar uma ação Esses dois recursos expandem muito os limites de aplicação dos modelos de big language. Ele não só permite que o modelo acesse e utilize informações externas para gerar respostas mais inteligentes e práticas, mas também conduz sistemas externos para realizar operações e atingir um nível mais alto de automação, estabelecendo a base para a criação de aplicativos de IA mais avançados. A aquisição de dados como uma implementação de RAG é um recurso fundamental da chamada de função V2 em aplicativos com uso intensivo de conhecimento.

Aqui está a versão oficial da OpenAI chamada de função(Chamada de função) Uma nova versão da descrição que permite que o modelo busque dados e realize operações.

chamada de função fornece uma maneira avançada e flexível para que os modelos da OpenAI interajam com seu código ou serviços externos, e tem dois casos de uso principais:

Se você quiser apenas fazerGeração de modelo JSONConsulte a documentação da OpenAI sobre saídas estruturadas para garantir que o modelo sempre gere saídas que correspondam às saídas fornecidas por você. Esquema JSON A resposta.

Obter o clima

Exemplo de uma chamada de função usando a função 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)

exportações

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

correio

Exemplo de uma chamada de função usando a função 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)

exportações

[
{
"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\"}"
}
}
]

Pesquisar a base de conhecimento

Exemplo de uma chamada de função usando a função 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)

exportações

[{
"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\"}}"
}
}]

delineado

Você pode tornar o modelo OpenAI acessível, dando a ele acesso ao ferramentas para ampliar sua funcionalidade.ferramentas Ele pode assumir duas formas:

Este guia explicará como aproveitar ao máximo o chamada de função Dê ao modelo acesso às suas próprias funções. Com base em avisos e mensagens do sistema, o modelo pode decidir chamar essas funções - a funçãoEm vez de (ou além de) gerar texto ou áudio.

Depois disso, você precisa executar o código da função, enviar de volta os resultados, e o modelo integrará os resultados em sua resposta final.

função de amostragem (computação)

Vamos dar uma olhada em como permitir que o modelo use o seguinte real definido get_weather Etapas da função:

Exemplo de função get_weather implementada em sua base de código

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

Diferentemente do fluxograma anterior, essa função requer um latitude responder cantando longitudee não genérico localização Parâmetros. (Entretanto, nosso modelo pode determinar automaticamente as coordenadas de muitos locais!)

etapa de chamada da função

Use o modelo de chamada de função definido, juntamente com as mensagens do sistema e do usuário.

Etapa 1: Chame o modelo com a ferramenta get_weather definida

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

Etapa 2: O modelo decide qual função chamar - o modelo retorna o nome e os parâmetros de entrada.

completion.choices[0].message.tool_calls

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

Etapa 3: Executar o código da função - analisar a resposta do modelo e processar a chamada da função

Executar a função 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"])

Etapa 4: Forneça os resultados ao modelo, para que o modelo possa integrá-los à sua resposta final.

Fornecer resultados e chamar o modelo novamente

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

Etapa 4: Resposta do modelo - Integre os resultados em sua saída.

completion_2.choices[0].message.content

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

Definição de funções

pode ser adicionada a cada solicitação de API ferramentas no parâmetro função O objeto é definido na forma de um objeto.

Uma função é definida por seu esquema, que informa ao modelo o que a função faz e quais parâmetros de entrada são esperados. Ele contém os seguintes campos:

Exemplos de padrões de funções

{
"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
}
}

por conta de parâmetros definido pelo esquema JSON, para que você possa aproveitar seus muitos recursos avançados, como tipos de propriedade, enumerações, descrições, objetos aninhados e objetos recursivos.

(Opcional) Chamadas de função com pydantic e zod

Embora recomendemos que você defina os modos de função diretamente, nosso SDK fornece auxiliares que podem ser usados para converter o pydantic responder cantando zod Os objetos são convertidos em padrões. Nem todos os pydantic responder cantando zod As funções são suportadas.

Definição de objetos para representar padrões de função

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)

Práticas recomendadas para a definição de funções

Escreva nomes de funções, descrições de parâmetros e instruções claras e detalhadas.

• Descreva claramente para que a função e cada parâmetro são usados (e seu formato) e o que a saída representa.
• Use as dicas do sistema para descrever quando (e quando não) usar cada função. Normalmente, diga ao modelo exatamente o que fazer.
• Contém exemplos e casos extremos, especialmente para a correção de falhas recorrentes. (Atenção: A adição de exemplos pode prejudicar o desempenho do modelo de inferência).
  Aplicar as práticas recomendadas de engenharia de software.
  • Tornar as funções fáceis de entender e intuitivas. (Princípio da menor surpresa)
  • Use enumerações e estruturas de objetos para tornar os estados inválidos irrepresentáveis. (Por exemplo.toggle_light(on: bool, off: bool) (Chamadas inválidas são permitidas)
  • Passar no teste do estagiário. O estagiário/humano consegue usar a função corretamente apenas com o que você forneceu ao modelo? (Se não, que perguntas ele faria a você? Adicione a resposta ao prompt).

Minimize a carga sobre o modelo e use código sempre que possível.

• Não deixe que o modelo preencha os parâmetros que você já conhece. Por exemplo, se você já tiver obtido o menu com base no order_idSe você não quiser definir o order_id Parâmetros - em vez de definir parâmetros submit_refund()e passar o código order_id.
• Mesclar funções que são sempre chamadas sequencialmente. Por exemplo, se você sempre chamar as funções em query_location() seguido de uma chamada para mark_location()Se o usuário não tiver a opção de marcar, basta mover a lógica de marcação para a chamada da função de consulta.Para obter maior precisão, mantenha o número de funções pequeno.
  • Avalie seu desempenho usando um número diferente de funções.
  • O objetivo é ter menos de 20 funções ao mesmo tempo, mas essa é apenas uma recomendação leve.

Aproveitamento dos recursos da OpenAI.

• existir Playground Geração e iteração de padrões de função em
• Considere o ajuste fino para melhorar a precisão da chamada de função para um grande número de funções ou tarefas difíceis.

Uso de token

No nível inferior, as funções são injetadas nas mensagens do sistema na sintaxe que o modelo foi treinado para usar. Isso significa que as funções contam contra as restrições contextuais do modelo e são usadas como entradas Token Cobranças. Se você estiver enfrentando um limite de tokens, recomendamos limitar o número de funções ou o tamanho da descrição que você fornece para os argumentos da função.

Se houver muitas funções definidas na especificação da ferramenta, você também poderá usar o ajuste fino para reduzir o número de tokens usados.

Tratamento de chamadas de função

Quando um modelo chama uma função, você deve executá-la e retornar o resultado. Como a resposta do modelo pode conter zero, uma ou mais chamadas, a melhor prática é presumir que há várias chamadas.

A resposta contém um chamadas_de_ferramenta cada um dos quais tem um id(a ser usado posteriormente para enviar os resultados da função) e um contendo um nome e codificado em JSON argumentos (usado em uma expressão nominal) função.

Exemplo de resposta com várias chamadas de função

[
{
"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\"}"
}
}
]

Executar a chamada de função e anexar o resultado

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

No exemplo acima, temos uma call_function hipotética para rotear cada chamada. Essa é uma implementação possível:

Execução de chamadas de função e anexação de resultados

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

Formatação de resultados

O resultado deve ser uma cadeia de caracteres, mas o formato fica a seu critério (JSON, código de erro, texto simples etc.). O modelo interpretará a string conforme necessário.

Se sua função não tiver valor de retorno (por exemplo enviar_email), basta retornar uma cadeia de caracteres para indicar sucesso ou falha. (Por exemplo "sucesso")

Integrar os resultados às respostas

Anexe os resultados ao seu mensagens Depois disso, você pode enviá-los de volta ao modelo para uma resposta final.

Enviar os resultados de volta ao modelo

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

resposta final

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

Configurações adicionais

Seleção de ferramentas

Por padrão, o modelo determinará quando e quantas ferramentas devem ser usadas. Você pode usar o escolha de ferramenta impõe um comportamento específico.

• Automático: (padrão (configuração)) chama zero, uma ou mais funções. tool_choice: "auto"
• Obrigatório: chamar uma ou mais funções. tool_choice: "obrigatório"
• Função forçada: chamar exatamente uma função específica. tool_choice: {"type": "function", "function": {"name": "get_weather"}}

Você também pode definir o escolha de ferramenta definido como "nenhum"para simular o comportamento da função sem passagem.

chamada de função paralela

O modelo pode optar por chamar várias funções em uma única rodada. Você pode fazer isso definindo o parâmetro chamadas de ferramentas paralelas definido como falso para evitar isso, o que garantirá que exatamente zero ou uma ferramenta seja chamada.

Atenção: Atualmente, se um modelo chamar mais de uma função em uma rodada, o modo estrito desativa essas chamadas.

modelo rígido

comandante-em-chefe (militar) rigoroso definido como verdadeiro garantirá que as chamadas de função sigam de forma confiável o padrão de função, em vez de fazer o melhor possível. Recomendamos sempre ativar o modo estrito.

Na parte inferior, o modo estrito é implementado utilizando nosso recurso de saídas estruturadas, introduzindo assim vários requisitos:

• com relação a parâmetros para cada objeto noadditionalProperties deve ser definido como falso.
• Todos os campos nas propriedades devem ser rotulados como necessário.

Você pode fazer isso adicionando o nulo atuar como tipo para indicar campos opcionais (veja o exemplo abaixo).

Ativar o modo estrito

{
"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
}
}
}

Desativar o modo estrito

{
"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"],
}
}
}

Todos os padrões gerados no playground têm o modo estrito ativado.

Embora recomendemos que você ative o modo estrito, ele tem algumas limitações:

• Não há suporte para alguns recursos do esquema JSON. (Consulte esquemas compatíveis.)
• Os padrões passam por um processamento adicional na primeira solicitação (e depois são armazenados em cache). Se o seu padrão variar de uma solicitação para outra, isso poderá resultar em uma latência maior.
• Os padrões são armazenados em cache para fins de desempenho e não se qualificam para retenção zero de dados.

transmissão

O streaming pode ser usado para mostrar o progresso, exibindo funções que são chamadas à medida que o modelo preenche seus parâmetros, ou até mesmo exibindo parâmetros em tempo real.

O streaming de uma chamada de função é muito semelhante ao streaming de uma resposta normal: você fluxo definido como verdadeiro e obter os dados com o delta Bloco de objetos.

Chamadas de função de streaming

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)

Saída 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

No entanto, em vez de agregar blocos em um único conteúdo mas, em vez disso, agrega os blocos na string codificada argumentos Objeto JSON.

Quando o modelo chama uma ou mais funções, cada uma das delta (usado em uma expressão nominal) chamadas_de_ferramenta serão preenchidos. Cada chamada_de_ferramenta Contém os seguintes campos:

Muitos desses campos só estão disponíveis na primeira chamada de ferramenta de cada delta Instalado em, por exemplo idefunction.name responder cantando tipo.

Aqui está um trecho de código que demonstra como o delta Agregado ao final chamadas_de_ferramenta no objeto.

Ferramenta de acumulação_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

Chamadas_de_ferramenta_final acumuladas[0]

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