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

O Processo de 5 Passos

Aula 2 de 14 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Um protocolo claro entre si e o modelo
  2. O fluxo em detalhe
  3. Padrões de fluxo
  4. Pontos-chave

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.

1

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.

2

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.

3

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.

4

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.

5

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)