Model Context Protocol (MCP) com Claude: guia de implementação completo

O Model Context Protocol (MCP) é o novo padrão da Anthropic para conectar agentes Claude às suas ferramentas, bancos de dados e serviços de negócios. Lançado oficialmente em junho de 2026 e integrado ao Claude Sonnet 5, MCP permite que seus agentes de IA acessem dados diretamente sem passar por integrações fake ou gambiarras de API.

Se você está construindo agentes de IA em 2026, MCP não é mais opcional, é a base. Veja como implementar.

O que é realmente o model context protocol?

MCP não é uma nova API para chamar Claude (você já tem isso). É um protocolo de interoperabilidade que define como uma aplicação cliente (Claude, Cursor, Grok Build, ou sua própria IA) se conecta a servidores MCP que expõem ferramentas, recursos e dados.

Analogia: MCP é para Claude o que plugins são para um navegador. Exceto que é padronizado, bidirecional, e pensado para IA.

Componentes principais:

• Cliente MCP: Claude, seu agente de IA, ou sua aplicação
• Servidor MCP: endpoint que expõe ferramentas e recursos
• Recursos: dados que o servidor disponibiliza (banco de dados, arquivos, API)
• Ferramentas: funções que o agente pode chamar para executar uma ação
• Prompts: templates reutilizáveis para guiar Claude

É exatamente o que Simple Booking fez em junho de 2026, construíram um servidor MCP que expõe seu sistema de reservas CRS, e agora Claude pode consultar/modificar diretamente reservas de hotéis.

Arquitetura: como encaixa

Antes de MCP, a arquitetura era caótica:

Claude (via API)
    ↓ [manual prompt engineering]
    ↓ [tool_use call]
Application -> [You parse the response] -> Custom integration
    ↓
Database

Com MCP:

Claude (via MCP client)
    ↓
MCP Client Protocol (JSON-RPC padronizado)
    ↓
Seu Servidor MCP
    ↓ [reconnection automática]
    ↓
Suas ferramentas (funções), recursos (dados), prompts

O agente Claude agora pode:

• Interrogar seus recursos diretamente: "Qual é o número de pedidos pendentes?" -> requisição MCP -> seu banco de dados
• Chamar suas ferramentas atomicamente: "Cria uma fatura" -> chamada de ferramenta MCP -> sua lógica de negócios
• Reutilizar prompts otimizados: use_mcp_resource("context_facturation") -> template consistente em todos os agentes

Como implementar um servidor MCP mínimo

O protocolo MCP usa JSON-RPC 2.0 em stdio ou HTTP. Aqui está um servidor mínimo em Python que expõe um banco de dados PostgreSQL:

from MCP.server import Server
from MCP.types import Tool, Resource, TextContent
import asyncio
import psycopg2

app = Server("my-database-server")

# Declara um recurso: lista de clientes
@app.resource("db://customers")
async def get_customers():
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute("SELECT id, name, email FROM customers LIMIT 100")
    rows = cur.fetchall()
    conn.close()
    
    return TextContent(
        type="text/plain",
        text="\n".join([f"ID: {r[0]}, Name: {r[1]}, Email: {r[2]}" for r in rows])
    )

# Declara uma ferramenta: criar novo pedido
@app.tool("create_order")
async def create_order(customer_id: int, items: list, total: float):
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute(
        "INSERT INTO orders (customer_id, items, total, status) VALUES (%s, %s, %s, %s)",
        (customer_id, str(items), total, "pending")
    )
    conn.commit()
    order_id = cur.lastrowid
    conn.close()
    
    return f"Order {order_id} created successfully"

if __name__ == "__main__":
    asyncio.run(app.run())

São 30 linhas. Nenhuma análise manual, nenhum prompt engineering complicado. Claude agora sabe que pode:

1. Chamar get_customers para ver os clientes
2. Chamar create_order(customer_id, items, total) para criar um pedido

Mas tem uma pegadinha. Você está expondo seu banco de dados diretamente. E se Claude alucinar um customer_id inválido? Precisa adicionar validação:

@app.tool("create_order")
async def create_order(customer_id: int, items: list, total: float):
    # Validação: o cliente realmente existe?
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute("SELECT id FROM customers WHERE id = %s", (customer_id,))
    if not cur.fetchone():
        return f"Error: customer {customer_id} does not exist"
    
    # Continue with order creation...

Limitação honesta: quanto mais funcionalidades você expõe via MCP, mais depende de Claude para tomar boas decisões. Um agente mal orientado ainda pode causar problemas. Você precisa de:

• Rate limiting nas ferramentas perigosas
• Logging e audit trails
• Prompts de sistema muito claros sobre restrições de negócios
• Testes caóticos para ver o que acontece se Claude chamar uma ferramenta com inputs estranhos

Conectar claude sonnet 5 ao seu servidor MCP

Uma vez que seu servidor MCP está no lugar, você o chama via SDK Claude. Claude Sonnet 5 (lançado em 30 de junho de 2026) tem suporte nativo MCP integrado.

from anthropic import Anthropic

client = Anthropic()

# Configura servidor MCP para esta sessão
mcp_config = {
    "servers": {
        "my_database": {
            "command": "python",
            "args": ["./mcp_server.py"],
            "env": {"DATABASE_URL": "postgresql://..."}
        }
    }
}

response = client.messages.create(
    model="claude-sonnet-5",  # Novo, lançado 30 de junho de 2026
    max_tokens=2048,
    tools=[
        # MCP tools are auto-discovered from servers
    ],
    messages=[
        {
            "role": "user",
            "content": "Crée une commande pour le client #42 : 2x produit A, 1x produit B. Total : 150€"
        }
    ]
)

# Claude vai agora:
# 1. Analisar a mensagem do usuário
# 2. Verificar que tem acesso à ferramenta "create_order" via MCP
# 3. Chamar create_order(customer_id=42, items=[...], total=150)
# 4. Receber a resposta do servidor MCP
# 5. Continuar o diálogo

Claude Sonnet 5 também adiciona agentic loops melhorados, pode chamar múltiplas ferramentas em sequência sem voltar ao seu código cada vez. Útil para: "Recupera pedidos pendentes, cria faturas para cada um, depois envia email."

Casos de uso reais em produção

1. Integrações hoteleiras (Simple Booking, junho de 2026)

Simple Booking expõe seu sistema de reservas CRS via MCP. Agências de viagem usam Claude para:

• "Quais suites estão disponíveis em 15 de agosto no hotel de Lyon?" -> Claude interroga MCP -> resposta em tempo real
• "Reserve a suite 42 para os Dupont de 15 a 20 de agosto" -> Claude chama a ferramenta de reserva

Antes de MCP, eram webhooks customizados. Agora: um servidor MCP padronizado, e qualquer ferramenta compatível com MCP pode usá-lo.

2. Automação de media buying (Nexxen, junho de 2026)

Nexxen expõe seus parâmetros de campanha, orçamentos e audiências via MCP. Agências constroem agentes Claude que:

• Analisam desempenho de campanhas ("Nosso CPM está caindo, por quê?")
• Ajustam orçamentos automaticamente ("Aloca 20% do orçamento para audiência premium")
• Criam novas campanhas baseadas em briefs em texto

Antes: integração Zapier + scripts customizados. Agora: um servidor MCP, pronto.

3. Seu caso de uso: gestão de conteúdo e-commerce

Você tem uma loja Shopify ou sistema de produtos customizado. Construa um servidor MCP que exponha:

• Recurso: inventory/sku-123 -> número de estoques
• Recurso: products/all -> catálogo completo
• Ferramenta: update_product_description(sku, new_desc) -> atualiza sua base
• Ferramenta: create_bundle(products, discount) -> cria um bundle
• Prompt: contexto_refonte_catalogue -> instruções para Claude ao refatorar 100 fichas de produto

Exemplo concreto: você diz a Claude "Revisa todas as descrições de produto e corrige erros, melhora SEO, adiciona dimensões em cm". Claude:

1. Interroga products/all via MCP
2. Analisa as 200 descrições
3. Para cada produto, chama update_product_description(sku, new_desc)
4. Faz um relatório

Tempo humano: 10 minutos de supervisão. Antes: um dia completo para sua equipe.

Gestão de permissões e segurança

Um risco maior: se Claude tem acesso a todas suas ferramentas, pode chamar uma função perigosa. Adicionar controles:

1. Delimite ferramentas por caso de uso

# Em vez de expor "delete_order" globalmente
@app.tool("delete_order", scopes=["admin_only"])
async def delete_order(order_id: int):
    # Requer permissão especial
    pass

2. Rate limiting

from functools import wraps

def rate_limit(max_calls=10, period=60):
    def decorator(func):
        calls = []
        async def wrapper(*args, **kwargs):
            now = time.time()
            calls = [c for c in calls if c > now - period]
            if len(calls) >= max_calls:
                raise Exception("Rate limit exceeded")
            calls.append(now)
            return await func(*args, **kwargs)
        return wrapper
    return decorator

@app.tool("create_order")
@rate_limit(max_calls=50, period=3600)
async def create_order(...):
    pass

3. Logging exaustivo

import logging

logger = logging.getLogger("mcp_audit")

@app.tool("delete_order")
async def delete_order(order_id: int):
    logger.warning(f"Claude called delete_order({order_id}) - action requires approval")
    # Opcional: pedir confirmação humana antes de deletar
    return "Deletion queued for human approval"

Deploy de um servidor MCP em produção

Duas abordagens:

1. Stdio (para desenvolvimento rápido)

Seu servidor MCP é executado como um processo filho do cliente Claude. Simples, mas limitado em escalabilidade.

{
  "servers": {
    "my_server": {
      "command": "python",
      "args": ["./mcp_server.py"]
    }
  }
}

2. HTTP com autenticação (para produção)

{
  "servers": {
    "my_server": {
      "url": "HTTPS://MCP.mycompany.com",
      "auth": {
        "type": "bearer",
        "token": "sk_live_..."
      }
    }
  }
}

Seu servidor MCP escuta em um endpoint HTTPS seguro, com certificados SSL e rate limiting na gateway.

Deploy recomendado:

• Servidor MCP: Docker em ECS/K8s, atrás de um load balancer
• Banco de dados: PostgreSQL ou MongoDB, estritamente em VPC privada
• Monitoramento: CloudWatch, logs estruturados em JSON, alertas em erros
• Versionamento: versione seus recursos e ferramentas MCP (ex: /API/v1/resources)

{
  "servers": {
    "database": { "command": "python", "args": ["./db_mcp.py"] },
    "email": { "command": "node", "args": ["./email_mcp.js"] },
    "shopify": { "url": "HTTPS://MCP.shopify.com" }
  }
}

Conclusão

O Model Context Protocol resolve um problema real: antes de 2026, cada integração de agente de IA era uma customização única. Agora, é padronizado.

Três pontos-chave para lembrar:

1. MCP é o novo padrão para agentes de IA em 2026, substitui gambiarras de API customizadas
2. Implementar um servidor MCP é simples, 50 linhas de código para expor suas ferramentas e dados
3. Claude Sonnet 5 tem o melhor suporte nativo MCP, se você está construindo um agente hoje, é o modelo certo

Você está construindo um agente de IA para seu negócio? Comece expondo seus dados e ferramentas críticas via MCP. Depois conecte-os a Claude Sonnet 5. Em uma semana, você automatiza o que levava um dia antes.

Precisa de ajuda para implementar MCP na sua empresa? Podemos auditar sua arquitetura atual e propor um plano de integração. Entre em contato.