Servidor proxy MCP enchufado

📋 Descripción general

El servidor proxy MCP de plugged.in es un potente middleware que integra varios servidores MCP (Protocolo de Contexto de Modelo) en una única interfaz unificada. Obtiene las configuraciones de herramientas, indicaciones y recursos de la aplicación de plugged.in y enruta las solicitudes de forma inteligente a los servidores MCP subyacentes correspondientes.

Este proxy permite una integración perfecta con cualquier cliente MCP (Claude, Cline, Cursor, etc.) al tiempo que proporciona capacidades de gestión avanzadas a través del ecosistema plugged.in.

Related MCP server: mcp-server-collector

✨ Características principales

Compatibilidad universal con MCP : funciona con cualquier cliente MCP, incluidos Claude Desktop, Cline y Cursor
Compatibilidad con múltiples servidores : conecte servidores MCP STDIO (línea de comandos) y WebSocket (basados en HTTP)
Aislamiento del espacio de nombres : mantenga los MCP unidos separados y organizados con el prefijo adecuado
Capa de múltiples espacios de trabajo : cambie entre diferentes conjuntos de configuraciones de MCP con un solo clic
Arquitectura simplificada : base de código optimizada con tiempo de inicio mejorado y complejidad reducida
Proxy impulsado por API : obtiene capacidades de las API de aplicaciones conectadas en lugar del descubrimiento directo
Soporte completo para MCP : maneja herramientas, recursos, plantillas de recursos y avisos
Instrucciones personalizadas : admite instrucciones específicas del servidor formateadas como indicaciones MCP

🚀 Inicio rápido

Prerrequisitos

Node.js 18+ (recomendado v20+)
Una clave API de la aplicación plugged.in (obtenga una en plugged.in/api-keys )

Instalación

# Install and run with npx
npx -y @pluggedin/mcp-proxy@latest --pluggedin-api-key YOUR_API_KEY

Configuración para clientes MCP

Escritorio de Claude

Agregue lo siguiente a su configuración de Claude Desktop:

{
  "mcpServers": {
    "pluggedin": {
      "command": "npx",
      "args": ["-y", "@pluggedin/mcp-proxy@latest"],
      "env": {
        "PLUGGEDIN_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Cline

Agregue lo siguiente a su configuración de Cline:

{
  "mcpServers": {
    "pluggedin": {
      "command": "npx",
      "args": ["-y", "@pluggedin/mcp-proxy@latest"],
      "env": {
        "PLUGGEDIN_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Cursor

Para Cursor, puede utilizar argumentos de línea de comandos en lugar de variables de entorno:

npx -y @pluggedin/mcp-proxy@latest --pluggedin-api-key YOUR_API_KEY

⚙️ Opciones de configuración

Variables de entorno

Variable	Descripción	Requerido	Por defecto
`PLUGGEDIN_API_KEY`	Clave API de la aplicación plugged.in	Sí	-
`PLUGGEDIN_API_BASE_URL`	URL base para la aplicación plugged.in	No	`https://plugged.in`

Argumentos de la línea de comandos

Los argumentos de la línea de comandos tienen prioridad sobre las variables de entorno:

npx -y @pluggedin/mcp-proxy@latest --pluggedin-api-key YOUR_API_KEY --pluggedin-api-base-url https://your-custom-url.com

Para obtener una lista completa de opciones:

npx -y @pluggedin/mcp-proxy@latest --help

🐳 Uso de Docker

También puedes construir y ejecutar el servidor proxy usando Docker.

Construyendo la imagen

Asegúrate de tener Docker instalado y en ejecución. Accede al directorio pluggedin-mcp y ejecuta:

docker build -t pluggedin-mcp-proxy:latest .

Se incluye un archivo .dockerignore para optimizar el contexto de compilación.

Ejecución del contenedor

Ejecute el contenedor, proporcionando las variables de entorno necesarias:

docker run -it --rm \
  -e PLUGGEDIN_API_KEY="YOUR_API_KEY" \
  -e PLUGGEDIN_API_BASE_URL="YOUR_API_BASE_URL" \
  --name pluggedin-mcp-container \
  pluggedin-mcp-proxy:latest

Reemplace YOUR_API_KEY y YOUR_API_BASE_URL (si no usa el valor predeterminado https://plugged.in ).

Pruebas con MCP Inspector

Mientras el contenedor esté en ejecución, puedes conectarte a él mediante el Inspector MCP:

npx @modelcontextprotocol/inspector docker://pluggedin-mcp-container

Esto se conectará a la entrada/salida estándar del contenedor en ejecución.

Detener el contenedor

Presione Ctrl+C en la terminal donde se ejecuta docker run . El indicador --rm garantiza que el contenedor se elimine automáticamente al detenerse.

🏗️ Arquitectura del sistema

El servidor proxy MCP conectado actúa como un puente entre los clientes MCP y varios servidores MCP subyacentes:

sequenceDiagram
    participant MCPClient as MCP Client (e.g. Claude Desktop)
    participant PluggedinMCP as plugged.in MCP Proxy
    participant PluggedinApp as plugged.in App
    participant MCPServers as Underlying MCP Servers

    MCPClient ->> PluggedinMCP: Request list tools/resources/prompts
    PluggedinMCP ->> PluggedinApp: Get capabilities via API
    PluggedinApp ->> PluggedinMCP: Return capabilities (prefixed)

    MCPClient ->> PluggedinMCP: Call tool/read resource/get prompt
    alt Standard capability
        PluggedinMCP ->> PluggedinApp: Resolve capability to server
        PluggedinApp ->> PluggedinMCP: Return server details
        PluggedinMCP ->> MCPServers: Forward request to target server
        MCPServers ->> PluggedinMCP: Return response
    else Custom instruction
        PluggedinMCP ->> PluggedinApp: Get custom instruction
        PluggedinApp ->> PluggedinMCP: Return formatted messages
    end
    PluggedinMCP ->> MCPClient: Return response

    alt Discovery tool
        MCPClient ->> PluggedinMCP: Call pluggedin_discover_tools
        PluggedinMCP ->> PluggedinApp: Trigger discovery action
        PluggedinApp ->> MCPServers: Connect and discover capabilities
        MCPServers ->> PluggedinApp: Return capabilities
        PluggedinApp ->> PluggedinMCP: Confirm discovery complete
        PluggedinMCP ->> MCPClient: Return discovery result
    end

🔄 Flujo de trabajo

Configuración : El proxy obtiene las configuraciones del servidor desde la aplicación conectada
Listado de capacidades : el proxy obtiene las capacidades descubiertas de las API de la aplicación conectada.
- tools/list : Obtiene de /api/tools (devuelve nombres con prefijo)
- resources/list : Obtiene de /api/resources
- resource-templates/list : Obtiene datos de /api/resource-templates
- prompts/list : Obtiene de /api/prompts y /api/custom-instructions , fusiona los resultados
Resolución de capacidad : el proxy resuelve las capacidades a los servidores de destino
- tools/call : analiza el prefijo del nombre de la herramienta y busca el servidor en el mapa interno
- resources/read : llama a /api/resolve/resource?uri=... para obtener detalles del servidor
- prompts/get : busca prefijos de instrucciones personalizados o llama a /api/resolve/prompt?name=...
Enrutamiento de solicitudes : las solicitudes se enrutan al servidor MCP subyacente apropiado
Manejo de respuestas : las respuestas de los servidores subyacentes se devuelven al cliente.

🧩 Integración con la aplicación plugged.in

El servidor proxy MCP plugged.in está diseñado para funcionar sin problemas con la aplicación plugged.in , que proporciona:

Una interfaz basada en web para administrar las configuraciones del servidor MCP
Descubrimiento centralizado de capacidades (herramientas, recursos, plantillas, indicaciones)
Gestión de instrucciones personalizadas
Compatibilidad con múltiples espacios de trabajo para diferentes conjuntos de configuraciones
Un patio de juegos interactivo para probar herramientas MCP
Autenticación de usuarios y gestión de claves API

Recursos relacionados

🤝 Contribuyendo

¡Agradecemos sus contribuciones! No dude en enviar una solicitud de incorporación de cambios.

📄 Licencia

Este proyecto está licenciado bajo la licencia MIT: consulte el archivo de LICENCIA para obtener más detalles.

🙏 Agradecimientos

Inspirado en el servidor proxy MCP
Construido sobre el Protocolo de Contexto Modelo

pluggedin-mcp-proxy