Protocolos para conectar modelos computacionais distintos são conjuntos de regras, formatos e padrões que permitem a integração, comunicação e interoperabilidade entre diferentes sistemas, algoritmos ou arquiteturas de modelagem. Eles atuam como pontes semânticas e estruturais, garantindo que os modelos compartilhem informações contextuais, metadados, entradas e saídas, mesmo quando desenvolvidos com linguagens, objetivos ou arquiteturas diferentes. Esses protocolos são fundamentais em cenários como sistemas multiagentes, gêmeos digitais, orquestração de modelos de IA, fluxos RAG e infraestruturas de MLOps, onde é necessário manter consistência, rastreabilidade e colaboração inteligente entre os diversos componentes do sistema.

Figure 1:Imagem ilustrando os protocolos de integração entre agentes de IA.
Antes de abordarmos os protocolos de integração entre modelos computacionais, é importante garantir a compreensão de alguns conceitos fundamentais relacionados a redes, APIs, agentes inteligentes e fluxo de dados.
Além dos conhecimentos teóricos, também é recomendável familiaridade com determinadas ferramentas e bibliotecas que viabilizam a implementação prática desses protocolos, como plataformas de orquestração, frameworks de agentes e ambientes de teste com suporte à integração por API.
Alguns protocolos de integração entre agentes de IA e sistemas computacionais vêm sendo desenvolvidos com o objetivo de padronizar a comunicação entre modelos, agentes e ambientes. Entre os principais, destacam-se:
Neste e-book, optamos por aprofundar o Model Context Protocol (MCP) por três motivos principais:
Ele propõe uma estrutura simples e modular para orquestração de agentes em fluxos complexos.
Permite organizar a troca de informações em blocos reutilizáveis e interpretáveis, facilitando o rastreamento do raciocínio do agente.
Está alinhado com práticas modernas de construção de sistemas multiagentes baseados em linguagem natural.
Model Context Protocol¶
O Model Context Protocol (MCP) (MCP) é uma iniciativa aberta e recente que busca padronizar a comunicação entre modelos de linguagem e aplicações. Seu objetivo central é permitir que diferentes agentes de IA interajam com fontes de dados, APIs e sistemas legados de forma segura, consistente e escalável — sem a necessidade de integrações manuais e fragmentadas.
Imagine que você tem um assistente de IA superinteligente (como o ChatGPT ou o Claude), mas ele está isolado, sem acesso aos seus arquivos, e-mails, agendas ou sistemas corporativos. O MCP funciona como uma “ponte universal”, que permite conectar esse assistente a tudo isso, garantindo controle, segurança e estrutura na troca de informações.
Essa padronização torna-se essencial em ecossistemas mais complexos, nos quais coexistem LLMs proprietários, aplicações empresariais, repositórios sensíveis e ferramentas de automação. Ao criar uma interface comum entre esses elementos, o MCP promove interoperabilidade real e reduz drasticamente os atritos técnicos.
Além disso, o protocolo foi desenvolvido com foco em modularidade e clareza. Em vez de construir integrações do zero para cada agente, você pode utilizar os blocos definidos no MCP para orquestrar fluxos, registrar raciocínios e controlar interações com outros sistemas.
Você pode se aprofundar acessando a documentação oficial do Model Context Protocol ou outras fontes como Canal YouTube (2024)Sakal (2024).
Por que o MCP Existe?¶
O Problema Antes do MCP | A Solução do MCP |
|---|---|
Cada empresa criava sua própria forma de conectar IA aos seus sistemas | Um padrão único que funciona para todas as aplicações de IA |
Muito trabalho duplicado e incompatibilidade entre soluções | Qualquer ferramenta que implemente MCP pode ser usada por qualquer aplicação de IA compatível |
Desenvolvedores precisavam criar integrações específicas para cada ferramenta | Redução drástica do tempo de desenvolvimento |
Usuários ficavam limitados aos sistemas que cada aplicação de IA conseguia acessar | Maior segurança e controle sobre as integrações |
A Filosofia e Motivação por Trás do MCP¶
A motivação central por trás do MCP, especialmente para a Anthropic, é a premissa de que “modelos são tão bons quanto o contexto que lhes fornecemos”. Há alguns anos, a integração de contexto em chatbots ou aplicações de IA era muitas vezes feita por meio de copiar e colar ou digitação manual. No entanto, a evolução levou a sistemas onde os modelos precisam de “ganchos” diretos em seus dados e contexto, tornando-os mais poderosos e personalizados.
O que a Anthropic observou antes do MCP era uma grande fragmentação na forma como as empresas e equipes construíam sistemas de IA. Cada equipe criava suas próprias implementações personalizadas para conectar LLMs a dados e ferramentas, com lógicas de prompt e formas de federação de acesso diferentes. Isso resultava em um problema “N vezes M”, onde havia inúmeras permutações para a interação entre aplicações cliente e servidores.
O MCP nasceu para padronizar esse desenvolvimento de IA, atuando como uma camada intermediária que “achata” essa complexidade. Ele busca ser para as aplicações de IA o que as APIs foram para a interação entre frontend e backend da web, ou o que o Language Server Protocol (LSP) é para a padronização da interação de IDEs com ferramentas específicas de linguagem.
MCP versus Outras Soluções¶
Para entender melhor o valor do MCP, vamos compará-lo com outras abordagens existentes:
| Aspecto | MCP | APIs REST Tradicionais | Webhooks | Plugins Específicos |
|---|---|---|---|---|
| Padronização | Protocolo único | Cada API é diferente | Implementação varia | Específico por aplicação |
| Bidirecionalidade | Cliente ↔ Servidor | Principalmente Cliente → Servidor | Servidor → Cliente | Varia |
| Tempo Real | Suporte nativo | Polling necessário | Push notifications | Varia |
| Descoberta Automática | Capacidades expostas | Documentação manual | Configuração manual | Manual |
| Controle de Acesso | Granular e padronizado | Varia por API | Limitado | Varia |
| Facilidade de Integração | Uma vez implementado, funciona com todos | Integração por API | Configuração por webhook | Por aplicação |
Para ajudar na escolha do protocolo mais adequado ao seu cenário, a tabela a seguir compara MCP, APIs REST, Webhooks e Plugins Específicos em diferentes situações de uso. Ela mostra, de forma visual, onde cada abordagem é recomendada ✅, possível mas com limitações ⚠️ ou não recomendada ❌.
| Situação de Uso | MCP | APIs REST | Webhooks | Plugins Específicos |
|---|---|---|---|---|
| Conectar IA a múltiplos sistemas | ✅ | ❌ | ❌ | ❌ |
| Solução padronizada e reutilizável | ✅ | ❌ | ❌ | ❌ |
| Aproveitar ecossistema existente | ✅ | ❌ | ❌ | ❌ |
| Comunicação bidirecional em tempo real | ✅ | ❌ | ⚠️ (limitada) | ❌ |
| Integração simples e específica | ❌ | ✅ | ⚠️ | ✅ |
| Sem necessidade de IA avançada | ❌ | ✅ | ✅ | ✅ |
| Já existe API REST disponível | ❌ | ✅ | ❌ | ❌ |
| Notificações simples | ❌ | ❌ | ✅ | ❌ |
| Comunicação unidirecional | ❌ | ✅ | ✅ | ✅ |
| Requisitos específicos de tempo real | ❌ | ❌ | ✅ | ❌ |
| Aplicação única | ❌ | ✅ | ✅ | ✅ |
| Funcionalidades muito específicas | ❌ | ⚠️ | ✅ | ✅ |
| Aplicação sem suporte a MCP | ❌ | ✅ | ✅ | ✅ |
Arquitetura Central do MCP¶
A arquitetura central do MCP se baseia em uma estrutura cliente-servidor robusta e modular, projetada para facilitar a integração entre modelos de IA e sistemas externos. Para quem deseja se aprofundar nos detalhes dessa arquitetura, recomendamos a leitura da documentação oficial e de recursos complementares disponíveis em Anthropic (2024)DeepLearning.AI (2024)Microsoft (2024).
Componentes Detalhados¶
MCP Host (Anfitrião):
É a aplicação ou ferramenta que o usuário interage diretamente.
MCP Client (Cliente):
Componente interno do MCP Host
Mantém conexões um-para-um com os servidores MCP
MCP Server (Servidor):
Programa leve que atua como “wrapper” para sistemas externos
Pode ser executado localmente ou remotamente
Fluxo de Comunicação¶
Inicialização: Host inicia e configura conexões com servidores
Descoberta: Cliente solicita capacidades de cada servidor
Disponibilização: Servidor informa suas ferramentas, recursos e prompts
Uso: Usuário interage com Host, que decide quando usar cada capacidade
Execução: Cliente invoca ferramentas do servidor conforme necessário
Resultado: Servidor processa e retorna resultados ao cliente/host

Na prática:

Componentes Primários do protocolo¶
O MCP padroniza as interações em três interfaces principais, além de outras funcionalidades:
1. Ferramentas (Tools)¶
As ferramentas no contexto do Model Context Protocol (MCP) são funcionalidades expostas pelo servidor MCP que podem ser utilizadas pelos modelos de linguagem (LLMs) durante a execução de tarefas. Elas funcionam como extensões das capacidades do modelo, permitindo que ele interaja com o mundo externo de maneira programada.
O que são: São funções executáveis que podem ser chamadas pelo LLM para realizar ações (como buscar dados, consultar sistemas, fazer cálculos, enviar mensagens, etc.).
Controle: A decisão de usar ou não uma ferramenta é tomada autonomamente pelo modelo, com base no contexto da conversa ou tarefa em andamento.
Função: Ampliar o poder do modelo, permitindo que ele recupere informações externas ou execute comandos no ambiente do usuário, de forma segura e contextualizada.
Essas ferramentas são o que transformam um modelo estático em um agente dinâmico e funcional, capaz de realizar operações complexas, acessar bancos de dados, interagir com APIs, ou controlar outros sistemas integrados.
Exemplos de Ferramentas:
Pense neste bloco de código JSON abaixo como o “cardápio” ou a “etiqueta de instruções” de uma ferramenta. Este JSON não é a ferramenta que executa a ação, mas sim a definição que o protocolo (MCP) lê para entender o que a ferramenta faz e o que ela precisa.
{
"name": "send_email",
"description": "Enviar email para um destinatário",
"inputSchema": {
"type": "object",
"properties": {
"to": {
"type": "string",
"description": "Email do destinatário"
},
"subject": {
"type": "string",
"description": "Assunto do email"
},
"body": {
"type": "string",
"description": "Corpo do email"
}
},
"required": ["to", "subject", "body"]
}
}Uso Prático
Imagine que você está conversando com um agente de IA e pede:
Usuário diz(Você): “Envie um email para a equipe@empresa.com sobre a Reunião Semanal. Avise que o link da chamada foi atualizado.”
A IA, então, usa a definição (o seu JSON) como um “formulário” para preencher, e assim poder passar como argumento, para a função em python(ou qualquer outra linguagem de programação) que de fato vai executar a ação “send_email”.
A IA traduz seu pedido de linguagem natural para a estrutura exata que a definição da ferramenta exige:
{
"name": "send_email",
"arguments": {
"to": "equipe@empresa.com",
"subject": "Reunião Semanal",
"body": "Aviso: o link da chamada foi atualizado."
}
}A ferramenta real de envio de email é executada(A função em python) no servidor e retorna uma confirmação:
{
"status": "sucesso",
"destinatario": "equipe@empresa.com",
"horario_envio": "2025-11-13T15:15:00Z"
}2. Recursos (Resources)¶
Os recursos no contexto do MCP são dados disponibilizados pela aplicação (ou MCP Host) para enriquecer o contexto da conversa. Diferentemente das ferramentas, os recursos não são invocados diretamente pelo LLM. Em vez disso, são anexados ao contexto de forma automática, fornecendo informações adicionais que auxiliam o modelo a gerar respostas mais completas e contextualizadas.
Controle: Controlados pela aplicação (o MCP Host).
Função: São dados expostos à aplicação, incorporados ao contexto para melhorar a compreensão e relevância das respostas geradas pelo modelo.
Exemplos de Recursos:
Este JSON abaixo não é o dado em si, mas sim a definição que o protocolo (MCP) usa para dizer ao modelo de IA: “Ei, este dado existe, este é o nome dele (name), é deste tipo (mimeType), e aqui está a descrição do que ele contém (description).”
Isso permite que a aplicação/cliente (o Host) saiba quais dados ela pode pegar da estante para entregar ao modelo de IA quando ele precisar de contexto.
{
"uri": "file:///home/user/project/README.md",
"name": "Project Documentation",
"description": "Documentação principal do projeto",
"mimeType": "text/markdown"
}Uso Prático
Pense que você está conversando com um assistente de IA que está integrado ao seu computador e tem acesso a esse recurso.
Usuário diz(Você): “Como eu faço a instalação deste projeto?”
A aplicação (o Host) percebe que você está perguntando sobre o projeto. Ela usa a definição do recurso para entender que file:///.../README.md é a “Documentação principal do projeto” e que é um arquivo de texto.
Diferente de uma ferramenta, a IA não “chama” o arquivo. Em vez disso, o Host (a aplicação) “pega os dados” e o “anexa” à conversa para a IA ler.Com esse contexto, a IA pode responder sua pergunta de forma mais “inteligente”.
3. Prompts¶
Os prompts funcionam como templates configuráveis ou atalhos inteligentes que os usuários podem utilizar para iniciar fluxos específicos de conversa com o modelo. Eles encapsulam instruções complexas em comandos simples, semelhantes a “comandos de barra” (ex: /resumir-documento ou /gerar-relatório), permitindo ao usuário acionar comportamentos predefinidos de forma rápida e consistente.
Controle: definidos e acionados pelo usuário
Função: atuam como modelos predefinidos de interação para tarefas recorrentes
Estrutura de um Prompt:
Pense neste bloco de código como a “criação de um atalho” ou um “comando de barra” personalizado (como /resumir ou /traduzir em um chat).
Este JSON não executa a tarefa sozinho. Ele é a definição que o protocolo (MCP) usa para:
1.Saber que este “atalho” (name) existe.
2.Entender o que ele faz (description).
3.Saber quais “opções” ou “filtros” (arguments) ele aceita.
Por exemplo, a definição summarize_code abaixo diz ao sistema:
"Ei, eu tenho um atalho chamado summarize_code.
O que ele faz? Resumir arquivos de código do projeto.
Quais opções ele aceita? Ele aceita um argumento opcional (required: false) chamado file_pattern, que serve para filtrar quais arquivos resumir (por exemplo, *.py ou main.js)."
{
"name": "summarize_code",
"description": "Resumir arquivos de código do projeto",
"arguments": [
{
"name": "file_pattern",
"description": "Padrão de arquivos a resumir (ex: *.py)",
"required": false
}
]
}Uso Prático
Imagine que você é um desenvolvedor e quer um resumo rápido de todos os arquivos Python do seu projeto. Você usa o “atalho” que acabou de ser definido.
Usuário digita(Você): /summarize_code *.py
O Host (a aplicação onde você está digitando) reconhece o comando /summarize_code. Ele usa a definição do prompt para entender o que fazer com o texto *.py. O Host traduz seu comando para a estrutura exata que a definição do prompt exige:
{
"name": "summarize_code",
"arguments": {
"file_pattern": "*.py"
}
}Por que isso é importante? A definição garantiu que o Host soubesse que *.py era um valor para o argumento file_pattern.
OUTPUT (A Resposta da IA) A “implementação” deste prompt (uma função no servidor, como vimos nos códigos Python) é acionada. Ela:
1.Recebe file_pattern: “*.py”.
2.Busca todos os arquivos *.py no contexto atual.
3.Monta uma instrução complexa para a IA (ex: “Resuma os seguintes arquivos: [conteúdo do main.py], [conteúdo do utils.py]...”).
4.A IA processa tudo e te entrega o resultado final:
IA diz: "Certo! Analisei os 2 arquivos .py do seu projeto. Aqui está o resumo:
api_server.py: Define os endpoints principais da API (login, dados).
data_utils.py: Contém funções para limpar e validar os dados de entrada."(exemplo)
Exemplos de Mensagens Comuns¶
Antes de entender os exemplos, é importante saber o que são essas mensagens.
No MCP, a comunicação entre o Cliente (como um agente de IA ou aplicativo) e o Servidor (que fornece dados, como papers ou APIs) ocorre por meio de um protocolo padronizado chamado JSON-RPC.
Esse formato define com precisão como as mensagens devem ser estruturadas, enviadas e interpretadas, permitindo que diferentes sistemas se comuniquem de forma segura e padronizada.
Analogia para Entender
Imagine um atendimento em um drive-thru:
Você (Cliente): “Quero um hambúrguer com queijo.”
Atendente (Servidor): “Certo! São R$ 15,00. Seu pedido está sendo preparado.”
Assim também funciona a comunicação no MCP:
O Cliente envia uma requisição JSON pedindo algo.
O Servidor retorna uma resposta estruturada, com o resultado, confirmação ou erro.
Todas as mensagens seguem esse padrão de “pergunta → resposta”.
Estrutura Básica das Mensagens¶
Toda mensagem JSON-RPC tem estes elementos:
{
"jsonrpc": "2.0",
"id": "1",
"method": "fazer_algo",
"params": {
"dado1": "valor1"
}
}Inicialização da Conexão
Antes de qualquer troca de dados úteis, cliente e servidor precisam se reconhecer e alinhar capacidades. É nesse momento que ocorre a inicialização da conexão, uma etapa essencial para estabelecer uma comunicação clara e segura.
A seguir, apresentamos o script em formato JSON que representa essa etapa inicial de comunicação, onde cliente e servidor trocam suas primeiras informações para estabelecer a conexão.
{
"jsonrpc": "2.0",
"id": "1",
"method": "initialize",
"params": {
"protocolVersion": "2024-11-05",
"capabilities": {
"tools": {},
"resources": {},
"prompts": {}
},
"clientInfo": {
"name": "ExampleClient",
"version": "1.0.0"
}
}
}Tradução em português:
Cliente: "Olá servidor! Sou o ExampleClient versão 1.0.0.
Uso o protocolo MCP versão 2024-11-05.
Posso trabalhar com ferramentas, recursos e prompts.
Você pode me responder?"Servidor responde: “Oi! Eu posso fazer isso...”
{
"jsonrpc": "2.0",
"id": "1",
"result": {
"protocolVersion": "2024-11-05",
"capabilities": {
"tools": {
"listChanged": true
},
"resources": {
"subscribe": true,
"listChanged": true
},
"prompts": {
"listChanged": true
}
},
"serverInfo": {
"name": "ExampleServer",
"version": "1.0.0"
}
}
}Tradução em português:
Servidor: "Olá ExampleClient! Sou o ExampleServer versão 1.0.0.
Também uso o protocolo MCP versão 2024-11-05.
Minhas capacidades:
✅ Ferramentas: Posso notificar quando a lista mudar
✅ Recursos: Você pode se inscrever e serei notificado sobre mudanças
✅ Prompts: Posso notificar quando a lista mudar
Estamos conectados!"Listagem de Ferramentas Disponíveis
Após o processo de inicialização, o próximo passo é a descoberta de capacidades.
Neste momento, o cliente envia uma solicitação ao servidor perguntando quais ferramentas estão disponíveis para uso. Essa listagem permite que o modelo saiba o que está ao seu alcance — funções, integrações e recursos que pode utilizar durante uma interação.
É como entrar em uma oficina e perguntar:
**"Quais ferramentas vocês têm aí? Martelo? Chave de fenda? Furadeira?"**
O servidor responde com a lista do que tem disponível, e o modelo decide como usar essas ferramentas conforme necessário.Cliente pergunta: “Que ferramentas você oferece?”
{
"jsonrpc": "2.0",
"id": "2",
"method": "tools/list"
}Tradução em português:
Cliente: "Me mostre a lista de todas as ferramentas disponíveis."Servidor responde: “Tenho estas ferramentas...”
{
"jsonrpc": "2.0",
"id": "2",
"result": {
"tools": [
{
"name": "get_weather",
"description": "Obter informações meteorológicas",
"inputSchema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "Cidade para consultar o clima"
}
},
"required": ["location"]
}
}
]
}
}Tradução em português:
Servidor: "Tenho 1 ferramenta disponível:
📍 Nome: get_weather
📝 O que faz: Busca informações sobre o clima
Como usar:
- Você DEVE me dar: 'location' (nome da cidade)
- location deve ser texto (string)
- Exemplo: 'São Paulo', 'Rio de Janeiro'
Pronto! É só chamar essa ferramenta quando precisar."Execução de uma Ferramenta
Após conhecer as ferramentas disponíveis, o cliente pode invocar uma delas para executar uma ação específica.
Essa etapa representa o momento em que o modelo passa da descoberta para a execução, colocando em prática uma funcionalidade oferecida pelo servidor.
Por exemplo, se entre as ferramentas listadas há uma chamada get_weather, o cliente pode enviar uma solicitação como:
“Quero usar a ferramenta
get_weatherpara consultar a previsão do tempo em São Paulo.”
Esse processo é essencial para que o LLM realize operações externas, como consultas a APIs, cálculos personalizados ou acesso a sistemas, expandindo suas capacidades além do texto gerado localmente.
É como estar em uma oficina: depois de saber que há um **termômetro**, você diz —
**"Ok, quero usar essa ferramenta para medir a temperatura agora!"**
O servidor então executa a função e retorna o resultado solicitado. Veja os comandos utilizados para uma execução em JSON:
Cliente chama: “Use a ferramenta X com estes dados”
{
"jsonrpc": "2.0",
"id": "3",
"method": "tools/call",
"params": {
"name": "get_weather",
"arguments": {
"location": "São Paulo"
}
}
}Tradução em português:
Cliente: "Quero EXECUTAR a ferramenta 'get_weather'.
Os dados que estou enviando são:
📍 location: 'São Paulo'
Me retorne o resultado, por favor!"Servidor responde: “Aqui está o resultado!”
{
"jsonrpc": "2.0",
"id": "3",
"result": {
"content": [
{
"type": "text",
"text": "Clima em São Paulo: 25°C, ensolarado, umidade 60%"
}
]
}
}Tradução em português:
Servidor: "Executei a ferramenta 'get_weather' para São Paulo.
Resultado:
🌡️ Temperatura: 25°C
☀️ Condição: Ensolarado
💧 Umidade: 60%
Tudo certo!"Exemplo Real do Nosso Projeto¶
A seguir, apresentamos um exemplo real extraído do nosso projeto, ilustrando como o cliente pode chamar uma ferramenta de busca de papers para recuperar informações acadêmicas. Este é um exemplo prático de comunicação entre cliente e servidor utilizando o MCP, a troca de mensagens segue o padrão JSON-RPC.
Cliente pede:
{
"jsonrpc": "2.0",
"id": "3",
"method": "tools/call",
"params": {
"name": "search_papers",
"arguments": {
"query": "artificial intelligence",
"max_results": 3
}
}
}O cliente está solicitando ao servidor que execute uma ferramenta chamada search_papers, com os seguintes argumentos:
"query": "artificial intelligence"→ tema da busca."max_results": 3→ quantidade de resultados desejados.
Essa chamada equivale a dizer:
“Servidor, por favor, busque 3 artigos sobre inteligência artificial.”
Servidor responde:
{
"jsonrpc": "2.0",
"id": "3",
"result": {
"content": [
{
"type": "text",
"text": "Encontrados 3 papers sobre 'artificial intelligence':\n\n1. Deep Learning Advances (2024)\n Autores: John Smith, Jane Doe\n ArXiv: 2409.12345\n\n2. Neural Networks Review (2024)\n Autores: Bob Johnson\n ArXiv: 2409.54321\n\n3. AI Ethics Study (2024)\n Autores: Alice Brown\n ArXiv: 2409.98765"
}
]
}
}O servidor compreendeu a solicitação e devolveu um resultado com 3 artigos, contendo:
Título do artigo
Nome dos autores
Identificador ArXiv
Tratamento de Erros¶
O que acontece se algo sair do esperado?
Quando ocorre uma falha durante a comunicação, o servidor não retorna um campo result, como em uma resposta bem-sucedida.
Em vez disso, ele envia uma mensagem de erro estruturada, contendo informações sobre o que deu errado.
Isso permite que o cliente trate adequadamente a situação — por exemplo, exibindo uma mensagem ao usuário ou tentando novamente com outros parâmetros.
Exemplo: Ferramenta não encontrada
{
"jsonrpc": "2.0",
"id": "3",
"error": {
"code": -32601,
"message": "Method not found",
"data": {
"detail": "A ferramenta 'get_clima' não existe. Ferramentas disponíveis: get_weather"
}
}
}Tradução:
Servidor: "ERRO! A ferramenta que você pediu não existe.
🔴 Código do erro: -32601 (Método não encontrado)
📝 Mensagem: Method not found
ℹ️ Detalhes: A ferramenta 'get_clima' não existe.
Ferramentas disponíveis: get_weather"Fluxo Completo de Comunicação¶
Sequência típica de uso¶
INICIALIZAÇÃO
Cliente: "initialize" → Servidor: "Ok, conectado!"DESCOBERTA
Cliente: "tools/list" → Servidor: "Tenho estas ferramentas..."EXECUÇÃO (pode repetir várias vezes)
Cliente: "tools/call get_weather" → Servidor: "25°C, sol"Cliente: "tools/call search_papers" → Servidor: "Encontrei 5 papers"Cliente: "tools/call analyze_papers" → Servidor: "Análise completa..."FINALIZAÇÃO
Cliente fecha a conexão
Diagrama Visual¶
┌─────────┐ ┌─────────┐
│ CLIENTE │ │SERVIDOR │
└────┬────┘ └────┬────┘
│ │
│ 1. initialize │
│────────────────────────────────────>│
│ │
│ 2. Conectado + Capacidades │
│<────────────────────────────────────│
│ │
│ 3. tools/list │
│────────────────────────────────────>│
│ │
│ 4. Lista de ferramentas │
│<────────────────────────────────────│
│ │
│ 5. tools/call "get_weather" │
│────────────────────────────────────>│
│ │
│ 6. Resultado: "25°C, sol" │
│<────────────────────────────────────│
│ │Resumindo...¶
Analogia: Restaurante¶
1. INITIALIZE = Entrar no restaurante e ser recebido
"Boa noite! Bem-vindo ao restaurante!"
2. TOOLS/LIST = Pedir o cardápio
"Aqui está nosso menu: pizza, hambúrguer, salada..."
3. TOOLS/CALL = Fazer o pedido
"Quero uma pizza margherita"
→ "Sua pizza está pronta!"Dicas Práticas¶
Antes de finalizar, vale destacar algumas boas práticas tanto para quem desenvolve quanto para quem utiliza integrações com o MCP.
Recursos Adicionais¶
Abaixo estão listados alguns recursos úteis para aprofundar o entendimento e aplicar na prática o que foi apresentado até o momento. Esses materiais complementares ajudam tanto no domínio da estrutura de mensagens quanto na validação e aplicação real do MCP:
Especificação JSON-RPC 2.0
Documento oficial que define como funciona o protocolo de comunicação usado entre cliente e servidor.Documentação Oficial do MCP
Página com exemplos, especificações e guia completo sobre o Model Context Protocol.Validador de JSON Online
Ferramenta prática para testar se os scripts JSON estão corretos e bem formatados.
Outras Capacidades Essenciais¶
O MCP oferece ainda um conjunto de capacidades avançadas que ampliam sua flexibilidade e inteligência. Elas tornam possível controlar o comportamento do modelo, organizar fluxos de interação e extrair informações de forma mais precisa e estruturada. Para se aprofundar nesses conceitos, recomendamos a leitura dos materiais Canal YouTube (2024)Anthropic (2024).
1. Composability (Componibilidade)¶
Uma característica poderosa do MCP é que qualquer aplicação, API ou agente pode ser tanto um cliente MCP quanto um servidor MCP simultaneamente. Isso permite criar arquiteturas complexas e em camadas.
Como Cliente, usa: | Como Servidor, expõe: |
|---|---|
Web Search MCP Server | research_topic() |
Database MCP Server | summarize_findings() |
File System MCP Server | generate_report() |
2. Sampling (Amostragem)¶
Permite que um servidor MCP solicite inferências (chamadas de LLM) do cliente, sem precisar hospedar seu próprio modelo.
Por que isso é poderoso?
Simplicidade no servidor
O servidor permanece leve e direto, sem precisar incorporar capacidades próprias de IA.Controle total
Você mantém o controle sobre os custos e a privacidade, já que toda a inteligência vem do seu próprio modelo de linguagem (LLM).
O script abaixo cria uma solicitação de amostragem (sampling) para o modelo de linguagem, pedindo que ele classifique um e-mail em uma das três categorias — urgente, normal ou baixa prioridade —, utilizando o modelo preferencial Claude 3 Sonnet.
{
"jsonrpc": "2.0",
"method": "sampling/createMessage",
"params": {
"messages": [
{
"role": "user",
"content": {
"type": "text",
"text": "Classifique este email como urgente, normal ou baixa prioridade: [email content...]"
}
}
],
"modelPreferences": {
"hints": [
{
"name": "claude-3-sonnet"
}
]
}
}
}3. Elicitation (Elicitação)¶
Capacidade que permite ao servidor solicitar informações adicionais dos usuários durante a execução de uma ferramenta.
{
"jsonrpc": "2.0",
"method": "elicitation/request",
"params": {
"prompt": "Confirmar reserva do restaurante X para 4 pessoas às 19h?",
"options": ["Confirmar", "Cancelar", "Alterar horário"]
}
}4. Completions (Conclusões/Sugestões)¶
O MCP suporta autocompletar para argumentos de prompt e parâmetros de recursos.
Implementação:
Cliente solicita sugestões
{
"jsonrpc": "2.0",
"id": "4",
"method": "completion/complete",
"params": {
"ref": {
"type": "prompt",
"name": "analyze_data"
},
"argument": {
"name": "data_source",
"value": "sales_"
}
}
}Servidor retorna sugestões
{
"jsonrpc": "2.0",
"id": "4",
"result": {
"completion": {
"values": [
"sales_2024",
"sales_monthly",
"sales_quarterly"
],
"total": 3,
"hasMore": false
}
}
}5. Authentication (Autenticação)¶
Os servidores MCP podem implementar OAuth 2.0/2.1 para acessar recursos protegidos.
Exemplo de configuração:
{
"mcpServers": {
"google-drive": {
"command": "mcp-server-google-drive",
"env": {
"GOOGLE_CLIENT_ID": "your-client-id",
"GOOGLE_CLIENT_SECRET": "your-client-secret"
}
}
}
}6. Notifications (Notificações)¶
Servidores podem enviar notificações para clientes sobre mudanças de estado.
O script do exemplo abaixo envia uma notificação ao servidor informando que o recurso localizado no URI file:///project/config.json foi atualizado, permitindo que o servidor reaja a essa mudança se necessário (como recarregar o arquivo ou ajustar o contexto).
{
"jsonrpc": "2.0",
"method": "notifications/resources/updated",
"params": {
"uri": "file:///project/config.json"
}
}7. Transports (Transportes)¶
O MCP suporta diferentes mecanismos de comunicação:
Transporte Local (STDIO) | Transporte Remoto (HTTP/SSE) |
|---|---|
|
|
Configuração de Transporte:
{
"mcpServers": {
"local-server": {
"command": "python",
"args": [
"server.py"
],
"transport": "stdio"
},
"remote-server": {
"url": "https://api.example.com/mcp",
"transport": "http"
}
}
}Limitações e Considerações de Segurança¶
As implementações do MCP trazem avanços significativos em interoperabilidade e integração entre modelos de IA, mas é essencial compreender suas limitações técnicas e riscos de segurança. Antes de aplicar o MCP em ambientes produtivos, recomenda-se avaliar aspectos como exposição de dados sensíveis, controle de acesso, auditoria de logs e tratamento de falhas, garantindo que a adoção do protocolo seja feita de forma segura e escalável. Para saber mais sobre limitações e considerações de segurança consulte, Data Science Academy (2024)Neo4j (2024).
1. Limitações do MCP¶
Limitações de Performance | Limitações Funcionais |
|---|---|
Latência de Rede: Servidores remotos podem ter latência alta | Stateless: Servidores MCP são geralmente stateless entre requisições |
Throughput: Limitado pela capacidade do transporte (HTTP vs STDIO) | Transações: Não há suporte nativo para transações distribuídas |
Concorrência: Nem todos os servidores suportam requisições paralelas | Streaming de Dados: Limitado para grandes volumes de dados |
Timeout: Operações longas podem exceder limites de timeout | Compatibilidade: Nem todas as ferramentas/APIs têm servidor MCP |
2. Considerações de Segurança¶
Antes de implementar qualquer integração baseada em MCP, é fundamental compreender as considerações de segurança que garantem o uso confiável do protocolo. A proteção de dados sensíveis e o controle de acesso são pilares para manter a integridade e a confidencialidade do sistema.
Autenticação e Autorização¶
{
"mcpServers": {
"database-server": {
"command": "mcp-database-server",
"env": {
"DB_CONNECTION": "postgresql://user:pass@localhost/db",
"ALLOWED_OPERATIONS": "SELECT, INSERT",
"MAX_ROWS": "1000"
}
}
}
}Controle de Acesso¶
Exemplo de verificação de permissões
def verify_permissions(operation, resource):
if operation == "DELETE" and not user.has_permission("admin"):
raise PermissionError("Operação DELETE requer permissão de admin")
if resource.startswith("/system/") and not user.has_permission("system"):
raise PermissionError("Acesso a recursos do sistema negado")Isolamento e Sandboxing¶
Execute servidores MCP em containers ou ambientes isolados
Use usuários com privilégios limitados
Implemente timeouts para prevenir operações infinitas
Monitore recursos (CPU, memória, disco)
Auditoria e Logging¶
Sistema de registro que monitora e documenta todas as operações realizadas através do MCP. É como ter um “diário detalhado” de tudo que acontece entre cliente e servidor.
Informações Registradas¶
Durante as interações no contexto do MCP, é essencial registrar detalhes operacionais para garantir segurança, rastreabilidade e auditoria adequada. Abaixo estão os principais elementos recomendados para registro:
Timestamp: momento exato em que a operação foi realizada
Ferramenta/recurso acessado: nome da funcionalidade ou recurso utilizado
Usuário que realizou a ação: identificação do agente ou usuário solicitante
Parâmetros enviados: dados ou argumentos fornecidos na chamada
Status do resultado: indicação de sucesso ou erro da operação
Exemplo Prático:
import logging
from datetime import datetime
def log_mcp_operation(tool_name, params, user_id, result_status):
logging.info({
"timestamp": datetime.utcnow().isoformat(),
"tool": tool_name,
"user": user_id,
"params": params,
"status": result_status,
"type": "mcp_operation"
})Benefícios do MCP¶
O MCP oferece vantagens significativas para todo o ecossistema de IA:
1. Para Desenvolvedores de Aplicações¶
Desenvolvimento Acelerado: Uma vez que o cliente é compatível com MCP, pode conectar a qualquer servidor sem trabalho adicional
Foco na Lógica Principal: Desenvolvedores se concentram na lógica do agente em vez de integrações específicas
Ecossistema Rico: Aproveitar servidores MCP existentes da comunidade
Manutenção Simplificada: Updates centralizados no protocolo beneficiam todos
2. Para Provedores de Ferramentas/APIs¶
Alcance Ampliado: Um servidor MCP funciona com múltiplas aplicações de IA
Padronização: Não precisa criar integrações específicas para cada cliente
Descoberta Automática: Ferramentas são automaticamente descobertas por aplicações compatíveis
Monetização: Oportunidades de criar serviços MCP premium
3. Para Usuários Finais¶
Experiência Unificada: Mesmo assistente IA acessa múltiplos sistemas
Personalização Avançada: IA com acesso a dados pessoais e preferências
Automação Poderosa: Fluxos de trabalho complexos executados automaticamente
Controle Granular: Permissões específicas por ferramenta/recurso
4. Para Empresas¶
Separação de Responsabilidades: Diferentes equipes podem gerenciar diferentes servidores MCP
Governança Centralizada: Controle unificado sobre integrações de IA
ROI Acelerado: Implementação mais rápida de soluções de IA
Interoperabilidade: Redução de silos entre sistemas
5. Para o Ecossistema de IA¶
Padronização da Indústria: Protocolo comum para toda a indústria
Inovação Acelerada: Foco em capacidades específicas em vez de integrações
Redução de Fragmentação: Menos duplicação de esforços
Crescimento Sustentável: Base sólida para evolução futura
Aplicação Prática: Sistema MCP para Busca e Análise de Papers Acadêmicos¶
Agora que compreendemos os conceitos e estruturas fundamentais do MCP, é hora de visualizar esses conhecimentos em ação. A seguir, apresentaremos uma aplicação prática, que demonstra passo a passo como implementar as funcionalidades do MCP em um cenário real.
Trata-se de um Sistema MCP para Busca e Análise de Papers Acadêmicos — uma solução completa que permite buscar, analisar e interagir com artigos científicos utilizando o protocolo MCP aliado à inteligência artificial. Esse exemplo mostra como integrar agentes com ferramentas externas, manipulando dados em tempo real e simulando conversas orientadas por LLMs.
Você pode acessar todo o código comentado desta aplicação clicando aqui.
O que é este projeto? Este é um sistema que permite:
Buscar artigos científicos no ArXiv (maior repositório de artigos acadêmicos).
Ler detalhes completos de qualquer artigo encontrado.
Analisar automaticamente com IA (resumos, tendências, comparações).
Conversar sobre os artigos com um assistente inteligente.
Cache inteligente para respostas mais rápidas.
Como funciona? O sistema possui duas partes:
Servidor MCP (
mcp_papers_server.py): O “cérebro” que busca artigos e usa IACliente MCP (
mcp_papers_client.py): A interface que você usa para interagir
Você → Cliente → Servidor → ArXiv/Gemini IA
↓
Resultados
↓
Você recebeRequisitos¶
Antes de iniciar a aplicação, certifique-se de que os seguintes requisitos estão atendidos no seu ambiente:
Python 3.8 ou superior — Baixe aqui
pip — Gerenciador de pacotes do Python (já incluído na instalação padrão)
Chave de API do Google Gemini — Obtenha gratuitamente aqui
Instalação Completa (Passo a Passo)¶
Passo 1: Preparar o Ambiente¶
1.1 Criar a estrutura de pastas¶
Crie uma pasta para o projeto:
# Windows (no prompt de comando)
mkdir CHATBOT-PAPERS
cd CHATBOT-PAPERS
mkdir Servidores
mkdir Servidores\logs
# Linux/Mac (no terminal)
mkdir -p CHATBOT-PAPERS/Servidores/logs
cd CHATBOT-PAPERSEstrutura final:
CHATBOT-PAPERS/
├── .venv/ # Ambiente virtual (será criado)
├── Servidores/
│ ├── logs/ # Logs do sistema
│ ├── .env # Configurações (criar)
│ ├── mcp_papers_server.py # Servidor (criar)
│ ├── mcp_papers_client.py # Cliente (criar)
│ └── requirements.txt # Dependências (criar)1.2 Criar ambiente virtual¶
Por que fazer isso? Para isolar as dependências do projeto e não bagunçar seu Python.
# Windows
python -m venv .venv
.venv\Scripts\activate
# Linux/Mac
python3 -m venv .venv
source .venv/bin/activatePasso 2: Instalar Dependências¶
2.1 Criar arquivo requirements.txt¶
Na pasta Servidores, crie o arquivo requirements.txt:
# Dependências principais
fastmcp>=0.1.0
arxiv>=2.0.0
google-generativeai>=0.3.0
python-dotenv>=1.0.0
# Dependências do cliente
mcp>=0.1.0
colorama>=0.4.6
# Ferramentas de desenvolvimento (opcional)
mcp-inspector>=0.1.02.2 Instalar tudo de uma vez¶
cd Servidores
pip install -r requirements.txtPasso 3: Configurar API Key¶
3.1 Obter sua chave API do Google Gemini¶
Faça login com sua conta Google
Clique em “Create API Key”
Copie a chave gerada
3.2 Criar arquivo .env¶
Na pasta Servidores, crie o arquivo .env:
# Chave da API do Google Gemini (OBRIGATÓRIO)
GOOGLE_API_KEY=sua_chave_api_aqui
# Configurações opcionais
MCP_SERVER_NAME=papers-academic-server
MCP_LOG_LEVEL=INFOPasso 4: Adicionar os Códigos¶
4.1 Criar o servidor (mcp_papers_server.py)¶
Cole o código do servidor fornecido anteriormente.
4.2 Criar o cliente (mcp_papers_client.py)¶
Cole o código do cliente fornecido anteriormente.
Como Usar¶
Método 1: Modo Simples (Recomendado para Iniciantes)¶
Basta executar o cliente, que iniciará tudo automaticamente:
# Na pasta Servidores, com ambiente ativado
python mcp_papers_client.pyMétodo 2: Modo Avançado (Debug)¶
Execute servidor e cliente separadamente para ver logs detalhados:
Terminal 1 - Servidor:
cd CHATBOT-PAPERS/Servidores
.venv\Scripts\activate # Windows
source .venv/bin/activate # Linux/Mac
python mcp_papers_server.pyTerminal 2 - Cliente:
cd CHATBOT-PAPERS/Servidores
.venv\Scripts\activate # Windows
source .venv/bin/activate # Linux/Mac
python mcp_papers_client.pyGuia de Uso Interativo¶
Menu Principal¶
Quando você executar o cliente, verá:
📚 Cliente MCP de Papers Acadêmicos
=================================
🔌 Conectando ao servidor MCP...
✅ Conectado com sucesso!
📦 6 ferramentas disponíveis
📋 Menu de Opções
========================================
1 - Buscar papers
2 - Ver detalhes de um paper
3 - Analisar papers (resumo)
4 - Analisar papers (tendências)
5 - Analisar papers (comparação)
6 - Chat sobre papers
7 - Informações do cache
8 - Limpar cache
9 - Ajuda
0 - Sair
========================================
Escolha uma opção:Exemplo de Uso Completo¶
Buscar Papers sobre Inteligência Artificial¶
Escolha uma opção: 1
Digite os termos de busca: artificial intelligence ethics
Número de resultados (1-10, padrão 5): 5
🔍 Buscando papers...
✅ Encontrados 5 papers!
📄 Paper 1:
Título: Ethics in AI: A Comprehensive Review
Autores: John Smith, Jane Doe
Data: 2024-09-15
ArXiv ID: 2409.12345Ver Detalhes de um Paper¶
Escolha uma opção: 2
Digite o número do paper (1-5): 1
📄 Detalhes do Paper
========================================
Título: Ethics in AI: A Comprehensive Review
Autores: John Smith, Jane Doe
Data de Publicação: 2024-09-15
ArXiv ID: 2409.12345
Link: https://arxiv.org/abs/2409.12345
📝 Resumo:
This paper reviews ethical considerations in artificial
intelligence systems, focusing on bias, transparency,
and accountability...Gerar Análise Inteligente¶
Escolha uma opção: 3
🤖 Gerando análise com IA...
📊 RESUMO EXECUTIVO
========================================
Com base nos 5 papers analisados sobre ética em IA:
🔑 Principais Descobertas:
- Viés algorítmico é o tema mais recorrente
- Necessidade de frameworks regulatórios
- Importância da transparência em sistemas críticos
📈 Tendências:
- Crescente preocupação com privacidade
- Desenvolvimento de IA explicável (XAI)
- Foco em IA centrada no ser humanoChat Interativo¶
Escolha uma opção: 6
Digite sua pergunta (ou 'voltar' para menu):
> Quais metodologias são mais usadas para detectar viés?
🤖 Resposta:
Baseado nos papers analisados, as principais metodologias
incluem:
1. Análise estatística de disparidade de impacto
2. Testes de fairness (equidade) em diferentes grupos
3. Auditoria algorítmica com datasets de teste
4. Métodos de interpretabilidade como SHAP e LIME
Os papers recomendam usar uma combinação de técnicas...
Digite sua pergunta (ou 'voltar' para menu):
> voltarFuncionalidades Detalhadas¶
1. Busca de Papers (search_papers)¶
O que faz: Busca artigos no ArXiv
Parâmetros:
query: Termos de busca (ex: “machine learning”, “quantum computing”)max_results: Quantidade de resultados (1-10)
2. Detalhes do Paper (get_paper_details)¶
O que faz: Mostra informações completas de um artigo
Informações exibidas:
Título completo
Lista de autores
Data de publicação
Resumo (abstract)
Link direto para o ArXiv
3. Análise com IA (analyze_papers)¶
O que faz: Usa Gemini para analisar os papers encontrados
Tipos de análise:
Summary: Resumo executivo geral
Trends: Identifica tendências e padrões
Comparison: Compara metodologias e resultados
4. Chat Inteligente (chat_about_papers)¶
O que faz: Conversa sobre os papers em linguagem natural
5. Gerenciamento de Cache¶
O que é cache? Memória temporária que acelera respostas repetidas.
Comandos:
get_cache_info: Ver quantos papers estão em cacheclear_cache: Limpar cache (útil para buscas novas)
Monitoramento e Logs¶
Visualizar Logs em Tempo Real¶
Windows:
# Em um novo terminal
cd CHATBOT-PAPERS\Servidores
type logs\mcp_server.logLinux/Mac:
# Visualização contínua
tail -f Servidores/logs/mcp_server.logEntender os Logs¶
Formato dos logs:
2025-09-30 14:32:15 - INFO - Searching for: machine learning
2025-09-30 14:32:17 - INFO - Found 5 papers
2025-09-30 14:32:20 - ERROR - API key invalidCasos de Uso Práticos¶
1. Revisão Bibliográfica Rápida¶
2. Identificar Tendências de Pesquisa¶
3. Comparar Abordagens¶
Segurança e Boas Práticas¶
Arquivo .gitignore recomendado¶
Para manter seu repositório limpo e evitar o versionamento de arquivos desnecessários, recomendamos utilizar um arquivo .gitignore adequado ao projeto.
# Ambiente virtual
.venv/
venv_mcp/
# Configurações sensíveis
.env
*.env
# Logs
logs/
*.log
# Python
__pycache__/
*.pyc
*.pyo
*.pyd
# IDE
.vscode/
.idea/
*.swpLicença¶
Este projeto está sob a licença MIT. Veja o arquivo LICENSE para mais detalhes.
Observação: O que é uma licença MIT? A licença MIT é uma licença de software permissiva, curta e simples, que permite usar, copiar, modificar e distribuir o código-fonte livremente, até mesmo para fins comerciais, desde que o aviso de direitos autorais original e o texto da licença sejam incluídos em todas as cópias do software ou partes substanciais dele.
Recursos Úteis¶
Durante a implementação e aprofundamento no uso do MCP, é importante ter à mão algumas ferramentas e documentações de apoio. Abaixo estão links úteis das tecnologias usadas para acelerar o desenvolvimento e facilitar a integração com APIs e modelos de IA, desta aplicação:
Documentação FastMCP: https://
github .com /jlowin /fastmcp ArXiv API: https://
arxiv .org /help /api Google Gemini: https://
ai .google .dev/
- Canal YouTube. (2024). Workshop sobre Model Context Protocol. https://www.youtube.com/watch?v=kQmXtrmQ5Zg
- Sakal, N. (2024). MCP vs API: Model Context Protocol Explained. https://norahsakal.com/blog/mcp-vs-api-model-context-protocol-explained/
- Anthropic. (2024). Model Context Protocol - Documentação Oficial. Anthropic. https://modelcontextprotocol.io/introduction
- DeepLearning.AI. (2024). Build Rich Context AI Apps with Anthropic. DeepLearning.AI. https://www.deeplearning.ai/short-courses/mcp-build-rich-context-ai-apps-with-anthropic/
- Microsoft. (2024). MCP for Beginners - Tutorial Completo. Microsoft Corporation. https://github.com/microsoft/mcp-for-beginners/blob/main/translations/br/00-Introduction/README.md
- Data Science Academy. (2024). Model Context Protocol (MCP) para Sistemas de IA Generativa: Conceito, Aplicações e Desafios. Data Science Academy. https://blog.dsacademy.com.br/model-context-protocol-mcp-para-sistemas-de-ia-generativa-conceito-aplicacoes-e-desafios/
- Neo4j. (2024). Model Context Protocol: A Developer’s Guide. Neo4j Inc. https://neo4j.com/blog/developer/model-context-protocol/