---
title: "Function calling na API do WhatsApp sem MCP"
description: "Como implementar function calling na API do WhatsApp sem MCP: o agente decide qual função chamar, seu código executa e a resposta volta pela API."
url: "https://api-wa.me/blog/function-calling-api-whatsapp-agente-ia"
language: "pt-BR"
og:type: "article"
og:site_name: "WAME API"
---

[Início](https://api-wa.me/)/[Blog da API do WhatsApp](https://api-wa.me/blog)/Function calling na API do WhatsApp: como o agente agenda, consulta e cria tickets sozinho

Raphael Serafim· Publicado em 16 de setembro de 2026· 9 min de leitura

Compartilhar

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

Como implementar function calling na API do WhatsApp sem MCP: o agente decide qual função chamar, seu código executa e a resposta volta pela API.

Copiar para LLM[Ver como Markdown](https://api-wa.me/blog/function-calling-api-whatsapp-agente-ia.md)

**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

Copiar

```
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.

javascript

Copiar

```
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

javascript

Copiar

```
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](https://api-wa.me/blog/quanto-custa-agente-ia-whatsapp) 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:

javascript

Copiar

```
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](https://api-wa.me/blog/mcp-agente-ia-whatsapp): 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](https://api-wa.me/blog/agente-ia-sdr-whatsapp-qualificar-vender) 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](https://api-wa.me/blog/quando-ia-deve-parar-responder-whatsapp). E qualquer um dos dois se beneficia de [RAG](https://api-wa.me/blog/rag-whatsapp-base-conhecimento-ia) 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.

### Pronto para automatizar seu WhatsApp?

Crie sua conta gratuita e comece a enviar mensagens pela API em minutos.

[Começar grátis](https://portal.api-wa.me/sign-up)

## Perguntas frequentes

O que é function calling num agente de IA?+

É o modelo decidir, durante a conversa, que precisa chamar uma função do seu código para responder — como consultar o status de um pedido ou verificar um horário disponível — em vez de responder só com o que já sabe. Você descreve as funções disponíveis, o modelo escolhe qual chamar e com quais parâmetros, e seu código executa e devolve o resultado.

Function calling é a mesma coisa que MCP?+

Não. Function calling é o mecanismo do modelo decidir chamar uma função; MCP é um protocolo padronizado para expor essas funções (chamadas de 'ferramentas') de forma que qualquer agente compatível descubra e use sem você escrever a integração para cada cliente. Function calling direto dá mais controle sobre quando e como cada função roda; MCP economiza a integração quando o consumidor é um agente externo, como Claude ou Cursor — a diferença está detalhada em \[MCP na prática\](/blog/mcp-agente-ia-whatsapp).

Quando faz sentido usar function calling em vez de MCP?+

Quando o agente é parte do seu próprio produto — um bot de atendimento ou de vendas que você controla de ponta a ponta — e você precisa de controle fino sobre quando cada função executa, como validar o resultado e como tratar erro. MCP compensa mais quando o consumidor é um agente de terceiros (Claude, Cursor, um cliente do seu cliente) que você não controla.

O modelo pode chamar uma função errada ou com parâmetro errado?+

Pode, principalmente se a descrição da função for vaga. Descrições claras e específicas de cada parâmetro reduzem bastante esse erro, mas seu código ainda deve validar o que recebe antes de executar — nunca confiar cegamente no que o modelo passou, da mesma forma que você validaria um input de usuário.

Function calling funciona com qualquer modelo?+

Os modelos mais usados em produção (GPT da OpenAI, Claude da Anthropic, Gemini do Google) suportam function calling de forma nativa, com pequenas diferenças de formato na API. A lógica é a mesma nos três: você declara as funções, o modelo retorna qual chamar, seu código executa e devolve o resultado para o modelo formular a resposta final.

## Continue lendo

[### Automatizar grupos de WhatsApp pela API: guia completo

Como automatizar grupos de WhatsApp pela API: criar, adicionar participante, moderar entrada e enviar aviso automático, com exemplos práticos em cURL.](https://api-wa.me/blog/automatizar-grupos-whatsapp-api)[### Catálogo com carrinho no WhatsApp: como vender sem sair da conversa via API

Veja como popular o catálogo de produtos via API do WhatsApp e montar um fluxo de carrinho nativo, sem redirecionar o cliente pra fora da conversa.](https://api-wa.me/blog/catalogo-carrinho-whatsapp-api-vendas)[### Checklist de compliance para WhatsApp API em 2026

Checklist prático de compliance para WhatsApp API: opt-in, LGPD, Quality Rating e política de template — o que auditar antes de escalar o envio em 2026.](https://api-wa.me/blog/checklist-compliance-whatsapp-api-2026)

[Voltar ao blog](https://api-wa.me/blog)

## Structured data

```json
{
  "@context": "https://schema.org",
  "@type": "WebSite",
  "name": "WAME API",
  "alternateName": "API Oficial e Não Oficial de WhatsApp, Instagram e Messenger",
  "url": "https://api-wa.me",
  "inLanguage": "pt-BR",
  "publisher": {
    "@id": "https://api-wa.me/#organization",
    "@type": "Organization",
    "name": "WAME API",
    "url": "https://api-wa.me"
  }
}
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "@id": "https://api-wa.me/#organization",
  "name": "WAME API",
  "alternateName": [
    "WAME",
    "Wame API",
    "wame.api.br",
    "api-wa.me"
  ],
  "url": "https://api-wa.me",
  "logo": {
    "@type": "ImageObject",
    "url": "https://api-wa.me/images/web-app-manifest-512x512.png",
    "width": 512,
    "height": 512
  },
  "disambiguatingDescription": "WAME API é uma empresa brasileira de software, fundada em 2017 e parceira oficial da Meta (Meta Business Partner), que fornece APIs de WhatsApp, Instagram Direct e Messenger. Não tem relação com o wa.me, que é o encurtador de links operado pela WhatsApp LLC.",
  "identifier": {
    "@type": "PropertyValue",
    "propertyID": "INPI-BR",
    "name": "Pedido de registro de marca (INPI, classe NCL 42)",
    "value": "944724159"
  },
  "foundingDate": "2017",
  "slogan": "Parceira Oficial da Meta — WhatsApp, Instagram e Messenger numa instância só. Desde 2017.",
  "description": "Plataforma brasileira e Parceira Oficial da Meta (Meta Business Partner) para as APIs oficiais de WhatsApp (Cloud API), Instagram Direct e Messenger — os três numa única instância, com os mesmos endpoints e um único formato de webhook. Também oferece a API não oficial via QR Code, na mesma plataforma. No mercado desde 2017, com mais de 50 mil instâncias criadas, 99,9% de uptime e suporte humano 24/7 em português. SDKs oficiais para Node.js/TypeScript e PHP.",
  "knowsAbout": [
    "WhatsApp Cloud API oficial (Meta)",
    "API oficial de Instagram (Direct)",
    "API oficial de Messenger",
    "API multicanal Meta",
    "Meta Business Partner",
    "WhatsApp API",
    "API não oficial de WhatsApp",
    "automação de WhatsApp",
    "números virtuais",
    "webhooks"
  ],
  "sameAs": [
    "https://github.com/wame-api",
    "https://www.linkedin.com/company/wameapi",
    "https://www.instagram.com/wame.api/",
    "https://www.youtube.com/@wameapi"
  ],
  "contactPoint": {
    "@type": "ContactPoint",
    "contactType": "customer support",
    "url": "https://api-wa.me/contact",
    "availableLanguage": [
      "Portuguese"
    ]
  }
}
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Function calling na API do WhatsApp: como o agente agenda, consulta e cria tickets sozinho",
  "description": "Como implementar function calling na API do WhatsApp sem MCP: o agente decide qual função chamar, seu código executa e a resposta volta pela API.",
  "image": "https://api-wa.me/blog/function-calling-api-whatsapp-agente-ia/opengraph-image",
  "datePublished": "2026-09-16",
  "dateModified": "2026-09-16",
  "author": {
    "@type": "Person",
    "name": "Raphael Serafim",
    "url": "https://github.com/raphaelvserafim",
    "sameAs": [
      "https://github.com/raphaelvserafim"
    ]
  },
  "publisher": {
    "@type": "Organization",
    "name": "api-wa.me",
    "logo": {
      "@type": "ImageObject",
      "url": "https://api-wa.me/images/screenshot.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://api-wa.me/blog/function-calling-api-whatsapp-agente-ia"
  },
  "keywords": "function calling whatsapp api, agente de ia que executa acoes whatsapp, tool use whatsapp api, ia consulta pedido whatsapp, ia cria ticket whatsapp automatico, function calling openai whatsapp, agente de ia com ferramentas whatsapp",
  "inLanguage": "pt-BR"
}
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://api-wa.me"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog da API do WhatsApp",
      "item": "https://api-wa.me/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Function calling na API do WhatsApp: como o agente agenda, consulta e cria tickets sozinho",
      "item": "https://api-wa.me/blog/function-calling-api-whatsapp-agente-ia"
    }
  ]
}
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "O que é function calling num agente de IA?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "É o modelo decidir, durante a conversa, que precisa chamar uma função do seu código para responder — como consultar o status de um pedido ou verificar um horário disponível — em vez de responder só com o que já sabe. Você descreve as funções disponíveis, o modelo escolhe qual chamar e com quais parâmetros, e seu código executa e devolve o resultado."
      }
    },
    {
      "@type": "Question",
      "name": "Function calling é a mesma coisa que MCP?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Não. Function calling é o mecanismo do modelo decidir chamar uma função; MCP é um protocolo padronizado para expor essas funções (chamadas de 'ferramentas') de forma que qualquer agente compatível descubra e use sem você escrever a integração para cada cliente. Function calling direto dá mais controle sobre quando e como cada função roda; MCP economiza a integração quando o consumidor é um agente externo, como Claude ou Cursor — a diferença está detalhada em [MCP na prática](/blog/mcp-agente-ia-whatsapp)."
      }
    },
    {
      "@type": "Question",
      "name": "Quando faz sentido usar function calling em vez de MCP?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Quando o agente é parte do seu próprio produto — um bot de atendimento ou de vendas que você controla de ponta a ponta — e você precisa de controle fino sobre quando cada função executa, como validar o resultado e como tratar erro. MCP compensa mais quando o consumidor é um agente de terceiros (Claude, Cursor, um cliente do seu cliente) que você não controla."
      }
    },
    {
      "@type": "Question",
      "name": "O modelo pode chamar uma função errada ou com parâmetro errado?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Pode, principalmente se a descrição da função for vaga. Descrições claras e específicas de cada parâmetro reduzem bastante esse erro, mas seu código ainda deve validar o que recebe antes de executar — nunca confiar cegamente no que o modelo passou, da mesma forma que você validaria um input de usuário."
      }
    },
    {
      "@type": "Question",
      "name": "Function calling funciona com qualquer modelo?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Os modelos mais usados em produção (GPT da OpenAI, Claude da Anthropic, Gemini do Google) suportam function calling de forma nativa, com pequenas diferenças de formato na API. A lógica é a mesma nos três: você declara as funções, o modelo retorna qual chamar, seu código executa e devolve o resultado para o modelo formular a resposta final."
      }
    }
  ]
}
```