O Protocolo de Contexto do Modelo (MCP), apresentado pela Anthropic em 26 de novembro de 2024, é um padrão aberto destinado a preencher a lacuna entre modelos de IA e fontes de dados externas. Este protocolo aborda um desafio crítico: mesmo modelos de linguagem grande (LLMs) avançados, apesar de serem poderosos na geração de texto, muitas vezes estão isolados de dados e ferramentas em tempo real, limitando sua utilidade prática. Servidores MCP, como componentes integrais, permitem que assistentes de IA como Claude acessem arquivos, bancos de dados, APIs e muito mais, aprimorando sua capacidade de fornecer respostas relevantes e acionáveis.
A importância do MCP está em seu potencial de padronizar integrações, reduzindo a fragmentação que tem atormentado o desenvolvimento de IA. Ao fornecer um protocolo universal, ele visa ajudar modelos de fronteira a produzir respostas melhores e mais relevantes, quebrando silos de informação e barreiras de sistemas legados.
A partir de 25 de março de 2025, o ecossistema está crescendo rapidamente, com contribuições da comunidade e adoções empresariais, como adotantes iniciais como Block e Apollo integrando o MCP em seus sistemas.
Baixe Apidog gratuitamente hoje e descubra como ele pode transformar seu fluxo de trabalho!
O que são Servidores MCP?
Os servidores MCP, parte do Protocolo de Contexto do Modelo (MCP), são programas especiais que ajudam modelos de IA, como os da Anthropic, a se conectar e usar dados e ferramentas externas. Introduzidos em novembro de 2024, eles permitem que a IA faça mais do que apenas gerar texto, acessando coisas como arquivos no seu computador, bancos de dados ou até mesmo serviços como GitHub, tudo de maneira segura e padronizada.
Pense nos servidores MCP como pontes que permitem que a IA interaja com o mundo exterior, semelhante a como portas USB permitem que você conecte diferentes dispositivos ao seu computador. Por exemplo, se você pedir a uma IA para resumir um documento, ela pode puxar o arquivo diretamente do seu sistema. Ou, se você precisar criar uma questão no GitHub, a IA pode fazer isso também, graças a um servidor MCP. Eles podem fornecer dados (como arquivos), ferramentas (como chamadas de API) ou prompts (guias para interação), tornando a IA mais útil para tarefas como codificação, pesquisa ou gerenciamento de projetos.
Um detalhe inesperado é o quão rapidamente a comunidade cresceu, com mais de 250 servidores já disponíveis, incluindo tanto integrações oficiais quanto contribuições da comunidade, exibindo um ecossistema vibrante que está se expandindo rapidamente.
Como os Servidores MCP Funcionam (E Como Eles São Diferentes de APIs)
O MCP opera em um modelo cliente-servidor, conforme descrito na documentação. A arquitetura inclui:
- Hospedagens MCP: Aplicações como Claude Desktop, IDEs ou ferramentas de IA que buscam aproveitar dados externos.
- Clientes MCP: Clientes do protocolo que mantêm conexões seguras de um para um com os servidores, garantindo comunicação eficiente.
- Servidores MCP: Programas leves que expõem capacidades específicas por meio do Protocolo de Contexto do Modelo padronizado. Essa estrutura permite integração perfeita, com as hospedagens usando clientes para se conectar a vários servidores, cada um oferecendo funcionalidades exclusivas. O protocolo suporta três tipos principais de exposições:
- Recursos: Fontes de dados como arquivos, documentos ou consultas de banco de dados que a IA pode carregar em seu contexto. Por exemplo, um servidor de sistema de arquivos pode permitir o acesso a documentos locais.
- Ferramentas: Ações que a IA pode executar, como fazer chamadas de API ou executar comandos. Um exemplo é um servidor GitHub que permite o gerenciamento de repositórios, detalhado no mesmo repositório.
- Prompts: Modelos reutilizáveis para interações de LLM, guiando o comportamento da IA em cenários específicos.
O protocolo é baseado em JSON-RPC 2.0, garantindo conexões com estado e negociação de capacidades entre clientes e servidores. Essa fundação técnica permite comunicação robusta e segura, com recursos como rastreamento de progresso, cancelamento e relatórios de erros aprimorando a confiabilidade.
Então, O que os MCPs realmente podem fazer?
Os servidores MCP são projetados para serem versáteis, atendendo a uma ampla gama de necessidades. Eles podem ser executados localmente ou remotamente, dependendo da implementação, e são construídos com princípios de segurança em primeiro lugar. Cada servidor controla seus próprios recursos, mantendo limites de sistema claros para prevenir acesso não autorizado.
Essa segurança é crucial, especialmente ao lidar com dados sensíveis, garantindo que as conexões sejam seguras e que as permissões sejam rigorosamente controladas.
Tecnicamente, os servidores expõem suas capacidades por meio de endpoints JSON-RPC, permitindo que os clientes consultem recursos, ferramentas e prompts disponíveis.
Por exemplo, um servidor pode expor um recurso "readFile" que retorna o conteúdo de um arquivo especificado ou uma ferramenta "createIssue" que interage com a API do GitHub. O protocolo também suporta comportamentos iniciados pelo servidor, como amostragem, permitindo interações de IA agentiva, que podem ser recursivas e dinâmicas, conforme descrito na especificação.
Interessado em Servidores MCP? Você pode experimentar estes agora
O ecossistema de servidores MCP é rico e crescente, com numerosos exemplos ilustrando sua utilidade, conforme listado no repositório em GitHub - awesome-mcp-servers:
- Servidor MCP de Sistema de Arquivos: Permite que a IA leia e escreva arquivos, útil para acessar notas pessoais ou scripts, como visto na implementação de referência em GitHub - filesystem.
- Servidor MCP do GitHub: Facilita interações como criar questões ou comprometer código, aprimorando os fluxos de trabalho dos desenvolvedores, detalhados em GitHub - github.
- Servidor MCP de Web Scraping: Permite que a IA pesquise e extraia conteúdo da web, fornecendo dados em tempo real, como mencionado em servidores comunitários como tavily-ai/tavily-mcp.
- Servidores MCP de Banco de Dados: Oferecem acesso a bancos de dados SQL ou NoSQL, como PostgreSQL ou MongoDB, permitindo consultas de dados, como visto em GitHub - postgres.
- Servidores MCP de Integração API: Conectam-se a serviços como Slack, Trello ou APIs de clima, expandindo a base de conhecimento da IA, com exemplos como GitHub - slack. Esses servidores demonstram a flexibilidade do protocolo, com contribuições da comunidade como servidores de gerenciamento Kubernetes acrescentando ao ecossistema, conforme listado em servidores de terceiros em GitHub - servers.
Qual é a Diferença Entre Servidores MCP e APIs?
Embora tanto os servidores MCP quanto as APIs tradicionais permitam que o software interaja com serviços externos, seus propósitos diferem no contexto da IA:
- Propósito: APIs tradicionais são interfaces de propósito geral para comunicação de software, frequentemente usadas para enviar consultas a modelos de IA ou acessar serviços externos. Servidores MCP são projetados especificamente para fornecer contexto a modelos de IA, com foco em dados, ferramentas e prompts em um formato padronizado.
- Interação: Com uma API tradicional, o modelo de IA precisa saber como chamar a API, analisar sua resposta e integrar essa informação em seu contexto. Com um servidor MCP, o servidor gerencia a interação com a fonte de dados ou ferramenta e apresenta a informação de uma maneira que o modelo de IA possa entender e usar facilmente, sem precisar conhecer os detalhes da fonte de dados subjacente.
- Padronização: O MCP fornece um protocolo padronizado, tornando-o plug-and-play para vários servidores, enquanto APIs tradicionais podem exigir integração personalizada para cada serviço.
- Segurança: Servidores MCP são otimizados para segurança, com autenticação e controles de acesso integrados, enquanto APIs tradicionais podem exigir medidas adicionais de segurança, dependendo da implementação.
Por exemplo, em uma configuração tradicional, a IA pode precisar chamar uma API REST para obter dados climáticos, analisando respostas JSON e integrando-as em seu contexto. Com um servidor MCP, o servidor poderia expor uma ferramenta "get_weather", e a IA simplesmente a chamaria com parâmetros, recebendo dados formatados prontos para uso.
Como Configurar Servidores MCP (com Claude como Exemplo)
O Protocolo de Contexto do Modelo (MCP) é uma estrutura poderosa que habilita
Os servidores MCP podem fornecer três tipos principais de capacidades:
- Recursos: Dados semelhantes a arquivos que podem ser lidos pelos clientes (como respostas de API ou conteúdos de arquivos)
- Ferramentas: Funções que podem ser chamadas pelo LLM (com aprovação do usuário)
- Prompts: Modelos pré-escritos que ajudam os usuários a realizar tarefas específicas
Configurando Seu Ambiente
Antes de começar, certifique-se de ter:
- Python 3.10 ou superior instalado
- Node.js (se estiver usando implementações em JavaScript/TypeScript)
- Familiaridade básica com programação em Python ou JavaScript
- Compreensão de LLMs como Claude
Instalando o Gerenciador de Pacotes UV
UV é o gerenciador de pacotes recomendado para projetos de MCP em Python:
# MacOS/Linux
curl -LsSf <https://astral.sh/uv/install.sh> | sh
# Certifique-se de reiniciar seu terminal depois
Construindo um Servidor MCP
Vamos construir um servidor de clima simples como exemplo.
Este servidor fornecerá duas ferramentas: get-alerts e get-forecast.
Passo 1: Configurar a Estrutura do Projeto
# Crie um novo diretório para nosso projeto
uv init weather
cd weather
# Crie um ambiente virtual e ative-o
uv venv
source .venv/bin/activate # No Windows: .venv\\\\Scripts\\\\activate
# Instale as dependências
uv add "mcp[cli]" httpx
# Crie nosso arquivo servidor
touch weather.py
Passo 2: Implementar o Servidor
Aqui está uma implementação completa do nosso servidor de clima (em weather.py):
from typing import Any
import httpx
from mcpserver.fastmcp import FastMCP
# Inicializa o servidor FastMCP
mcp = FastMCP("weather")
# Constantes
NWS_API_BASE = "<https://api.weather.gov>"
USER_AGENT = "weather-app/1.0"
async def make_nws_request(url: str) -> dict[str, Any] | None:
"""Faz uma solicitação para a API do NWS com tratamento de erro adequado."""
headers = {
"User-Agent": USER_AGENT,
"Accept": "application/geo+json"
}
async with httpx.AsyncClient() as client:
try:
response = await client.get(url, headers=headers, timeout=30.0)
response.raise_for_status()
return response.json()
except Exception:
return None
def format_alert(feature: dict) -> str:
"""Formata um recurso de alerta em uma string legível."""
props = feature["properties"]
return f"""
Evento: {props.get('event', 'Desconhecido')}
Área: {props.get('areaDesc', 'Desconhecida')}
Gravidade: {props.get('severity', 'Desconhecida')}
Descrição: {props.get('description', 'Nenhuma descrição disponível')}
Instruções: {props.get('instruction', 'Nenhuma instrução específica fornecida')}
"""
@mcp.tool()
async def get_alerts(state: str) -> str:
"""Obtém alertas climáticos para um estado dos EUA.
Args:
state: Código do estado dos EUA de duas letras (ex.: CA, NY)
"""
url = f"{NWS_API_BASE}/alerts/active/area/{state}"
data = await make_nws_request(url)
if not data or "features" not in data:
return "Não foi possível buscar alertas ou nenhum alerta encontrado."
if not data["features"]:
return "Nenhum alerta ativo para este estado."
alerts = [format_alert(feature) for feature in data["features"]]
return "\\\\n---\\\\n".join(alerts)
@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:
"""Obtém previsão do tempo para uma localização.
Args:
latitude: Latitude da localização
longitude: Longitude da localização
"""
# Primeiro obtenha o endpoint da grade de previsão
points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
points_data = await make_nws_request(points_url)
if not points_data:
return "Não foi possível buscar dados de previsão para esta localização."
# Obtenha a URL da previsão a partir da resposta dos pontos
forecast_url = points_data["properties"]["forecast"]
forecast_data = await make_nws_request(forecast_url)
if not forecast_data:
return "Não foi possível buscar previsão detalhada."
# Formate os períodos em uma previsão legível
periods = forecast_data["properties"]["periods"]
forecasts = []
for period in periods[:5]: # Mostra apenas os próximos 5 períodos
forecast = f"""
{period['name']}: Temperatura: {period['temperature']}°{period['temperatureUnit']}
Vento: {period['windSpeed']} {period['windDirection']}
Previsão: {period['detailedForecast']}
"""
forecasts.append(forecast)
return "\\\\n---\\\\n".join(forecasts)
if __name__ == "__main__":
# Inicializa e executa o servidor
mcp.run(transport='stdio')
Passo 3: Execute Seu Servidor
Para testar seu servidor diretamente, execute:
uv run weather.py
Conectando ao Claude para Desktop
Claude para Desktop é uma maneira simples de interagir com seus servidores MCP.
Passo 1: Instale o Claude para Desktop
Certifique-se de ter Claude para Desktop instalado e atualizado para a versão mais recente.
Passo 2: Configure o Claude para Desktop
- Abra a configuração do seu App Claude para Desktop em um editor de texto:
# macOS
code ~/Library/Application\\\\ Support/Claude/claude_desktop_config.json
2. Adicione sua configuração de servidor:
{
"mcpServers": {
"weather": {
"command": "uv",
"args": [
"--directory",
"/CAMINHO/ABSOLUTO/DA/Pasta/PARENTE/weather",
"run",
"weather.py"
]
}
}
}
Certifique-se de:
- Usar o caminho absoluto para o diretório do seu servidor
- Garantir que o comando corresponda ao seu ambiente (por exemplo,
uvou o caminho completo parauv)
Passo 3: Reinicie o Claude para Desktop
Após salvar a configuração, reinicie completamente o Claude para Desktop.
Passo 4: Teste Seu Servidor
Procure o ícone de martelo no canto inferior direito da caixa de entrada do Claude para Desktop. Clicar nele deve mostrar as ferramentas do seu servidor.
Agora você pode fazer perguntas ao Claude como:
- "Qual é o tempo em Sacramento?"
- "Quais são os alertas climáticos ativos no Texas?"
Construindo um Cliente MCP Personalizado para Servidores MCP Claude
Em vez de usar Claude para Desktop, você pode construir seu próprio cliente personalizado.
Passo 1: Configure o Projeto do Cliente
# Crie o diretório do projeto
uv init mcp-client
cd mcp-client
# Crie um ambiente virtual
uv venv
source .venv/bin/activate # No Windows: .venv\\\\Scripts\\\\activate
# Instale os pacotes necessários
uv add mcp anthropic python-dotenv
# Crie nosso arquivo principal
touch client.py
Passo 2: Configure Sua Chave de API
Crie um arquivo .env com sua chave de API da Anthropic:
ANTHROPIC_API_KEY=<sua chave aqui>
Passo 3: Implemente o Cliente
Aqui está uma implementação básica do cliente (em client.py):
import asyncio
import sys
from typing import Optional
from contextlib import AsyncExitStack
from mcp.client.stdio import ClientSession, StdioServerParameters, stdio_client
from anthropic import Anthropic
from dotenv import load_dotenv
load_dotenv() # carrega variáveis de ambiente do .env
class MCPClient:
def __init__(self):
# Inicializa objetos de sessão e cliente
self.session: Optional[ClientSession] = None
self.exit_stack = AsyncExitStack()
self.anthropic = Anthropic()
async def connect_to_server(self, server_script_path: str):
"""Conecta-se a um servidor MCP
Args:
server_script_path: Caminho para o script do servidor (py ou js)
"""
is_python = server_script_path.endswith('.py')
is_js = server_script_path.endswith('.js')
if not (is_python or is_js):
raise ValueError("O script do servidor deve ser um arquivo .py ou .js")
command = "python" if is_python else "node"
server_params = StdioServerParameters(command=command, args=[server_script_path], env=None)
stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
self.stdio, self.write = stdio_transport
self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
await self.session.initialize()
# Lista as ferramentas disponíveis
response = await self.session.list_tools()
tools = response.tools
print("\\\\nConectado ao servidor com ferramentas:", [tool.name for tool in tools])
async def process_query(self, query: str) -> str:
"""Processa uma consulta usando Claude e ferramentas disponíveis"""
messages = [
{
"role": "user",
"content": query
}
]
response = await self.session.list_tools()
available_tools = [{
"name": tool.name,
"description": tool.description,
"input_schema": tool.input_schema
} for tool in response.tools]
# Chamada inicial da API do Claude
response = self.anthropic.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1000,
messages=messages,
tools=available_tools
)
# Processa a resposta e gerencia chamadas de ferramentas
final_text = []
assistant_message_content = []
for content in response.content:
if content.type == 'text':
final_text.append(content.text)
assistant_message_content.append(content)
elif content.type == 'tool_use':
tool_name = content.name
tool_args = content.input
# Executa a chamada da ferramenta
result = await self.session.call_tool(tool_name, tool_args)
final_text.append(f"[Chamando ferramenta {tool_name} com args {tool_args}]")
assistant_message_content.append(content)
messages.append({
"role": "assistant",
"content": assistant_message_content
})
messages.append({
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": content.id,
"content": result
}
]
})
# Obtém a próxima resposta do Claude
response = self.anthropic.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1000,
messages=messages,
tools=available_tools
)
final_text.append(response.content[0].text)
return "\\\\n".join(final_text)
async def chat_loop(self):
"""Executa um loop de chat interativo"""
print("\\\\nCliente MCP Iniciado!")
print("Digite suas consultas ou 'sair' para sair.")
while True:
try:
query = input("\\\\nConsulta: ").strip()
if query.lower() == 'sair':
break
response = await self.process_query(query)
print("\\\\n" + response)
except Exception as e:
print(f"\\\\nErro: {str(e)}")
async def cleanup(self):
"""Limpa recursos"""
await self.exit_stack.aclose()
async def main():
if len(sys.argv) < 2:
print("Uso: python client.py <caminho_para_o_script_do_servidor>")
sys.exit(1)
client = MCPClient()
try:
await client.connect_to_server(sys.argv[1])
await client.chat_loop()
finally:
await client.cleanup()
if __name__ == "__main__":
asyncio.run(main())
Passo 4: Execute o Cliente
Para usar seu cliente com seu servidor de clima:
uv run client.py /caminho/para/weather.py
Usando Servidores MCP Pré-construídos com Claude para Desktop
Claude para Desktop suporta uma variedade de servidores MCP pré-construídos. Vamos ver como usar um servidor de sistema de arquivos como exemplo.
Passo 1: Configure o Servidor de Sistema de Arquivos
- Abra as configurações do Claude para Desktop e clique em "Editar Config"
- Atualize seu arquivo de configuração com:
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/usuario/Desktop",
"/Users/usuario/Downloads"
]
}
}
}
Substitua usuario pelo seu nome de usuário real e ajuste os caminhos conforme necessário.
Passo 2: Reinicie e Teste
Após reiniciar o Claude para Desktop, você pode usar as ferramentas do sistema de arquivos para:
- Ler arquivos
- Escrever arquivos
- Pesquisar arquivos
- Mover arquivos
Exemplos de prompts:
- "Você pode escrever um poema e salvá-lo na minha área de trabalho?"
- "Quais são alguns arquivos relacionados ao trabalho na minha pasta de downloads?"
- "Você pode pegar todas as imagens na minha área de trabalho e movê-las para uma nova pasta chamada 'Imagens'?"
Conclusão
Os servidores MCP representam um avanço significativo na funcionalidade da IA, preenchendo a lacuna entre poderosos modelos de linguagem e ferramentas externas. Seguindo este guia, você aprendeu como criar, configurar e usar servidores MCP para aprimorar as capacidades do Claude.
A abordagem padronizada do Protocolo de Contexto do Modelo garante que os modelos de IA possam acessar dados em tempo real, realizar ações e interagir com sistemas de maneira segura e controlada. Isso torna assistentes de IA mais práticos para aplicações do mundo real, abrangendo desenvolvimento, análise de dados, criação de conteúdo e mais.
À medida que o ecossistema MCP continua a crescer, os desenvolvedores estão criando servidores cada vez mais sofisticados que expandem o que é possível com a IA. Seja você um usuário de servidores pré-construídos ou um desenvolvedor de soluções personalizadas, o MCP fornece uma base flexível para construir aplicações de IA mais capazes.
Enquanto você continua trabalhando com servidores MCP que frequentemente envolvem integrações de API, você pode querer explorar o Apidog, uma plataforma abrangente de desenvolvimento de API que pode complementar seu fluxo de trabalho de implementação do MCP.
O Apidog oferece uma solução tudo-em-um para design de APIs, documentação, depuração e testes automatizados. Sua interface intuitiva torna fácil:
- Projetar APIs com uma interface visual ou importar especificações existentes
- Gerar automaticamente documentação que permanece sincronizada com seu código
- Testar endpoints de API com poderosos construtores de requisição
- Criar cenários de teste automatizados para suas APIs
- Colaborar com membros da equipe por meio de espaços de trabalho compartilhados
Ao desenvolver servidores MCP que interagem com APIs externas, o Apidog pode ajudar você a validar endpoints, entender estruturas de resposta e garantir que suas integrações funcionem corretamente antes de implementá-las em seu código de servidor.
Para começar com o Apidog ao lado do seu desenvolvimento MCP, visite o site do Apidog e explore como ele pode aprimorar seu fluxo de trabalho de desenvolvimento de API.
Ao combinar servidores MCP com ferramentas de desenvolvimento de API eficientes como o Apidog, você pode criar conexões mais robustas e confiáveis entre sistemas de IA e serviços externos, tornando suas aplicações de IA ainda mais poderosas.