Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Function Calling: Ligar a IA aos Seus Sistemas

Aula 10 de 22 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. Function Calling: Ligar a IA aos Seus Sistemas
  2. O Fluxo Completo, Passo a Passo
  3. Permitir que o Modelo Escolha Entre Múltiplas Ferramentas
  4. O Ciclo do Agente
  5. Bloquear Argumentos com o Modo Estrito
  6. Pontos-chave

Function Calling: Ligar a IA aos Seus Sistemas

O function calling permite ao modelo invocar funções que o utilizador define. Mantenha uma regra em primeiro plano, pois tudo o resto deriva dela: o modelo não as executa. Ele indica-lhe qual a função a chamar e com que argumentos; o seu código realiza a execução e devolve o resultado. A sua base de dados, as suas credenciais e a sua lógica de negócio nunca saem da sua infraestrutura.

O Fluxo Completo, Passo a Passo

A troca ocorre em quatro fases:

  1. Declara as funções disponíveis juntamente com os seus parâmetros
  2. O modelo analisa o pedido e decide chamar uma função
  3. O seu código executa a função e obtém o resultado
  4. Envia o resultado de volta ao modelo para que este possa formular a sua resposta

A declaração merece cuidado especial: a description da função e a descrição de cada parâmetro são a única documentação que o modelo possui para tomar a sua decisão. Descrições vagas levam a chamadas aproximadas. Note também como fechar o ciclo: o resultado é devolvido com o call_id que recebeu, o qual atua como um reconhecimento e permite à API associar a resposta ao pedido.

from openai import OpenAI
import json

client = OpenAI()

# Step 1: Declare available functions
tools = [{
    "type": "function",
    "name": "get_meteo",
    "description": "Get the current weather for a city",
    "parameters": {
        "type": "object",
        "properties": {
            "ville": {
                "type": "string",
                "description": "The name of the city"
            },
            "unite": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Temperature unit"
            }
        },
        "required": ["ville"]
    }
}]

# Step 2: The model decides to call the function
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather like in Marseille?",
    tools=tools
)

# Step 3: Execute the function
for item in response.output:
    if item.type == "function_call":
        print(f"Function: {item.name}")
        print(f"Arguments: {item.arguments}")
        args = json.loads(item.arguments)

        # Your actual implementation
        resultat_meteo = {"temperature": 22, "condition": "sunny"}

        # Step 4: Send the result back to the model
        final = client.responses.create(
            model="gpt-5.6-terra",
            input=[
                {"role": "user", "content": "What's the weather like in Marseille?"},
                {
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": json.dumps(resultat_meteo)
                }
            ],
            tools=tools
        )
        print(f"Response: {final.output_text}")

# Result:
# Function: get_meteo
# Arguments: {"ville": "Marseille"}
# Response: It is currently 22 C in Marseille with sunny weather.

Permitir que o Modelo Escolha Entre Múltiplas Ferramentas

O verdadeiro valor surge quando expõe um catálogo inteiro de capacidades. Num assistente de comércio eletrónico, declararia a pesquisa de produtos, a verificação de stocks e a colocação de encomendas, deixando depois o modelo arbitrar. Perante «O portátil gaming XPS está disponível?», ele não realizará uma pesquisa, mas consultará diretamente o stock: foram as descrições das suas funções, e não uma regra codificada, que conduziram essa escolha.

tools = [
    {
        "type": "function",
        "name": "rechercher_produit",
        "description": "Search for a product in the catalog",
        "parameters": {
            "type": "object",
            "properties": {
                "requête": {"type": "string", "description": "Search terms"},
                "categorie": {"type": "string", "description": "Category (optional)"}
            },
            "required": ["requête"]
        }
    },
    {
        "type": "function",
        "name": "verifier_stock",
        "description": "Check product availability",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string", "description": "Product ID"}
            },
            "required": ["produit_id"]
        }
    },
    {
        "type": "function",
        "name": "passer_commande",
        "description": "Place an order for a product",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string"},
                "quantite": {"type": "integer", "description": "Number of units"}
            },
            "required": ["produit_id", "quantite"]
        }
    }
]

# The model automatically chooses the right function
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Is the XPS gaming laptop available?",
    tools=tools
)

for item in response.output:
    if item.type == "function_call":
        print(f"Function chosen: {item.name}")
        print(f"Arguments: {item.arguments}")

# Result: Function chosen: verifier_stock
# Arguments: {"produit_id": "xps-gaming"}

Um único pedido pode também desencadear múltiplas chamadas em simultâneo. Comparar o tempo em duas cidades produz duas chamadas independentes: o seu código deve, portanto, iterar sobre response.output e tratar todos os itens function_call, nunca apenas o primeiro. Esta é também uma oportunidade para executar essas chamadas em paralelo e reduzir a latência para metade.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compare the weather between Paris and Lyon.",
    tools=[{
        "type": "function",
        "name": "get_meteo",
        "description": "Get the weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"]
        }
    }]
)

# The model makes two calls in parallel
function_calls = [item for item in response.output if item.type == "function_call"]
print(f"Number of calls: {len(function_calls)}")
for call in function_calls:
    args = json.loads(call.arguments)
    print(f"  - get_meteo({args['ville']})")

# Result:
# Number of calls: 2
#   - get_meteo(Paris)
#   - get_meteo(Lyon)

O Ciclo do Agente

Uma única ida e volta raramente é suficiente: o resultado de uma função leva frequentemente o modelo a chamar outra. Assim, envolve a troca num ciclo que corre enquanto a resposta contiver chamadas de função e para assim que deixar de as conter — um sinal de que o modelo formulou a sua resposta final. Esta é a espinha dorsal de qualquer agente, e verá esta estrutura sob várias formas em todas as frameworks de agentes.

def executer_fonction(nom: str, arguments: str) -> str:
    """Execute a function and return the result."""
    args = json.loads(arguments)

    if nom == "get_meteo":
        # Simulation — replace with your real API
        return json.dumps({"temp": 18, "condition": "cloudy"})
    elif nom == "get_heure":
        return json.dumps({"heure": "14:30", "timezone": "CET"})

    return json.dumps({"error": "Unknown function"})

def agent_loop(question: str, tools: list) -> str:
    """Agent loop: call functions until the final response."""
    input_messages = [{"role": "user", "content": question}]

    while True:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=input_messages,
            tools=tools
        )

        # Check for function calls
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # No function calls = final response
            return response.output_text

        # Execute each function and add results
        for call in function_calls:
            resultat = executer_fonction(call.name, call.arguments)
            input_messages.append({
                "type": "function_call_output",
                "call_id": call.call_id,
                "output": resultat
            })

# Usage
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)

Uma palavra de cautela sobre este padrão: o ciclo while True não possui salvaguardas. Em produção, adicione um contador máximo de iterações; caso contrário, um modelo que solicite indefinidamente a mesma ferramenta consumirá o seu orçamento sem jamais concluir.

Bloquear Argumentos com o Modo Estrito

O modo estrito aplica aos parâmetros das funções a mesma garantia que o Structured Output aplica às respostas: os argumentos aderem estritamente ao esquema declarado. Para uma função que cria um utilizador, isto impede que receba uma idade como cadeia de caracteres ou um campo extra que o seu código não esperava.

tools = [{
    "type": "function",
    "name": "creer_utilisateur",
    "description": "Create a new user",
    "strict": True,
    "parameters": {
        "type": "object",
        "properties": {
            "nom": {"type": "string"},
            "email": {"type": "string"},
            "age": {"type": "integer"}
        },
        "required": ["nom", "email", "age"],
        "additionalProperties": False
    }
}]

Pontos-chave

  • O function calling liga o modelo aos seus sistemas sem expor os seus dados
  • O modelo decide qual a função a chamar; o seu código executa-a
  • Devolva o resultado utilizando function_call_output e o call_id
  • O modelo pode chamar múltiplas funções em paralelo
  • Utilize um ciclo de agente para conversas em várias voltas que envolvam funções
  • Ative strict: True para garantir a conformidade dos argumentos