Chamada de função

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, base de conhecimento de pesquisa), e em ferramentas 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 enviar_email, create_calendar_event), e em ferramentas 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).

• ferramentas 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
cliente = OpenAI()
ferramentas = [{
"type": "function", "function": {
"function": {
"name": "get_weather", "description": "Obter a temperatura atual em um determinado local.
"description": "Obter a temperatura atual em um determinado local." ,
"parameters": {
"type": "object", "properties": {
"properties": {
"location" (local): {
"type": "string", "description": "Cidade e país
"description": "Cidade e país, por exemplo, Bogotá, Colômbia"
}
}, "required": [ [ "cidade e país, por exemplo, Bogotá, Colômbia" }
"required": [
"location"
], "additionalProperties": False
"additionalProperties": False
}, "strict": True
"strict": True
}
}]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "How's the weather in Paris today?"}] ,
tools=tools
)
print(completion.choices[0].message.tool_calls)

exportações

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

correio

Exemplo de uma chamada de função usando a função send_email

from openai import OpenAI
cliente = OpenAI()
ferramentas = [{
"type": "function", "function": {
"function": {
"name": "send_email", "description": "Enviar um e-mail para o assunto fornecido.
"description": "Envia um e-mail com assunto e mensagem para o destinatário fornecido." ,
"parameters": {
"type": "object", "properties": {
"properties": {
"to": {
"type": "string", "description": { "endereço de e-mail do destinatário".
"description": "Endereço de e-mail do destinatário".
},
"subject" (assunto): {
"type": "string",
"description": "Linha de assunto do e-mail".
},
"body": {
"type": "string",
"description": "Corpo da mensagem de e-mail".
}
},
"required": [
"para".
"subject" (assunto).
"body" (corpo)
], "additionalProperties": Falso
"additionalProperties": False
}, "additionalProperties": False
"strict": True
}
}]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Você pode enviar um e-mail para ilan@example.com e katia@example.com dizendo "oi"?"}] ,
tools=tools
)
print(completion.choices[0].message.tool_calls)

exportações

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

"function": {
"name": "send_email", "arguments":"{\to_":\95\",\\font/colour
"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
cliente = OpenAI()
ferramentas = [{
"type": "function", "function": {
"function": {
"name": "search_knowledge_base", "description": "Pesquisar em uma base de conhecimento informações sobre um tópico".
"description": "Consulta uma base de conhecimento para recuperar informações relevantes sobre um tópico." ,
"parameters": {
"tipo": "objeto", "propriedades": {
"properties": {
"query" (consulta): {
"type": "string", "description": { "pergunta do usuário ou consulta de pesquisa".
"description": "Pergunta do usuário ou consulta de pesquisa".
},
"options": {
"type": "object", "properties": {
"properties": {
"num_results": {
"type": "number", "description": "Para retornar ao topo da lista de resultados.
"description": "O número de resultados mais bem classificados a serem retornados."
},
"domain_filter": {
"type": [
"string".
"null"
],, "description".
"description": "Domínio opcional para restringir a pesquisa (por exemplo, "finanças", "médico"). Se não for necessário, passe null."
},
"sort_by": {
"type": [
"string".
"null"
],, "enum": [ "enum": [ "string", "null
"enum": [
"relevância".
"data".
"popularidade".
"alfabético"
],, "description": "Como classificar os resultados.
"description": "Como classificar os resultados. Passe null se não for necessário."
}
},
"required": [
"num_results".
"domain_filter",
"sort_by"
], "additionalProperties": False
"additionalProperties": Falso
}
}, "additionalProperties": False }
"required": [
"query" (consulta), "options" (opções): False } } }, "required" (obrigatório): [
"options"
], "additionalProperties": False
"additionalProperties": False
}, "strict": true
"strict": True
}
}]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "You can find information about the ChatGPT de informações?"}] ,
tools=ferramentas
)
print(completion.choices[0].message.tool_calls)

exportações

[{
"id": "call_4567xyz",
"type": "function",
"function": {
"name": "search_knowledge_base", "arguments":"{\query": "What is ChatGPT?
"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

importar solicitações
def get_weather(latitude, longitude): response = requests.
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") speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m")
dados = 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
importar json
cliente = OpenAI()
ferramentas = [{
"type": "function", "function": {
"function": {
"name": "get_weather", "description": "Obter a temperatura atual nas coordenadas fornecidas.
"description": "Obter a temperatura atual em graus Celsius para as coordenadas fornecidas." ,
"parameters": {
"type": "object", "properties": {
"properties": {
"latitude": {"tipo": "número"}, "descrição": {"parâmetros": {"tipo": "objeto", "propriedades": {
"longitude": {"tipo": "número"}
}, "required": ["latitude": ["número"], "longitude": {"tipo": "número"}
"required": ["latitude", "longitude"], "additionalProperties": F
"additionalProperties": False
}, "strict": True
"strict": True
}
}]
messages = [{"role": "user", "content": "What's the weather like in Paris today?"}]
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":"{\8566,\", "arguments": "48.8566,\
"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) # anexa a mensagem de chamada da função do modelo
messages.append({ # append result message

"tool_call_id": tool_call.id, "content": str(result)
"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

"A temperatura atual em Paris é de 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": {
"function": {
"name": "get_weather",
"description": "Recupera o clima atual para um determinado local." ,
"parameters": {
"type": "object", "properties": {
"properties": {
"location": {
"type": "string", "description": "Cidade e país
"description": "Cidade e país, por exemplo, Bogotá, Colômbia"
},
"units": {

"enum": [
"celsius", "fahrenheit
"fahrenheit"
],, "description": "Temp.
"description": "A unidade na qual a temperatura será retornada."
}
}, "description": "As unidades nas quais a temperatura será retornada.
"required": [
"location" (localização).
"units"
], "additionalProperties": False
"additionalProperties": False
}, "strict": True
"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

de openai import OpenAI, pydantic_function_tool
da pydantic import BaseModel, Field
cliente = OpenAI()
class GetWeather(BaseModel).
location: str = Field(
... , description="Cidade e país, por exemplo, Bogotá.
description="Cidade e país, por exemplo, Bogotá, Colômbia")
)
ferramentas = [pydantic_function_tool(GetWeather)]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "What's the weather in Paris today?"}] ,
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".
"function": {
"name": "get_weather", "arguments":"{\"location":\"Paris, France\"}
"arguments":"{\"location\":\"Paris, France\"}"
}
}, {"name": "get_weather", "arguments": "{"location":\"Paris, France\"}" }
{
"id": "call_67890abc", "type": "function", {
"type": "function", "function": { "id": "call_67890abc", "type": "function", "function".
"function": {
"name": "get_weather", "arguments": \"Bogotá", "location": \"Bogotá", "arguments".
"arguments":"{\"location\":\"Bogotá, Colombia\"}"
}
}, }
{
"id": "call_99999def", "type": "function", {
"type": "function", "function": { "call_99999def", { "id": "call_99999def", "type": "function", "function".
"function": {

"arguments":"{\"to\":\"bob@email.com\",\"body\":\"Hi bob\"}"
}
}
]

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

para tool_call em 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_function.function.arguments", result = call_function.arguments
"tool_call_id": tool_call.id, "content": resultado
"content": resultado
})

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

"Está cerca de 15°C em Paris, 18°C em Bogotá, e eu já enviei esse e-mail para o 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": {
"function": {
"name": "get_weather",
"description": "Recupera o clima atual para um determinado local." ,
"strict": true, "parameters": {
"parameters": {
"type": "object", "properties": {
"properties": {
"location": {
"type": "string", "description": "City", "description": "Bogotá",
"description": "Cidade e país, por exemplo, Bogotá, Colômbia"
},
"units": {
"type": ["string", "null"], "enum": ["celsius", ["celsius"], "description": "City and country, e.g. Bogotá, Colombia" }, "units": {
"enum": ["celsius", "fahrenheit"], "description": "A temperatura será
"description": "Em quais unidades a temperatura será retornada."
}
},
"required": ["location", "units"], "additionalProperties".
"additionalProperties": False
}
}
}

Desativar o modo estrito

{
"type": "function", "function": {
"function": {
"name": "get_weather",
"description": "Recupera o clima atual para um determinado local." ,
"parameters": {
"type": "object", "properties": {
"properties": {
"location": {
"type": "string", "description": "Cidade e país
"description": "Cidade e país, por exemplo, Bogotá, Colômbia"
},
"units": {

"enum": ["celsius", "fahrenheit"], "description": "Temp.
"description": "Em quais unidades a temperatura será retornada."
}
},
"required": ["location"],, "description": "A unidade na qual a temperatura será retornada." }
}
}
}

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
cliente = OpenAI()
ferramentas = [{
"type": "function", "function": {
"function": {
"name": "get_weather", "description": "Obter a temperatura atual em um determinado local.
"description": "Obter a temperatura atual em um determinado local." ,
"parameters": {
"type": "object", "properties": {
"properties": {
"location" (local): {
"type": "string", "description": "Cidade e país
"description": "Cidade e país, por exemplo, Bogotá, Colômbia"
}
}, "required".

"additionalProperties": Falso
}, "strict": ["location"], "additionalProperties": False
"strict": True
}
}]
stream = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "How's the weather in Paris today?"}] ,
tools=tools,
stream=True
)
para trecho no fluxo.
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.
para tool_call em chunk.choices[0].delta.tool_calls ou []:
index = tool_call.index
se o índice não estiver em 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".
"id": "call_RzfkBpJgzeR0S242qfvjadNe",
"function": {
"name": "get_weather", "arguments": {
"arguments":"{\"location\":\"Paris, France\"}"
}
}