Plugged.in MCP Server Proxy, Discovery & Playground

Overview

Plugged.in MCP Server acts as a unified proxy, discovery layer, and interactive playground for working with multiple Model Context Protocol (MCP) servers and their associated resources (prompts, templates, connectors, and metadata). Instead of managing disparate model endpoints, disparate prompt repositories, and ad-hoc debug workflows, Plugged.in centralizes discovery and routing so clients and developers can find, inspect, and exercise MCP-compatible services from one place.

This server is useful for teams that run multiple model endpoints (across environments, cloud providers, or model types) and need a single control plane for discovery, routing, and lightweight debugging. It exposes a discovery API, a proxy that forwards MCP requests to registered backends, and a playground UI for manual testing and prompt tuning.

Features

• Centralized discovery of MCP servers and their metadata
• Proxy routing to multiple MCP endpoints with simple identifiers
• Web-based playground for interactive request/response debugging
• Management and exposure of prompts, templates, and resource catalogs
• Environment-driven configuration and support for Docker deployment
• Lightweight access control and CORS-friendly behavior for local dev

Installation / Configuration

Prerequisites: Node.js (16+), Docker (optional)

Clone and install:

git clone https://github.com/VeriTeknik/pluggedin-mcp.git
cd pluggedin-mcp
npm install

Run locally:

# development
cp .env.example .env
# edit .env to register MCP targets or enable features
npm start

Example .env:

PORT=3000
ENABLE_PLAYGROUND=true
DISCOVERY_FILE=./discovery.json
LOG_LEVEL=info
CORS_ALLOWED_ORIGINS=*

Run with Docker:

# docker-compose.yml (example)
version: "3.8"
services:
  pluggedin-mcp:
    image: veriteknik/pluggedin-mcp:latest
    ports:
      - "3000:3000"
    environment:
      - PORT=3000
      - ENABLE_PLAYGROUND=true
      - DISCOVERY_FILE=/data/discovery.json
    volumes:
      - ./discovery.json:/data/discovery.json:ro

Start:

docker compose up -d

Configuration options (common env vars):

Available Resources

Plugged.in exposes a set of endpoints to view and manage available resources. Typical endpoints include:

• GET /api/discovery — list registered MCP servers and metadata
• GET /api/resources — list shared prompts, templates, and connectors
• GET /api/templates/:id — retrieve a specific template
• POST /api/proxy/:serverId/* — proxy an MCP request to the given server
• GET /playground — interactive UI for building and sending requests

Example discovery.json (static registration):

{
  "servers": [
    {
      "id": "local-gpt",
      "name": "Local GPT",
      "url": "http://localhost:8080/mcp",
      "description": "Local dev model"
    },
    {
      "id": "cloud-model",
      "name": "Cloud Model",
      "url": "https://api.cloud.example/mcp",
      "auth": "bearer"
    }
  ],
  "resources": {
    "prompts": ["customer_support", "product_summary"],
    "templates": ["email_followup", "summary_markdown"]
  }
}

Use Cases

• Prompt engineering and iteration: Open /playground, select a target MCP server, apply a template or prompt, and iterate on system/user/assistant turns while observing responses and model metadata.
• Multi-model orchestration: Use discovery to route requests to different MCP backends by id (e.g., canary vs. stable models) without changing client code — clients call /api/proxy/{id}/… instead of hardcoding URLs.
• Debugging and QA: Inspect headers, latency, and returned metadata from different MCP servers via the playground and discovery endpoints. Quickly reproduce bugs by replaying proxy requests.
• Resource sharing: Store and expose common prompt templates so teams can reuse tested prompts across projects. The /api/resources endpoint provides a single catalog for CI pipelines or admin UIs.
• Local development: Run a lightweight proxy that behaves like production MCP servers but points to local or mocked model instances for integration testing.

Examples

List discovered servers:

curl -s http://localhost:3000/api/discovery | jq

Proxy a request to server “local-gpt”:

curl -X POST http://localhost:3000/api/proxy/local-gpt/v1/generate \
  -H "Content-Type: application/json" \
  -d '{"input":"Write a short product description for a smart mug."}'

Use the playground:

• Visit http://localhost:3000/playground in a browser.
• Choose server (from discovery), select a template, edit the prompt, and send the request. View raw response and timing information.

Tips & Security

• Protect discovery and proxy endpoints behind authentication in production (reverse proxy or API gateway).
• When storing discovery.json in source control, avoid embedding sensitive credentials; use runtime secrets or environment variables instead.
• Limit allowed origins via CORS_ALLOWED_ORIGINS to prevent unauthorized browser-based requests.
• For CI workflows, use the resources endpoints to programmatically fetch templates and run validations against your MCP backends.

For full source, issues, and contribution guidelines, see the GitHub repository: https://github.com/VeriTeknik/pluggedin-mcp.