O que é o Protocolo de Contexto do Modelo (MCP) e Por que Ele é Importante para APIs?

TL;DR

O Protocolo de Contexto de Modelo (MCP) é um padrão para conectar assistentes de IA a fontes de dados e APIs externas. Ele permite que o Claude Desktop, Cursor e outras ferramentas de IA acessem sua API de forma segura. A Modern PetstoreAPI implementa o MCP para que assistentes de IA possam pesquisar pets, fazer pedidos e gerenciar o inventário através da linguagem natural.

Introdução

Você pergunta ao Claude Desktop: “Mostre-me gatos disponíveis por menos de $300.” Claude responde: “Não tenho acesso aos dados da pet shop.” Você precisa copiar/colar da sua API, quebrando seu fluxo de trabalho.

Com o MCP (Protocolo de Contexto de Modelo), Claude pode acessar sua API diretamente. Você faz a mesma pergunta, e Claude consulta a PetstoreAPI, filtra os resultados e mostra os gatos disponíveis por menos de $300.

A Modern PetstoreAPI implementa o MCP, permitindo que assistentes de IA interajam com a pet shop através da linguagem natural.

Se você está construindo APIs para integração com IA, o Apidog ajuda a testar implementações de MCP e validar as interações do assistente de IA.

O Que É MCP?

MCP é um protocolo criado pela Anthropic para conectar assistentes de IA a recursos externos.

O Problema Que o MCP Resolve

Assistentes de IA são poderosos, mas isolados. Eles não conseguem:

• Acessar as APIs internas da sua empresa
• Consultar seu banco de dados
• Ler arquivos do seu sistema de arquivos
• Interagir com serviços externos

O MCP fornece uma maneira padrão para assistentes de IA se conectarem a esses recursos de forma segura.

Componentes do MCP

1. Servidor MCP - Expõe recursos e ferramentas para assistentes de IA

2. Cliente MCP - Assistente de IA (Claude Desktop, Cursor, etc.)

3. Recursos - Dados que a IA pode ler (arquivos, registros de banco de dados, respostas de API)

4. Ferramentas - Ações que a IA pode realizar (criar pedido, atualizar pet, pesquisar inventário)

Arquitetura do MCP

AI Assistant (Claude Desktop)
    ↓ MCP Protocol
MCP Server (PetstoreAPI MCP Server)
    ↓ Internal APIs
PetstoreAPI Backend
    ↓
Database

Como o MCP Funciona

1. Registro do Servidor

Configure o Claude Desktop para conectar-se ao servidor MCP:

{
  "mcpServers": {
    "petstore": {
      "command": "node",
      "args": ["/path/to/petstore-mcp-server.js"],
      "env": {
        "PETSTORE_API_KEY": "your-api-key"
      }
    }
  }
}

2. Descoberta de Ferramentas

O assistente de IA pergunta: “Quais ferramentas estão disponíveis?”

O servidor MCP responde:

{
  "tools": [
    {
      "name": "search_pets",
      "description": "Search for pets by species, status, and price",
      "inputSchema": {
        "type": "object",
        "properties": {
          "species": {"type": "string", "enum": ["CAT", "DOG"]},
          "maxPrice": {"type": "number"},
          "status": {"type": "string", "enum": ["AVAILABLE", "ADOPTED"]}
        }
      }
    },
    {
      "name": "create_order",
      "description": "Place an order for a pet",
      "inputSchema": {
        "type": "object",
        "properties": {
          "petId": {"type": "string"},
          "userId": {"type": "string"}
        },
        "required": ["petId", "userId"]
      }
    }
  ]
}

3. Execução de Ferramentas

O usuário pergunta: “Mostre-me gatos disponíveis por menos de $300”

O assistente de IA chama:

{
  "tool": "search_pets",
  "arguments": {
    "species": "CAT",
    "status": "AVAILABLE",
    "maxPrice": 300
  }
}

O servidor MCP executa:

async function search_pets({ species, status, maxPrice }) {
  const response = await fetch(
    `https://petstoreapi.com/v1/pets?species=${species}&status=${status}&maxPrice=${maxPrice}`
  );
  return await response.json();
}

Retorna os resultados para a IA, que os formata para o usuário.

MCP vs. APIs Tradicionais

Comparação de Exemplos

API Tradicional:

curl -H "Authorization: Bearer token" \
  "https://petstoreapi.com/v1/pets?species=CAT&maxPrice=300"

MCP:

Usuário: "Mostre-me gatos disponíveis por menos de $300"
IA: [Chama a ferramenta search_pets, formata os resultados]
"Aqui estão 5 gatos disponíveis por menos de $300:
1. Fluffy - $250
2. Whiskers - $280
..."

Como a Modern PetstoreAPI Implementa o MCP

A Modern PetstoreAPI fornece um servidor MCP.

Ferramentas Disponíveis

1. search_pets - Pesquisa pets por critérios 2. get_pet - Obtém detalhes do pet 3. create_order - Faz um pedido 4. get_inventory - Verifica o inventário 5. update_pet_status - Atualiza a disponibilidade do pet

Exemplo: Busca e Pedido

Usuário: “Encontre-me um cachorro por menos de $500 e faça um pedido”

Fluxo de trabalho da IA:

1. Chama search_pets({species: "DOG", maxPrice: 500})
2. Mostra os resultados ao usuário
3. Usuário confirma: "Peça o Labrador"
4. Chama create_order({petId: "019b4132", userId: "user-456"})
5. Confirma o pedido feito

Código do Servidor MCP

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = new Server({
  name: 'petstore-mcp',
  version: '1.0.0'
}, {
  capabilities: {
    tools: {}
  }
});

server.setRequestHandler('tools/list', async () => ({
  tools: [
    {
      name: 'search_pets',
      description: 'Search for pets',
      inputSchema: {
        type: 'object',
        properties: {
          species: { type: 'string' },
          maxPrice: { type: 'number' }
        }
      }
    }
  ]
}));

server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;

  if (name === 'search_pets') {
    const response = await fetch(
      `https://petstoreapi.com/v1/pets?${new URLSearchParams(args)}`
    );
    return { content: [{ type: 'text', text: JSON.stringify(await response.json()) }] };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);

Testando MCP com Apidog

Apidog ajuda a testar implementações de MCP:

1. Testar se as APIs subjacentes funcionam corretamente
2. Validar se os esquemas de ferramentas correspondem aos contratos de API
3. Testar o tratamento de erros
4. Verificar os fluxos de autenticação

Por Que o MCP Importa

1. APIs Nativas para IA

APIs se tornam acessíveis através da linguagem natural. Usuários não técnicos podem interagir com sua API por meio de assistentes de IA.

2. Padronização

O MCP está se tornando o padrão para integração de IA-API. Suporte-o uma vez, funcione com todos os clientes MCP.

3. Segurança

Servidores MCP lidam com a autenticação. Assistentes de IA não precisam de acesso direto à API.

4. Componibilidade

Assistentes de IA podem combinar vários servidores MCP, criando fluxos de trabalho entre serviços.

Conclusão

O MCP une assistentes de IA e APIs. A Modern PetstoreAPI implementa o MCP, permitindo que o Claude Desktop e outras ferramentas de IA interajam com a pet shop através da linguagem natural.

Principais pontos:

• MCP conecta assistentes de IA a APIs
• Ferramentas definem o que a IA pode fazer
• Linguagem natural substitui chamadas de API
• Modern PetstoreAPI demonstra a implementação de MCP

FAQ

Quais assistentes de IA suportam MCP?

Claude Desktop, Cursor e outras ferramentas alimentadas pela Anthropic. O suporte está crescendo.

O MCP é seguro?

Sim. Servidores MCP lidam com a autenticação. Assistentes de IA não veem chaves de API.

Posso usar MCP com APIs existentes?

Sim. Construa um servidor MCP que envolva sua API existente.

O MCP substitui as APIs REST?

Não. O MCP é para acesso de assistentes de IA. APIs REST permanecem para acesso programático direto.

Como testo as ferramentas MCP?

Use o Apidog para testar as APIs subjacentes e, em seguida, teste as ferramentas MCP com o Claude Desktop.