Blog

O que são servidores MCP? Explicação clara

@apidog

@apidog

26 março 2025

O que são servidores MCP? Explicação clara

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.

💡
Precisa encontrar a melhor ferramenta alternativa ao Postman que integre todo o seu fluxo de trabalho de Testes de API em um só lugar?
Baixe Apidog gratuitamente hoje e descubra como ele pode transformar seu fluxo de trabalho!
button

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.

Fonte: Blog de Norah Sakal

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:

Fonte: Tahir

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:

💡
Quer explorar mais de 1000 servidores MCP?

Descubra mais em Himcp.ai!
button

Qual é a Diferença Entre Servidores MCP e APIs?

Fonte: Blog de Norah Sakal

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:

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:

Configurando Seu Ambiente

Antes de começar, certifique-se de ter:

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

  1. 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:

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:

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

  1. Abra as configurações do Claude para Desktop e clique em "Editar Config"
  2. 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:

Exemplos de prompts:

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:

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.

button


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.


Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs

Cadastre-se gratuitamenteBaixar