Skip to Content
DocumentaçãoGuiasFunction Calling

Function Calling

O Function Calling permite que o modelo selecione e chame automaticamente funções predefinidas conforme a necessidade do usuário, possibilitando consultas de dados, chamadas de API, execução de tarefas e mais.

Conceito básico

O fluxo completo do Function Calling:

  1. Definir ferramentas — Descreva na requisição as funções disponíveis e seus parâmetros
  2. Decisão do modelo — O modelo decide se precisa chamar uma ferramenta
  3. Retornar chamada — O modelo retorna o nome da função e os argumentos
  4. Executar função — Você executa a função e obtém o resultado
  5. Continuar diálogo — Envie o resultado de volta ao modelo para a resposta final

Protocolo OpenAI

function_calling.py
from openai import OpenAI
import json
 
client = OpenAI(
    base_url="https://api.ofox.ai/v1",
    api_key="<Sua OFOXAI_API_KEY>"
)
 
# 1. Definir ferramentas
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Obter informações meteorológicas em tempo real de uma cidade específica",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Nome da cidade, ex.: Pequim, Xangai"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Unidade de temperatura"
                }
            },
            "required": ["city"]
        }
    }
}]
 
# 2. Enviar requisição
messages = [{"role": "user", "content": "Como está o tempo em Pequim hoje?"}]
 
response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)
 
message = response.choices[0].message
 
# 3. Processar chamada de ferramenta
if message.tool_calls:
    for tool_call in message.tool_calls:
        args = json.loads(tool_call.function.arguments)
 
        # 4. Executar sua função
        result = get_weather(args["city"])  # Sua implementação
 
        # 5. Enviar resultado de volta ao modelo
        messages.append(message)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result)
        })
 
    # Obter resposta final
    final = client.chat.completions.create(
        model="openai/gpt-4o",
        messages=messages,
        tools=tools
    )
    print(final.choices[0].message.content)

Protocolo Anthropic

O Anthropic usa o parâmetro tools com formato ligeiramente diferente:

anthropic_tools.py
import anthropic
 
client = anthropic.Anthropic(
    base_url="https://api.ofox.ai/anthropic",
    api_key="<Sua OFOXAI_API_KEY>"
)
 
response = client.messages.create(
    model="anthropic/claude-sonnet-4.5",
    max_tokens=1024,
    tools=[{
        "name": "get_weather",
        "description": "Obter informações meteorológicas em tempo real de uma cidade específica",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "Nome da cidade"}
            },
            "required": ["city"]
        }
    }],
    messages=[{"role": "user", "content": "Como está o tempo em Pequim hoje?"}]
)
 
# Processar content block tool_use
for block in response.content:
    if block.type == "tool_use":
        print(f"Chamada de ferramenta: {block.name}, Parâmetros: {block.input}")

Chamadas de função paralelas

O modelo pode retornar múltiplas chamadas de ferramenta em uma única resposta, que devem ser executadas em paralelo:

# O modelo pode solicitar múltiplas chamadas de ferramenta simultaneamente
if message.tool_calls:
    # Executar todas as chamadas de ferramenta em paralelo
    import asyncio
 
    async def execute_tools(tool_calls):
        tasks = []
        for tc in tool_calls:
            args = json.loads(tc.function.arguments)
            tasks.append(execute_function(tc.function.name, args))
        return await asyncio.gather(*tasks)

Parâmetro tool_choice

ValorDescrição
"auto"O modelo decide automaticamente se chama ferramentas (padrão)
"none"Desabilitar chamadas de ferramenta
"required"Forçar chamada de ferramenta
{"type": "function", "function": {"name": "xxx"}}Forçar chamada de uma ferramenta específica

Modelos suportados

Os seguintes modelos suportam Function Calling:

  • OpenAI: gpt-4o, gpt-4o-mini, o1, o3-mini
  • Anthropic: claude-opus-4, claude-sonnet-4, claude-3-5-haiku
  • Google: gemini-3.1-pro-preview, gemini-3-flash-preview, gemini-3-pro-preview
  • Outros: deepseek-chat, qwen-max, glm-4
Last updated on
StreamingCompreensão visual