Which integrations are available for this server?

Provides a persistent, sandboxed Python REPL environment for executing code and performing complex data analysis on large datasets outside of the model's context window.

How do I use RLM MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@RLM MCP Server Analyze the 500MB access.log and group all 404 errors by hour" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

RLM MCP Server

Servidor MCP (Model Context Protocol) que implementa Recursive Language Models para análise de dados massivos sem poluir o contexto do Claude.

Baseado no paper "Recursive Language Models" do MIT CSAIL.

Por Que Usar?

O Claude Code tradicional:

Carrega todo output no contexto
Precisa de /compact frequente
Limita análise de arquivos grandes

Com RLM MCP:

Dados ficam em variáveis fora do contexto
Contexto permanece pequeno
Analise arquivos de 100MB+ sem compact

Arquitetura

┌─────────────────────────────────────────────────────────────┐
│  Sua máquina local                                          │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  Claude Code                                        │    │
│  │  Tools MCP: rlm_execute, rlm_load_data, etc.       │    │
│  └──────────────────────┬──────────────────────────────┘    │
└─────────────────────────┼───────────────────────────────────┘
                          │ SSH Tunnel (porta 8765)
                          ▼
┌─────────────────────────────────────────────────────────────┐
│  Seu Servidor (Digital Ocean, AWS, etc.)                    │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  Docker: rlm-mcp-server                             │    │
│  │  ┌───────────────────────────────────────────────┐  │    │
│  │  │  Python REPL Persistente                      │  │    │
│  │  │  variables = {"logs": <500MB>, ...}           │  │    │
│  │  │  Dados em memória, NÃO no contexto            │  │    │
│  │  └───────────────────────────────────────────────┘  │    │
│  └─────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────┘

Instalação

1. No Servidor (via Dokploy ou Docker)

# Clone o repositório
git clone https://github.com/seu-usuario/rlm-mcp-server.git
cd rlm-mcp-server

# Copie o .env
cp .env.example .env
# Edite .env com suas configurações

# Crie o diretório de dados
mkdir -p data
# Coloque seus arquivos em ./data/

# Build e start
docker-compose up -d --build

Via Dokploy

No Dokploy, crie um novo Application
Source: Git → URL do repositório
Build: Docker Compose
Deploy

2. Na Máquina Local (Claude Code)

Opção A: SSH Tunnel (Recomendado)

# Crie um túnel SSH para a porta do servidor
ssh -L 8765:localhost:8765 root@seu-servidor.com -N &

# O túnel fica rodando em background

Opção B: Uso Local (sem servidor remoto)

Se quiser rodar localmente para testes:

cd rlm-mcp-server
pip install -e .

# Teste manualmente
python -c "from rlm_mcp.server import main; main()"

3. Configure o Claude Code

Adicione ao ~/.claude/claude.json:

{
  "mcpServers": {
    "rlm": {
      "type": "sse",
      "url": "https://rlm.seudominio.com/sse",
      "headers": {
        "Authorization": "Bearer SUA_API_KEY_AQUI"
      }
    }
  }
}

Nota: Substitua rlm.seudominio.com pelo domínio configurado no Traefik/Dokploy.

Alternativa - via SSH tunnel (se não quiser expor publicamente):

{
  "mcpServers": {
    "rlm": {
      "command": "socat",
      "args": ["TCP:localhost:8765", "STDIO"]
    }
  }
}

4. Reinicie o Claude Code

# Feche e abra novamente, ou:
claude --mcp-restart

Uso

Tools Disponíveis

Tool	Descrição
`rlm_load_data`	Carrega dados diretamente em variável
`rlm_load_file`	Carrega arquivo do servidor (text, json, csv, lines, pdf, pdf_ocr)
`rlm_execute`	Executa código Python
`rlm_list_vars`	Lista variáveis disponíveis
`rlm_var_info`	Info detalhada de uma variável
`rlm_clear`	Limpa variáveis
`rlm_memory`	Estatísticas de memória
`rlm_load_s3`	Carrega arquivo do Minio/S3 (text, json, csv, lines, pdf, pdf_ocr)
`rlm_list_buckets`	Lista buckets do Minio
`rlm_list_s3`	Lista objetos em um bucket
`rlm_upload_url`	Gera URL assinada para upload

Funções Disponíveis Dentro do Código (RLM)

Dentro do código executado via rlm_execute, estas funções estão disponíveis:

Função	Descrição
`llm_query(prompt, data=None, model=None)`	Faz sub-chamada a um LLM
`llm_stats()`	Retorna estatísticas de uso
`llm_reset_counter()`	Reseta contador de chamadas

Exemplos de Uso no Claude Code

Analisar logs massivos:

Você: "Analise o log /data/app.log e encontre todos os erros"

Claude: [usa rlm_load_file para carregar em variável 'logs']
Claude: [usa rlm_execute com código Python para filtrar erros]
Claude: "Encontrei 1,234 erros. Os mais comuns são..."

Busca exata em código:

Você: "Quantas vezes 'TODO' aparece perto de 'FIXME' no código?"

Claude: [usa rlm_load_file para carregar código]
Claude: [usa rlm_execute]:
    import re
    matches = re.findall(r'TODO.{0,50}FIXME|FIXME.{0,50}TODO', data)
    print(f"Encontrados: {len(matches)}")

Agregação de dados:

Você: "Agrupe os logs por hora e conte requests"

Claude: [usa rlm_execute]:
    from collections import Counter
    hours = [line.split()[0][:13] for line in logs if 'request' in line]
    counts = Counter(hours)
    for hour, count in counts.most_common(10):
        print(f"{hour}: {count}")

Sub-chamadas LLM (Recursive Language Model):

Você: "Analise 1GB de logs e encontre padrões de erro"

Claude: [usa rlm_execute com llm_query]:
    # Divide dados massivos em chunks
    chunk_size = 50000
    chunks = [logs[i:i+chunk_size] for i in range(0, len(logs), chunk_size)]

    # Processa cada chunk com sub-LLM (padrão map-reduce)
    summaries = []
    for i, chunk in enumerate(chunks):
        summary = llm_query(
            "Liste os erros críticos encontrados neste log:",
            data="\n".join(chunk)
        )
        summaries.append(summary)
        print(f"Chunk {i+1}/{len(chunks)} processado")

    # Sintetiza resultados
    final = llm_query(
        "Combine estes resumos em um relatório final:",
        data="\n---\n".join(summaries)
    )
    print(final)

Este padrão implementa o paper "Recursive Language Models" do MIT CSAIL, permitindo processar dados que excedem a janela de contexto do LLM.

Processamento de PDFs

Use data_type="pdf" ou data_type="pdf_ocr" em rlm_load_file ou rlm_load_s3:

data_type	Uso	Requer
`pdf`	Auto-detecta: tenta pdfplumber, fallback para OCR	`MISTRAL_API_KEY` para fallback
`pdf_ocr`	Força OCR (para escaneados/imagens)	`MISTRAL_API_KEY`

Exemplo com Minio (recomendado):

# Upload via mc CLI
mc cp relatorio.pdf minio/docs/

# No Claude Code
rlm_load_s3(bucket="docs", key="relatorio.pdf", name="doc", data_type="pdf")

Forçando OCR para documentos escaneados:

rlm_load_s3(bucket="docs", key="escaneado.pdf", name="doc", data_type="pdf_ocr")

Segurança

Sandbox Python

O REPL executa em sandbox com:

Imports permitidos: re, json, math, collections, datetime, csv, etc.
Imports bloqueados: os, subprocess, socket, requests, etc.
Funções bloqueadas: exec, eval, open, __import__, etc.

Acesso a Arquivos

Somente arquivos em /data/ são acessíveis
Volume montado como read-only
Path traversal é bloqueado

Rede

Container em rede isolada (sem acesso à internet)
Conexão apenas via localhost (SSH tunnel)

Configuração

Variáveis de Ambiente

Variável	Padrão	Descrição
`RLM_MAX_MEMORY_MB`	1024	Limite de memória para variáveis
`RLM_API_KEY`	(vazio)	API key para autenticação (opcional)
`OPENAI_API_KEY`	(obrigatório para llm_query)	API key do OpenAI
`RLM_SUB_MODEL`	gpt-4o-mini	Modelo para sub-chamadas LLM
`RLM_MAX_SUB_CALLS`	100	Limite de sub-chamadas por execução
`MISTRAL_API_KEY`	(opcional)	API key do Mistral para OCR de PDFs
`MINIO_ENDPOINT`	(opcional)	Endpoint do Minio/S3
`MINIO_ACCESS_KEY`	(opcional)	Access key do Minio
`MINIO_SECRET_KEY`	(opcional)	Secret key do Minio
`MINIO_SECURE`	true	Usar HTTPS para Minio

Limites de Recursos (Docker)

deploy:
  resources:
    limits:
      cpus: '2'
      memory: 2G

Troubleshooting

Claude Code não encontra o MCP

Verifique se o túnel SSH está ativo: ps aux | grep ssh
Teste conexão: nc -zv localhost 8765
Verifique logs: docker logs rlm-mcp-server

Erro "SecurityError: Import bloqueado"

O sandbox bloqueia imports perigosos. Use apenas imports permitidos.

Memória insuficiente

Aumente RLM_MAX_MEMORY_MB
Use rlm_clear para limpar variáveis não usadas
Processe dados em chunks menores

Desenvolvimento

# Clone
git clone https://github.com/seu-usuario/rlm-mcp-server.git
cd rlm-mcp-server

# Ambiente virtual
python -m venv venv
source venv/bin/activate

# Instale em modo desenvolvimento
pip install -e ".[dev]"

# Testes
pytest

# Rode localmente
rlm-mcp

Licença

MIT

RLM MCP Server

RLM MCP Server

Por Que Usar?

Arquitetura

Instalação

1. No Servidor (via Dokploy ou Docker)

Via Dokploy

2. Na Máquina Local (Claude Code)

Opção A: SSH Tunnel (Recomendado)

Opção B: Uso Local (sem servidor remoto)

3. Configure o Claude Code

4. Reinicie o Claude Code

Uso

Tools Disponíveis

Funções Disponíveis Dentro do Código (RLM)

Exemplos de Uso no Claude Code

Processamento de PDFs

Segurança

Sandbox Python

Acesso a Arquivos

Rede

Configuração

Variáveis de Ambiente

Limites de Recursos (Docker)

Troubleshooting

Claude Code não encontra o MCP

Erro "SecurityError: Import bloqueado"

Memória insuficiente

Desenvolvimento

Licença

Referências

Resources

Latest Blog Posts

MCP directory API