Function calling na API do WhatsApp: como o agente agenda, consulta e cria tickets sozinho

Function calling é o modelo decidir, no meio da conversa, que precisa executar uma ação do seu sistema — consultar um pedido, checar um horário, abrir um ticket — em vez de responder só com texto. Você declara as funções disponíveis com uma descrição clara de cada uma, o modelo escolhe qual chamar e com quais parâmetros, seu código executa de verdade, e o resultado volta para o modelo formular a resposta final ao cliente.

O loop, em quatro passos

1. Cliente pergunta → 2. Modelo decide chamar uma função → 3. Seu código executa → 4. Modelo responde com o resultado

Isso é uma volta a mais do que um chatbot simples: em vez de responder direto, o modelo pode "pausar" e pedir a execução de uma ação antes de formular a resposta final.

import OpenAI from "openai";
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const ferramentas = [
  {
    type: "function",
    function: {
      name: "consultar_pedido",
      description: "Consulta o status de um pedido pelo número",
      parameters: {
        type: "object",
        properties: { numeroPedido: { type: "string" } },
        required: ["numeroPedido"],
      },
    },
  },
  {
    type: "function",
    function: {
      name: "criar_ticket",
      description: "Abre um ticket de suporte quando o cliente relata um problema",
      parameters: {
        type: "object",
        properties: {
          assunto: { type: "string" },
          descricao: { type: "string" },
          prioridade: { type: "string", enum: ["baixa", "media", "alta"] },
        },
        required: ["assunto", "descricao"],
      },
    },
  },
];

Executando o que o modelo pede

const FUNCOES = {
  consultar_pedido: async ({ numeroPedido }) => {
    const pedido = await buscarPedidoNoBanco(numeroPedido); // sua consulta real
    if (!pedido) return { erro: "Pedido não encontrado" };
    return { status: pedido.status, previsao: pedido.previsaoEntrega };
  },
  criar_ticket: async ({ assunto, descricao, prioridade }) => {
    const ticket = await abrirTicketNoSistema({ assunto, descricao, prioridade });
    return { ticketId: ticket.id, mensagem: "Ticket aberto com sucesso" };
  },
};

async function responderComFerramentas(historico, mensagemNova) {
  const mensagens = [...historico, { role: "user", content: mensagemNova }];

  const primeira = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: mensagens,
    tools: ferramentas,
  });

  const escolha = primeira.choices[0].message;

  // O modelo respondeu direto, sem precisar de função
  if (!escolha.tool_calls) return escolha.content;

  // O modelo pediu uma ou mais funções — executa cada uma
  mensagens.push(escolha);
  for (const chamada of escolha.tool_calls) {
    const funcao = FUNCOES[chamada.function.name];
    const argumentos = JSON.parse(chamada.function.arguments);

    // NUNCA confie cegamente no que o modelo passou — valide antes de executar
    const resultado = funcao ? await funcao(argumentos) : { erro: "Função desconhecida" };

    mensagens.push({
      role: "tool",
      tool_call_id: chamada.id,
      content: JSON.stringify(resultado),
    });
  }

  // Segunda chamada: o modelo formula a resposta final com o resultado da função
  const final = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: mensagens,
  });

  return final.choices[0].message.content;
}

Repare que são duas chamadas ao modelo por interação com função: a primeira decide o quê chamar, a segunda formula a resposta com o resultado em mãos. Isso soma latência e custo — vale considerar no orçamento do agente quando o volume de conversas com função é alto.

Validar antes de executar

O modelo pode errar o parâmetro, ou tentar chamar uma função com dado incompleto. Tratar a saída do modelo como entrada não confiável — do mesmo jeito que trataria um input vindo de um formulário público — evita que um número de pedido malformado chegue direto na consulta ao banco:

consultar_pedido: async ({ numeroPedido }) => {
  if (!/^\d{6,10}$/.test(numeroPedido)) {
    return { erro: "Número de pedido em formato inválido" };
  }
  // ...segue a consulta
},

Quando isso substitui function calling por MCP

A pergunta que decide entre os dois caminhos: quem é o consumidor do agente?

Se o agente é parte do seu produto — um bot de atendimento ou vendas rodando dentro do seu sistema, que você controla de ponta a ponta — function calling direto, como no código acima, dá controle total sobre validação, log e tratamento de erro de cada função.

Se o consumidor é um agente de terceiros — alguém usando Claude, Cursor ou outro cliente compatível para operar o WhatsApp da própria conta — reescrever essa mesma lógica de function calling para cada cliente não escala. Aí o caminho mais direto é expor as ações como ferramentas MCP: o protocolo já padroniza a descoberta e a chamada, e você não integra de novo a cada agente novo que aparece.

Os dois não competem — um agente de vendas seu pode usar function calling direto para consultar pedido, e ao mesmo tempo o MCP da WAME serve outro caso de uso: alguém no seu time usando Claude Code para operar a caixa de entrada.

Combinando com o resto da arquitetura

Function calling raramente aparece sozinho. Um agente de SDR qualificando lead usa function calling para agendar reunião. Um bot de suporte usa para consultar pedido e, quando não resolve, para abrir um ticket e escalar para humano. E qualquer um dos dois se beneficia de RAG para responder dúvidas de catálogo antes mesmo de precisar chamar uma função.

Conclusão

Function calling é o que transforma um agente de "conversa bem" em "resolve de verdade" — a diferença entre responder "seu pedido deve chegar em breve" e responder com o status real, consultado na hora. A implementação não exige nenhum protocolo especial: descrever bem cada função, validar o que o modelo devolve antes de executar, e tratar o resultado como parte normal da conversa. MCP entra depois, quando o consumidor dessas mesmas capacidades deixa de ser só o seu próprio bot.