MCP vs API: quando usar MCP ou HTTP direto em ferramentas de IA

Ao conectar um agente de IA a ferramentas e APIs externas, há duas abordagens gerais: usar o Model Context Protocol (MCP) como uma camada de abstração ou chamar uma API diretamente por HTTP. Ambas funcionam. Elas fazem escolhas diferentes em flexibilidade, complexidade, desempenho e portabilidade.

Este artigo compara as duas abordagens com exemplos concretos de código, análise de latência e um framework de decisão para escolher entre elas.

As duas abordagens

Integração HTTP direta

A aplicação de IA (ou seu backend) chama APIs externas diretamente usando requisições HTTP padrão. O desenvolvedor escreve código para construir requisições, lidar com autenticação, analisar respostas e enviar os resultados de volta ao LLM.

┌─────────┐     ┌────────────────┐                        ┌──────────────────┐
│ Usuário │────▶│ App de IA      │──── Requisição HTTP ───▶│ API de Clima     │
└─────────┘     │                │◀─── Resposta JSON ─────│                  │
                │                │                        └──────────────────┘
                │                │── resultado como contexto ──▶ LLM
                │                │◀── resposta formatada ──────
                └───────┬────────┘
                        │
                        ▼
                  Usuário recebe resposta

Integração MCP

A aplicação de IA se conecta a um servidor MCP que encapsula a API externa. A aplicação usa o protocolo MCP para descobrir as ferramentas disponíveis, chamá-las por nome e receber resultados. O servidor MCP lida com as chamadas HTTP reais para a API externa.

┌─────────┐     ┌───────────────────────┐              ┌──────────────┐     ┌──────────┐
│ Usuário │────▶│ App de IA/Cliente MCP │── JSON-RPC ─▶│ Servidor MCP │────▶│ API HTTP │
└─────────┘     │                       │◀─ JSON-RPC ──│              │◀────│          │
                │                       │              └──────────────┘     └──────────┘
                │                       │── resultado como contexto ──▶ LLM
                │                       │◀── resposta formatada ──────
                └───────────┬───────────┘
                            │
                            ▼
                      Usuário recebe resposta

A principal diferença: com HTTP direto, a aplicação de IA é responsável pelo código de integração com a API. Com MCP, o servidor MCP é responsável por isso, e a aplicação de IA apenas chama ferramentas por nome.

Você pode ter o lado MCP deste diagrama sem criar o servidor: a Quickchat AI hospeda um servidor MCP por HTTP streamable para cada AI Agent, e transformar seu agente em um servidor MCP se resume a colar uma URL no app de IA.

Comparação de código

Vamos comparar as duas abordagens em um exemplo prático: buscar os repositórios de um usuário do GitHub.

Integração HTTP direta

import httpx

async def get_user_repos(username: str, token: str) -> list[dict]:
    """Busca repositórios de um usuário do GitHub."""
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://api.github.com/users/{username}/repos",
            headers={
                "Authorization": f"Bearer {token}",
                "Accept": "application/vnd.github.v3+json",
                "X-GitHub-Api-Version": "2022-11-28"
            },
            params={"sort": "updated", "per_page": 10}
        )
        response.raise_for_status()
        repos = response.json()
        return [
            {
                "name": r["name"],
                "description": r["description"],
                "stars": r["stargazers_count"],
                "language": r["language"],
                "url": r["html_url"]
            }
            for r in repos
        ]

Para integrar isso a um LLM, você também precisa de:

• Uma definição de ferramenta no formato esperado pelo LLM (schema de function calling da OpenAI, schema de tool use do Claude etc.)
• Código para analisar a chamada de ferramenta do LLM, invocar get_user_repos e inserir o resultado de volta na conversa
• Tratamento de erros para falhas HTTP, limites de taxa e expiração de autenticação

Servidor MCP

from mcp.server.fastmcp import FastMCP
import httpx

mcp = FastMCP("github-server")

GITHUB_TOKEN = os.environ["GITHUB_TOKEN"]

@mcp.tool()
async def get_user_repos(username: str) -> str:
    """Busca os 10 repositórios atualizados mais recentemente de um usuário do GitHub.

    Args:
        username: nome de usuário do GitHub a pesquisar
    """
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://api.github.com/users/{username}/repos",
            headers={
                "Authorization": f"Bearer {GITHUB_TOKEN}",
                "Accept": "application/vnd.github.v3+json",
                "X-GitHub-Api-Version": "2022-11-28"
            },
            params={"sort": "updated", "per_page": 10}
        )
        response.raise_for_status()
        repos = response.json()
        lines = []
        for r in repos:
            stars = r["stargazers_count"]
            lang = r["language"] or "desconhecida"
            lines.append(f"- {r['name']} ({lang}, {stars} estrelas): {r['description'] or 'Sem descrição'}")
        return "\n".join(lines)

if __name__ == "__main__":
    mcp.run(transport="stdio")

A versão MCP encapsula a chamada de API, a autenticação e a formatação da resposta dentro do servidor. Qualquer cliente compatível com MCP pode usar essa ferramenta sem saber nada sobre a API do GitHub.

O que muda para a aplicação de IA

Comparação de desempenho

MCP adiciona uma camada entre a aplicação de IA e a API externa. Essa camada tem um custo.

Latência

Para transporte stdio (servidores MCP locais), a sobrecarga é mínima: criação do processo na inicialização (uma única vez, normalmente abaixo de 100ms) e comunicação entre processos por mensagem (menos de um milissegundo em sistemas modernos). Na prática, a chamada à API externa domina a latência total.

Para servidores MCP remotos (Streamable HTTP ou SSE), você adiciona uma ida e volta HTTP entre o cliente e o servidor MCP, além da ida e volta HTTP do servidor MCP para a API externa. Se o servidor MCP e a API externa estiverem na mesma localização, essa sobrecarga é pequena (milissegundos de um dígito). Se estiverem em regiões diferentes, ela se acumula. Porém, o transporte raramente é o que o usuário percebe: ao criar um agente de central de ajuda no servidor MCP hospedado do Notion, 248 chamadas de ferramenta tiveram média de 2,7 segundos cada, quase tudo devido à busca do Notion e à renderização de páginas, e não ao salto intermediário.

Para a maioria dos casos de uso de agentes de IA, em que a inferência do LLM leva 500ms-5s, a sobrecarga do MCP é desprezível.

Gerenciamento de conexões

HTTP direto: sua aplicação gerencia conexões com cada API externa. Isso significa lidar com pools de conexão, lógica de repetição e limites de taxa por API.

MCP: sua aplicação gerencia uma conexão por servidor MCP. O servidor gerencia a conexão com a API externa. Se você tiver 10 ferramentas distribuídas em 3 servidores MCP, gerencia 3 conexões em vez de 10.

Quando usar MCP

Múltiplas integrações de ferramentas

Se sua aplicação de IA precisa se conectar a mais de 5 serviços externos, MCP reduz o esforço de integração. Em vez de escrever e manter clientes de API personalizados para cada serviço, você se conecta a servidores MCP (muitos deles disponíveis como projetos open-source).

Portabilidade entre plataformas de IA

Se você cria servidores MCP para suas ferramentas, esses servidores funcionam com qualquer cliente MCP: Claude Desktop, Cursor, Windsurf, aplicações personalizadas e plataformas como Quickchat AI. Com HTTP direto, você precisaria reimplementar definições de ferramentas para o formato de cada plataforma.

Descoberta dinâmica de ferramentas

MCP oferece descoberta de ferramentas em tempo de execução por meio de tools/list. Uma aplicação de IA pode se conectar a um servidor e saber quais ferramentas estão disponíveis sem qualquer configuração codificada. Isso é útil em cenários em que as ferramentas mudam com frequência ou são configuráveis pelo usuário.

Separação de responsabilidades

Se equipes diferentes são responsáveis por ferramentas diferentes, MCP fornece um limite claro. A equipe responsável pela integração com Salesforce cria e mantém o servidor MCP do Salesforce. A equipe da aplicação de IA se conecta a ele sem precisar entender a API do Salesforce. Atualizações na API do Salesforce são tratadas no servidor MCP sem alterar a aplicação de IA.

Quando usar HTTP direto

Uma ou duas integrações

Se seu agente de IA só precisa chamar uma API (por exemplo, uma consulta em banco de dados), a sobrecarga de executar um servidor MCP é desnecessária. Uma chamada HTTP direta é mais simples e tem menos partes móveis.

Você também não precisa escrever a requisição manualmente. O construtor de API Action em linguagem simples lê uma API REST documentada, gera o método, a URL, os parâmetros e a descrição, e então permite testar a resposta real antes de habilitá-la.

Controle máximo sobre as requisições

Servidores MCP abstraem os detalhes HTTP. Se você precisa de controle preciso sobre a construção da requisição (headers específicos, parâmetros de consulta, assinatura de requisições ou autenticação fora do padrão), HTTP direto oferece esse controle sem lutar contra uma camada de abstração.

Operações sensíveis à latência

Se cada milissegundo importa (por exemplo, agentes de voz em tempo real em que as chamadas de ferramenta devem ser concluídas dentro de orçamentos de tempo estritos), remover a camada MCP elimina um salto.

Chamadas HTTP que não são de IA

Se a chamada HTTP não é acionada por um agente de IA (por exemplo, um cron job de backend que sincroniza dados), MCP é irrelevante. MCP foi projetado especificamente para comunicação entre IA e ferramentas. Serviços de backend regulares devem usar clientes HTTP regulares.

Abordagem híbrida

Muitos sistemas em produção usam ambos. O padrão:

• MCP para integrações de ferramentas que o agente de IA chama durante conversas (consultas em CRM, criação de tickets, consultas em base de conhecimento)
• HTTP direto para operações internas de backend, webhooks e comunicação sistema a sistema

É assim que a Quickchat AI funciona internamente. A plataforma oferece suporte a HTTP Request Actions (chamadas diretas de API com parametrização por template) e Remote MCP Actions (conexões a servidores MCP externos). Você escolhe a abordagem correta para cada integração:

Para uma comparação detalhada de como isso funciona na prática, incluindo as diferenças entre GPT Actions da OpenAI e MCP, consulte GPT Actions vs MCP.

Framework de decisão

Use este fluxograma para escolher:

1. O agente de IA está chamando a ferramenta? Se não (é uma operação de backend), use HTTP direto.
2. De quantas ferramentas externas você precisa? Se forem 1-2, HTTP direto é mais simples. Se forem 3 ou mais, considere MCP.
3. Existe um servidor MCP pré-construído para o serviço? Se sim, usá-lo economiza tempo de desenvolvimento.
4. Você precisa que a integração funcione em várias plataformas de IA? Se sim, MCP oferece portabilidade.
5. A latência é crítica (orçamento abaixo de 100ms para chamadas de ferramenta)? Se sim, meça a sobrecarga do MCP e decida de acordo.
6. Equipes diferentes são responsáveis por integrações diferentes? Se sim, o modelo de um servidor por integração do MCP ajuda com limites de responsabilidade.

Na prática, se você está criando um agente de IA que precisa interagir com serviços externos, MCP é cada vez mais a escolha padrão. O ecossistema de servidores pré-construídos já é grande o suficiente para que muitas vezes você possa começar sem escrever qualquer código de servidor.

Leitura adicional

• Conecte seu AI Agent a um servidor MCP remoto: dê ao seu agente ferramentas ativas, passo a passo
• Como o Model Context Protocol funciona. MCP explicado: introdução ao MCP
• GPT Actions vs MCP: comparação com a abordagem da OpenAI
• Especificação MCP: a especificação oficial do protocolo
• HubSpot AI Actions: exemplo de ações de IA baseadas em HTTP na prática
• O incidente OpenAI Hugging Face, o que realmente aconteceu: o incidente explicado passo a passo, e o que hacking realmente significa