PluggedinMCP

by VeriTeknik

319 downloads

Not rated

GitHub

Description

# plugged.in MCP Proxy Server <div align="center"> <img src="https://plugged.in/_next/image?url=%2Fpluggedin-wl.png&w=256&q=75" alt="plugged.in Logo" width="256" height="75"> <h3>The Crossroads for AI Data Exchanges</h3> <p>A unified interface for managing all your MCP…

About

Details

Author: VeriTeknik
Downloads: 319
Categories: Developer Tools, API, Automation, Other

- Aggregates multiple MCP servers into one interface
- Supports both STDIO and WebSocket MCP servers
- Keeps servers organized with namespace prefixing
- Allows switching between workspace configurations
- Fetches capabilities from plugged.in App APIs
- Handles tools, resources, resource templates, and prompts

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name PluggedinMCP

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

From the repository

Install and run with npx -y @pluggedin/mcp-proxy@latest --pluggedin-api-key YOUR_API_KEY. Then configure your MCP client (e.g., Claude Desktop, Cline, Cursor) to use the proxy as a server, setting the PLUGGEDIN_API_KEY environment variable or via command-line argument. Docker builds are also supported.

`pluggedin_setup`

Get started with Plugged.in MCP - shows setup instructions and API key configuration (no API key required)

`pluggedin_discover_tools`

Triggers discovery of tools (and resources/templates) for configured MCP servers in the Pluggedin App.

`pluggedin_ask_knowledge_base`

Ask questions and get AI-generated answers from your knowledge base. Returns structured JSON with answer, document sources, and metadata.

`pluggedin_create_document`

Create and save AI-generated documents to the user's library in Plugged.in (requires API key)

`pluggedin_list_documents`

List documents with filtering options from the user's library (requires API key)

`pluggedin_search_documents`

Search for specific documents in your library. Returns document metadata (ID, title, snippet). To retrieve full content, use pluggedin_get_document with the returned document ID.

`pluggedin_get_document`

Retrieve a specific document's full content by ID. Use this after pluggedin_search_documents to get the complete content of documents you found. Set includeContent=true to get the full text.

`pluggedin_update_document`

Update or append to an existing AI-generated document (requires API key)

`pluggedin_send_notification`

Send custom notifications through the Plugged.in system with optional email delivery. You can provide a custom title or let the system use a localized default.

`pluggedin_list_notifications`

List notifications from the Plugged.in system with optional filters for unread only and result limit

`pluggedin_mark_notification_done`

Mark a notification as done in the Plugged.in system

`pluggedin_delete_notification`

Delete a notification from the Plugged.in system

`pluggedin_clipboard_set`

Set a clipboard entry by name (semantic key) or index (array-like). Named entries are upserted; indexed entries fail if index exists. Max 2MB per entry.

`pluggedin_clipboard_get`

Get clipboard entries. Specify name or idx for a single entry, or omit both to list all entries with pagination.

`pluggedin_clipboard_delete`

Delete clipboard entries by name, index, or clear all entries.

`pluggedin_clipboard_list`

List all clipboard entries with metadata. Image values are truncated to first 1000 chars for preview.

`pluggedin_clipboard_push`

Push a value to the indexed clipboard with auto-incrementing index. Useful for building ordered pipelines or stack-like operations.

`pluggedin_clipboard_pop`

Pop the highest-indexed entry from the clipboard (LIFO behavior). Returns the entry value and removes it.

`pluggedin_memory_session_start`

Start a new memory session to begin capturing observations. Returns a session UUID and memory_session_id for subsequent operations.

`pluggedin_memory_session_end`

End a memory session and trigger Z-report generation (AI-compressed session summary).

`pluggedin_memory_observe`

Record an observation during a memory session. Observations are classified by the Analytics Agent into memory ring types (procedures, practice, longterm, shocks).

`pluggedin_memory_search`

Search memories using semantic similarity. Returns lightweight results (50-150 tokens each) for token-efficient progressive disclosure. Use pluggedin_memory_details for full content.

`pluggedin_memory_details`

Get full details for selected memories (progressive disclosure Layer 3). Use after pluggedin_memory_search to retrieve complete content for specific memories.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "pluggedinmcp": {
            "PluggedinMCP": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pluggedin/pluggedin-mcp-proxy"
                ],
                "env": {
                    "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
                }
            }
        }
    }
}

McpServers

{
    "PluggedinMCP": {
        "command": "npx",
        "args": [
            "-y",
            "@pluggedin/pluggedin-mcp-proxy"
        ],
        "env": {
            "PLUGGEDIN_API_KEY": "<YOUR_PLUGGEDIN_API_KEY>"
        }
    }
}

A middleware that aggregates multiple Model Context Protocol (MCP) servers into a single unified interface.

plugged.in MCP Hub — Proxy · Knowledge · Memory · Tools

A unified MCP hub that gives your AIKnowledge,Memory, andTools— not just a proxy. Manage and test all MCP servers from a single connection while powering document-aware and memory-augmented workflows across clients.

The plugged.in MCP Proxy Server is a powerful middleware that aggregates multiple Model Context Protocol (MCP) servers into a single unified interface. It fetches tool, prompt, and resource configurations from theplugged.in Appand intelligently routes requests to the appropriate underlying MCP servers.

This proxy enables seamless integration with any MCP client (Claude, Cline, Cursor, etc.) while providing advanced management capabilities through the plugged.in ecosystem.

Hub Pillars: Knowledge · Memory · Tools · Proxy

Knowledge (RAG v2 / AI Document Exchange)
Search and ground model outputs with unified, attribution‑aware document retrieval. MCP servers can create and manage documents in your library with versioning, visibility controls, and model attribution. Use the built‑in RAG to search across all connected sources and return relevant snippets and metadata.

Memory (Persistent AI Memory)
Long‑lived, workspace/profile‑scoped memory that survives sessions. The hub integrates with the plugged.in App's persistent memory so agent actions and insights can be stored and recalled across tasks. Built‑in memory tools are on the roadmap to expose low‑frictionget/put/searchpatterns under the same auth model.

Tools
Aggregate built‑in capabilities with downstream MCP servers (STDIO, SSE, Streamable HTTP). Tool discovery is cached and can be refreshed on demand; hub‑level discovery returns a unified catalog for any MCP client. The hub supports tools, resources, resource templates, and prompts.

Proxy
One connection for every client. Run as STDIO (default) or Streamable HTTP with optional API auth and stateless mode. Works with Claude Desktop, Cline, Cursor, MCP Inspector, and more; keep your existing client configs while centralizing policies and telemetry.

⭐If you find this project useful, please consider giving it a star on GitHub!It helps us reach more developers and motivates us to keep improving.

- Built-in AI Playground: Test your MCPs instantly with Claude, Gemini, OpenAI, and xAI without any client setup
- Universal MCP Compatibility: Works with any MCP client including Claude Desktop, Cline, and Cursor
- Multi-Server Support: Connect to STDIO, SSE, and Streamable HTTP MCP servers
- Dual Transport Modes: Run proxy as STDIO (default) or Streamable HTTP server
- Unified Document Search: Search across all connected servers with built-in RAG capabilities
- AI Document Exchange (RAG v2): MCP servers can create and manage documents in your library with full attribution
- Notifications from Any Model: Receive real-time notifications with optional email delivery
- Multi-Workspace Layer: Switch between different sets of MCP configurations with one click
- API-Driven Proxy: Fetches capabilities from plugged.in App APIs rather than direct discovery
- Full MCP Support: Handles tools, resources, resource templates, and prompts
- Custom Instructions: Supports server-specific instructions formatted as MCP prompts

🎯 New in v1.5.0 (RAG v2 - AI Document Exchange)

- AI Document Creation: MCP servers can now create documents directly in your library

- Full model attribution tracking (which AI created/updated the document)
- Version history with change tracking
- Content deduplication via SHA-256 hashing
- Support for multiple formats: MD, TXT, JSON, HTML, PDF, and more

- Filter by AI model, provider, date range, tags, and source type
- Semantic search with relevance scoring
- Automatic snippet generation with keyword highlighting
- Support for filtering:ai_generated,upload, orapisources

- Set document visibility: private, workspace, or public
- Parent-child relationships for document versions
- Profile-based organization alongside project-based scoping
- Real-time progress tracking for document processing

🎯 Features from v1.4.0 (Registry v2 Support)

- OAuth Token Management: Seamless OAuth authentication handling for Streamable HTTP MCP servers

- Automatic token retrieval from plugged.in App
- Secure token storage and refresh mechanisms
- No client-side authentication needed

- Send notifications to plugged.in App
- Receive notifications from MCP servers
- Mark notifications as read/unread
- Delete notifications programmatically

- Every tool call is logged and tracked
- Contributes to trending server calculations
- Usage metrics and popularity insights

- Automatic server discovery from registry
- Installation tracking and metrics
- Community server support

- Streamable HTTP Support: Full support for downstream MCP servers using Streamable HTTP transport
- HTTP Server Mode: Run the proxy as an HTTP server with configurable ports
- Flexible Authentication: Optional Bearer token authentication for HTTP endpoints
- Session Management: Choose between stateful (session-based) or stateless operation modes

- Real-Time Notifications: Track all MCP activities with comprehensive notification support
- RAG Integration: Support for document-enhanced queries through the plugged.in App
- Inspector Scripts: Automated testing tools for debugging and development
- Health Monitoring: Built-in ping endpoint for connection monitoring

The proxy provides two distinct categories of tools:

🔧 Static Built-in Tools (Always Available)

These tools are built into the proxy and work without any server configuration:

- pluggedin_discover_tools- Smart discovery with caching for instant results
- pluggedin_ask_knowledge_base- RAG search across your documents with AI filtering capabilities
- pluggedin_send_notification- Send notifications with optional email delivery
- pluggedin_create_document- Create AI-generated documents in your library
- pluggedin_list_documents- List documents with filtering options
- pluggedin_search_documents- Search for specific documents by query
- pluggedin_get_document- Retrieve a specific document's full content by ID
- pluggedin_update_document- Update or append to an existing document

- pluggedin_clipboard_set- Set a clipboard entry by name (semantic key) or index
- pluggedin_clipboard_get- Get clipboard entries by name, index, or list all
- pluggedin_clipboard_delete- Delete clipboard entries by name, index, or clear all
- pluggedin_clipboard_list- List all clipboard entries with metadata
- pluggedin_clipboard_push- Push a value with auto-incrementing index (stack push)
- pluggedin_clipboard_pop- Pop the highest-indexed entry (LIFO behavior)

⚡ Dynamic MCP Tools (From Connected Servers)

These tools come from your configured MCP servers and can be turned on/off:

- Database tools (PostgreSQL, SQLite, etc.)
- File system tools
- API integration tools
- Custom tools from any MCP server

The discovery tool intelligently shows both categories, giving AI models immediate access to all available capabilities.

# Quick discovery - returns cached data instantly pluggedin_discover_tools() # Force refresh - shows current tools + runs background discovery pluggedin_discover_tools({"force_refresh": true}) # Discover specific server pluggedin_discover_tools({"server_uuid": "uuid-here"})

## 🔧 Static Built-in Tools (Always Available): 1. pluggedin_discover_tools - Smart discovery with caching 2. pluggedin_rag_query - RAG v2 search across documents with AI filtering 3. pluggedin_send_notification - Send notifications 4. pluggedin_create_document - (Coming Soon) Create AI-generated documents ## ⚡ Dynamic MCP Tools (8) - From Connected Servers: 1. query - Run read-only SQL queries 2. generate_random_integer - Generate secure random integers ...

The clipboard system provides persistent memory for AI workflows:

# Store a named entry (upserts if exists) pluggedin_clipboard_set({ "name": "customer_context", "value": "{\"name\": \"John Doe\", \"account_id\": \"12345\"}", "contentType": "application/json" }) # Store an indexed entry for ordered pipelines pluggedin_clipboard_set({ "idx": 0, "value": "First pipeline step result", "createdByTool": "data_processor" }) # Push to stack (auto-incrementing index) pluggedin_clipboard_push({ "value": "Analysis result from step 1", "contentType": "text/plain" }) # Get a specific entry by name pluggedin_clipboard_get({"name": "customer_context"}) # Pop from stack (LIFO - returns and removes highest index) pluggedin_clipboard_pop() # List all entries with metadata pluggedin_clipboard_list({"limit": 20}) # Delete specific entry pluggedin_clipboard_delete({"name": "customer_context"}) # Clear all clipboard entries pluggedin_clipboard_delete({"clearAll": true})

The enhanced RAG v2 system allows MCP servers to create and search documents with full AI attribution:

# Search for documents created by specific AI models pluggedin_rag_query({ "query": "system architecture", "filters": { "modelName": "Claude 3 Opus", "source": "ai_generated", "tags": ["technical"] } }) # Search across all document sources pluggedin_rag_query({ "query": "deployment guide", "filters": { "dateFrom": "2024-01-01", "visibility": "workspace" } }) # Future: Create AI-generated documents (Coming Soon) pluggedin_create_document({ "title": "Analysis Report", "content": "# Market Analysis\n\nDetailed findings...", "format": "md", "tags": ["analysis", "market"], "metadata": { "model": { "name": "Claude 3 Opus", "provider": "Anthropic" } } })

- Node.js 18+ (recommended v20+)
- An API key from the plugged.in App (get one atplugged.in/api-keys)

# Install and run with npx (latest v1.0.0) npx -y @pluggedin/pluggedin-mcp-proxy@latest --pluggedin-api-key YOUR_API_KEY

For existing installations, see our Migration Guidefor detailed upgrade instructions.

# Quick upgrade npx -y @pluggedin/pluggedin-mcp-proxy@1.0.0 --pluggedin-api-key YOUR_API_KEY

Add the following to your Claude Desktop configuration:

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

Add the following to your Cline configuration:

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

For Cursor, you can use command-line arguments instead of environment variables:

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

Command line arguments take precedence over environment variables:

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

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

The proxy can run as an HTTP server instead of STDIO, enabling web-based access and remote connections.

# Run as HTTP server on default port (12006) npx -y @pluggedin/pluggedin-mcp-proxy@latest --transport streamable-http --pluggedin-api-key YOUR_API_KEY # Custom port npx -y @pluggedin/pluggedin-mcp-proxy@latest --transport streamable-http --port 8080 --pluggedin-api-key YOUR_API_KEY # With authentication required npx -y @pluggedin/pluggedin-mcp-proxy@latest --transport streamable-http --require-api-auth --pluggedin-api-key YOUR_API_KEY # Stateless mode (new session per request) npx -y @pluggedin/pluggedin-mcp-proxy@latest --transport streamable-http --stateless --pluggedin-api-key YOUR_API_KEY

- POST /mcp- Send MCP messages
- GET /mcp- Server-sent events stream (optional)
- DELETE /mcp- Terminate session
- GET /health- Health check endpoint

In stateful mode (default), use themcp-session-idheader to maintain sessions:

# First request creates a session curl -X POST http://localhost:12006/mcp \ -H "Content-Type: application/json" \ -H "Accept: application/json, text/event-stream" \ -d '{"jsonrpc":"2.0","method":"tools/list","id":1}' # Subsequent requests use the same session curl -X POST http://localhost:12006/mcp \ -H "Content-Type: application/json" \ -H "Accept: application/json, text/event-stream" \ -H "mcp-session-id: YOUR_SESSION_ID" \ -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"tool_name"},"id":2}'

When using--require-api-auth, include your API key as a Bearer token:

curl -X POST http://localhost:12006/mcp \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -H "Accept: application/json, text/event-stream" \ -d '{"jsonrpc":"2.0","method":"ping","id":1}'

You can also build and run the proxy server using Docker.

Ensure you have Docker installed and running. Navigate to thepluggedin-mcpdirectory and run:

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

A.dockerignorefile is included to optimize the build context.

Run the container in STDIO mode for MCP Inspector testing:

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

docker run -d --rm \ -e PLUGGEDIN_API_KEY="YOUR_API_KEY" \ -e PLUGGEDIN_API_BASE_URL="YOUR_API_BASE_URL" \ -p 12006:12006 \ --name pluggedin-mcp-http \ pluggedin-mcp-proxy:latest \ --transport streamable-http --port 12006

ReplaceYOUR_API_KEYandYOUR_API_BASE_URL(if not using the defaulthttps://plugged.in).

While the container is running, you can connect to it using the MCP Inspector:

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

This will connect to the standard input/output of the running container.

PressCtrl+Cin the terminal wheredocker runis executing. The--rmflag ensures the container is removed automatically upon stopping.

Deploy the plugged.in MCP Proxy toSmithery Cloudfor hosted, always-available access to your MCP servers.

- 24/7 Availability: Your proxy is always running
- Zero Configuration: Smithery auto-detects settings fromsmithery.yaml
- Automatic Scaling: Handle multiple concurrent connections
- Web Access: Perfect for web applications and remote clients

For complete deployment instructions, configuration options, troubleshooting, and technical details, see:

The hub is designed to support agentic loops end‑to‑end:

MCP Client → plugged.in MCP Hub → (Plan → Act → Reflect) ↘ Knowledge ↘ Memory ↘ Tools

- Plan — derive goals and constraints, form task graphs.
- Act — call tools from the unified catalog; route safely across STDIO/SSE/HTTP servers.
- Reflect — persist outcomes into Memory and Knowledge (documents, notes, artifacts) to improve subsequent steps.

Safety & Ops
Enable--require-api-authin Streamable HTTP mode; use allowlists for commands, arguments, and env. Combine server‑level validation with client‑side prompts hardened against prompt‑injection. Leverage existing logging/telemetry to track tool usage and document mutations.

The plugged.in MCP Proxy Server acts as a bridge between MCP clients and multiple underlying MCP servers:

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 (Smart Caching) MCPClient ->> PluggedinMCP: Call pluggedin_discover_tools alt Cached data available PluggedinMCP ->> PluggedinApp: Check cached capabilities PluggedinApp ->> PluggedinMCP: Return cached tools/resources/prompts PluggedinMCP ->> MCPClient: Return instant results (static + dynamic) else Force refresh or no cache PluggedinMCP ->> PluggedinApp: Trigger background discovery PluggedinMCP ->> MCPClient: Return current tools + "discovery running" PluggedinApp ->> MCPServers: Connect and discover capabilities (background) MCPServers ->> PluggedinApp: Return fresh capabilities end end

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

Description

About

Details

Jump to

Setting up with Highlight

From the repository

pluggedin_setup

pluggedin_discover_tools

pluggedin_ask_knowledge_base

pluggedin_create_document

pluggedin_list_documents

pluggedin_search_documents

pluggedin_get_document

pluggedin_update_document

pluggedin_send_notification

pluggedin_list_notifications

pluggedin_mark_notification_done

pluggedin_delete_notification

pluggedin_clipboard_set

pluggedin_clipboard_get

pluggedin_clipboard_delete

pluggedin_clipboard_list

pluggedin_clipboard_push

pluggedin_clipboard_pop

pluggedin_memory_session_start

pluggedin_memory_session_end

pluggedin_memory_observe

pluggedin_memory_search

pluggedin_memory_details

Claude Desktop / Cursor

McpServers

plugged.in MCP Hub — Proxy · Knowledge · Memory · Tools

Hub Pillars: Knowledge · Memory · Tools · Proxy

🎯 New in v1.5.0 (RAG v2 - AI Document Exchange)

🎯 Features from v1.4.0 (Registry v2 Support)

🔧 Static Built-in Tools (Always Available)

⚡ Dynamic MCP Tools (From Connected Servers)

Install

More like this

@mendableai/firecrawl Mcp Server

Umut Naci

Playwright

Sentry

Github

Fetch

`pluggedin_setup`

`pluggedin_discover_tools`

`pluggedin_ask_knowledge_base`

`pluggedin_create_document`

`pluggedin_list_documents`

`pluggedin_search_documents`

`pluggedin_get_document`

`pluggedin_update_document`

`pluggedin_send_notification`

`pluggedin_list_notifications`

`pluggedin_mark_notification_done`

`pluggedin_delete_notification`

`pluggedin_clipboard_set`

`pluggedin_clipboard_get`

`pluggedin_clipboard_delete`

`pluggedin_clipboard_list`

`pluggedin_clipboard_push`

`pluggedin_clipboard_pop`

`pluggedin_memory_session_start`

`pluggedin_memory_session_end`

`pluggedin_memory_observe`

`pluggedin_memory_search`

`pluggedin_memory_details`