Plugged.in MCP Server

offiziell

Ein umfassender Proxy, der mehrere MCP-Server zu einem einzigen MCP zusammenfasst. Er bietet die Erkennung und Verwaltung von Tools, Prompts, Ressourcen und Vorlagen über mehrere Server hinweg sowie eine Spielwiese zum Debuggen beim Erstellen von MCP-Servern.

GitHub

130

Dokumentation

plugged.in MCP Hub – Proxy · Wissen · Speicher · Werkzeuge

Die Kreuzung für KI-Datenaustausch

Ein einheitlicher MCP-Hub, der Ihrer KI Wissen, Speicher und Werkzeuge bereitstellt – nicht nur ein Proxy. Verwalten und testen Sie alle MCP-Server über eine einzige Verbindung und ermöglichen Sie dokumentenbewusste und speichererweiterte Workflows über verschiedene Clients hinweg.

📋 Übersicht

Der plugged.in MCP-Proxy-Server ist eine leistungsstarke Middleware, die mehrere Model Context Protocol (MCP)-Server in einer einzigen, einheitlichen Schnittstelle bündelt. Er ruft Werkzeug-, Prompt- und Ressourcenkonfigurationen von der plugged.in App ab und leitet Anfragen intelligent an die entsprechenden zugrunde liegenden MCP-Server weiter.

Dieser Proxy ermöglicht eine nahtlose Integration mit jedem MCP-Client (Claude, Cline, Cursor usw.) und bietet gleichzeitig erweiterte Verwaltungsfunktionen über das plugged.in-Ökosystem.

Hub-Säulen: Wissen · Speicher · Werkzeuge · Proxy

Wissen (RAG v2 / KI-Dokumentenaustausch)
Durchsuchen und untermauern Sie Modellausgaben mit einheitlicher, quellenbewusster Dokumentenabfrage. MCP-Server können Dokumente in Ihrer Bibliothek mit Versionierung, Sichtbarkeitskontrollen und Modellzuordnung erstellen und verwalten. Nutzen Sie das integrierte RAG, um über alle verbundenen Quellen hinweg zu suchen und relevante Ausschnitte sowie Metadaten zurückzugeben.

Speicher (Persistenter KI-Speicher)
Langlebiger, arbeitsbereichs-/profilbezogener Speicher, der Sitzungen überdauert. Der Hub integriert sich mit dem persistenten Speicher der plugged.in App, sodass Agentenaktionen und Erkenntnisse aufgabenübergreifend gespeichert und abgerufen werden können. Integrierte Speicherwerkzeuge sind auf der Roadmap, um reibungsarme get/put/search-Muster unter demselben Authentifizierungsmodell bereitzustellen.

Werkzeuge
Bündeln Sie integrierte Fähigkeiten mit nachgelagerten MCP-Servern (STDIO, SSE, Streamable HTTP). Die Werkzeugerkennung wird zwischengespeichert und kann bei Bedarf aktualisiert werden; die Erkennung auf Hub-Ebene liefert einen einheitlichen Katalog für jeden MCP-Client. Der Hub unterstützt Werkzeuge, Ressourcen, Ressourcenvorlagen und Prompts.

Proxy
Eine Verbindung für jeden Client. Ausführung als STDIO (Standard) oder Streamable HTTP mit optionaler API-Authentifizierung und zustandslosem Modus. Funktioniert mit Claude Desktop, Cline, Cursor, MCP Inspector und mehr; behalten Sie Ihre bestehenden Client-Konfigurationen bei, während Sie Richtlinien und Telemetrie zentralisieren.

⭐ Wenn Sie dieses Projekt nützlich finden, geben Sie ihm bitte einen Stern auf GitHub! Es hilft uns, mehr Entwickler zu erreichen, und motiviert uns, weiter zu verbessern.

✨ Hauptfunktionen

🚀 Kernfähigkeiten

Integrierter KI-Spielplatz: Testen Sie Ihre MCPs sofort mit Claude, Gemini, OpenAI und xAI ohne jegliche Client-Einrichtung
Universelle MCP-Kompatibilität: Funktioniert mit jedem MCP-Client, einschließlich Claude Desktop, Cline und Cursor
Multi-Server-Unterstützung: Verbinden Sie sich mit STDIO-, SSE- und Streamable-HTTP-MCP-Servern
Duale Transportmodi: Führen Sie den Proxy als STDIO (Standard) oder Streamable-HTTP-Server aus
Einheitliche Dokumentensuche: Durchsuchen Sie alle verbundenen Server mit integrierten RAG-Funktionen
KI-Dokumentenaustausch (RAG v2): MCP-Server können Dokumente in Ihrer Bibliothek mit vollständiger Quellenangabe erstellen und verwalten
Benachrichtigungen von jedem Modell: Erhalten Sie Echtzeit-Benachrichtigungen mit optionaler E-Mail-Zustellung
Multi-Workspace-Ebene: Wechseln Sie mit einem Klick zwischen verschiedenen MCP-Konfigurationen
API-gesteuerter Proxy: Ruft Fähigkeiten von plugged.in App-APIs ab, statt durch direkte Erkennung
Volle MCP-Unterstützung: Behandelt Werkzeuge, Ressourcen, Ressourcenvorlagen und Prompts
Benutzerdefinierte Anweisungen: Unterstützt serverspezifische Anweisungen, formatiert als MCP-Prompts

🎯 Neu in v1.5.0 (RAG v2 – KI-Dokumentenaustausch)

KI-Dokumentenerstellung: MCP-Server können jetzt Dokumente direkt in Ihrer Bibliothek erstellen
- Vollständige Nachverfolgung der Modellzuordnung (welche KI das Dokument erstellt/aktualisiert hat)
- Versionshistorie mit Änderungsverfolgung
- Inhaltsdeduplizierung mittels SHA-256-Hashing
- Unterstützung für mehrere Formate: MD, TXT, JSON, HTML, PDF und mehr
Erweiterte Dokumentensuche: Verbesserte RAG-Abfragen mit KI-Filterung
- Filtern nach KI-Modell, Anbieter, Datumsbereich, Tags und Quelltyp
- Semantische Suche mit Relevanzbewertung
- Automatische Ausschnittgenerierung mit Schlüsselworthervorhebung
- Unterstützung für Filterung: ai_generated, upload oder api Quellen
Dokumentenverwaltung via MCP:
- Dokumentensichtbarkeit festlegen: privat, Arbeitsbereich oder öffentlich
- Eltern-Kind-Beziehungen für Dokumentversionen
- Profilbasierte Organisation neben projektbezogener Eingrenzung
- Echtzeit-Fortschrittsverfolgung für die Dokumentenverarbeitung

🎯 Funktionen aus v1.4.0 (Registry v2-Unterstützung)

OAuth-Token-Verwaltung: Nahtlose OAuth-Authentifizierungsabwicklung für Streamable-HTTP-MCP-Server
- Automatischer Token-Abruf von der plugged.in App
- Sichere Token-Speicherung und Aktualisierungsmechanismen
- Keine clientseitige Authentifizierung erforderlich
Erweitertes Benachrichtigungssystem: Bidirektionale Benachrichtigungsunterstützung
- Senden Sie Benachrichtigungen an die plugged.in App
- Empfangen Sie Benachrichtigungen von MCP-Servern
- Markieren Sie Benachrichtigungen als gelesen/ungelesen
- Löschen Sie Benachrichtigungen programmgesteuert
Trend-Analysen: Echtzeit-Aktivitätsverfolgung
- Jeder Werkzeugaufruf wird protokolliert und verfolgt
- Trägt zu Trendberechnungen für Server bei
- Nutzungsmetriken und Beliebtheitseinblicke
Registry-Integration: Volle Unterstützung für Registry v2-Funktionen
- Automatische Servererkennung aus der Registry
- Installationsverfolgung und Metriken
- Community-Server-Unterstützung

📦 Funktionen aus v1.1.0

Streamable-HTTP-Unterstützung: Volle Unterstützung für nachgelagerte MCP-Server mit Streamable-HTTP-Transport
HTTP-Server-Modus: Führen Sie den Proxy als HTTP-Server mit konfigurierbaren Ports aus
Flexible Authentifizierung: Optionale Bearer-Token-Authentifizierung für HTTP-Endpunkte
Sitzungsverwaltung: Wählen Sie zwischen zustandsbehaftetem (sitzungsbasiertem) oder zustandslosem Betriebsmodus

🎯 Kernfunktionen aus v1.0.0

Echtzeit-Benachrichtigungen: Verfolgen Sie alle MCP-Aktivitäten mit umfassender Benachrichtigungsunterstützung
RAG-Integration: Unterstützung für dokumenterweiterte Abfragen über die plugged.in App
Inspektor-Skripte: Automatisierte Testwerkzeuge für Debugging und Entwicklung
Gesundheitsüberwachung: Integrierter Ping-Endpunkt zur Verbindungsüberwachung

🔧 Werkzeugkategorien

Der Proxy bietet zwei unterschiedliche Werkzeugkategorien:

🔧 Statische integrierte Werkzeuge (immer verfügbar)

Diese Werkzeuge sind in den Proxy integriert und funktionieren ohne jegliche Serverkonfiguration:

pluggedin_discover_tools - Intelligente Erkennung mit Caching für sofortige Ergebnisse
pluggedin_ask_knowledge_base - RAG-Suche in Ihren Dokumenten mit KI-Filterfunktionen
pluggedin_send_notification - Senden Sie Benachrichtigungen mit optionaler E-Mail-Zustellung
pluggedin_create_document - Erstellen Sie KI-generierte Dokumente in Ihrer Bibliothek
pluggedin_list_documents - Listen Sie Dokumente mit Filteroptionen auf
pluggedin_search_documents - Suchen Sie nach bestimmten Dokumenten per Abfrage
pluggedin_get_document - Rufen Sie den vollständigen Inhalt eines bestimmten Dokuments anhand der ID ab
pluggedin_update_document - Aktualisieren oder ergänzen Sie ein bestehendes Dokument

📋 Zwischenablage-Werkzeuge (Speichersystem)

pluggedin_clipboard_set - Setzen Sie einen Zwischenablageeintrag nach Name (semantischer Schlüssel) oder Index
pluggedin_clipboard_get - Rufen Sie Zwischenablageeinträge nach Name, Index ab oder listen Sie alle auf
pluggedin_clipboard_delete - Löschen Sie Zwischenablageeinträge nach Name, Index oder leeren Sie alle
pluggedin_clipboard_list - Listen Sie alle Zwischenablageeinträge mit Metadaten auf
pluggedin_clipboard_push - Fügen Sie einen Wert mit automatisch inkrementierendem Index hinzu (Stack-Push)
pluggedin_clipboard_pop - Entfernen Sie den Eintrag mit dem höchsten Index (LIFO-Verhalten)

⚡ Dynamische MCP-Werkzeuge (von verbundenen Servern)

Diese Werkzeuge stammen von Ihren konfigurierten MCP-Servern und können ein-/ausgeschaltet werden:

Datenbankwerkzeuge (PostgreSQL, SQLite usw.)
Dateisystemwerkzeuge
API-Integrationswerkzeuge
Benutzerdefinierte Werkzeuge von jedem MCP-Server

Das Erkennungswerkzeug zeigt intelligent beide Kategorien an und gibt KI-Modellen sofortigen Zugriff auf alle verfügbaren Fähigkeiten.

🚀 Nutzung des Erkennungswerkzeugs

# 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"})

Beispielantwort:

## 🔧 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
...

📋 Beispiele zur Nutzung der Zwischenablage

Das Zwischenablagesystem bietet persistenten Speicher für KI-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})

📚 RAG v2-Nutzungsbeispiele

Das erweiterte RAG v2-System ermöglicht MCP-Servern das Erstellen und Durchsuchen von Dokumenten mit vollständiger KI-Zuordnung:

# 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"
    }
  }
})

🚀 Schnellstart

Voraussetzungen

Node.js 18+ (empfohlen v20+)
Ein API-Schlüssel von der plugged.in App (erhältlich unter plugged.in/api-keys)

Installation

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

🔄 Upgrade auf v1.0.0

Für bestehende Installationen lesen Sie unseren Migrationsleitfaden für detaillierte Upgrade-Anweisungen.

# Quick upgrade
npx -y @pluggedin/[email protected] --pluggedin-api-key YOUR_API_KEY

Konfiguration für MCP-Clients

Claude Desktop

Fügen Sie Folgendes zu Ihrer Claude Desktop-Konfiguration hinzu:

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

Cline

Fügen Sie Folgendes zu Ihrer Cline-Konfiguration hinzu:

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

Cursor

Für Cursor können Sie Befehlszeilenargumente anstelle von Umgebungsvariablen verwenden:

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

⚙️ Konfigurationsoptionen

Umgebungsvariablen

Variable	Beschreibung	Erforderlich	Standard
`PLUGGEDIN_API_KEY`	API-Schlüssel von der plugged.in App	Ja	-
`PLUGGEDIN_API_BASE_URL`	Basis-URL für die plugged.in App	Nein	`https://plugged.in`

Befehlszeilenargumente

Befehlszeilenargumente haben Vorrang vor Umgebungsvariablen:

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

Transportoptionen

Option	Beschreibung	Standard
`--transport <type>`	Transporttyp: `stdio` oder `streamable-http`	`stdio`
`--port <number>`	Port für Streamable-HTTP-Server	`12006`
`--stateless`	Zustandslosen Modus für Streamable HTTP aktivieren	`false`
`--require-api-auth`	API-Schlüssel für Streamable-HTTP-Anfragen erforderlich	`false`

Für eine vollständige Liste der Optionen:

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

🌐 Streamable-HTTP-Modus

Der Proxy kann als HTTP-Server anstelle von STDIO ausgeführt werden und ermöglicht so webbasierten Zugriff und entfernte Verbindungen.

Grundlegende Nutzung

# 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

HTTP-Endpunkte

POST /mcp - MCP-Nachrichten senden
GET /mcp - Server-Sent-Events-Stream (optional)
DELETE /mcp - Sitzung beenden
GET /health - Gesundheitscheck-Endpunkt

Sitzungsverwaltung

Verwenden Sie im zustandsbehafteten Modus (Standard) den mcp-session-id-Header, um Sitzungen aufrechtzuerhalten:

# 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}'

Authentifizierung

Wenn Sie --require-api-auth verwenden, geben Sie Ihren API-Schlüssel als Bearer-Token an:

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}'

🐳 Docker-Nutzung

Sie können den Proxy-Server auch mit Docker erstellen und ausführen.

Image erstellen

Stellen Sie sicher, dass Docker installiert ist und ausgeführt wird. Navigieren Sie zum Verzeichnis pluggedin-mcp und führen Sie aus:

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

Eine .dockerignore-Datei ist enthalten, um den Build-Kontext zu optimieren.

Container ausführen

STDIO-Modus (Standard)

Führen Sie den Container im STDIO-Modus für MCP Inspector-Tests aus:

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

Streamable-HTTP-Modus

Führen Sie den Container als HTTP-Server aus:

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

Ersetzen Sie YOUR_API_KEY und YOUR_API_BASE_URL (falls nicht der Standard https://plugged.in verwendet wird).

Testen mit MCP Inspector

Während der Container läuft, können Sie sich mit dem MCP Inspector verbinden:

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

Dies verbindet sich mit der Standardeingabe/-ausgabe des laufenden Containers.

Container anhalten

Drücken Sie Ctrl+C im Terminal, in dem docker run ausgeführt wird. Das --rm-Flag stellt sicher, dass der Container beim Anhalten automatisch entfernt wird.

☁️ Smithery Cloud-Bereitstellung

Stellen Sie den plugged.in MCP-Proxy in der Smithery Cloud bereit, um gehosteten, stets verfügbaren Zugriff auf Ihre MCP-Server zu erhalten.

Schnellstart

Besuchen Sie smithery.ai und melden Sie sich an
Verbinden Sie Ihr GitHub-Konto und wählen Sie das pluggedin-mcp-Repository aus
Konfigurieren Sie Ihren Plugged.in-API-Schlüssel in der Smithery-Benutzeroberfläche
Stellen Sie den Dienst bereit und erhalten Sie Ihren HTTPS-Endpunkt

Vorteile

24/7-Verfügbarkeit: Ihr Proxy läuft immer
Keine Konfiguration: Smithery erkennt Einstellungen automatisch aus smithery.yaml
Automatische Skalierung: Bewältigt mehrere gleichzeitige Verbindungen
Webzugriff: Perfekt für Webanwendungen und entfernte Clients

Dokumentation

Vollständige Bereitstellungsanweisungen, Konfigurationsoptionen, Fehlerbehebung und technische Details finden Sie hier:

📖 Smithery-Bereitstellungsleitfaden

Autonome Agenten (Vorschau)

Der Hub ist darauf ausgelegt, agentische Schleifen durchgängig zu unterstützen:

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

Planen — Ziele und Einschränkungen ableiten, Aufgabengraphen bilden.
Handeln — Werkzeuge aus dem einheitlichen Katalog aufrufen; sicher über STDIO/SSE/HTTP-Server routen.
Reflektieren — Ergebnisse in Memory und Knowledge (Dokumente, Notizen, Artefakte) speichern, um nachfolgende Schritte zu verbessern.

Sicherheit & Betrieb
Aktivieren Sie --require-api-auth im Streamable-HTTP-Modus; verwenden Sie Zulassungslisten für Befehle, Argumente und Umgebungsvariablen. Kombinieren Sie serverseitige Validierung mit clientseitigen, gegen Prompt-Injection gehärteten Prompts. Nutzen Sie vorhandenes Logging/Telemetrie, um Werkzeugnutzung und Dokumentmutationen zu verfolgen.

🏗️ Systemarchitektur

Der plugged.in MCP-Proxy-Server fungiert als Brücke zwischen MCP-Clients und mehreren zugrunde liegenden MCP-Servern:

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

🔄 Arbeitsablauf

Konfiguration: Der Proxy ruft Serverkonfigurationen von der plugged.in-App ab
Intelligente Erkennung (pluggedin_discover_tools):
- Cache-Prüfung: Prüft zuerst auf vorhandene zwischengespeicherte Daten (< 1 Sekunde)
- Sofortige Antwort: Gibt statische Werkzeuge + zwischengespeicherte dynamische Werkzeuge sofort zurück
- Hintergrundaktualisierung: Für force_refresh=true wird die Erkennung im Hintergrund ausgeführt, während aktuelle Werkzeuge angezeigt werden
- Vollständige Erkennung: Führt nur dann eine vollständige Erkennung durch, wenn keine zwischengespeicherten Daten vorhanden sind
Fähigkeitsauflistung: Der Proxy ruft erkannte Fähigkeiten von den plugged.in-App-APIs ab
- tools/list: Ruft von /api/tools ab (enthält statische + dynamische Werkzeuge)
- resources/list: Ruft von /api/resources ab
- resource-templates/list: Ruft von /api/resource-templates ab
- prompts/list: Ruft von /api/prompts und /api/custom-instructions ab, führt Ergebnisse zusammen
Fähigkeitsauflösung: Der Proxy löst Fähigkeiten zu Zielservern auf
- tools/call: Parst Präfix aus Werkzeugname, schlägt Server in interner Zuordnung nach
- resources/read: Ruft /api/resolve/resource?uri=... auf, um Serverdetails zu erhalten
- prompts/get: Prüft auf benutzerdefiniertes Anweisungspräfix oder ruft /api/resolve/prompt?name=... auf
Anfrage-Routing: Anfragen werden an den entsprechenden zugrunde liegenden MCP-Server weitergeleitet
Antwortbehandlung: Antworten der zugrunde liegenden Server werden an den Client zurückgegeben

🔒 Sicherheitsfunktionen

Der plugged.in MCP-Proxy implementiert umfassende Sicherheitsmaßnahmen zum Schutz Ihres Systems und Ihrer Daten:

Eingabevalidierung und -bereinigung

Verhinderung von Befehlsinjektion: Alle Befehle und Argumente werden vor der Ausführung anhand von Zulassungslisten validiert
Sicherheit von Umgebungsvariablen: Sicheres Parsen von .env-Dateien mit korrekter Behandlung von Anführungszeichen und mehrzeiligen Werten
Token-Validierung: Starke Regex-Muster für API-Schlüssel und Authentifizierungstoken (32-64 Hex-Zeichen)

Netzwerksicherheit

SSRF-Schutz: URL-Validierung blockiert den Zugriff auf:
- Localhost- und Loopback-Adressen (127.0.0.1, ::1)
- Private IP-Bereiche (10.x, 172.16-31.x, 192.168.x)
- Link-lokale Adressen (169.254.x)
- Multicast- und reservierte Bereiche
- Häufige interne Dienstports (SSH, Datenbanken usw.)
Header-Validierung: Schutz vor Header-Injektion mit:
- Blockierung gefährlicher Header
- RFC 7230-konformer Header-Namensvalidierung
- Erkennung von Steuerzeichen
- Header-Größenbeschränkungen (max. 8 KB)
Ratenbegrenzung:
- Werkzeugaufrufe: 60 Anfragen pro Minute
- API-Aufrufe: 100 Anfragen pro Minute
Fehlerbereinigung: Verhindert Informationsweitergabe durch Bereinigung von Fehlermeldungen

Prozesssicherheit

Sichere Befehlsausführung: Verwendet execFile() anstelle von exec(), um Shell-Injektion zu verhindern
Befehls-Zulassungsliste: Erlaubt nur die Ausführung von:
- node, npx - Node.js-Befehle
- python, python3 - Python-Befehle
- uv, uvx, uvenv - UV-Python-Werkzeuge
Argumentbereinigung: Entfernt Shell-Metazeichen und Steuerzeichen aus allen Argumenten
Validierung von Umgebungsvariablen: Erlaubt nur alphanumerische Schlüssel mit Unterstrichen

Streamable-HTTP-Sicherheit

Lazy Authentication: Werkzeugerkennung erfordert keine Authentifizierung, was die Kompatibilität verbessert
Sitzungssicherheit: Kryptografisch sichere Generierung von Sitzungs-IDs
CORS-Schutz: Konfigurierbare CORS-Header für Webzugriff
Anfragegrößenbeschränkungen: Verhindert DoS durch große Nutzdaten

Sicherheitsdienstprogramme

Ein dediziertes security-utils.ts-Modul bietet:

Bearer-Token-Validierung
URL-Validierung mit SSRF-Schutz
Bereinigung von Befehlsargumenten
Validierung von Umgebungsvariablen
Implementierung der Ratenbegrenzung
Bereinigung von Fehlermeldungen

Detaillierte Informationen zur Sicherheitsimplementierung finden Sie unter SECURITY.md.

🧩 Integration mit der plugged.in-App

Der plugged.in MCP-Proxy-Server ist für die nahtlose Zusammenarbeit mit der plugged.in-App konzipiert, die Folgendes bietet:

Eine webbasierte Oberfläche zur Verwaltung von MCP-Serverkonfigurationen
Zentrale Fähigkeitserkennung (Werkzeuge, Ressourcen, Vorlagen, Prompts)
RAG v2-Dokumentbibliothek: Dokumente hochladen und KI-generierte Inhalte mit vollständiger Quellenangabe aktivieren
Verwaltung benutzerdefinierter Anweisungen
Multi-Workspace-Unterstützung für verschiedene Konfigurationssätze
Einen interaktiven Spielplatz zum Testen von MCP-Werkzeugen mit jedem KI-Modell
Benutzerauthentifizierung und API-Schlüsselverwaltung
KI-Dokumentenaustausch: Dokumente mit Nachverfolgung der Modellquellenangabe erstellen, suchen und verwalten

📚 Verwandte Ressourcen

🤝 Mitwirken

Beiträge sind willkommen! Bitte reichen Sie gerne einen Pull Request ein.

📝 Aktuelle Updates

Version 1.9.0 (September 2025) - Sicherheitsverbesserungen

🔒 Verbesserte HTML-Bereinigung

Branchenübliche Bereinigung: Ersetzte benutzerdefinierte regex-basierte HTML-Bereinigung durch die sanitize-html-Bibliothek
XSS-Prävention: Umfassender Schutz vor Cross-Site-Scripting-Angriffen
HTML-Attributsicherheit: Verbesserte Bereinigung für HTML-Attributkontexte (Anführungszeichen, kaufmännische Und-Zeichen)
Format-String-Injektion: Behobene Schwachstellen durch Format-String-Injektion im Logging
Sicherheitstests: Umfassende Testabdeckung für alle Bereinigungsfunktionen

🛡️ Sicherheitsverbesserungen

CodeQL-Konformität: Alle von der GitHub CodeQL-Analyse identifizierten Sicherheitslücken behoben
Eingabevalidierung: Verstärkte Eingabevalidierung und -bereinigung in allen Funktionen
Abhängigkeitsaktualisierungen: sanitize-html für robuste HTML-Inhaltsfilterung hinzugefügt
Testabdeckung: Erweiterte Sicherheitstestsuite mit Überprüfung der XSS-Angriffsprävention

Version 1.5.0 (Januar 2025) - RAG v2

🤖 KI-Dokumentenaustausch

KI-generierte Dokumente: MCP-Server können jetzt Dokumente in Ihrer Bibliothek mit vollständiger KI-Quellenangabe erstellen
Nachverfolgung der Modellquellenangabe: Vollständiger Verlauf, welche KI-Modelle jedes Dokument erstellt oder aktualisiert haben
Erweiterte Dokumentensuche: Filtern nach KI-Modell, Anbieter, Datum, Tags und Quelltyp
Dokumentversionierung: Änderungen verfolgen und Versionsverlauf für KI-generierte Inhalte pflegen
Multi-Source-Unterstützung: Dokumente aus Uploads, KI-Generierung oder API-Integrationen

🔍 Erweiterte RAG-Funktionen

Semantische Suche: Verbesserte Relevanzbewertung mit PostgreSQL-Volltextsuche
Intelligente Filterung: Ergebnisse nach Sichtbarkeit, Modellquellenangabe und Dokumentquelle filtern
Snippet-Generierung: Automatische Snippet-Extraktion mit Schlüsselworthervorhebung
Leistungsoptimierung: Schnellere Abfragen durch optimierte Indizierung

Version 1.2.0 (Januar 2025)

🔒 Sicherheitsverbesserungen

URL-Validierung: Umfassender SSRF-Schutz, der private IPs, Localhost und gefährliche Ports blockiert
Befehls-Zulassungsliste: Nur genehmigte Befehle (node, npx, python usw.) können ausgeführt werden
Header-Bereinigung: Schutz vor Header-Injektionsangriffen
Lazy Authentication: Verbesserte Smithery-Kompatibilität durch authentifizierungsfreie Werkzeugerkennung

🚀 Leistungsverbesserungen

Optimierte Docker-Builds: Multi-Stage-Builds für minimalen Container-Footprint
Nur Produktionsabhängigkeiten: Testdateien und Entwicklungsabhängigkeiten aus Docker-Images ausgeschlossen
Ressourceneffizienz: Konzipiert für die Bereitstellung in ressourcenbeschränkten Umgebungen

🔧 Technische Verbesserungen

Verbesserte Fehlerbehandlung im Streamable-HTTP-Transport
Bessere Sitzungsbereinigung und Speicherverwaltung
Verbesserte TypeScript-Typen und Codeorganisation

Version 1.1.0 (Dezember 2024)

🚀 Neue Funktionen

Streamable-HTTP-Unterstützung: Verbindung zu nachgelagerten MCP-Servern über den modernen Streamable-HTTP-Transport
HTTP-Servermodus: Betreiben Sie den Proxy als HTTP-Server für webbasierten Zugriff
Flexible Sitzungsverwaltung: Wählen Sie zwischen zustandslosem oder zustandsbehaftetem Modus
Authentifizierungsoptionen: Optionale Bearer-Token-Authentifizierung für HTTP-Endpunkte
Gesundheitsüberwachung: /health-Endpunkt für die Dienstüberwachung

🔧 Technische Verbesserungen

Aktualisiertes MCP SDK auf v1.13.1 für neueste Protokollunterstützung
Express.js-Integration für HTTP-Serverfunktionalität hinzugefügt
Erweiterte TypeScript-Typen für bessere Entwicklererfahrung

Version 1.0.0 (Juni 2025)

🎯 Hauptfunktionen

Echtzeit-Benachrichtigungssystem: Verfolgen Sie alle MCP-Aktivitäten mit umfassender Benachrichtigungsunterstützung
RAG-Integration: Unterstützung für dokumenterweiterte Abfragen über die plugged.in-App
Inspektor-Skripte: Neue automatisierte Testwerkzeuge für Debugging und Entwicklung
Gesundheitsüberwachung: Integrierter Ping-Endpunkt für die Verbindungsüberwachung

🔒 Sicherheitsverbesserungen

Eingabevalidierung: Branchenübliche Validierung und Bereinigung für alle Eingaben
URL-Sicherheit: Verbesserte URL-Validierung mit SSRF-Schutz
Umgebungssicherheit: Sicheres Parsen von Umgebungsvariablen mit dotenv
Fehlerbereinigung: Verhindert Informationsweitergabe in Fehlerantworten

🐛 Fehlerbehebungen

Behobene JSON-RPC-Protokollinterferenz (stdout vs. stderr-Trennung)
Aufgelöste Localhost-URL-Validierung für Entwicklungsumgebungen
Behobene API-Schlüsselbehandlung in Inspektor-Skripten
Verbesserte Verbindungsstabilität und Speicherverwaltung

🔧 Entwicklerwerkzeuge

Neue Inspektor-Skripte für automatisierte Tests
Verbesserte Fehlermeldungen und Debugging-Funktionen
Strukturiertes Logging mit korrekter stderr-Nutzung
Erweiterte TypeScript-Typsicherheit

Vollständige Details finden Sie in den Release Notes.

🧪 Testen und Entwicklung

Lokale Entwicklung

Tests sind für Entwicklungszwecke enthalten, werden jedoch aus Docker-Builds ausgeschlossen, um den Container-Footprint zu minimieren.

# Run tests locally
npm test
# or
./scripts/test-local.sh

# Run tests in watch mode
npm run test:watch

# Run tests with UI
npm run test:ui

Schlanke Docker-Builds

Das Docker-Image ist für minimalen Footprint optimiert:

Multi-Stage-Build-Prozess
Nur Produktionsabhängigkeiten im endgültigen Image
Testdateien und Entwicklungsabhängigkeiten ausgeschlossen
Optimiert für ressourcenbeschränkte Umgebungen

# Build optimized Docker image
docker build -t pluggedin-mcp .

# Check image size
docker images pluggedin-mcp

📄 Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert – siehe LICENSE-Datei für Details.

🙏 Danksagungen

Inspiriert vom MCP Proxy Server
Aufbauend auf dem Model Context Protocol