Protocolo de Contexto do Modelo: Crie o Seu Primeiro Servidor MCP Hoje

O Protocolo de Contexto do Modelo (MCP) é um padrão aberto que oferece aos modelos de IA uma forma universal de se ligarem a ferramentas externas, fontes de dados e serviços. Em vez de escrever código de integração personalizado para cada combinação de modelo e ferramenta, escreve-se apenas um servidor MCP e qualquer modelo compatível pode utilizá-lo. A Anthropic criou o MCP no final de 2024, a Linux Foundation gere-o atualmente, e a OpenAI, a Google e o restante ecossistema de IA agentiva já o adotaram. Eis tudo o que precisa de saber para compreender, construir e implementar o MCP.

MCP num Relance

Se deseja a versão rápida antes de mergulhar em 6.000 palavras de detalhes, aqui está.

Agora, vamos detalhar cada um destes pontos, começando pelo que é realmente o MCP e pelo problema que tornou a sua existência necessária.

O Que É o Protocolo de Contexto do Modelo?

O Protocolo de Contexto do Modelo é um protocolo aberto, baseado em JSON-RPC, que padroniza a forma como os modelos de IA descobrem e interagem com ferramentas e dados externos. Pense nele como o HTTP para integrações de IA, uma linguagem comum que qualquer modelo e qualquer ferramenta podem falar.

Provavelmente já ouviu a analogia do USB-C, e ela é útil até certo ponto: antes do USB-C, cada dispositivo precisava do seu próprio cabo. O MCP faz o mesmo para a IA, mas a analogia fica aquém da realidade. O USB-C transporta apenas dados e energia. O MCP transporta definições de ferramentas, padrões de acesso a dados, modelos de prompts reutilizáveis e até permite que os servidores solicitem conclusões ao modelo. É um protocolo mais rico do que a metáfora de um cabo sugere.

O Problema M x N que o MCP Resolve

Sem o MCP, ligar M modelos a N ferramentas requer M x N integrações personalizadas. Digamos que suporta 5 LLMs (Claude, GPT-4, Gemini, Llama, Mistral) e precisa que acedam a 10 ferramentas (GitHub, Postgres, Slack, Jira, e assim por diante). São 50 camadas de integração feitas à medida, cada uma com a sua própria autenticação, tratamento de erros e formatação de dados.

Com o MCP, cada modelo implementa o protocolo cliente MCP uma vez, e cada ferramenta implementa um servidor MCP uma vez. Agora são 5 + 10 = 15 implementações em vez de 50. Adiciona um novo modelo? Funciona imediatamente com todas as 10 ferramentas. Adiciona uma nova ferramenta? Todos os 5 modelos podem utilizá-la.

Uma Breve História do MCP

A Anthropic tornou o MCP open-source em novembro de 2024 juntamente com SDKs para Python e TypeScript e conectores para o Claude Desktop. A adoção foi rápida. A OpenAI adicionou suporte MCP ao ChatGPT em março de 2025. A Google seguiu-se para o Gemini em abril de 2025. Em dezembro de 2025, a Anthropic doou o MCP à nova Agentic AI Foundation (AAIF) da Linux Foundation, cofundada com a Block e a OpenAI, tornando o MCP um padrão neutro em relação ao fornecedor com governação transversal à indústria.

O que o MCP NÃO é:

• Não é um modelo ou uma framework de IA (é um protocolo, como o HTTP)
• Não substitui o LangChain ou o LlamaIndex (estas são camadas de orquestração; o MCP situa-se abaixo delas)
• Não se limita à Anthropic ou ao Claude (é agnóstico em relação ao modelo por conceção)
• Não é o mesmo que chamadas de função (mais sobre isso na secção de comparação)

Como Funciona o MCP? Análise Profunda da Arquitetura

O MCP tem três funções, e confundi-las é o erro mais comum dos iniciantes. Vamos esclarecer a distinção.

Host, Cliente e Servidor, Qual a Diferença?

Eis um exemplo concreto: pede ao Claude Desktop para verificar os seus pull requests abertos no GitHub. O Claude Desktop é o host. O seu cliente MCP integrado abre uma ligação ao servidor MCP do GitHub. O servidor chama a API do GitHub, obtém os seus PRs e devolve os resultados ao cliente, que os entrega ao modelo.

Um único host pode executar múltiplos clientes, cada um ligado a um servidor diferente. É assim que o Claude Desktop pode aceder simultaneamente ao GitHub, à sua base de dados Postgres e ao Slack, três servidores MCP separados, três ligações de cliente separadas, um host.

Como Fluem as Mensagens (JSON-RPC 2.0)

Toda a comunicação MCP utiliza JSON-RPC 2.0, um protocolo leve de pedido/resposta. Eis o aspeto de uma troca tools/list na rede:

// Client request: "What tools do you have?"
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list"
}

// Server response: one tool available
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "inputSchema": {
          "type": "object",
          "properties": {
            "city": { "type": "string" }
          },
          "required": ["city"]
        }
      }
    ]
  }
}

O modelo lê estas definições de ferramentas, decide quando as chamar com base no pedido do utilizador e o cliente envia de volta um pedido tools/call ao servidor com os argumentos apropriados.

Ciclo de Vida da Ligação

Cada sessão MCP segue o mesmo ciclo de vida:

1. Inicialização, o cliente envia capacidades, o servidor responde com as suas
2. Negociação de capacidades, ambas as partes concordam com as funcionalidades suportadas (ferramentas, recursos, prompts, amostragem)
3. Pronto, a ligação está ativa; os pedidos fluem em ambas as direções
4. Pedidos/respostas, tools/call, resources/read, etc.
5. Encerramento, desligamento limpo

Este aperto de mão garante compatibilidade futura. Se um servidor adicionar uma nova primitiva, os clientes mais antigos ignoram-na graciosamente em vez de falharem.

Primitivas MCP: Ferramentas, Recursos, Prompts e Amostragem

O MCP define quatro primitivas, e compreender quem controla cada uma é a chave para desenhar bons servidores MCP.

Ferramentas (Controladas pelo Modelo)

As ferramentas são funções que o modelo pode chamar. O servidor declara-as com um nome, descrição e definição de entrada em JSON Schema. O modelo lê estas definições e, quando o pedido de um utilizador o exige, o modelo decide invocar a ferramenta.

// Client sends tools/call request
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": { "city": "Berlin" }
  }
}

Se já utilizou as chamadas de função da OpenAI, as ferramentas parecer-lhe-ão familiares, mas estão padronizadas em todos os modelos compatíveis com MCP.

Recursos (Controlados pela Aplicação)

Os recursos são endpoints de dados apenas de leitura. Ao contrário das ferramentas, o modelo não decide obter um recurso por si só; a aplicação host ou o utilizador anexam explicitamente os recursos ao contexto da conversa. Pense neles como endpoints GET: postgres://mydb/users/schema, file://docs/api-reference.md.

Os recursos suportam subscrições via resources/subscribe, para que o cliente possa ser notificado quando os dados mudam.

Prompts (Controlados pelo Utilizador)

Os prompts são modelos reutilizáveis que um servidor MCP expõe. Um prompt code_review pode aceitar um caminho de ficheiro e gerar um pedido de revisão estruturado. O utilizador (ou a interface do host) aciona os prompts explicitamente; não são invocados automaticamente pelo modelo.

Amostragem (Iniciada pelo Servidor), Avançado

Eis a primitiva que a maioria dos guias ignora. A Amostragem permite que o servidor peça ao cliente para gerar uma conclusão utilizando o LLM. Isto inverte o fluxo habitual: em vez de o modelo chamar uma ferramenta, a ferramenta chama o modelo.

Porquê? Loops agentivos. Imagine um servidor MCP que processa tickets de suporte. Lê o ticket (um recurso), utiliza sampling/createMessage para pedir ao modelo um resumo e depois usa esse resumo para encaminhar o ticket através de uma ferramenta. O servidor orquestra um fluxo de trabalho em várias etapas utilizando a inteligência do modelo.

A amostragem é condicionada pela aplicação host; o utilizador deve aprová-la e o host controla o que o servidor pode solicitar. Isto impede loops descontrolados e mantém a supervisão humana.

Construa o Seu Primeiro Servidor MCP: Python e TypeScript Lado a Lado

Chega de teoria. Vamos construir um servidor MCP funcional que expõe uma ferramenta get_weather. Vou mostrar tanto em Python como em TypeScript para que possa comparar a experiência de desenvolvimento e escolher a stack que melhor se adapta ao seu projeto.

Python com FastMCP

FastMCP é o SDK oficial de alto nível para Python. Trata de toda a infraestrutura do protocolo para que se possa concentrar na lógica da sua ferramenta.

# Install FastMCP
pip install fastmcp

# weather_server.py
from fastmcp import FastMCP

mcp = FastMCP("Weather Server")

@mcp.tool()
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    # In production, call a real weather API here
    weather_data = {
        "Berlin": "Cloudy, 12°C",
        "Tokyo": "Sunny, 22°C",
        "New York": "Rainy, 8°C",
    }
    return weather_data.get(city, f"No data for {city}")

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

É tudo -- 15 linhas. O FastMCP infere o esquema de entrada da ferramenta a partir das dicas de tipo (type hints) e da docstring em Python. Sem código boilerplate de JSON Schema.

TypeScript com o SDK Oficial

O SDK TypeScript (@modelcontextprotocol/sdk) é um pouco mais explícito, mas oferece controlo total sobre as definições de esquema.

# Install the SDK and Zod for schema validation
npm install @modelcontextprotocol/sdk zod

// weather-server.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "Weather Server",
  version: "1.0.0",
});

server.tool(
  "get_weather",
  "Get the current weather for a city",
  { city: z.string() },
  async ({ city }) => {
    const weatherData: Record<string, string> = {
      Berlin: "Cloudy, 12°C",
      Tokyo: "Sunny, 22°C",
      "New York": "Rainy, 8°C",
    };
    return {
      content: [
        { type: "text", text: weatherData[city] ?? `No data for ${city}` },
      ],
    };
  }
);

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

A versão TypeScript utiliza esquemas Zod em vez de dicas de tipo e devolve blocos de conteúdo estruturados. Mais verboso, mas a segurança de tipos é excelente.

Ligar ao Claude Desktop

Para integrar qualquer um dos servidores no Claude Desktop, adicione-o ao seu claude_desktop_config.json:

{
  "mcpServers": {
    "weather-python": {
      "command": "python",
      "args": ["weather_server.py"],
      "cwd": "/path/to/your/project"
    },
    "weather-typescript": {
      "command": "npx",
      "args": ["tsx", "weather-server.ts"],
      "cwd": "/path/to/your/project"
    }
  }
}

Reinicie o Claude Desktop e ambos os servidores meteorológicos aparecerão na lista de ferramentas. Pergunte "Qual é o tempo em Berlim?" e o modelo chamará a sua ferramenta get_weather automaticamente.

Testar com o MCP Inspector

Antes de ligar o seu servidor a um host, teste-o isoladamente com o MCP Inspector:

npx @modelcontextprotocol/inspector python weather_server.py

O Inspector abre uma interface no navegador onde pode ver as ferramentas descobertas, invocá-las manualmente e inspecionar as mensagens JSON-RPC trocadas. É a melhor ferramenta de depuração no ecossistema MCP; utilize-a cedo e frequentemente.

Transportes MCP: stdio para Desenvolvimento, Streamable HTTP para Produção

As mensagens MCP precisam de um meio para viajar entre o cliente e o servidor. Essa é a camada de transporte, e escolher a correta é importante.

O stdio funciona ao iniciar o servidor MCP como um subprocesso e comunicar através de stdin/stdout. Foi o que utilizou no tutorial acima, sem portas, sem TLS, sem necessidade de autenticação. Perfeito para desenvolvimento e ferramentas locais de utilizador único.

O Streamable HTTP é o transporte de produção, adicionado na atualização da especificação de 2025. Os clientes enviam pedidos HTTP POST padrão para o servidor. O servidor pode responder sincronamente ou abrir um fluxo SSE para operações mais longas. É amigável para stateless, funciona atrás de balanceadores de carga e suporta autenticação HTTP padrão.

Se vir tutoriais mais antigos a mencionar "HTTP+SSE" como dois transportes separados (um para enviar, outro para receber), essa é a abordagem obsoleta. O Streamable HTTP consolida ambos num mecanismo único e mais limpo.

A decisão é direta: utilize stdio quando desenvolver localmente, mude para streamable-http quando implementar para outros.

// Switching from stdio to Streamable HTTP in TypeScript
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";

const transport = new StreamableHTTPServerTransport({ port: 3001 });
await server.connect(transport);

MCP vs Chamadas de Função vs APIs REST, Quando Utilizar Cada Um

Esta é a pergunta que surge em todas as discussões sobre MCP, por isso vamos resolvê-la com uma comparação direta.

Quando as Chamadas de Função São Suficientes

Se tiver menos de 5 ferramentas e utilizar um modelo, as chamadas de função são mais simples. Define os esquemas das suas ferramentas inline com cada chamada API, o modelo devolve o nome da função e os argumentos, e executa-os no código da sua aplicação. Nenhum servidor para executar, nenhum protocolo para aprender. Para um chatbot que verifica o estado de encomendas e procura FAQs, as chamadas de função são perfeitamente adequadas.

Quando o MCP Vale a Pena

O MCP justifica a sua complexidade quando:

• Suporta múltiplos LLMs e não quer reescrever definições de ferramentas para cada fornecedor
• Precisa de descoberta de ferramentas, o modelo pode consultar o que está disponível em vez de codificar esquemas rigidamente
• Quer recursos e prompts, não apenas chamadas de ferramentas
• Está a construir agentes de IA que coordenam autonomamente e precisa de uma camada de integração padronizada
• A sua equipa está a crescer e diferentes engenheiros constroem diferentes ferramentas, o MCP permite-lhes trabalhar independentemente

Veredito: O MCP vence quando precisa de acesso a ferramentas padronizado e multi-modelo. As chamadas de função vencem em casos de uso simples e de modelo único. As APIs REST continuam a ser a escolha certa para a comunicação tradicional serviço-a-serviço que não envolve um LLM.

O Ecossistema MCP em 2026: Quem Suporta e O Que Está Disponível

O MCP passou de um projeto secundário da Anthropic para um padrão da indústria em menos de 18 meses. Eis a situação atual.

Quais LLMs Suportam MCP?

Servidores MCP Populares que Deve Conhecer

O anúncio da AAIF da Linux Foundation citou mais de 10.000 servidores ativos e 97 milhões de downloads mensais de SDKs no momento da doação do MCP em dezembro de 2025. O ecossistema já não é experimental, é de grau de produção.

As Aplicações MCP são uma nova primitiva introduzida em janeiro de 2026. Permitem que os servidores forneçam componentes de interface interativos que são renderizados dentro da aplicação host. Ainda é cedo, mas sinaliza a evolução do MCP de um protocolo de dados para uma framework completa de aplicação-agente. Vale a pena acompanhar.

Governação: Da Anthropic para a Linux Foundation

O MCP é gerido pela Agentic AI Foundation (AAIF) sob a égide da Linux Foundation, cofundada pela Anthropic, Block e OpenAI. Isto é importante para a adoção empresarial: o MCP não está vinculado ao roteiro de um único fornecedor. As prioridades do roteiro de 2026 são a evolução do transporte, comunicação agente-a-agente (uma nova primitiva "Tarefas"), maturação da governação e prontidão empresarial.

Para equipas que constroem sistemas de IA de produção, frameworks como uma framework de agente de IA autónomo como o OpenClaw já integram com servidores MCP para dar capacidades do mundo real aos agentes.

Segurança MCP: OAuth 2.1, Ameaças e uma Lista de Verificação Prática

A segurança é a área onde o ecossistema MCP tem mais terreno para cobrir. E os números pintam um quadro nítido.

O Problema dos 88%: Por Que a Maioria dos Servidores MCP São Inseguros

A Astrix Security analisou mais de 5.200 implementações de servidores MCP open-source e descobriu que 88% requerem credenciais de algum tipo, mas 53% dependem de segredos estáticos inseguros de longa duração, como chaves API e tokens de acesso pessoal codificados em ficheiros de configuração. Apenas 8,5% implementam OAuth.

Isto significa que a grande maioria dos servidores MCP existentes estão a usar o equivalente de autenticação de colar a chave de casa na porta da frente.

OAuth 2.1 para Servidores MCP

A especificação MCP requer OAuth 2.1 para todos os servidores baseados em HTTP a partir da atualização de junho de 2025. O fluxo funciona assim: o cliente MCP inicia um fluxo de autorização OAuth 2.1 com o servidor, obtém um token de acesso com escopo definido e inclui-o em cada pedido subsequente. O PKCE (Proof Key for Code Exchange) é obrigatório para todos os clientes, sem exceções.

Se estiver a construir um servidor MCP que funciona sobre Streamable HTTP, o OAuth 2.1 não é opcional. É mandatado pela especificação.

Modelo de Ameaça: O Que Pode Correr Mal

Quatro ameaças merecem atenção em qualquer implementação MCP:

• Injeção de prompt via ferramentas, Uma fonte de dados maliciosa ou comprometida devolve conteúdo concebido para manipular o modelo. Se uma ferramenta obtiver uma página web e essa página contiver instruções ocultas, o modelo pode executá-las.
• Ataque de deputado confuso, O modelo invoca uma ferramenta com permissões mais amplas do que o utilizador pretendia. Se o servidor MCP tiver acesso de administrador a uma base de dados, o modelo poderia teoricamente eliminar uma tabela.
• Risco de concentração de tokens, Um servidor MCP que detém chaves API para GitHub, Slack e a sua base de dados de produção é um alvo único de alto valor. Comprometer um servidor compromete tudo a que este se liga.
• Transporte inseguro, Executar um servidor MCP HTTP sem TLS expõe cada pedido, incluindo tokens OAuth e dados sensíveis, em texto simples.

Lista de Verificação de Segurança para MCP em Produção

1. Implemente OAuth 2.1 para qualquer servidor exposto via HTTP. Sem chaves API estáticas em ficheiros de configuração.
2. Aplique o princípio do privilégio mínimo. Se a sua ferramenta apenas lê dados, as credenciais do servidor devem ser apenas de leitura. Não dê acesso de escrita a uma ferramenta de relatórios.
3. Isole as credenciais. Cada servidor MCP deve ter os seus próprios tokens com escopo definido. Não partilhe um único "token divino" entre servidores.
4. Force TLS em todo o lado. Streamable HTTP sem HTTPS é automaticamente inviável para produção.
5. Valide e sanitize as saídas das ferramentas. Trate os dados devolvidos pelas ferramentas da mesma forma que trataria o input do utilizador, não confie cegamente.
6. Limite a taxa de invocações de ferramentas. Um loop de agente descontrolado a chamar uma ferramenta milhares de vezes pode esgotar quotas de API ou causar efeitos secundários indesejados.
7. Audite e registe cada chamada de ferramenta. Inclua IDs de pedido, carimbos de data/hora, o modelo chamador e os argumentos da ferramenta. Precisa disto para depuração e para resposta a incidentes de segurança.

Depuração MCP: Inspector, Registos e Erros Comuns

Vai encontrar erros. Todos os programadores encontram. Eis como corrigi-los rapidamente.

O MCP Inspector é a ferramenta oficial de depuração e a sua primeira linha de defesa. Liga-se a qualquer servidor MCP, descobre as suas ferramentas/recursos/prompts e permite invocá-los manualmente enquanto mostra o tráfego JSON-RPC bruto.

# Launch Inspector against your Python server
npx @modelcontextprotocol/inspector python weather_server.py

# Or against a TypeScript server
npx @modelcontextprotocol/inspector npx tsx weather-server.ts

O Inspector abre uma interface baseada no navegador com separadores para Ferramentas, Recursos, Prompts e um painel de notificações. Pode chamar qualquer ferramenta com argumentos personalizados e ver exatamente que JSON passa pela rede. Utilize-o antes de ligar a uma aplicação host, é muito mais fácil depurar o servidor isoladamente.

Erros Comuns e Correções

• "Servidor não encontrado" no Claude Desktop, Quase sempre um problema de caminho em claude_desktop_config.json. Verifique novamente se o command resolve para um binário real e se o cwd aponta para o diretório correto. No macOS, utilize caminhos absolutos.
• Falhas de validação do esquema da ferramenta, Se o modelo enviar argumentos que não correspondem ao inputSchema da ferramenta, o servidor rejeita a chamada. Verifique se os tipos do seu esquema correspondem ao que o modelo espera. O Zod (TypeScript) e as dicas de tipo (Python) capturam a maioria destes na altura da definição.
• Quedas de ligação de transporte, Para stdio, isto geralmente significa que o processo do servidor falhou. Verifique a saída stderr. Para Streamable HTTP, verifique as definições de timeout, ferramentas de longa duração podem exceder os timeouts HTTP padrão.
• Erros "Permissão negada" ou 401, Escopo OAuth demasiado restrito. O servidor está a rejeitar o token porque não tem as permissões necessárias. Alargue o escopo, mas apenas o necessário para a ferramenta.

Melhores Práticas de Registo

Estruture os seus registos com IDs de pedido para que possa rastrear um único pedido do utilizador através do cliente MCP, servidor e quaisquer APIs downstream. Registe cada invocação tools/call com o nome da ferramenta, argumentos, tempo de resposta e estado do resultado. Em produção, envie estes registos para uma plataforma de observabilidade; quando algo correr mal às 3 da manhã, ficará agradecido por o ter feito.

Como a Techsy Constrói com MCP

Temos integrado o MCP em projetos de clientes desde o início de 2025, e o padrão que vemos com mais frequência é este: uma equipa tem uma funcionalidade de IA que funciona com um modelo e um punhado de ferramentas, mas planeia escalar, mais modelos, mais fontes de dados, mais capacidades de agente. Esse é o ponto de inflexão onde o MCP começa a valer a pena.

A nossa abordagem segue três passos:

1. Avaliar a adequação. Nem todos os projetos precisam de MCP. Se estiver a chamar duas ferramentas a partir de um único modelo, as chamadas de função são mais simples e diremos isso. O MCP faz sentido quando está a ligar 3+ fontes de dados, a suportar múltiplos modelos ou a construir fluxos de trabalho de agentes onde as ferramentas precisam de ser descobertas.
2. Construir e testar servidores isoladamente. Desenvolvemos servidores MCP personalizados para cada fonte de dados, bases de dados internas, APIs SaaS, serviços proprietários, e validamos-nos com o MCP Inspector antes de ligar a qualquer host.
3. Implementar com Streamable HTTP e OAuth 2.1. Para produção, executamos servidores MCP como serviços containerizados atrás de TLS, com tokens OAuth com escopo definido e registos estruturados desde o primeiro dia. Sem segredos estáticos.

As integrações mais comuns que construímos: ligar assistentes de IA a bases de dados Postgres internas, construir servidores MCP personalizados para plataformas SaaS de clientes e migrar equipas de configurações dispersas de chamadas de função para uma arquitetura MCP padronizada.

A construir ferramentas alimentadas por IA que precisam de se ligar à sua infraestrutura? Ajudamos equipas a arquitetar e implementar integrações MCP. Obtenha uma consulta gratuita

Perguntas Frequentes Sobre MCP

O que é o Protocolo de Contexto do Modelo (MCP)?

O MCP é um padrão aberto, originalmente criado pela Anthropic e agora gerido pela Linux Foundation, que define como os modelos de IA se ligam a ferramentas externas, fontes de dados e serviços. Padroniza a camada de integração para que um servidor MCP funcione com qualquer modelo compatível, como uma ficha universal para IA.

Como funciona o MCP?

O MCP utiliza uma arquitetura de três partes: uma aplicação host (como o Claude Desktop ou o Cursor), um cliente MCP dentro do host que gere as ligações e servidores MCP que expõem ferramentas e dados. Toda a comunicação utiliza mensagens JSON-RPC 2.0 sobre stdio (local) ou Streamable HTTP (remoto).

Para que é usado o MCP?

Casos de uso comuns incluem ligar assistentes de IA a bases de dados (Postgres, MySQL), integrar com plataformas de código (GitHub, GitLab), aceder a ferramentas SaaS (Slack, Notion, Google Drive) e construir agentes de IA autónomos que precisam de interagir com serviços do mundo real.

O MCP é o mesmo que chamadas de função?

Não. As chamadas de função são específicas do modelo (o formato da OpenAI difere do da Anthropic) e por pedido, envia esquemas de ferramentas com cada chamada API. O MCP é um protocolo padronizado que funciona entre modelos, suporta descoberta de ferramentas e inclui recursos e prompts além da apenas execução de funções.

O que são servidores MCP?

Os servidores MCP são programas que expõem ferramentas, recursos e prompts a modelos de IA via o protocolo MCP. Envolvem APIs externas e fontes de dados numa interface padronizada. Exemplos incluem o servidor MCP do GitHub (para gestão de PR e issues) e o servidor MCP do Postgres (para consultas à base de dados).

Como construo um servidor MCP?

Utilize Python com FastMCP (pip install fastmcp) ou TypeScript com o SDK oficial (npm install @modelcontextprotocol/sdk). Defina as suas ferramentas como funções decoradas (Python) ou handlers registados (TypeScript), depois execute o servidor. Veja a secção do tutorial acima para código funcional completo, ou siga o nosso guia passo a passo para construir um servidor MCP do zero para uma explicação completa.

O MCP é seguro?

O protocolo em si suporta OAuth 2.1 para autenticação e permissões com escopo definido. No entanto, a investigação da Astrix Security descobriu que 88% das implementações existentes de servidores MCP dependem de segredos estáticos em vez de OAuth. O protocolo é seguro por conceção, mas a maioria das implementações no mundo real ainda não acompanhou.

Quais LLMs suportam MCP?

O Claude tem suporte nativo MCP desde a sua criação em novembro de 2024. O ChatGPT adicionou suporte em março de 2025, e o Gemini seguiu-se em abril de 2025. Modelos open-source podem usar MCP através de adaptadores no LangChain e LlamaIndex.

Qual a diferença entre MCP e uma API REST?

As APIs REST são concebidas para comunicação geral serviço-a-serviço. O MCP é concebido especificamente para interação com modelos de IA, inclui descoberta de ferramentas, negociação de esquemas, acesso a recursos e modelos de prompt que o REST não tem. Não substituiria as suas APIs REST pelo MCP; servem camadas diferentes.

Quem mantém o MCP agora?

A Agentic AI Foundation (AAIF) da Linux Foundation, formada em dezembro de 2025, gere o MCP. Foi cofundada pela Anthropic, Block e OpenAI. Esta governação neutra em relação ao fornecedor é uma razão chave para a adoção do MCP pelas empresas.

O que é o Streamable HTTP no MCP?

O Streamable HTTP é o mecanismo de transporte de produção adicionado na atualização da especificação MCP de 2025. Substitui o transporte HTTP+SSE mais antigo por um design mais limpo: os clientes enviam pedidos HTTP POST, e os servidores podem responder sincronamente ou via streaming SSE. Funciona atrás de balanceadores de carga e suporta autenticação HTTP padrão.

Quantos servidores MCP existem?

A Linux Foundation citou mais de 10.000 servidores ativos e 97 milhões de downloads mensais de SDKs quando o MCP foi doado à AAIF em dezembro de 2025. O ecossistema abrange bases de dados, ferramentas de código, integrações SaaS, motores de pesquisa e fornecedores de infraestrutura cloud.

Conclusão

O MCP passou da experiência open-source da Anthropic para o protocolo padrão da indústria para ligar modelos de IA a ferramentas em pouco mais de um ano. Eis o que importa:

• O MCP resolve o problema M x N, um servidor funciona com cada modelo compatível, um cliente funciona com cada servidor
• Pode construir um servidor MCP funcional em menos de 50 linhas de Python (FastMCP) ou TypeScript
• Utilize stdio para desenvolvimento, Streamable HTTP para produção, a escolha de transporte é direta
• Proteja os seus servidores com OAuth 2.1 -- 88% das implementações atuais não o fazem, e isso é um risco real
• O ecossistema está pronto para produção -- mais de 10.000 servidores, todos os principais LLMs, governação neutra em relação ao fornecedor sob a Linux Foundation

Olhando para o futuro, o roteiro de 2026 foca-se na comunicação agente-a-agente através de uma nova primitiva de Tarefas, segurança empresarial aprimorada e Aplicações MCP para interfaces interativas conduzidas pelo servidor. O MCP já não é apenas um protocolo para acesso a ferramentas, está a tornar-se a camada de infraestrutura para IA agentiva.

Comece com o código do tutorial acima, teste-o no MCP Inspector e ligue-o ao Claude Desktop. Terá uma integração MCP funcional em menos de uma hora.

Fontes

• Especificação MCP (2025-11-25)
• Especificação de Autorização MCP
• Especificação de Transportes MCP
• Documentação do MCP Inspector
• Apresentação do Protocolo de Contexto do Modelo, Anthropic
• Doação do MCP à Linux Foundation, Anthropic
• Anúncio da AAIF da Linux Foundation
• Suporte MCP do Google Cloud
• SDK Python FastMCP
• SDK TypeScript MCP
• Astrix Security: Estado da Segurança dos Servidores MCP 2025
• Roteiro MCP 2026