mcpproxy-go

Servidor proxy MCP local de código abierto. Enruta múltiples servidores MCP a través de un único endpoint con filtrado de herramientas BM25, seguridad de cuarentena, registro de actividad e interfaz web.

GitHub

381

Prueba este MCPPatrocinado

Documentación

MCPProxy web UI demo: server dashboard, tool discovery, activity log, and security quarantine

📺 Ver el recorrido completo · 📚 Leer la documentación · 🌐 mcpproxy.app

La demostración anterior muestra la interfaz web integrada. El núcleo de MCPProxy es un único binario para macOS, Linux y Windows — la interfaz web viene incluida dentro de él, sin necesidad de ejecutar un servicio adicional. En macOS, una aplicación opcional de barra de menú añade comodidad con un solo clic (iniciar/detener, estado del servidor, cuarentena, registros).

MCPProxy macOS app — Activity log with sensitive-data detection

Aplicación de barra de menú para macOS · Registro de actividad y auditoría en la aplicación de macOS

¿Por qué MCPProxy?

Supera los límites de la API – Federar cientos de servidores MCP mientras se evita el límite de 40 herramientas de Cursor y el tope de 128 funciones de OpenAI.
Ahorra tokens y acelera las respuestas – Los agentes cargan solo una retrieve_tools función en lugar de cientos de esquemas. La investigación muestra una reducción de tokens de aproximadamente el 99 % con una mejora de precisión del 43 %.
Protección de seguridad avanzada – La cuarentena automática bloquea los ataques de envenenamiento de herramientas hasta que apruebes manualmente los nuevos servidores.
Escáneres de seguridad conectables – Ejecuta escáneres basados en Docker como Snyk, Semgrep, Trivy, Cisco y otros contra los servidores en cuarentena antes de aprobarlos; los hallazgos se normalizan a SARIF con una puntuación de riesgo compuesta. Consulta Complementos de escáner de seguridad.
Funciona sin conexión y multiplataforma – Un único binario central para macOS (Intel y Apple Silicon), Windows (x64 y ARM64) y Linux (x64 y ARM64), con la interfaz web integrada. macOS además incluye una aplicación opcional de barra de menú.

Inicio rápido

1. Instalación

macOS (Recomendado - Instalador DMG):

Descarga el instalador DMG más reciente para tu arquitectura:

Apple Silicon (M1/M2): Descargar DMG → mcpproxy-*-darwin-arm64.dmg
Mac Intel: Descargar DMG → mcpproxy-*-darwin-amd64.dmg

Windows (Recomendado - Instalador):

Descarga el instalador de Windows más reciente para tu arquitectura:

x64 (64 bits): Descargar instalador → mcpproxy-setup-*-amd64.exe
ARM64: Descargar instalador → mcpproxy-setup-*-arm64.exe

El instalador automáticamente:

Instala tanto mcpproxy.exe (servidor central) como mcpproxy-tray.exe (aplicación de bandeja del sistema) en Archivos de programa
Añade MCPProxy a la ruta PATH de tu sistema para acceso desde la línea de comandos
Crea accesos directos en el menú Inicio
Admite instalación silenciosa: .\mcpproxy-setup.exe /VERYSILENT

Métodos de instalación alternativos:

macOS (Homebrew):

# macOS — GUI tray app (recommended):
brew install --cask smart-mcp-proxy/mcpproxy/mcpproxy

# macOS / Linux — headless CLI only:
brew install smart-mcp-proxy/mcpproxy/mcpproxy

La cask instala la aplicación de barra de menú (incluye la CLI); la fórmula es solo el binario de la CLI. Ambos se actualizan mediante brew upgrade.

Linux (Debian/Ubuntu) — repositorio apt, actualizaciones automáticas mediante apt upgrade:

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://apt.mcpproxy.app/mcpproxy.gpg \
  | sudo tee /etc/apt/keyrings/mcpproxy.gpg > /dev/null
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/mcpproxy.gpg] https://apt.mcpproxy.app stable main" \
  | sudo tee /etc/apt/sources.list.d/mcpproxy.list > /dev/null
sudo apt update && sudo apt install mcpproxy

Linux (Fedora / RHEL / Rocky / AlmaLinux) — repositorio dnf, actualizaciones automáticas mediante dnf upgrade:

sudo dnf config-manager --add-repo https://rpm.mcpproxy.app/mcpproxy.repo
# Fedora 41+ (dnf5): sudo curl -fsSL https://rpm.mcpproxy.app/mcpproxy.repo -o /etc/yum.repos.d/mcpproxy.repo
sudo dnf install -y mcpproxy

Arch Linux (AUR): mcpproxy-bin

yay -S mcpproxy-bin
# or
git clone https://aur.archlinux.org/mcpproxy-bin.git && cd mcpproxy-bin && makepkg -si

Los paquetes apt y dnf incluyen una unidad systemd reforzada e inician el servicio automáticamente. Huella de la clave de firma del repositorio: 3B6F A1AD 5D53 59DA 51F1 8DDC E1B5 9B9B A1CB 8A3B.

Para descargas únicas de .deb / .rpm (instalaciones sin conexión), descárgalas desde la última versión.

Descarga manual (todas las plataformas):

Archivo tar de Linux: AMD64 | ARM64
Windows: AMD64 | ARM64

Versiones preliminares (funciones más recientes):

¿Quieres probar las funciones más nuevas? Descarga las versiones preliminares desde la rama next:

Ve a GitHub Actions
Haz clic en la ejecución más reciente del flujo de trabajo "Prerelease" que haya tenido éxito
Descarga desde Artefactos:
- dmg-darwin-arm64 (Macs con Apple Silicon)
- dmg-darwin-amd64 (Macs Intel)
- versioned-linux-amd64, versioned-windows-amd64 (otras plataformas)

Nota: Las versiones preliminares están firmadas y notarizadas para macOS, pero contienen funciones de vanguardia que pueden ser inestables.

macOS: Intel | Apple Silicon

En cualquier lugar con Go 1.26+:

go install github.com/smart-mcp-proxy/mcpproxy-go/cmd/mcpproxy@latest

2. Ejecutar

mcpproxy serve          # starts HTTP server on :8080 and shows tray

3. Añade tu primer servidor

Crea o edita ~/.mcpproxy/mcp_config.json:

{
  "listen": "127.0.0.1:8080",
  "mcpServers": [
    { "name": "local-python", "command": "python", "args": ["-m", "my_server"], "protocol": "stdio", "enabled": true },
    { "name": "remote-http", "url": "http://localhost:3001", "protocol": "http", "enabled": true }
  ]
}

Consulta Configuración y Servidores ascendentes para la referencia completa.

4. Conéctate a tu IDE/herramienta de IA

📖 Guía de configuración completa - Instrucciones detalladas para Cursor, VS Code, Claude Desktop y Goose

Añadir proxy a Cursor

Instalación con un clic en el IDE de Cursor

Instalación manual

Abre la configuración de Cursor
Haz clic en "Herramientas e integraciones"
Añade el servidor MCP

    "MCPProxy": {
      "type": "http",
      "url": "http://localhost:8080/mcp/"
    }

Cómo funcionan los agentes de IA a través de MCPProxy

Una vez conectado, tu agente ve un puñado de herramientas integradas de MCPProxy en lugar de cientos de esquemas ascendentes. Una sesión típica tiene tres fases: descubrir, llamar y auditar, más una compuerta opcional de verificación previa para automatizaciones no supervisadas.

1. Descubrir: gasta una consulta, no tu ventana de contexto

El agente solicita lo que necesita en palabras clave simples mediante retrieve_tools:

{ "query": "create github issue", "limit": 5 }

MCPProxy ejecuta una búsqueda BM25 en todos los servidores conectados y devuelve solo las coincidencias mejor clasificadas, cada una con una sugerencia call_with que recomienda la variante de llamada correcta según sus anotaciones:

{
  "tools": [
    { "name": "github:create_issue", "score": 0.89, "call_with": "call_tool_write" },
    { "name": "gitlab:create_issue", "score": 0.72, "call_with": "call_tool_write" }
  ]
}

Aquí es donde se ahorran tokens: los esquemas de las cientos de herramientas que el agente no necesitó nunca entran en su contexto. El agente carga los esquemas completos bajo demanda con describe_tool (lote de hasta 5 identificadores) solo para las herramientas que está a punto de usar.

2. Llamar: con intención declarada

El agente ejecuta la herramienta mediante la variante que coincide con su intención (call_tool_read, call_tool_write o call_tool_destructive), dirigiéndose a ella como server:tool:

{
  "name": "github:create_issue",
  "args_json": "{\"repo\": \"acme/api\", \"title\": \"Bug report\"}",
  "intent": { "operation_type": "write", "reason": "Filing bug per user request" }
}

MCPProxy valida la intención contra las anotaciones de la herramienta (una llamada de "lectura" no puede alcanzar una herramienta destructiva), verifica el estado de cuarentena y aprobación, y escanea argumentos y respuestas en busca de datos sensibles antes de que algo salga de la máquina.

3. Auditar: cada llamada queda registrada

Cada llamada se registra en el Registro de actividad local con un ID de solicitud, para que puedas reconstruir exactamente lo que hizo un agente:

mcpproxy activity list                          # everything, newest first
mcpproxy activity list --request-id <id>        # one workflow, correlated

Controla las automatizaciones antes de que gasten tokens

Para trabajos recurrentes sin supervisión (cron, CI, n8n), no dejes que el agente descubra una herramienta faltante de la forma costosa. Un comando de verificación previa comprueba que cada herramienta requerida esté lista, sin contactar ningún servidor ascendente, e informa exactamente por qué no lo está (servidor en cuarentena, herramienta cambiada desde la aprobación, OAuth caducado, ID mal escrito):

mcpproxy tools preflight gh-ops:sync_issues slack:post_message --wait 10s
case $? in
  0)  run-agent-session ;;   # all ready — go
  10) exit 75 ;;             # transient (server starting) — let the next cron tick retry
  11) page-operator ;;       # blocked — someone must approve / enable / log in
  12) fail-pipeline ;;       # unknown tool id — the automation itself is misconfigured
esac

Consulta Verificación previa de herramientas requeridas para la taxonomía completa de razones, el endpoint REST y las recetas para GitHub Actions / n8n.

🔐 Configuración HTTPS opcional

MCPProxy funciona con HTTP por defecto para una configuración sencilla. HTTPS es opcional y principalmente útil para entornos de producción o cuando se requiere una seguridad más estricta.

💡 Nota: La mayoría de los usuarios pueden quedarse con HTTP (el valor predeterminado), ya que funciona perfectamente con todos los clientes compatibles, incluidos Claude Desktop, Cursor y VS Code.

Configuración HTTPS rápida

1. Habilita HTTPS (elige un método):

# Method 1: Environment variable
export MCPPROXY_TLS_ENABLED=true
mcpproxy serve

# Method 2: Config file
# Edit ~/.mcpproxy/mcp_config.json and set "tls.enabled": true

2. Confía en el certificado (configuración única):

mcpproxy trust-cert

3. Usa URLs HTTPS:

Endpoint MCP: https://localhost:8080/mcp
Interfaz web: https://localhost:8080/ui/

Integración con Claude Desktop

Para Claude Desktop, añade esto a tu claude_desktop_config.json:

HTTP (predeterminado - recomendado):

{
  "mcpServers": {
    "mcpproxy": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "http://localhost:8080/mcp"
      ]
    }
  }
}

HTTPS (con confianza en el certificado):

{
  "mcpServers": {
    "mcpproxy": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://localhost:8080/mcp"
      ],
      "env": {
        "NODE_EXTRA_CA_CERTS": "~/.mcpproxy/certs/ca.pem"
      }
    }
  }
}

Gestión de certificados

Generación automática: los certificados se crean en el primer inicio con HTTPS
Soporte multidominio: funciona con localhost, 127.0.0.1, ::1
Instalación de confianza: usa mcpproxy trust-cert para añadir al llavero del sistema
Ubicación del certificado: ~/.mcpproxy/certs/ (ca.pem, server.pem, server-key.pem)

Solución de problemas de HTTPS

Problemas de confianza en el certificado:

# Re-trust certificate
mcpproxy trust-cert --force

# Check certificate location
ls ~/.mcpproxy/certs/

# Test HTTPS connection
curl -k https://localhost:8080/api/v1/status

Problemas de conexión con Claude Desktop:

Asegúrate de que NODE_EXTRA_CA_CERTS apunte al archivo ca.pem correcto
Reinicia Claude Desktop después de los cambios de configuración
Verifica que HTTPS esté habilitado: mcpproxy serve --log-level=debug

Documentación

Primeros pasos

Configuración

Funciones

Referencia de CLI

API

Contribuciones

¡Damos la bienvenida a problemas, ideas de funciones y solicitudes de extracción!

Configuración de desarrollo

make dev-setup                # Install swag, frontend deps, Playwright
brew install prek             # Install pre-commit hook runner (or: uv tool install prek)
prek install                  # Install pre-commit hooks
prek install --hook-type pre-push  # Install pre-push hooks

Hooks de pre-commit

Usamos prek para detectar problemas antes de que lleguen a CI:

Hook	Etapa	Qué hace
`gofmt`	pre-commit	Formatea automáticamente los archivos Go en etapa de preparación
`trailing-whitespace`	pre-commit	Elimina espacios en blanco al final
`end-of-file-fixer`	pre-commit	Garantiza que los archivos terminen con nueva línea
`check-merge-conflict`	pre-commit	Detecta marcadores de conflicto de fusión
`swagger-verify`	pre-push	Falla si la especificación OpenAPI está desactualizada
`go-build`	pre-push	Verifica que el proyecto compile

Ejecuta los hooks manualmente: prek run --all-files

Compilación y pruebas

make build          # Build frontend + backend
make swagger        # Regenerate OpenAPI spec
make test           # Unit tests
make test-e2e       # E2E tests
make lint           # Run linters