---
title: "MCP Servers: Guia Completo do Model Context Protocol"
url: "https://openclaw.ia.br/blog/mcp-servers-guia-completo-model-context-protocol/"
markdown_url: "https://openclaw.ia.br/blog/mcp-servers-guia-completo-model-context-protocol.MD"
description: "Entenda o que são MCP Servers, como funcionam e como usar para conectar LLMs a ferramentas externas. Lista completa de servidores disponíveis e configuração passo a passo."
date: "2026-01-31"
author: "OpenClaw Brasil"
---

# MCP Servers: Guia Completo do Model Context Protocol

Entenda o que são MCP Servers, como funcionam e como usar para conectar LLMs a ferramentas externas. Lista completa de servidores disponíveis e configuração passo a passo.


O Model Context Protocol (MCP) é um padrão aberto que revoluciona como LLMs acessam ferramentas e dados externos. Criado pela Anthropic e adotado pela indústria, o MCP permite que assistentes de IA se conectem a praticamente qualquer sistema.

## O Que é MCP?

MCP é um protocolo de comunicação padronizado entre:
- **Hosts:** Aplicações que executam LLMs (Claude Desktop, OpenClaw, Cursor)
- **Clients:** Conectores dentro do host que gerenciam comunicação
- **Servers:** Serviços que expõem ferramentas e dados

Fluxo simplificado:
```
Usuário → Host (Claude) → Client → MCP Server → Recurso Externo
                    ↓
              Resposta formatada
```

## Por Que MCP Importa?

Antes do MCP, cada integração exigia código custom. Agora:

| Antes | Depois (MCP) |
|-------|--------------|
| Integração por integração | Protocolo universal |
| Código específico por LLM | Funciona com qualquer host |
| Segurança variável | Padrão de permissões |
| Difícil manutenção | Ecossistema compartilhado |

## Servidores MCP Oficiais

### Referência (Mantidos pela Anthropic)

**Filesystem** - Operações de arquivo seguras
```bash
npx -y @modelcontextprotocol/server-filesystem /caminho/permitido
```
Recursos:
- Leitura/escrita de arquivos
- Listagem de diretórios
- Busca por padrões
- Controle de acesso granular

**Git** - Manipulação de repositórios
```bash
uvx mcp-server-git
```
Recursos:
- Clone, pull, push
- Histórico de commits
- Diff entre versões
- Busca em código

**Memory** - Sistema de memória persistente
```bash
npx -y @modelcontextprotocol/server-memory
```
Recursos:
- Grafo de conhecimento
- Relacionamentos entre entidades
- Busca semântica
- Persistência entre sessões

**Fetch** - Busca de conteúdo web
```bash
npx -y @modelcontextprotocol/server-fetch
```
Recursos:
- Busca de URLs
- Conversão para markdown
- Extração de texto
- Cache inteligente

**Time** - Conversão de fusos horários
```bash
npx -y @modelcontextprotocol/server-time
```
Recursos:
- Hora atual em qualquer fuso
- Conversão entre timezones
- Cálculos de data/hora

**Sequential Thinking** - Raciocínio estruturado
```bash
npx -y @modelcontextprotocol/server-sequentialthinking
```
Recursos:
- Decomposição de problemas
- Reflexão sobre soluções
- Pensamento em etapas

### Integrações Oficiais (Por Empresas)

| Servidor | Empresa | Uso |
|----------|---------|-----|
| GitHub | GitHub/Microsoft | Repos, issues, PRs |
| Notion | Notion | Páginas, databases |
| Slack | Slack | Mensagens, canais |
| Google Drive | Google | Documentos, planilhas |
| PostgreSQL | Community | Banco de dados |
| Puppeteer | Community | Automação web |
| Astra DB | DataStax | NoSQL distribuído |
| Home Assistant | HA Team | Automação residencial |

### Servidores da Comunidade

Centenas de servidores criados pela comunidade:
- **Browser Tools** - Controle de navegador
- **YouTube** - Transcrições e metadados
- **Spotify** - Controle de música
- **Twitter/X** - Posts e timeline
- **AWS** - Serviços cloud
- **Kubernetes** - Gestão de clusters

Lista completa: [github.com/modelcontextprotocol/servers](https://github.com/modelcontextprotocol/servers)

## Configuração Passo a Passo

### Para Claude Desktop

1. Abra o arquivo de configuração:
   - **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
   - **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
   - **Linux:** `~/.config/claude/claude_desktop_config.json`

2. Adicione servidores:
```json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/home/usuario/documentos"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx"
      }
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}
```

3. Reinicie Claude Desktop

4. Verifique os ícones de ferramentas na interface

### Para OpenClaw

O OpenClaw suporta MCP nativamente:

```yaml
# config.yaml
mcp:
  servers:
    - name: filesystem
      command: npx
      args: ["-y", "@modelcontextprotocol/server-filesystem", "/home/user"]
    - name: memory
      command: npx
      args: ["-y", "@modelcontextprotocol/server-memory"]
```

### Para Cursor

1. Vá em **Settings > MCP**
2. Adicione servidor:
```json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    }
  }
}
```

## Criando Seu Próprio MCP Server

### Python (Recomendado)

```python
# server.py
from mcp.server import Server
from mcp.types import Tool, TextContent

server = Server("meu-servidor")

@server.tool()
async def saudacao(nome: str) -> str:
    """Retorna uma saudação personalizada"""
    return f"Olá, {nome}! Bem-vindo ao MCP."

@server.tool()
async def calcular(expressao: str) -> str:
    """Calcula uma expressão matemática"""
    try:
        resultado = eval(expressao)  # Cuidado em produção!
        return f"Resultado: {resultado}"
    except Exception as e:
        return f"Erro: {str(e)}"

if __name__ == "__main__":
    import asyncio
    asyncio.run(server.run())
```

Instalação:
```bash
pip install mcp
python server.py
```

### TypeScript

```typescript
// server.ts
import { Server } from "@modelcontextprotocol/sdk/server";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio";

const server = new Server({
  name: "meu-servidor",
  version: "1.0.0"
});

server.setRequestHandler("tools/call", async (request) => {
  const { name, arguments: args } = request.params;
  
  if (name === "saudacao") {
    return {
      content: [{
        type: "text",
        text: `Olá, ${args.nome}!`
      }]
    };
  }
});

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

## Segurança

### Boas Práticas

1. **Princípio do menor privilégio**
   - Exponha apenas o necessário
   - Use caminhos específicos, não raiz

2. **Tokens com escopo limitado**
   ```json
   "env": {
     "GITHUB_TOKEN": "ghp_readonly_xxx"
   }
   ```

3. **Validação de entrada**
   - Nunca execute comandos sem sanitização
   - Limite recursos acessíveis

4. **Logs e monitoramento**
   - Registre todas as chamadas
   - Alertas para padrões suspeitos

### O Que Evitar

- Expor credenciais em configs compartilhadas
- Dar acesso a diretórios sensíveis (`/`, `~/.ssh`)
- Executar comandos shell arbitrários
- Conectar a bancos de produção sem read-only

## Casos de Uso

### Desenvolvimento

```json
{
  "mcpServers": {
    "git": {"command": "uvx", "args": ["mcp-server-git"]},
    "filesystem": {"command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "./projeto"]}
  }
}
```

Perguntas que você pode fazer:
- "Quais commits foram feitos hoje?"
- "Mostre os arquivos modificados no último PR"
- "Crie um arquivo de teste para esta função"

### Pesquisa

```json
{
  "mcpServers": {
    "fetch": {"command": "npx", "args": ["-y", "@modelcontextprotocol/server-fetch"]},
    "memory": {"command": "npx", "args": ["-y", "@modelcontextprotocol/server-memory"]}
  }
}
```

Fluxo:
1. Buscar informações de URLs
2. Armazenar na memória
3. Relacionar conceitos
4. Recuperar em sessões futuras

### Casa Inteligente

```json
{
  "mcpServers": {
    "homeassistant": {
      "command": "mcp-proxy",
      "args": ["--transport=streamablehttp", "http://localhost:8123/api/mcp"],
      "env": {"API_ACCESS_TOKEN": "xxx"}
    }
  }
}
```

## OpenClaw e MCP

O OpenClaw integra naturalmente com o ecossistema MCP:

**Como Host MCP:**
- Execute servidores MCP como ferramentas
- Gerencie permissões centralizadamente
- Combine múltiplos servidores

**Como Server MCP:**
- Exponha funcionalidades do OpenClaw para outros clientes
- Permita controle remoto via Claude Desktop
- Integre com pipelines de desenvolvimento

## Próximos Passos

1. **Explore:** Veja a lista completa de servidores no [GitHub](https://github.com/modelcontextprotocol/servers)
2. **Teste:** Configure filesystem + memory no Claude Desktop
3. **Crie:** Desenvolva um servidor para sua necessidade específica
4. **Contribua:** Compartilhe seus servidores com a comunidade

## Recursos

- [Especificação MCP](https://spec.modelcontextprotocol.io/)
- [Documentação oficial](https://modelcontextprotocol.io/)
- [SDK Python](https://github.com/modelcontextprotocol/python-sdk)
- [SDK TypeScript](https://github.com/modelcontextprotocol/typescript-sdk)
- [Discussões da comunidade](https://github.com/orgs/modelcontextprotocol/discussions)

---

*O OpenClaw suporta MCP nativamente. [Instale agora](/instalacao/) e conecte seu assistente a qualquer ferramenta.*