# MCP Simple Server (HTTP Bridge)

Este é um servidor MCP (Model Context Protocol) simplificado que expõe ferramentas através de uma interface HTTP POST. Ele permite que LLMs e agentes remotos acessem funcionalidades locais ou específicas de forma segura através de um túnel ou acesso direto.

## 🚀 Configurações Técnicas

- **Porta:** `3030`
- **Endpoint:** `/mcp`
- **Método:** `POST`
- **Autenticação:** `Authorization: Bearer senha-facil-123`
- **Protocolo:** JSON-RPC 2.0 (Adaptado para HTTP)

---

## 🧪 Testando com CURL

### Localmente
```bash
# Listar ferramentas disponíveis
curl -X POST http://localhost:3030/mcp \
  -H "Authorization: Bearer senha-facil-123" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tools/list","id":1}'

# Chamar a ferramenta 'hello'
curl -X POST http://localhost:3030/mcp \
  -H "Authorization: Bearer senha-facil-123" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"hello","arguments":{"name":"Fabão"}},"id":2}'
```

### Remotamente (pela rede)
Se acessar de outra máquina, substitua `localhost` pelo IP ou hostname:
```bash
curl -X POST http://<IP_DO_SERVIDOR>:3030/mcp \
  -H "Authorization: Bearer senha-facil-123" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tools/list","id":1}'
```

*Exemplo: `http://192.168.1.100:3030/mcp` ou `http://vpn-server:3030/mcp`*

---

## ♊ Configurando Gemini-CLI (Remoto)

Para que o `gemini-cli` em sua máquina local ou outra VPS acesse este servidor, você deve configurá-lo no arquivo de configuração do Gemini CLI (geralmente em `~/.gemini/config.yaml` ou via comando).

Como este servidor usa HTTP direto (e não o padrão stdio), você pode usar um "wrapper" ou configurar o acesso via SSE se o servidor for estendido, ou usar o plugin de fetch se disponível. 

**Exemplo de configuração (Assumindo uso de um proxy stdio-to-http):**
```bash
# Substitua <IP_DO_SERVIDOR> pelo IP ou hostname onde o servidor está rodando
gemini mcp add remote-server --command "npx @modelcontextprotocol/inspector http://<IP_DO_SERVIDOR>:3030/mcp"
```

No arquivo ~/.gemini/settings.json

```json
{
  "mcpServers": {
    "local-mcp": {
      "url": "http://<IP_DO_SERVIDOR>:3030/mcp",
      "headers": {
        "Authorization": "Bearer senha-facil-123"
      }
    }
  }
}
```

**Nota:** Substitua `<IP_DO_SERVIDOR>` pelo:
- `localhost` para acesso local
- IP da máquina (ex: `192.168.1.100`) para acesso na rede local
- IP/domínio público para acesso remoto

---

## 🤖 Configurando Claude Code

O Claude Code (e o Claude Desktop) geralmente esperam um comando local. Para acessar este servidor remoto:

1. Edite o arquivo `claude_desktop_config.json`:
   - **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
   - **Linux:** `~/.config/Claude/claude_desktop_config.json`

2. Adicione a configuração (substitua `<IP_DO_SERVIDOR>` pelo IP ou hostname):
```json
{
  "mcpServers": {
    "mcp-simple-server": {
      "command": "curl",
      "args": [
        "-s",
        "-X", "POST",
        "http://<IP_DO_SERVIDOR>:3030/mcp",
        "-H", "Authorization: Bearer senha-facil-123",
        "-H", "Content-Type: application/json",
        "-d", "{\"jsonrpc\":\"2.0\",\"method\":\"tools/call\",\"params\":<params>}"
      ]
    }
  }
}
```

**Para acesso local (mesma máquina):** use `http://localhost:3030/mcp`

*Dica: Para uma integração mais robusta, recomenda-se usar o `mcp-proxy` que converte stdio para a API HTTP do seu servidor.*

---

## 💬 Configurando ChatGPT (GPT Codex / Actions)

Para usar este servidor como uma **Action** no ChatGPT:

1. Vá em **Custom GPTs** -> **Create a GPT** -> **Configure** -> **Create new action**.
2. No campo **Authentication**, escolha **API Key**, selecione **Bearer** e insira: `senha-facil-123`.
3. No campo **Schema**, use uma especificação OpenAPI (exemplo simplificado abaixo):

```yaml
openapi: 3.0.0
info:
  title: MCP Simple Server
  version: 1.0.0
servers:
  - url: http://<IP_PUBLICO_OU_DOMAIN>:3030 # Substitua pelo IP público ou domínio
paths:
  /mcp:
    post:
      operationId: callMcpTool
      summary: Chama uma ferramenta do MCP
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                method: {type: string, example: "tools/call"}
                params: {type: object}
                id: {type: integer, example: 1}
      responses:
        '200':
          description: Sucesso
```

---

## 🐳 Docker

Este projeto está pronto para ser executado em containers.

### 1. Construir a Imagem
Para gerar a imagem Docker localmente:
```bash
docker build -t mcp-simple-server .
```

### 2. Subir o Container (Docker Compose)
A forma recomendada de rodar é utilizando o `docker-compose.yml` já incluso, que configura a rede e as variáveis de ambiente:
```bash
docker compose up -d
```

O container será criado com o nome `mcp-simple-server` e estará disponível na porta `3030`.

### 3. Verificar Status e Logs
```bash
# Ver se o container está rodando
docker ps | grep mcp-simple-server

# Ver logs do servidor
docker compose logs -f
```

---

## 🛠️ Desenvolvimento

Para rodar o servidor localmente:
```bash
cd ~/apps/mcp-simple-server
npm install
node server.js
```

O servidor estará ouvindo em `http://localhost:3030`.