Model Context Protocol (MCP) é um padrão aberto criado pela Anthropic que padroniza como sistemas de inteligência artificial se conectam a ferramentas externas, bancos de dados e fontes de informação
Imagine conectar seu smartphone a qualquer acessório usando uma única porta USB-C. Antes dessa padronização, cada fabricante criava seu próprio conector, e consumidores acumulavam gavetas cheias de cabos incompatíveis. O Model Context Protocol resolve esse problema para a inteligência artificial: ele cria um ponto de conexão universal entre modelos de linguagem e o mundo externo.
O MCP foi lançado pela Anthropic em 25 de novembro de 2024 e, em apenas um ano, tornou-se o padrão dominante do setor. Os números impressionam: mais de 97 milhões de downloads mensais do SDK, mais de 10.000 servidores ativos e adoção por OpenAI, Google, Microsoft e centenas de empresas Fortune 500. Em dezembro de 2025, o protocolo foi doado para a Linux Foundation, consolidando sua posição como infraestrutura neutra e aberta.
Este artigo oferece a cobertura mais completa em língua portuguesa sobre o MCP. Ele explica a arquitetura técnica, os componentes fundamentais, as formas de implementação, os casos de uso empresariais e as implicações para profissionais de tecnologia e marketing que desejam entender essa peça central da infraestrutura de inteligência artificial generativa.
O que é o Model Context Protocol (MCP)?
O Model Context Protocol é um padrão aberto e framework de código aberto que define como sistemas de IA, especialmente grandes modelos de linguagem (LLMs), integram-se a ferramentas externas, sistemas empresariais e fontes de dados. Antes do MCP, desenvolvedores precisavam construir conectores personalizados para cada combinação de modelo e ferramenta, criando o que engenheiros chamam de “problema M×N”.
Se uma empresa quisesse conectar 10 aplicações de IA a 100 ferramentas diferentes, potencialmente precisaria de 1.000 integrações customizadas. O MCP reduz essa complexidade para uma equação simples: implemente o protocolo cliente uma vez, implemente o protocolo servidor uma vez, e todas as combinações funcionam automaticamente.
Segundo a documentação oficial, o protocolo permite aos desenvolvedores construir conexões seguras e bidirecionais entre fontes de dados e ferramentas alimentadas por IA. A analogia mais comum compara o MCP a uma porta USB-C: um único ponto de extensão universal que simplifica o acesso a diversos recursos.
Por isso, o MCP não é apenas uma especificação técnica. Ele representa uma mudança arquitetural na forma como sistemas de IA interagem com o mundo, substituindo integrações fragmentadas por um padrão coeso que economiza tempo, reduz custos de manutenção e permite soluções mais escaláveis.
A história do MCP: de experimento interno a padrão da indústria
A origem do MCP remonta a julho de 2024, quando David Soria Parra trabalhava em ferramentas internas de desenvolvimento na Anthropic. Ele utilizava o Claude Desktop regularmente, mas ficava frustrado com suas limitações: não havia forma padronizada de estender as capacidades do assistente. O desenvolvedor passava tempo copiando informações entre o Claude e seu ambiente de desenvolvimento, um processo manual e ineficiente.
David Soria Parra e Justin Spahr-Summers, também da Anthropic, começaram a desenvolver uma solução. Em 25 de novembro de 2024, a empresa lançou publicamente o Model Context Protocol junto com SDKs para Python e TypeScript, servidores de referência para sistemas como GitHub, Slack e Google Drive, e integração nativa com o Claude Desktop.
A adoção foi rápida. Em 26 de março de 2025, Sam Altman, CEO da OpenAI, anunciou suporte completo ao MCP com a declaração: “As pessoas adoram o MCP, e estamos animados para adicionar suporte em toda a nossa linha de produtos.” Em abril de 2025, Demis Hassabis do Google DeepMind confirmou que os próximos modelos Gemini também suportariam o protocolo.
O marco definitivo veio em dezembro de 2025, quando a Anthropic doou o MCP para a Agentic AI Foundation (AAIF), um fundo sob a Linux Foundation cofundado por Anthropic, Block e OpenAI, com apoio de Google, Microsoft, AWS, Cloudflare e Bloomberg. Essa governança neutra eliminou preocupações de lock-in e acelerou a adoção corporativa.
Arquitetura do MCP: hosts, clientes e servidores
O MCP utiliza uma arquitetura cliente-servidor que separa claramente as responsabilidades de cada componente. Essa estrutura modular permite que diferentes partes do sistema evoluam independentemente e garante isolamento de segurança entre as camadas.
Host
O host é a aplicação de IA que o usuário interage diretamente. Exemplos incluem o Claude Desktop, ChatGPT Desktop, editores de código como Cursor e VS Code, ou qualquer aplicação que incorpore um modelo de linguagem. O host instancia e gerencia os clientes MCP, controlando quais servidores podem ser conectados e aplicando políticas de segurança.
Cliente
O cliente MCP é um componente dentro do host que estabelece conexões com servidores MCP. Cada cliente mantém uma conexão dedicada com um servidor específico. Quando o host precisa acessar múltiplas ferramentas, ele cria múltiplos clientes, cada um gerenciando sua própria conexão de forma independente.
Servidor
O servidor MCP expõe capacidades para os clientes. Ele pode oferecer ferramentas (funções executáveis), recursos (fontes de dados) ou prompts (templates reutilizáveis). Os servidores podem rodar localmente na máquina do usuário ou remotamente em infraestrutura de nuvem. A Block, por exemplo, desenvolveu mais de 60 servidores MCP para suas operações internas.
Comunicação
Os componentes comunicam-se usando JSON-RPC 2.0, um protocolo estruturado que garante mensagens consistentes independentemente de quem construiu o cliente ou servidor. Essa escolha técnica deriva do Language Server Protocol (LSP), amplamente utilizado em editores de código, o que facilitou a adoção por desenvolvedores familiarizados com esse padrão.
As três primitivas do MCP: tools, resources e prompts
O protocolo define três tipos fundamentais de capacidades que servidores podem expor. Cada primitiva tem um propósito específico e um modelo de controle distinto.
Tools (Ferramentas)
Ferramentas são funções executáveis que permitem ao modelo de IA realizar ações no mundo real. Exemplos incluem operações de arquivo, chamadas de API, consultas a bancos de dados, envio de mensagens e automação de navegador. Segundo a especificação do MCP, ferramentas são “controladas pelo modelo”, o que significa que o LLM decide quando invocá-las, geralmente com aprovação humana no loop.
Uma ferramenta típica poderia ser “criar_arquivo” que aceita parâmetros como caminho e conteúdo, ou “enviar_email” que requer destinatário, assunto e corpo da mensagem. O modelo analisa o contexto da conversa, identifica quando uma ferramenta é relevante e gera a chamada apropriada.
Resources (Recursos)
Recursos são fontes de dados que fornecem contexto ao modelo. Diferentemente de ferramentas, recursos são “controlados pela aplicação”: o host decide quando buscar e passar informações como contexto, não o modelo. Exemplos incluem conteúdo de arquivos, registros de banco de dados, respostas de APIs e documentação.
Recursos podem ser estáticos (um arquivo de configuração) ou dinâmicos (resultados de uma consulta SQL). Eles permitem que o modelo tenha acesso a informações atualizadas sem que essas informações precisem estar embutidas em seu treinamento.
Prompts
Prompts são templates pré-definidos que estruturam interações com o modelo. Eles podem incluir instruções de sistema, exemplos few-shot ou padrões de formatação. Prompts são “controlados pelo usuário”: tipicamente, o usuário escolhe quando aplicar um template específico, como “resumir texto” ou “gerar código no estilo X”.
Cada primitiva possui métodos associados para descoberta (/list), recuperação (/get) e, no caso de ferramentas, execução (tools/call). Quando um cliente MCP inicia, ele consulta os servidores conectados para descobrir quais capacidades estão disponíveis.
Transportes: STDIO, HTTP e SSE
O MCP suporta diferentes mecanismos de transporte para comunicação entre clientes e servidores. A escolha do transporte afeta onde o servidor executa, como a conexão é estabelecida e quais medidas de segurança são aplicáveis.
STDIO (Standard Input/Output)
O transporte STDIO permite comunicação através de streams de entrada e saída padrão. O cliente inicia o servidor como um processo filho e comunica-se através de stdin e stdout do processo. Esse transporte é ideal para servidores locais e ferramentas de linha de comando.
Quando o Claude Desktop executa um servidor de filesystem, por exemplo, o servidor roda localmente na mesma máquina usando STDIO. A vantagem é simplicidade: não requer configuração de rede ou autenticação complexa. A desvantagem é que funciona apenas localmente.
Streamable HTTP
O transporte HTTP moderno usa requisições POST e GET, com opção de Server-Sent Events (SSE) para streaming de múltiplas mensagens do servidor. Segundo a especificação de transportes, esse transporte simplifica o protocolo usando um único endpoint, permite flexibilidade entre respostas em streaming ou únicas, e habilita implementações completamente stateless.
Servidores remotos, como o servidor oficial do Sentry, utilizam Streamable HTTP. Isso permite que o servidor rode em infraestrutura de nuvem e atenda múltiplos clientes simultaneamente.
SSE Legacy
O Server-Sent Events permanece disponível para compatibilidade com servidores MCP mais antigos. O cliente conecta-se ao endpoint SSE via HTTP GET, estabelecendo uma conexão persistente onde o servidor pode enviar eventos ao cliente.
Segurança nos transportes
Para Streamable HTTP, autenticação segura é obrigatória. A especificação MCP de autenticação é baseada em OAuth 2.0/2.1, classificando servidores MCP como Resource Servers OAuth. Toda comunicação HTTP deve usar HTTPS para garantir confidencialidade e integridade.
Para STDIO, a segurança depende do contexto de execução do processo. O cliente deve iniciar o servidor de forma segura, e credenciais podem ser passadas via variáveis de ambiente com tratamento cuidadoso.
Servidores MCP populares e o ecossistema
O ecossistema MCP cresceu de aproximadamente 100 servidores em novembro de 2024 para mais de 5.800 em outubro de 2025. Esse crescimento de 5.700% em menos de um ano demonstra a demanda por integrações padronizadas.
Servidores oficiais de referência
A Anthropic disponibiliza servidores de referência para sistemas empresariais populares:
- Filesystem: operações seguras de arquivo com controles de acesso configuráveis
- GitHub: gerenciamento de repositórios, operações de arquivo e integração com a API do GitHub
- Slack: gerenciamento de canais e capacidades de mensageria
- PostgreSQL: acesso somente-leitura a bancos de dados com inspeção de schema
- Google Drive: acesso a arquivos e busca no Google Drive
- Puppeteer: automação de navegador e web scraping
- Git: ferramentas para operações em repositórios Git
- Fetch: busca de conteúdo web
- Memory: memória persistente baseada em grafos de conhecimento
Servidores da comunidade
Listas curadas como awesome-mcp-servers agregam milhares de servidores desenvolvidos pela comunidade. Categorias populares incluem:
- Bancos de dados: MySQL, MongoDB, Redis, Supabase, SQLite
- Produtividade: Notion, Todoist, Linear, Asana
- Comunicação: Discord, Telegram, Email
- Desenvolvimento: Docker, Kubernetes, AWS, Azure
- Busca e conhecimento: Wikipedia, Arxiv, documentação técnica
Os servidores mais baixados, segundo estatísticas do ecossistema, são GitHub, Fetch, Context7 (banco de dados de documentação), Playwright (automação de navegador) e Filesystem.
Como configurar o MCP no Claude Desktop
A forma mais acessível de experimentar o MCP é através do Claude Desktop. A configuração pode ser feita de duas maneiras: via Desktop Extensions (método simplificado) ou configuração manual via JSON.
Método 1: Desktop Extensions
Com a introdução de Desktop Extensions, instalar servidores MCP tornou-se tão simples quanto instalar extensões de navegador. Segundo o centro de ajuda do Claude:
- Navegue até Settings > Extensions no Claude Desktop
- Clique em “Browse extensions” para visualizar o diretório
- Selecione as ferramentas que deseja usar
- Configure requisitos como chaves de API através da interface
- A extensão estará disponível automaticamente nas conversas
Método 2: Configuração manual via JSON
Para maior controle ou servidores não listados no diretório oficial:
- Acesse Settings > Developer no Claude Desktop
- Selecione seu servidor MCP e clique em “edit config”
- Edite o arquivo de configuração:
- macOS:
~/Library/Application Support/Claude/claude_desktop_config.json - Windows:
%APPDATA%\Claude\claude_desktop_config.json
Um exemplo de configuração para o servidor de filesystem:
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/caminho/para/diretorio/permitido"
]
}
}
}- Salve o arquivo e reinicie completamente o Claude Desktop
- Após reiniciar, um indicador de servidor MCP aparecerá no canto inferior direito da caixa de conversa
Pré-requisitos
O Node.js é necessário para executar a maioria dos servidores MCP baseados em TypeScript. Verifique a instalação executando node -v no terminal. Para servidores Python, Python 3.10 ou superior é requerido.
Como construir um servidor MCP
Para desenvolvedores que desejam criar servidores customizados, o MCP oferece SDKs oficiais em múltiplas linguagens. A escolha do SDK depende da stack tecnológica existente e das preferências da equipe.
SDK TypeScript
O SDK TypeScript é a opção mais madura, com bibliotecas para servidores (tools, resources, prompts, transportes) e clientes. Instalação:
npm install @modelcontextprotocol/sdk zodUm servidor básico que expõe uma ferramenta de soma:
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: "calculadora",
version: "1.0.0"
});
server.tool(
"somar",
{ a: z.number(), b: z.number() },
async ({ a, b }) => ({
content: [{ type: "text", text: String(a + b) }]
})
);
const transport = new StdioServerTransport();
await server.connect(transport);SDK Python
O SDK Python permite iteração rápida com FastMCP. Instalação:
pip install mcpExemplo equivalente em Python:
from mcp.server import Server
from mcp.server.stdio import stdio_server
app = Server("calculadora")
@app.tool()
async def somar(a: int, b: int) -> str:
"""Soma dois números"""
return str(a + b)
async def main():
async with stdio_server() as (read, write):
await app.run(read, write)Boas práticas de logging
Para servidores STDIO, nunca escreva em stdout (saída padrão). Isso corrompe as mensagens JSON-RPC e quebra a comunicação. Use stderr para logs ou configure logging para arquivo. Em Python, lembre-se que print() escreve em stdout por padrão — use print(..., file=sys.stderr) ou configure um logger apropriado.
Para servidores HTTP, logging em stdout é seguro porque não interfere com as respostas HTTP.
MCP vs Function Calling vs LangChain
Desenvolvedores frequentemente questionam como o MCP se compara a outras abordagens para conectar LLMs a ferramentas. Cada tecnologia opera em uma camada diferente e pode ser combinada conforme necessário.
Function Calling
Function Calling, popularizado pela OpenAI, permite que LLMs gerem schemas JSON correspondentes a funções definidas pelo desenvolvedor. O modelo não executa a função diretamente — ele retorna argumentos que o código cliente pode processar. É uma abordagem específica de cada provedor, sem padronização universal.
O MCP complementa Function Calling. Enquanto Function Calling formata a chamada de função (o modelo gera o JSON), o MCP padroniza a execução dessa chamada de forma interoperável. Os dois frequentemente trabalham em conjunto.
LangChain
LangChain é um framework de orquestração para construir aplicações com LLMs. Ele gerencia memória de conversação, encadeamento de operações e integração de ferramentas através de sua própria abstração (a classe Tool).
A diferença fundamental é onde ocorre a padronização. LangChain cria um padrão voltado ao desenvolvedor para integrar ferramentas no código do agente. MCP cria um padrão voltado ao modelo — o agente de IA pode descobrir e usar qualquer ferramenta compatível com MCP em tempo de execução.
Na prática, os dois são complementares. LangChain adicionou suporte para tratar servidores MCP como fonte de ferramentas, permitindo que agentes construídos com LangChain acessem o crescente ecossistema de servidores MCP.
Recomendação estratégica
Use Function Calling para prototipagem rápida em aplicações simples. Implemente adaptadores MCP para escalabilidade e portabilidade entre diferentes hosts. Considere frameworks como LangChain para orquestração complexa de múltiplas ferramentas e agentes.
Casos de uso empresariais
O MCP habilita cenários que seriam impraticáveis com integrações customizadas. Empresas de diversos setores implementam o protocolo para automatizar processos e ampliar as capacidades de seus assistentes de IA.
Atendimento ao cliente
Um chatbot habilitado com MCP pode acessar o histórico de pedidos do cliente via CRM (recurso), consultar status de entrega via API logística (ferramenta) e iniciar processo de devolução via plataforma de e-commerce (ferramenta), tudo dentro da mesma conversa. O impacto mensurável inclui resolução mais rápida de problemas, melhoria em scores de satisfação e redução de carga em centrais de atendimento humano.
Desenvolvimento de software
Assistentes de código como Cursor, VS Code com Copilot e Replit utilizam MCP para acessar documentação específica do projeto (recursos), consultar schemas de banco de dados (recursos), interagir com sistemas de controle de versão como GitHub (ferramentas) e executar testes automatizados (ferramentas). O resultado é aumento significativo na produtividade de desenvolvedores.
Operações industriais
Em manufatura, agentes de IA podem acessar dados de sensores IoT (recursos), analisar padrões de manutenção (recursos) e acionar alertas ou ajustar parâmetros de produção via APIs de sistemas de controle (ferramentas). Benefícios incluem redução de tempo de inatividade por manutenção preditiva e otimização de rendimento.
Recrutamento e RH
Plataformas de recrutamento conectam agentes de IA a sistemas ATS (Applicant Tracking System) via MCP. O agente pode buscar candidatos por critérios específicos, analisar histórico de entrevistas e gerar relatórios comparativos. A automação acelera processos de triagem mantendo qualidade nas seleções.
SEO e Marketing Digital
Para profissionais de SEO e marketing, servidores MCP podem conectar assistentes de IA a ferramentas de análise como Google Analytics, Search Console, plataformas de monitoramento de ranking e bases de dados de palavras-chave. Isso permite análises contextualizadas e recomendações baseadas em dados atualizados, ampliando as capacidades de Generative Engine Optimization (GEO).
Segurança e considerações de risco
A capacidade do MCP de conectar agentes de IA a ferramentas arbitrárias introduz vetores de ataque que devem ser rigorosamente gerenciados. Pesquisadores de segurança identificaram vulnerabilidades significativas no ecossistema.
Vulnerabilidades conhecidas
Em julho de 2025, pesquisadores da Knostic escanearam quase 2.000 servidores MCP expostos à internet. Todos os servidores verificados careciam de qualquer forma de autenticação, permitindo potencialmente acesso a listagens de ferramentas internas e exfiltração de dados sensíveis.
Análises de segurança em abril de 2025 identificaram múltiplos problemas: injeção de prompt (onde entradas maliciosas manipulam o comportamento do modelo), permissões de ferramentas inadequadas (onde combinações de ferramentas podem exfiltrar arquivos) e ferramentas “lookalike” (onde servidores maliciosos substituem silenciosamente servidores confiáveis).
Práticas recomendadas
Para mitigar riscos, a especificação do MCP recomenda:
- Validar headers de Origin em todas as conexões para prevenir ataques de DNS rebinding
- Quando rodando localmente, vincular apenas a localhost (127.0.0.1), não a todas as interfaces (0.0.0.0)
- Implementar autenticação adequada para todas as conexões
- Usar HTTPS para toda comunicação HTTP
- Aplicar princípio de menor privilégio nas permissões de ferramentas
- Auditar regularmente servidores MCP em uso
Governança corporativa
Para implantações empresariais, é recomendável:
- Manter inventário de todos os servidores MCP autorizados
- Estabelecer processo de aprovação para novos servidores
- Monitorar atividade de ferramentas e recursos acessados
- Implementar logging centralizado para auditoria
- Treinar equipes sobre riscos específicos de agentes de IA
O futuro do MCP: roadmap e projeções
Com a doação para a Linux Foundation e adoção por todos os principais provedores de IA, o MCP está posicionado como infraestrutura fundamental da economia de agentes. Desenvolvimentos esperados incluem:
Evolução técnica
A versão 2 do SDK TypeScript está em desenvolvimento, com lançamento estável previsto para Q1 2026. Melhorias incluem suporte aprimorado a streaming, simplificação de APIs e maior robustez em cenários de produção. A especificação de autenticação continua evoluindo para endereçar cenários empresariais complexos.
Expansão do ecossistema
O crescimento de servidores remotos aumentou 4 vezes desde maio de 2025, indicando maturidade do ecossistema para implantações em nuvem. Projeções sugerem que 90% das organizações utilizarão MCP até o final de 2025. O mercado do ecossistema MCP é estimado em US$ 4,5 bilhões para 2025.
Integração com agentic commerce
O MCP é peça fundamental na infraestrutura de agentic commerce. Protocolos como o Agent Payments Protocol (AP2) do Google e o Agentic Commerce Protocol (ACP) da OpenAI/Stripe são construídos para interoperar com MCP, permitindo que agentes de IA completem transações comerciais de forma segura.
Governança neutra
A Agentic AI Foundation sob a Linux Foundation garante que o MCP evoluirá de forma neutra, sem favorecimento a nenhum provedor específico. OpenAI contribuiu com o Agents SDK e AGENTS.md, Block contribuiu com o framework Goose, e Anthropic contribuiu o próprio MCP. Essa colaboração entre concorrentes é rara e indica maturidade do ecossistema.
FAQ: perguntas frequentes sobre Model Context Protocol
O que significa MCP?
MCP é a sigla para Model Context Protocol, um padrão aberto criado pela Anthropic em novembro de 2024 para padronizar como sistemas de inteligência artificial se conectam a ferramentas externas, bancos de dados e fontes de informação. O nome reflete o propósito: fornecer contexto (Context) para modelos (Model) através de um protocolo padronizado (Protocol).
O MCP funciona apenas com o Claude?
Não. Embora tenha sido criado pela Anthropic para o Claude, o MCP é um padrão aberto adotado por toda a indústria. OpenAI integrou MCP ao ChatGPT Desktop, Agents SDK e Responses API. Google adicionou suporte no Gemini 2.5 Pro. Microsoft implementou no Copilot Studio. Qualquer aplicação pode implementar o protocolo.
Qual a diferença entre MCP e API?
APIs são interfaces específicas de cada serviço — a API do GitHub é diferente da API do Slack. O MCP é uma camada de abstração que padroniza como agentes de IA interagem com qualquer serviço. Um servidor MCP pode encapsular chamadas de API, mas o agente de IA não precisa conhecer os detalhes de cada API específica.
Preciso saber programar para usar o MCP?
Não necessariamente. Usuários podem instalar servidores MCP pré-construídos no Claude Desktop através de Desktop Extensions sem escrever código. Contudo, para criar servidores customizados ou configurações avançadas, conhecimento de programação em TypeScript ou Python é necessário.
O MCP é seguro para uso empresarial?
O MCP foi projetado com segurança em mente, mas a implementação segura depende de boas práticas. Riscos incluem servidores mal configurados, falta de autenticação e permissões excessivas. Empresas devem auditar servidores, implementar autenticação adequada, usar HTTPS e aplicar princípio de menor privilégio.
Quanto custa usar o MCP?
O protocolo MCP é gratuito e open source sob licença Apache 2.0. Custos podem surgir de infraestrutura (servidores remotos), ferramentas de terceiros acessadas via MCP, ou tempo de desenvolvimento para criar servidores customizados. O uso básico no Claude Desktop não tem custo adicional além da assinatura do serviço.
Como o MCP se relaciona com o ChatGPT Plugins?
ChatGPT Plugins foi uma tentativa anterior da OpenAI de conectar o ChatGPT a serviços externos, descontinuada em favor de GPTs customizados. O MCP é mais flexível, funciona com múltiplos provedores de IA, é open source e permite tanto ferramentas quanto recursos e prompts. A OpenAI adotou MCP como padrão para suas novas integrações.
O MCP funciona com agentes autônomos?
Sim. O MCP é fundamental para agentes de IA autônomos porque permite que eles descubram e utilizem ferramentas em tempo de execução. Frameworks como LangChain, CrewAI e LlamaIndex integram-se ao MCP para acessar seu ecossistema de servidores. Agentes podem executar workflows complexos combinando múltiplas ferramentas MCP.
Existe MCP para aplicações mobile?
Atualmente, o MCP é mais comum em aplicações desktop e servidor. Claude Desktop (macOS e Windows), VS Code, e IDEs similares são os principais hosts. Para mobile, a integração típica seria via backends que implementam MCP e expõem funcionalidades para apps móveis através de APIs tradicionais.
Como acompanhar novidades do MCP?
Fontes oficiais incluem o blog do Model Context Protocol, o repositório GitHub, a documentação oficial e anúncios da Agentic AI Foundation. Listas como awesome-mcp-servers agregam novos servidores da comunidade. O protocolo evolui rapidamente, com atualizações frequentes na especificação.
