O Processo de 5 Passos
Um protocolo claro entre si e o modelo
A chamada de funções do Mistral segue um processo bem definido de cinco passos. O que torna este protocolo legível é que cada passo tem um único proprietário: seja si (o programador), o modelo ou o utilizador. Nenhum passo é partilhado e nenhum é ambíguo. Dedique algum tempo a memorizar esta divisão de tarefas antes de escrever uma única linha de código: a maioria dos erros de chamada de funções ocorre quando um programador espera que o modelo trate de um passo que é, na realidade, da sua responsabilidade.
Definir as funções (Programador)
Descreve cada função disponível com um esquema JSON: nome, descrição, parâmetros, tipos e campos obrigatórios. O modelo vê apenas esta especificação, não o seu código.
O utilizador faz uma pergunta (Utilizador)
O utilizador coloca a sua pergunta em linguagem natural. Envia este pedido ao modelo Mistral juntamente com a lista de ferramentas disponíveis.
Gerar argumentos (Modelo)
O modelo analisa o pedido, seleciona a função adequada e gera os argumentos em formato JSON. Não executa a função; limita-se a indicar-lhe o que chamar e com quais parâmetros.
Executar a função (Programador)
O seu código extrai o nome da função e os argumentos da resposta do modelo, executa a função correspondente e recupera o resultado.
Gerar a resposta final (Modelo)
Envia o resultado da função de volta ao modelo. Este integra o resultado no contexto da conversa e formula uma resposta natural para o utilizador.
O fluxo em detalhe
Estes cinco passos mapeiam-se diretamente para o código. Vamos percorrer todos eles usando um único exemplo, intencionalmente minimalista: um utilizador quer saber o estado do pagamento T1001. Utilizaremos este mesmo exemplo como fio condutor até ao final do bloco «Implementação em Python», por isso familiarize-se agora com os seus identificadores.
Passo 1: Define as ferramentas
tools = [
{
"type": "function",
"function": {
"name": "get_payment_status",
"description": "Retrieves the status of a payment given its transaction ID",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The unique transaction identifier (e.g., T1001)"
}
},
"required": ["transaction_id"]
}
}
}
]
Nada aqui é código executável: é uma descrição. O modelo aprende que existe uma função chamada get_payment_status, o que ela faz e que requer um transaction_id do tipo string. Nunca aprende como a função é implementada.
Passo 2: O utilizador faz a sua pergunta
messages = [
{"role": "user", "content": "What is the status of payment T1001?"}
]
Passo 3: O modelo gera os argumentos
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
# The model returns a tool_call:
# function.name = "get_payment_status"
# function.arguments = '{"transaction_id": "T1001"}'
O modelo extraiu «T1001» da frase e colocou-o no campo correto. Note que arguments chega como uma string, não como um dicionário: tratará desse detalhe no passo seguinte.
Passo 4: Executa a função
import json
tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_payment_status(**args)
# → {"status": "paid", "date": "2026-03-15"}
Passo 5: O modelo formula a resposta
messages.append(response.choices[0].message)
messages.append({
"role": "tool",
"name": "get_payment_status",
"content": json.dumps(result),
"tool_call_id": tool_call.id
})
final = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
print(final.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026."
São adicionadas duas mensagens ao histórico, nunca apenas uma: a mensagem do assistente que transporta o pedido de chamada, seguida da mensagem que transporta o resultado. O tool_call_id liga as duas. Omita uma delas e a API rejeitará o pedido, ou o modelo responderá fora do contexto.
Padrões de fluxo
Dependendo da complexidade do pedido, este fluxo pode assumir diferentes formas. O caso mais simples é quando não está envolvida nenhuma função: o utilizador faz uma pergunta geral — «O que é que pode fazer?» — e o modelo responde diretamente sem jamais tocar nas ferramentas. Segue-se a chamada simples que acabámos de percorrer: uma função, um resultado, uma resposta.
As duas formas seguintes são mais interessantes. Numa cadeia sequencial, o modelo chama uma primeira função, lê o resultado e usa-o para decidir sobre uma segunda chamada — tipicamente recuperando um ID de cliente antes de consultar as suas faturas. Numa chamada paralela, solicita a execução de várias funções de uma vez porque nenhuma depende da outra. Dedicaremos lições inteiras a estes dois padrões; por agora, lembre-se de que ambos se baseiam exatamente nos cinco passos acima, simplesmente repetidos.
Pontos-chave
- A chamada de funções segue um processo de 5 passos com responsabilidades claras
- O modelo nunca pode executar uma função diretamente; apenas gera argumentos
- O seu código é o guardião: decide se executa ou não a função
- O resultado da função é enviado de volta ao modelo para que este possa formular uma resposta natural
- O fluxo pode ser simples (uma chamada) ou complexo (sequencial, paralelo)