Claude.ai MCP Server (Self-hosted)

Servidor MCP auto-hospedado para Claude.ai. Dê ao Claude acesso direto ao seu AWS, SSH, shell local, GitHub, PostgreSQL e PM2 — sem Claude Code. Suas chaves nunca saem da sua máquina.

GitHub

Experimente este MCPPatrocinado

Documentação

mcp-server

Servidor MCP auto-hospedado para Claude.ai

Dê a Claude acesso direto à sua conta AWS, conecte-se via SSH aos seus servidores, execute comandos shell no seu laptop, consulte seus bancos de dados e gerencie processos PM2 — tudo a partir de um chat com Claude. Não é necessária assinatura do Claude Code. Suas chaves nunca saem da sua máquina.

All 10 tools available as a Claude.ai custom connector

Todas as 10 ferramentas ficam na barra lateral do seu Claude.ai - sem instalação no Desktop, sem cliente separado, apenas um conector personalizado.

O que é isso?

Um pequeno servidor MCP em Node.js que você executa na sua própria máquina (laptop, desktop, VPS) e conecta ao Claude.ai (ou a qualquer cliente MCP) como um Conector Personalizado. Ele expõe um conjunto configurável de ferramentas que permitem a Claude realizar trabalho real na sua infraestrutura:

Executar comandos AWS CLI usando seu perfil local
Conectar via SSH aos seus servidores usando suas chaves .pem
Executar comandos shell na sua máquina local
Escrever arquivos diretamente no seu disco local (UTF-8 completo, sem aspas de shell)
Acessar a API REST do GitHub com seu Personal Access Token
Consultar bancos de dados PostgreSQL em hosts remotos via SSH
Inspecionar processos PM2 em servidores remotos
Iterar sobre documentos muito longos (edição de livros) que excedem a janela de contexto

Arquitetura:

  Claude.ai  ──HTTPS──►  nginx + cert  ──HTTP──►  frps  ──tunnel──►  frpc + node
   (cloud)               on a VPS         :8080    (vhost)            (your PC)
                                                                          │
                                ┌───────────────┬───────────────┬─────────┼─────────┐
                                ▼               ▼               ▼         ▼         ▼
                            AWS CLI       ssh -i *.pem      cmd.exe    psql via   pm2 list
                            (local)       user@host         git/npm      SSH      (remote)

Chaves SSH, PAT do GitHub e credenciais AWS nunca saem da sua máquina local. O túnel transporta apenas solicitações MCP e seus resultados.

Por que auto-hospedar isso?

O ecossistema MCP hoje faz principalmente duas coisas:

Servidores MCP como pacotes npm que rodam via stdio e exigem Claude Desktop.
Serviços MCP hospedados atrás da autenticação e limites de API de terceiros.

Este projeto é a terceira opção: seu próprio servidor MCP, suas chaves, seus servidores, acessível a partir do Claude.ai web (onde você já trabalha). É um único arquivo server.js de ~1000 linhas que você pode ler de ponta a ponta em 20 minutos e estender em 5.

Recursos matadores:

✅ Não é necessária assinatura do Claude Code — funciona com o Claude.ai comum (web)
✅ OAuth 2.1 com PKCE — integração adequada com Claude.ai, não um workaround improvisado
✅ Suas chaves continuam suas — chaves SSH, PATs do GitHub, credenciais AWS nunca saem da sua máquina
✅ Auto-hospedável — Windows, Linux, Mac, qualquer coisa que rode Node 18+
✅ Configurável via JSON — adicione um novo servidor ou nova chave sem tocar no código
✅ Um único arquivo para ler — sem mágica de framework, sem configuração oculta
✅ OAuth endurecido — PKCE S256, aplicação de client_secret, rotação de refresh token, revogação RFC 7009, allowlist de IP dinâmico com auto-inscrição, anti-clickjacking

Ferramentas

Ferramenta	O que faz
`aws_cli`	Execute qualquer `aws <command>` usando seu perfil AWS CLI local
`ssh_exec`	Conecte via SSH a qualquer host usando uma chave definida em `hosts.json`
`local_exec`	Execute qualquer comando shell na máquina local (`cmd.exe` no Windows, `/bin/sh` em outros lugares)
`write_file`	Escreva conteúdo de texto em um arquivo local (sobrescrever ou anexar). UTF-8 completo, sem problemas de aspas de shell — preferível a `local_exec` para qualquer escrita de arquivo não trivial
`github_api`	Faça solicitações à API REST do GitHub usando seu Personal Access Token
`postgres_query`	Execute consultas `psql` via SSH (`sudo -u postgres`) em um host de `hosts.json`
`pm2_status`	Mostre `pm2 list` e logs opcionais em um servidor remoto
`sftp_download`	Transmita um arquivo de um host remoto para o sistema de arquivos local (usa o pool SSH persistente). Essencial ao trabalhar a partir do Claude.ai web — o sandbox em nuvem não tem scp nativo
`sftp_upload`	Transmita um arquivo local para um host remoto. Flag opcional de modo POSIX (ex.: `0755`). O diretório pai deve existir no remoto
`book_split`	Divida um arquivo de texto grande em blocos de ~3000 palavras
`book_chunk`	Leia um bloco de um diretório criado por `book_split`
`book_note`	Gerencie notas JSON para trabalho iterativo em documentos longos

Veja em ação

Exemplos reais de um chat real do Claude.ai usando este servidor MCP.

Snapshot de saúde do servidor via SSH

"Conecte via SSH ao meu servidor matury e mostre: uso de disco (df -h), uso de memória (free -h) e uptime. Use um único comando e apresente a saída de forma organizada."

Claude composes a server health snapshot with disk, memory and uptime

Claude compõe um único comando SSH, analisa a saída de múltiplas seções e renderiza disco, memória e uptime como um snapshot limpo com os números-chave destacados.

Listar instâncias EC2 em qualquer região

"Usando AWS CLI, liste todas as minhas instâncias EC2 em eu-central-1 com seus IDs, tipos e estado. Formate o resultado como uma tabela limpa."

EC2 instance inventory rendered as a clean table

Claude chama aws_cli com um filtro describe-instances --query ..., depois analisa o JSON e o renderiza como uma tabela markdown com indicadores de status em execução/parado.

Consultar bancos de dados PostgreSQL via SSH

"Execute uma consulta SQL no meu banco PostgreSQL 'panel' para contar o total de usuários, depois no banco 'smart_edu' conte linhas na tabela de usuários e me diga como meu sistema está."

Claude orchestrates ssh_exec and postgres_query in parallel

Duas ferramentas trabalham juntas aqui: ssh_exec para enumerar bancos de dados quando o primeiro palpite falha, depois postgres_query contra o banco correto.

Database list and user counts across multiple databases

Claude lista todos os bancos de dados no host, identifica os que têm uma tabela users e executa consultas COUNT(*) em paralelo.

Requisitos

Node.js 18+ (testado em 22, 24, 25)
Chaves SSH .pem localmente (para hosts que você deseja controlar)
AWS CLI configurado localmente (aws configure) — apenas se você usar a ferramenta aws_cli
Um endpoint HTTPS público — apenas se você quiser expor isso ao Claude.ai

Início rápido

git clone https://github.com/LeszczynskiKarol/mcp-server.git
cd mcp-server
npm install
cp .env.example .env                # fill in MCP_PASS and MCP_BASE_URL
cp hosts.example.json hosts.json    # add your servers
node server.js

Você deve ver:

Loaded N hosts and M keys from ./hosts.json
MCP server: my-mcp-server
Port: 4500
Static IP allowlist: (none)
Auto-enroll: enabled (TTL 30 days)
Trust proxy: false
MCP listening on :4500

Isso é tudo para o local. Para usar isso a partir do Claude.ai (web), você precisa expô-lo via HTTPS — veja Expondo publicamente abaixo.

Configuração

`.env` (segredos — nunca commitar)

# REQUIRED
MCP_USER=admin
MCP_PASS=<long password, min 20 chars>
MCP_BASE_URL=https://your-domain.com

# OPTIONAL — GitHub integration
GITHUB_TOKEN=github_pat_xxxxxxxxxxxxxxxx
GITHUB_OWNER=YourGitHubUsername

# OPTIONAL — server tuning
PORT=4500
TOKEN_TTL_SECONDS=2592000      # 30 days
AUTH_CODE_TTL_SECONDS=600      # 10 minutes
CLIENT_TTL_SECONDS=7776000     # 90 days (unused-client cleanup)
EXEC_BUFFER_MB=10
EXEC_TIMEOUT_SECONDS=120       # per-command timeout
MCP_SERVER_NAME=my-mcp-server
HOSTS_CONFIG=./hosts.json
OAUTH_STATE_FILE=./oauth-state.json

# OPTIONAL — IP allowlist (security)
# Comma-separated static IPs/CIDRs that are always allowed.
# Leave empty if you only want auto-enroll via OAuth login.
MCP_ALLOWED_IPS=
# Trust X-Forwarded-For — use "loopback" when behind FRP/nginx on the same box.
# Other valid values: comma-separated list of trusted proxy IPs/CIDRs, "false"
# (default), or "true" (rejected in production — would let any client spoof XFF).
MCP_TRUST_PROXY=loopback
# Auto-enroll the requesting /24 subnet to allowlist after a successful OAuth login
MCP_AUTO_ENROLL=true
# How long an auto-enrolled subnet stays on the allowlist (default 30 days)
MCP_ENROLL_TTL_SECONDS=2592000

`hosts.json` (lista de servidores — nunca commitar)

{
  "hosts": {
    "production": {
      "ip": "1.2.3.4",
      "user": "ubuntu",
      "key": "main",
      "description": "Main production server"
    },
    "staging": {
      "ip": "5.6.7.8",
      "user": "ubuntu",
      "key": "main",
      "description": "Staging environment"
    }
  },
  "keys": {
    "main": "/path/to/main.pem"
  }
}

Os caminhos de chave podem usar:

Caminhos absolutos: D:/keys/server.pem ou D:\\keys\\server.pem
Expansão de til: ~/keys/server.pem (resolvido para $HOME / %USERPROFILE%)
Barras normais funcionam também no Windows

Expondo publicamente (Claude.ai)

Claude.ai exige HTTPS. A configuração recomendada usa FRP (Fast Reverse Proxy) + nginx + Let's Encrypt em um pequeno VPS.

1. Registro DNS

mcp.your-domain.com    A    <VPS_IP>    TTL 300

2. vhost nginx no VPS

/etc/nginx/sites-available/mcp.your-domain.com:

server {
    server_name mcp.your-domain.com;
    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # SSE / long-lived MCP connections
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_buffering off;
        proxy_read_timeout 3600s;
        proxy_send_timeout 3600s;
    }
    listen 80;
}

sudo ln -s /etc/nginx/sites-available/mcp.your-domain.com /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx
sudo certbot --nginx -d mcp.your-domain.com

3. Servidor FRP (`frps`) no VPS

/etc/frp/frps.toml:

bindPort = 7000
vhostHTTPPort = 8080
auth.method = "token"
auth.token = "<shared token>"

4. Cliente FRP (`frpc`) na sua máquina local

frpc-mcp.toml:

serverAddr = "<VPS_IP>"
serverPort = 7000
auth.method = "token"
auth.token = "<shared token from frps>"

[[proxies]]
name = "mcp"
type = "http"
localPort = 4500
customDomains = ["mcp.your-domain.com"]

5. Adicione o conector no Claude.ai

Abra Configurações → Conectores → Adicionar conector personalizado
URL: https://mcp.your-domain.com/mcp (com sufixo /mcp!)
OAuth Client ID/Secret: deixe vazio
Clique em Conectar → um formulário de login aparece → insira MCP_USER e MCP_PASS do seu .env
Em um chat: + → Conectores → ative este MCP → inicie uma nova conversa (as ferramentas são anexadas no início do chat)

A primeira solicitação de um novo IP acionará um novo login OAuth, que adiciona sua sub-rede /24 à allowlist por 30 dias. Isso é intencional — veja Segurança.

Preferências recomendadas do Claude.ai

Mesmo com as ferramentas certas instaladas, Claude às vezes desperdiça tokens em modos de falha comuns: reler arquivos após escrevê-los, copiar arquivos para o sandbox "para editá-los", mentir que um arquivo está no disco quando apenas um artefato foi criado.

CLAUDE_PREFERENCES.md é um conjunto selecionado de preferências de usuário que fecha essas lacunas. Cole-as em Configurações -> Perfil -> Preferências pessoais no Claude.ai. Elas são testadas em batalha contra os modos de falha exatos que motivaram a criação de algumas das ferramentas deste servidor (especialmente write_file).

Cobre, entre outras coisas:

Hierarquia de ferramentas de arquivo: sempre write_file para novos arquivos, PowerShell para edições cirúrgicas, nunca blocos base64 via cmd.exe
"Confie na escrita" -- não releia um arquivo apenas para confirmar que foi salvo
Isolamento do sandbox -- o sandbox bash não tem acesso ao seu disco local; não o ponte via hosts de arquivos públicos (uguu.se, transfer.sh, etc.)
Artefatos vs. escritas de arquivo MCP -- blocos "Arquivo criado" na interface do chat NÃO são salvos no seu disco
Regra de conteúdo bruto -- o conteúdo write_file deve ser bruto, não escapado em JSON
Limites anti-loop -- pare após 3 falhas no mesmo problema
Tratamento de caracteres não ASCII no Windows (pegadinha da página de código cmd.exe)

Executando no Windows

O autostart recomendado no Windows usa o Agendador de Tarefas + um pequeno .bat com um loop de reinicialização. PM2 costumava ser a recomendação, mas atualmente é incompatível com o tratamento de named-pipe do Node 25 (EPERM \\.\pipe\rpc.sock), então o projeto mudou para o Agendador de Tarefas simples.

Instalação única

Depois que .env e hosts.json estiverem no lugar, execute como administrador:

install-task.bat

Este é um pequeno wrapper em lote em torno de install-task.ps1. O script PowerShell:

Gera start-mcp-hidden.vbs (para que a janela cmd.exe permaneça oculta).
Gera mcp-task.generated.xml com %USERDOMAIN%\%USERNAME% preenchido — nada codificado.
Registra uma entrada no Agendador de Tarefas chamada MCP Server que é executada a cada logon com privilégio HighestAvailable.

A ação da tarefa é wscript.exe "...\start-mcp-hidden.vbs", que inicia silenciosamente start-mcp.bat. Esse lote mantém o node vivo com um loop de reinicialização:

@echo off
cd /d D:\mcp-server
if not exist logs mkdir logs
:loop
node server.js >> logs\mcp.log 2>&1
echo [%date% %time%] node exited, restarting in 5s >> logs\mcp.log
timeout /t 5 /nobreak >nul
goto loop

Comandos úteis:

schtasks /run /tn "MCP Server"            :: start now
schtasks /query /tn "MCP Server" /v /fo LIST  :: status
schtasks /delete /tn "MCP Server" /f      :: uninstall
tasklist | findstr node.exe               :: check that node is alive
type D:\mcp-server\logs\mcp.log           :: read the log

Para reiniciar após editar server.js:

taskkill /F /IM node.exe /T

O :loop em start-mcp.bat reiniciará o node em 5 segundos.

Autostart do túnel FRP

O túnel é separado do servidor MCP. A configuração mais simples é um start-mcp.bat (arquivo diferente em um diretório diferente) que apenas inicia frpc:

@echo off
cd /d C:\Users\YourUser\frp\frp_0.61.1_windows_amd64
start "FRP tunnel mcp" /min frpc.exe -c frpc-mcp.toml

Adicione-o ao Agendador de Tarefas da mesma forma (No logon, privilégios máximos), ou coloque-o em shell:startup.

Sem autostart

Se você quiser apenas executar o node manualmente para desenvolvimento:

cd /d D:\mcp-server
node server.js

Ctrl+C para parar.

Estendendo

Adicionando um novo host

Edite hosts.json:

{
  "hosts": {
    "production": {},
    "new-server": {
      "ip": "5.6.7.8",
      "user": "ubuntu",
      "key": "main",
      "description": "New server"
    }
  }
}

O servidor lê hosts.json na inicialização, então mate o node (taskkill /F /IM node.exe /T) e o loop de reinicialização pegará a nova configuração em 5 segundos. No Claude.ai, desconecte e reconecte o conector para que ele veja o novo host no menu suspenso do parâmetro host.

Adicionando uma nova chave SSH

{
  "keys": {
    "main": "/path/to/main.pem",
    "client-x": "~/keys/client-x.pem"
  }
}

Adicionando uma nova ferramenta

Em server.js:

server.tool(
  "your_tool_name",
  "Clear description of when Claude should use this tool",
  {
    param: z.string().describe("what this parameter does"),
  },
  async ({ param }) => {
    // your logic here
    return { content: [{ type: "text", text: "result" }] };
  },
);

Após salvar, taskkill /F /IM node.exe /T para que o loop de reinicialização detecte a alteração. Desconecte e reconecte o conector no Claude.ai para ver a nova ferramenta.

Segurança

Para uma lista completa do que o servidor impõe, consulte SECURITY.md. Os recursos principais:

OAuth 2.1 com PKCE (somente S256) e Registro Dinâmico de Clientes
Correspondência de client_id em /oauth/token — o código só pode ser resgatado pelo cliente que o emitiu (RFC 6749 §4.1.3)
Imposição de client_secret em /oauth/token e /oauth/revoke — os segredos emitidos no registro são realmente verificados
Validação e rotação de token de atualização — o token de atualização antigo é invalidado a cada uso, um novo par é emitido e somente o cliente proprietário pode rotacionar
Estado OAuth persistente em oauth-state.json — a reinicialização do nó não força mais a reautorização no Claude.ai
Endpoint de revogação de token em /oauth/revoke (RFC 7009)
Lista de permissões de IP dinâmica com autoinscrição — a sub-rede /24 de cada login OAuth bem-sucedido é adicionada à lista de permissões por 30 dias. IPs desconhecidos recebem 401 + WWW-Authenticate, então o Claude.ai executa silenciosamente o OAuth novamente e a nova sub-rede é adicionada. IPs/CIDRs estáticos podem ser configurados via MCP_ALLOWED_IPS
Proteção anti-clickjacking no formulário de login OAuth via helmet: X-Frame-Options: DENY e Content-Security-Policy: frame-ancestors 'none'
Limite de taxa em /oauth/*: 30 solicitações / 15 minutos / IP
Prevenção de poluição de protótipo em book_note (chaves __proto__, constructor, prototype rejeitadas)
Valores de token ocultados nos logs — apenas client_id e os primeiros 8 caracteres de qualquer token são gravados

Para assistentes de IA (Claude, Cursor, Cline, Aider, etc.)

Este repositório inclui CLAUDE.md com instruções críticas para qualquer assistente de IA que trabalhe neste código. Leia primeiro. Ele documenta:

A única maneira correta de editar arquivos no host Windows (ferramenta write_file)
Antipadrões que desperdiçaram tokens reais (sandbox como ponte, chunks base64, upload de arquivos para hosts públicos para transferi-los de volta ao disco do proprietário)
Regras anti-loop: 3 falhas → pare e proponha alternativas
Fluxo de trabalho de reinicialização do servidor que quebra sessões MCP

Se você é um humano implantando este servidor MCP para sua própria conta Claude.ai:

Copie as regras de CLAUDE.md para Configurações → Perfil → Preferências pessoais no Claude.ai. Esse é o único mecanismo na interface web que carrega instruções no início da sessão.
(Opcional) Copie CLAUDE.md para cada repositório que você editará por meio deste servidor. Ferramentas de IA executadas fora do claude.ai (Claude Code, Cursor, Cline) o lerão automaticamente.
O suporte futuro a Agent Skills da Anthropic no claude.ai web pode eventualmente carregar ~/.claude/skills/*.md automaticamente. Até lá, preferências + CLAUDE.md por repositório é o padrão de trabalho.

Postura de implantação recomendada

Atrás da topologia FRP + nginx descrita acima:

MCP_TRUST_PROXY=loopback   # frpc connects to node over 127.0.0.1
MCP_AUTO_ENROLL=true       # let Claude.ai's egress IP enroll itself on first login
MCP_ALLOWED_IPS=           # leave empty unless you have a fixed office/VPN IP
MCP_PASS=<random 20+ chars>

MCP_TRUST_PROXY=true é permissivo e será rejeitado por express-rate-limit porque permitiria que qualquer cliente falsificasse X-Forwarded-For e contornasse a limitação de taxa. Use loopback (ou uma lista separada por vírgulas de IPs de proxy confiáveis) em vez disso.

Endurecimento que você pode aplicar por conta própria

Perfil AWS somente leitura para aws_cli se você não precisar de mutações — crie credenciais IAM dedicadas com ReadOnlyAccess
Lista de permissões de comandos para aws_cli / local_exec / ssh_exec se você confiar menos no Claude do que no console AWS
Fixar chaves de host SSH — remova StrictHostKeyChecking=no de ssh_exec e pré-popule ~/.ssh/known_hosts
Log de auditoria em arquivo — a configuração do Agendador de Tarefas grava em logs/mcp.log; a rotação persistente é sua responsabilidade
ACL por ferramenta — restrinja qual cliente (por exemplo, conta de trabalho vs. pessoal do Claude.ai) pode chamar qual ferramenta com um dispatcher personalizado na frente de server.tool
Verifique .gitignore — deve incluir .env, hosts.json, oauth-state.json, logs/, mcp-task.generated.xml, start-mcp-hidden.vbs

Solução de problemas

Sintoma	Causa	Correção
`Couldn't reach the MCP server` no Claude.ai	URL sem `/mcp`	Use `https://domain/mcp` (com sufixo)
`Couldn't reach the MCP server` apesar da URL correta	Nó não está em execução, túnel FRP inativo ou seu IP não está na lista de permissões	Verifique `tasklist \| findstr node.exe`, o processo `frpc` e o log para `[allowlist] BLOCKED /mcp from X.X.X.X`
`404 Not Found` do nginx	Sem vhost para o subdomínio	Crie o vhost + execute o certbot
`502 Bad Gateway`	frpc não está em execução ou o nó travou	Verifique `tasklist` e o processo frpc
`[allowlist] BLOCKED /mcp from X.X.X.X`	Novo IP, ainda não inscrito	Deve se autocorrigir — o Claude.ai executará o OAuth novamente e adicionará o `/24`. Basta fazer login uma vez e tentar novamente
`ValidationError: The Express 'trust proxy' setting is true`	`MCP_TRUST_PROXY=true` é permissivo demais para `express-rate-limit`	Altere `.env` para `MCP_TRUST_PROXY=loopback`
`EADDRINUSE :4500`	Outro nó em execução na porta 4500	`taskkill /F /IM node.exe /T` no cmd como administrador
`MCP_PASS - OAuth login password` na inicialização	`.env` ausente	`cp .env.example .env` e preencha
`hosts.json not loaded`	`hosts.json` ausente	`cp hosts.example.json hosts.json` e preencha
`Unknown key 'xxx'` no SSH	Chave não definida em `hosts.json`	Adicione-a à seção `keys`
`ssh_exec` retorna "Permission denied (publickey)"	Usuário errado para o host	Em `hosts.json`, defina o usuário correto (geralmente `ubuntu` para AMIs Ubuntu, `ec2-user` para Amazon Linux)
`pm2: command not found` via `pm2_status`	NVM no host remoto — shell não interativo não carrega nvm.sh	A ferramenta lida com isso automaticamente (base64 + sourcing do nvm.sh). Certifique-se de que o NVM esteja em `$HOME/.nvm` no remoto
Claude vê o conector, mas nenhuma ferramenta	Alternância desativada ou sessão de chat antiga	`+` → Conectores → ativar → inicie uma nova conversa
Ferramentas alteradas, Claude mostra as antigas	Cache de esquema MCP	Configurações → Conectores → Desconectar → Conectar
O Agendador de Tarefas mostra `Last Result: 267009` e o nó não está em execução	A tarefa em si é `Running`, mas o lote subjacente ainda não iniciou o nó, ou ele travou	Aguarde 5 segundos (loop de reinicialização) ou execute `tasklist \| findstr node.exe` e `type logs\mcp.log`

Arquivos do projeto

mcp-server/
├── server.js              # MCP server (Express + StreamableHTTP + OAuth)
├── package.json
├── .env                   # (gitignored) secrets
├── .env.example
├── hosts.json             # (gitignored) server list
├── hosts.example.json
├── oauth-state.json       # (gitignored) persisted OAuth state
├── .gitignore
├── README.md              # English (this file)
├── README.pl.md           # Polish translation
├── LICENSE
├── CHANGELOG.md
├── CONTRIBUTING.md
├── SECURITY.md
├── setup.bat              # quick start for Windows
├── setup.sh               # quick start for Linux/Mac
├── start-mcp.bat          # node restart loop (Windows autostart)
├── install-task.bat       # wrapper that runs install-task.ps1
├── install-task.ps1       # registers the "MCP Server" scheduled task
└── logs/                  # (gitignored) mcp.log

Compatibilidade

Cliente MCP	Status
Claude.ai (web)	✅ Alvo principal — totalmente testado
Claude Desktop	✅ Testado — a mesma URL do conector funciona (conectores personalizados com OAuth)
Cliente MCP personalizado (com OAuth 2.1)	✅ Implementação padrão
Cliente MCP personalizado (sem OAuth)	❌ Requer modificação — OAuth é obrigatório no código atual

Roteiro

Ideias para versões futuras (PRs bem-vindos):

~~Estado OAuth persistente para que a reinicialização do nó não derrube conexões~~ (concluído na 1.1.0)
~~Limitação de taxa em /oauth/*~~ (concluído na 1.1.0)
~~Endpoint de revogação de token~~ (concluído na 1.1.0)
Log de auditoria em arquivo (audit.log com rotação)
ACL por ferramenta (qual cliente pode usar qual ferramenta)
Modo somente leitura para AWS / SSH (lista de permissões de comandos seguros)
Docker Compose para implantação em um comando
Mais ferramentas: upload S3, logs CloudWatch, Sentry, Stripe
Autenticação multiusuário (integração OIDC: login Google / GitHub)

Licença

Contribuição

Pull requests são bem-vindos! Consulte CONTRIBUTING.md para diretrizes.

Para perguntas ou ideias, use GitHub Discussions em vez de issues.

🇵🇱 README em polonês: README.pl.md