Redlib MCP Server

Servidor MCP Redlib

Um servidor Model Context Protocol (MCP) que permite que agentes de IA interajam com o Reddit através da sua instância Redlib privada. Sem necessidade de chaves de API do Reddit - apenas uma instância Redlib em execução!

https://github.com/user-attachments/assets/66eec084-e911-4eed-a51f-be303e86f1a7

Sumário

• Recursos
• Implementação Atual
• Pré-requisitos
• Início Rápido
• Configuração
• Ferramentas Disponíveis
• Integração com Clientes de IA
  • Claude Desktop
  • Cursor
  • VS Code / GitHub Copilot
  • OpenAI Codex
  • ForgeCode
  • KiloCode
• Docker Compose
• Segurança: Padrão vs Reforçado
• Desenvolvimento
• Exemplo de Uso com IA
• Contribuição
• Licença
• Agradecimentos
• Links

Recursos

• Privacidade em Primeiro Lugar - Usa seu Redlib auto-hospedado, sem rastreamento ou chaves de API
• 3 Ferramentas Poderosas - Pesquise posts, obtenha posts populares, busque detalhes completos de posts com comentários
• Pronto para Docker - Imagens Docker simples e reforçadas disponíveis
• Configuração Fácil - Funciona com Claude Desktop, Cursor, VS Code, Codex, ForgeCode, KiloCode e qualquer cliente compatível com MCP
• Saída Estruturada - Retorna JSON limpo em vez de HTML bruto

Implementação Atual: Transporte Stdio

Importante: Este servidor atualmente usa transporte stdio (comunicação stdin/stdout) para desenvolvimento local. Ele roda como um processo filho e se comunica através de entrada/saída padrão.

O Que Isso Significa:

• Sem endpoint HTTP - O servidor não expõe nenhuma porta HTTP
• Somente local - Projetado para cenários de desenvolvimento e teste local
• Processo filho - Clientes MCP iniciam este servidor como um subprocesso
• Sem acesso à rede - Toda a comunicação acontece localmente via stdin/stdout

Planos Futuros:

A funcionalidade de transporte HTTP está planejada para versões futuras para permitir:

• Acesso remoto via HTTP
• Múltiplas conexões simultâneas de clientes
• Cenários de implantação em produção
• Verificações de saúde baseadas em rede

Pré-requisitos

Antes de usar este servidor MCP, você precisa de:

1. Instância Redlib - Uma instância Redlib em execução (padrão: http://localhost:8080)

   • Redlib GitHub
   • Configuração Docker do Redlib

2. Cliente MCP - Um dos seguintes:

   • Claude Desktop
   • Cursor
   • VS Code com GitHub Copilot
   • OpenAI Codex
   • ForgeCode
   • KiloCode

Início Rápido

Opção 1: Docker (Recomendado)

# Pull and run the default version
docker run -i --rm \
  --network host \
  -e REDLIB_URL=http://localhost:8080 \
  alfafadock/mcp-redlib:latest

Opção 2: Docker Reforçado (Foco em Segurança)

# Uses non-root user and minimal privileges
docker run -i --rm \
  --network host \
  --cap-drop=ALL \
  --security-opt no-new-privileges:true \
  -e REDLIB_URL=http://localhost:8080 \
  alfafadock/mcp-redlib:hardened

Opção 3: Desenvolvimento Local

# Clone and setup
git clone https://github.com/Devthatdoes/redlib-mcp-server.git
cd redlib-mcp-server

# Install dependencies
npm install

# Build
npm run build

# Run
npm start

Docker Compose

services:
  redlib-mcp:
    image: alfafadock/mcp-redlib:latest
    container_name: redlib-mcp
    network_mode: "host"  # Uses host network for MCP client communication
    environment:
      - REDLIB_URL=http://localhost:8080  # Change if Redlib is on a different port
    restart: unless-stopped
    # For hardened image, change image to: alfafadock/mcp-redlib:hardened

Configuração

Variáveis de Ambiente

Exemplo de Porta Redlib Personalizada

Se o seu Redlib roda em uma porta diferente (ex.: 8085):

docker run -i --rm \
  --network host \
  -e REDLIB_URL=http://localhost:8085 \
  alfafadock/mcp-redlib:latest

Exemplo de Arquivo .env

Copie .env.example para .env e modifique conforme necessário:

cp .env.example .env

Ferramentas Disponíveis

1. search_reddit

Pesquise posts do Reddit usando sua instância Redlib privada.

Parâmetros:

• query (obrigatório) - String de consulta de pesquisa
• subreddit (opcional) - Limite a pesquisa a um subreddit específico

Exemplo:

{
  "query": "rust programming",
  "subreddit": "rust"
}

Retorna: JSON com IDs de posts, títulos, autores, pontuações e contagens de comentários.

2. get_subreddit_hot

Obtenha posts populares de um subreddit específico.

Parâmetros:

• subreddit (obrigatório) - Nome do subreddit (sem r/)
• limit (opcional) - Número de posts (padrão: 25)

Exemplo:

{
  "subreddit": "rust",
  "limit": 10
}

3. get_post

Obtenha um post específico com seus comentários.

Parâmetros:

• subreddit (obrigatório) - Nome do subreddit
• postId (obrigatório) - ID do post do Reddit (dos resultados da pesquisa)

Exemplo:

{
  "subreddit": "rust",
  "postId": "abc123"
}

Retorna: Corpo completo do post, pontuação e até 10 comentários principais.

🔌 Integração com Clientes de IA

Claude Desktop

Edite ~/.config/claude/claude_desktop_config.json (Linux/macOS) ou %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "redlib": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "--network", "host",
        "-e", "REDLIB_URL=http://localhost:8080",
        "alfafadock/mcp-redlib:latest"
      ]
    }
  }
}

Para porta Redlib personalizada (ex.: 8085):

{
  "mcpServers": {
    "redlib": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "--network", "host",
        "-e", "REDLIB_URL=http://localhost:8085",
        "alfafadock/mcp-redlib:latest"
      ]
    }
  }
}

Após atualizar: Reinicie o Claude Desktop. Você deve ver um ícone de martelo (🔨) indicando que as ferramentas MCP estão disponíveis.

Referência: Documentação MCP do Claude Desktop

Cursor

Adicione a ~/.cursor/mcp.json (global) ou .cursor/mcp.json (nível de projeto):

{
  "mcpServers": {
    "redlib": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "--network", "host", "-e", "REDLIB_URL=http://localhost:8080", "alfafadock/mcp-redlib:latest"]
    }
  }
}

Configuração em nível de projeto: Crie .cursor/mcp.json na raiz do seu projeto.

Após atualizar: O Cursor detectará automaticamente as alterações. Use a Paleta de Comandos (Cmd/Ctrl+Shift+P) e pesquise por "MCP" para gerenciar servidores.

Referência: Documentação MCP do Cursor

VS Code / GitHub Copilot

Opção A: Configuração do Workspace

Crie .vscode/mcp.json no seu projeto:

{
  "servers": {
    "redlib": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "--network", "host", "-e", "REDLIB_URL=http://localhost:8080", "alfafadock/mcp-redlib:latest"]
    }
  }
}

Opção B: Configuração do Usuário (Global)

Use a Paleta de Comandos (Cmd/Ctrl+Shift+P) → "MCP: Open User Configuration":

{
  "mcp": {
    "servers": {
      "redlib": {
        "command": "docker",
        "args": ["run", "-i", "--rm", "--network", "host", "-e", "REDLIB_URL=http://localhost:8080", "alfafadock/mcp-redlib:latest"]
      }
    }
  }
}

Após atualizar: Recarregue o VS Code. As ferramentas aparecerão no Modo Agente do GitHub Copilot.

Referência: Documentação MCP do VS Code

OpenAI Codex

Edite ~/.codex/config.toml (global) ou .codex/config.toml (projeto):

[mcp_servers.redlib]
command = "docker"
args = ["run", "-i", "--rm", "--network", "host", "-e", "REDLIB_URL=http://localhost:8080", "alfafadock/mcp-redlib:latest"]

Configuração em nível de projeto: Crie .codex/config.toml na raiz do seu projeto.

Após atualizar: Reinicie o Codex. Use codex mcp list para verificar se o servidor está carregado.

Referência: Documentação MCP do Codex

ForgeCode

O ForgeCode suporta servidores MCP através do comando forge mcp para importação fácil.

Opção A: Importação Rápida (Recomendado)

Use a funcionalidade de importação MCP integrada:

# Import the Redlib MCP server
forge mcp import alfafadock/mcp-redlib:latest

# List imported servers
forge mcp list

# Reload to apply changes
forge mcp reload

Opção B: Configuração do Projeto

Crie .mcp.json na raiz do seu projeto:

{
  "mcpServers": {
    "redlib": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "--network", "host", "-e", "REDLIB_URL=http://localhost:8080", "alfafadock/mcp-redlib:latest"]
    }
  }
}

Opção C: Configuração Global

Edite o diretório de configuração do ForgeCode (verifique as configurações da extensão para o caminho exato).

Após atualizar: Recarregue a extensão ForgeCode usando forge mcp reload. As ferramentas MCP devem aparecer na interface do assistente de IA.

Referência: Documentação do ForgeCode

KiloCode

Opção A: Configuração Global

Edite ~/.config/kilo/kilo.jsonc ou use Configurações → MCP no KiloCode:

{
  "mcpServers": {
    "redlib": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "--network", "host", "-e", "REDLIB_URL=http://localhost:8080", "alfafadock/mcp-redlib:latest"]
    }
  }
}

Opção B: Configuração do Projeto

Crie .kilocode/mcp.json ou kilo.jsonc na raiz do seu projeto:

{
  "mcpServers": {
    "redlib": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "--network", "host", "-e", "REDLIB_URL=http://localhost:8080", "alfafadock/mcp-redlib:latest"]
    }
  }
}

Após atualizar: Abra Configurações do KiloCode → MCP → Adicionar Servidor, ou edite o arquivo de configuração diretamente.

Referência: Documentação MCP do KiloCode

Segurança: Padrão vs Reforçado

Usando a Imagem Reforçada

docker run -i --rm \
  --cap-drop=ALL \
  --security-opt no-new-privileges:true \
  --network host \
  -e REDLIB_URL=http://localhost:8080 \
  alfafadock/mcp-redlib:hardened

Desenvolvimento

Estrutura do Projeto

redlib-mcp-server/
├── src/
│   └── index.ts          # Main server code (stdio transport)
├── dist/                  # Compiled JavaScript (gitignored)
├── Dockerfile             # Default Docker image
├── Dockerfile.hardened    # Hardened Docker image
├── docker-compose.yml     # Production compose
├── package.json
├── tsconfig.json
└── README.md

Build a partir do Código Fonte

# Install dependencies
npm install

# Build TypeScript
npm run build

# Run locally
npm start

Build de Imagens Docker Personalizadas

# Default version
docker build -t redlib-mcp-server .

# Hardened version
docker build -f Dockerfile.hardened -t redlib-mcp-server:hardened .

Exemplo de Uso com IA

Uma vez conectado ao seu cliente de IA (ex.: Claude), você pode:

User: "Search Reddit for 'home lab setup' and summarize the top results"

AI uses search_reddit tool →
Returns structured JSON with posts →
AI summarizes the findings for you

User: "Get the full post and comments for that Rust tutorial I searched earlier"

AI uses get_post with postId →
Returns post body + comments →
AI provides detailed analysis

Contribuição

Contribuições são bem-vindas! Por favor:

1. Faça um fork do repositório
2. Crie um branch de funcionalidade
3. Envie um pull request

Licença

Licença MIT - Sinta-se à vontade para usar este projeto como quiser!

Agradecimentos

• Redlib - O front-end privado do Reddit com o qual este servidor interage
• Model Context Protocol - O protocolo que torna esta integração possível
• Cheerio - Biblioteca de análise HTML usada para extrair dados estruturados

Links

• Docker Hub: alfafadock/mcp-redlib
• Issues: GitHub Issues
• Redlib: github.com/redlib-org/redlib

Feito com ❤️ para a comunidade do Reddit preocupada com privacidade