Plugged.in MCP Server

officiel

Un proxy complet qui combine plusieurs serveurs MCP en un seul MCP. Il offre la découverte et la gestion des outils, invites, ressources et modèles à travers les serveurs, ainsi qu’un espace de test pour le débogage lors de la construction de serveurs MCP.

GitHub

130

Documentation

plugged.in MCP Hub — Proxy · Connaissance · Mémoire · Outils

Le Carrefour des Échanges de Données IA

Un hub MCP unifié qui donne à votre IA Connaissance, Mémoire et Outils — pas seulement un proxy. Gérez et testez tous les serveurs MCP depuis une seule connexion tout en alimentant des flux de travail documentaires et augmentés par la mémoire à travers les clients.

📋 Aperçu

Le serveur proxy MCP plugged.in est un middleware puissant qui agrège plusieurs serveurs Model Context Protocol (MCP) en une interface unifiée unique. Il récupère les configurations d'outils, de prompts et de ressources depuis l'application plugged.in et route intelligemment les requêtes vers les serveurs MCP sous-jacents appropriés.

Ce proxy permet une intégration transparente avec n'importe quel client MCP (Claude, Cline, Cursor, etc.) tout en fournissant des capacités de gestion avancées via l'écosystème plugged.in.

Piliers du Hub : Connaissance · Mémoire · Outils · Proxy

Connaissance (RAG v2 / Échange de Documents IA)
Recherchez et ancrez les sorties des modèles avec une récupération de documents unifiée et sensible à l'attribution. Les serveurs MCP peuvent créer et gérer des documents dans votre bibliothèque avec gestion des versions, contrôles de visibilité et attribution du modèle. Utilisez le RAG intégré pour rechercher parmi toutes les sources connectées et renvoyer des extraits pertinents et des métadonnées.

Mémoire (Mémoire IA Persistante)
Mémoire persistante, à portée d'espace de travail/profil, qui survit aux sessions. Le hub s'intègre à la mémoire persistante de l'application plugged.in afin que les actions et les informations de l'agent puissent être stockées et rappelées d'une tâche à l'autre. Des outils de mémoire intégrés sont sur la feuille de route pour exposer des schémas get/put/search à faible friction sous le même modèle d'authentification.

Outils
Agrégez les capacités intégrées avec les serveurs MCP en aval (STDIO, SSE, HTTP Streamable). La découverte d'outils est mise en cache et peut être rafraîchie à la demande ; la découverte au niveau du hub renvoie un catalogue unifié pour tout client MCP. Le hub prend en charge les outils, les ressources, les modèles de ressources et les prompts.

Proxy
Une connexion pour chaque client. Fonctionne en STDIO (par défaut) ou en HTTP Streamable avec authentification API optionnelle et mode sans état. Compatible avec Claude Desktop, Cline, Cursor, MCP Inspector, et plus encore ; conservez vos configurations client existantes tout en centralisant les politiques et la télémétrie.

⭐ Si vous trouvez ce projet utile, pensez à lui attribuer une étoile sur GitHub ! Cela nous aide à atteindre plus de développeurs et nous motive à continuer à nous améliorer.

✨ Fonctionnalités Clés

🚀 Capacités Principales

Aire de Jeu IA Intégrée : Testez vos MCP instantanément avec Claude, Gemini, OpenAI et xAI sans aucune configuration client
Compatibilité MCP Universelle : Fonctionne avec n'importe quel client MCP, y compris Claude Desktop, Cline et Cursor
Support Multi-Serveur : Connectez-vous aux serveurs MCP STDIO, SSE et HTTP Streamable
Modes de Transport Doubles : Exécutez le proxy en tant que STDIO (par défaut) ou serveur HTTP Streamable
Recherche Documentaire Unifiée : Recherchez parmi tous les serveurs connectés avec des capacités RAG intégrées
Échange de Documents IA (RAG v2) : Les serveurs MCP peuvent créer et gérer des documents dans votre bibliothèque avec attribution complète
Notifications de N'importe Quel Modèle : Recevez des notifications en temps réel avec livraison optionnelle par e-mail
Couche Multi-Espace de Travail : Basculez entre différents ensembles de configurations MCP en un clic
Proxy Piloté par API : Récupère les capacités depuis les API de l'application plugged.in plutôt que par découverte directe
Support MCP Complet : Gère les outils, les ressources, les modèles de ressources et les prompts
Instructions Personnalisées : Prend en charge les instructions spécifiques au serveur formatées en tant que prompts MCP

🎯 Nouveautés de la v1.5.0 (RAG v2 - Échange de Documents IA)

Création de Documents IA : Les serveurs MCP peuvent désormais créer des documents directement dans votre bibliothèque
- Suivi complet de l'attribution du modèle (quelle IA a créé/mis à jour le document)
- Historique des versions avec suivi des modifications
- Déduplication du contenu via hachage SHA-256
- Prise en charge de multiples formats : MD, TXT, JSON, HTML, PDF, et plus
Recherche Documentaire Avancée : Requêtes RAG améliorées avec filtrage IA
- Filtrer par modèle IA, fournisseur, plage de dates, étiquettes et type de source
- Recherche sémantique avec score de pertinence
- Génération automatique d'extraits avec surlignage des mots-clés
- Prise en charge du filtrage : sources ai_generated, upload ou api
Gestion Documentaire via MCP :
- Définir la visibilité du document : privé, espace de travail ou public
- Relations parent-enfant pour les versions de documents
- Organisation basée sur le profil parallèlement à la portée basée sur le projet
- Suivi de la progression en temps réel pour le traitement des documents

🎯 Fonctionnalités de la v1.4.0 (Support Registre v2)

Gestion des Jetons OAuth : Gestion transparente de l'authentification OAuth pour les serveurs MCP HTTP Streamable
- Récupération automatique des jetons depuis l'application plugged.in
- Stockage sécurisé des jetons et mécanismes de rafraîchissement
- Aucune authentification côté client nécessaire
Système de Notification Amélioré : Support de notification bidirectionnelle
- Envoyer des notifications à l'application plugged.in
- Recevoir des notifications des serveurs MCP
- Marquer les notifications comme lues/non lues
- Supprimer les notifications par programmation
Analytiques de Tendance : Suivi d'activité en temps réel
- Chaque appel d'outil est journalisé et suivi
- Contribue aux calculs de tendance des serveurs
- Métriques d'utilisation et aperçus de popularité
Intégration du Registre : Support complet des fonctionnalités du Registre v2
- Découverte automatique des serveurs depuis le registre
- Suivi des installations et métriques
- Support des serveurs communautaires

📦 Fonctionnalités de la v1.1.0

Support HTTP Streamable : Support complet pour les serveurs MCP en aval utilisant le transport HTTP Streamable
Mode Serveur HTTP : Exécutez le proxy en tant que serveur HTTP avec des ports configurables
Authentification Flexible : Authentification optionnelle par jeton Bearer pour les points de terminaison HTTP
Gestion de Session : Choisissez entre des modes de fonctionnement avec état (basé sur la session) ou sans état

🎯 Fonctionnalités Principales de la v1.0.0

Notifications en Temps Réel : Suivez toutes les activités MCP avec un support de notification complet
Intégration RAG : Support pour les requêtes augmentées par documents via l'application plugged.in
Scripts Inspecteur : Outils de test automatisés pour le débogage et le développement
Surveillance de l'État : Point de terminaison ping intégré pour la surveillance de la connexion

🔧 Catégories d'Outils

Le proxy fournit deux catégories distinctes d'outils :

🔧 Outils Intégrés Statiques (Toujours Disponibles)

Ces outils sont intégrés au proxy et fonctionnent sans aucune configuration de serveur :

pluggedin_discover_tools - Découverte intelligente avec mise en cache pour des résultats instantanés
pluggedin_ask_knowledge_base - Recherche RAG dans vos documents avec capacités de filtrage IA
pluggedin_send_notification - Envoyer des notifications avec livraison optionnelle par e-mail
pluggedin_create_document - Créer des documents générés par IA dans votre bibliothèque
pluggedin_list_documents - Lister les documents avec options de filtrage
pluggedin_search_documents - Rechercher des documents spécifiques par requête
pluggedin_get_document - Récupérer le contenu complet d'un document spécifique par ID
pluggedin_update_document - Mettre à jour ou ajouter du contenu à un document existant

📋 Outils Presse-papiers (Système de Mémoire)

pluggedin_clipboard_set - Définir une entrée du presse-papiers par nom (clé sémantique) ou index
pluggedin_clipboard_get - Obtenir des entrées du presse-papiers par nom, index, ou toutes les lister
pluggedin_clipboard_delete - Supprimer des entrées du presse-papiers par nom, index, ou tout effacer
pluggedin_clipboard_list - Lister toutes les entrées du presse-papiers avec métadonnées
pluggedin_clipboard_push - Empiler une valeur avec index auto-incrémenté (empilement de pile)
pluggedin_clipboard_pop - Dépiler l'entrée à l'index le plus élevé (comportement LIFO)

⚡ Outils MCP Dynamiques (Depuis les Serveurs Connectés)

Ces outils proviennent de vos serveurs MCP configurés et peuvent être activés/désactivés :

Outils de base de données (PostgreSQL, SQLite, etc.)
Outils de système de fichiers
Outils d'intégration API
Outils personnalisés de n'importe quel serveur MCP

L'outil de découverte affiche intelligemment les deux catégories, donnant aux modèles IA un accès immédiat à toutes les capacités disponibles.

🚀 Utilisation de l'Outil de Découverte

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

Exemple de Réponse :

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

📋 Exemples d'Utilisation du Presse-papiers

Le système de presse-papiers fournit une mémoire persistante pour les flux de travail IA :

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

📚 Exemples d'Utilisation de RAG v2

Le système RAG v2 amélioré permet aux serveurs MCP de créer et de rechercher des documents avec une attribution IA complète :

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

🚀 Démarrage Rapide

Prérequis

Node.js 18+ (recommandé v20+)
Une clé API de l'application plugged.in (obtenez-en une sur 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

🔄 Mise à Niveau vers la v1.0.0

Pour les installations existantes, consultez notre Guide de Migration pour des instructions de mise à niveau détaillées.

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

Configuration pour les Clients MCP

Claude Desktop

Ajoutez ce qui suit à votre configuration Claude Desktop :

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

Cline

Ajoutez ce qui suit à votre configuration Cline :

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

Cursor

Pour Cursor, vous pouvez utiliser des arguments de ligne de commande au lieu de variables d'environnement :

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

⚙️ Options de Configuration

Variables d'Environnement

Variable	Description	Requis	Défaut
`PLUGGEDIN_API_KEY`	Clé API de l'application plugged.in	Oui	-
`PLUGGEDIN_API_BASE_URL`	URL de base pour l'application plugged.in	Non	`https://plugged.in`

Arguments de Ligne de Commande

Les arguments de ligne de commande prennent le pas sur les variables d'environnement :

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

Options de Transport

Option	Description	Défaut
`--transport <type>`	Type de transport : `stdio` ou `streamable-http`	`stdio`
`--port <number>`	Port pour le serveur HTTP Streamable	`12006`
`--stateless`	Activer le mode sans état pour HTTP Streamable	`false`
`--require-api-auth`	Exiger la clé API pour les requêtes HTTP Streamable	`false`

Pour une liste complète des options :

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

🌐 Mode HTTP Streamable

Le proxy peut fonctionner comme un serveur HTTP au lieu de STDIO, permettant un accès basé sur le web et des connexions à distance.

Utilisation de Base

# 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

Points de Terminaison HTTP

POST /mcp - Envoyer des messages MCP
GET /mcp - Flux d'événements envoyés par le serveur (optionnel)
DELETE /mcp - Terminer la session
GET /health - Point de terminaison de vérification de l'état

Gestion de Session

En mode avec état (par défaut), utilisez l'en-tête mcp-session-id pour maintenir les 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}'

Authentification

Lors de l'utilisation de --require-api-auth, incluez votre clé API en tant que jeton Bearer :

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

🐳 Utilisation avec Docker

Vous pouvez également construire et exécuter le serveur proxy en utilisant Docker.

Construction de l'Image

Assurez-vous que Docker est installé et en cours d'exécution. Naviguez vers le répertoire pluggedin-mcp et exécutez :

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

Un fichier .dockerignore est inclus pour optimiser le contexte de construction.

Exécution du Conteneur

Mode STDIO (Défaut)

Exécutez le conteneur en mode STDIO pour les tests avec MCP Inspector :

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

Mode HTTP Streamable

Exécutez le conteneur en tant que serveur HTTP :

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

Remplacez YOUR_API_KEY et YOUR_API_BASE_URL (si vous n'utilisez pas le défaut https://plugged.in).

Test avec MCP Inspector

Pendant que le conteneur est en cours d'exécution, vous pouvez vous y connecter en utilisant MCP Inspector :

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

Cela se connectera à l'entrée/sortie standard du conteneur en cours d'exécution.

Arrêt du Conteneur

Appuyez sur Ctrl+C dans le terminal où docker run s'exécute. Le drapeau --rm garantit que le conteneur est supprimé automatiquement à l'arrêt.

☁️ Déploiement Cloud Smithery

Déployez le proxy MCP plugged.in sur Smithery Cloud pour un accès hébergé et toujours disponible à vos serveurs MCP.

Démarrage Rapide

Visitez smithery.ai et connectez-vous
Connectez votre compte GitHub et sélectionnez le dépôt pluggedin-mcp
Configurez votre clé API Plugged.in dans l'interface Smithery
Déployez et obtenez votre point de terminaison HTTPS

Avantages

Disponibilité 24/7 : Votre proxy est toujours en cours d'exécution
Zéro Configuration : Smithery détecte automatiquement les paramètres depuis smithery.yaml
Mise à l'échelle automatique : Gérez plusieurs connexions simultanées
Accès Web : Parfait pour les applications web et les clients distants

Documentation

Pour des instructions de déploiement complètes, les options de configuration, le dépannage et les détails techniques, consultez :

📖 Guide de déploiement Smithery

Agents Autonomes (Aperçu)

Le hub est conçu pour prendre en charge les boucles agentiques de bout en bout :

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

Planifier — dériver des objectifs et des contraintes, former des graphes de tâches.
Agir — appeler des outils depuis le catalogue unifié ; router en toute sécurité à travers les serveurs STDIO/SSE/HTTP.
Réfléchir — persister les résultats dans la Mémoire et la Connaissance (documents, notes, artefacts) pour améliorer les étapes suivantes.

Sécurité & Opérations
Activez --require-api-auth en mode HTTP Diffusable ; utilisez des listes d'autorisation pour les commandes, les arguments et les variables d'environnement. Combinez la validation au niveau du serveur avec des invites côté client renforcées contre l'injection d'invite. Tirez parti de la journalisation/télémétrie existante pour suivre l'utilisation des outils et les mutations de documents.

🏗️ Architecture du Système

Le serveur proxy MCP plugged.in agit comme un pont entre les clients MCP et plusieurs serveurs MCP sous-jacents :

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

🔄 Flux de Travail

Configuration : Le proxy récupère les configurations de serveur depuis l'application plugged.in
Découverte Intelligente (pluggedin_discover_tools) :
- Vérification du Cache : Vérifie d'abord les données en cache existantes (< 1 seconde)
- Réponse Instantanée : Renvoie immédiatement les outils statiques + les outils dynamiques en cache
- Actualisation en Arrière-plan : Pour force_refresh=true, exécute la découverte en arrière-plan tout en affichant les outils actuels
- Découverte Fraîche : N'exécute une découverte complète que si aucune donnée en cache n'existe
Liste des Capacités : Le proxy récupère les capacités découvertes depuis les API de l'application plugged.in
- tools/list : Récupère depuis /api/tools (inclut les outils statiques + dynamiques)
- resources/list : Récupère depuis /api/resources
- resource-templates/list : Récupère depuis /api/resource-templates
- prompts/list : Récupère depuis /api/prompts et /api/custom-instructions, fusionne les résultats
Résolution des Capacités : Le proxy résout les capacités vers les serveurs cibles
- tools/call : Analyse le préfixe du nom de l'outil, recherche le serveur dans la carte interne
- resources/read : Appelle /api/resolve/resource?uri=... pour obtenir les détails du serveur
- prompts/get : Vérifie le préfixe d'instruction personnalisé ou appelle /api/resolve/prompt?name=...
Routage des Requêtes : Les requêtes sont routées vers le serveur MCP sous-jacent approprié
Gestion des Réponses : Les réponses des serveurs sous-jacents sont renvoyées au client

🔒 Fonctionnalités de Sécurité

Le proxy MCP plugged.in met en œuvre des mesures de sécurité complètes pour protéger votre système et vos données :

Validation et Assainissement des Entrées

Prévention des Injections de Commandes : Toutes les commandes et arguments sont validés par rapport à des listes d'autorisation avant exécution
Sécurité des Variables d'Environnement : Analyse sécurisée des fichiers .env avec gestion appropriée des guillemets et des valeurs multilignes
Validation des Jetons : Modèles regex robustes pour les clés API et les jetons d'authentification (32-64 caractères hexadécimaux)

Sécurité Réseau

Protection SSRF : La validation des URL bloque l'accès à :
- Adresses localhost et de bouclage (127.0.0.1, ::1)
- Plages IP privées (10.x, 172.16-31.x, 192.168.x)
- Adresses lien-local (169.254.x)
- Plages multicast et réservées
- Ports de services internes courants (SSH, bases de données, etc.)
Validation des En-têtes : Protection contre l'injection d'en-têtes avec :
- Blocage des en-têtes dangereux
- Validation des noms d'en-tête conforme à la RFC 7230
- Détection des caractères de contrôle
- Limites de taille d'en-tête (8 Ko max)
Limitation de Débit :
- Appels d'outils : 60 requêtes par minute
- Appels API : 100 requêtes par minute
Assainissement des Erreurs : Empêche la divulgation d'informations en assainissant les messages d'erreur

Sécurité des Processus

Exécution de Commandes Sûre : Utilise execFile() au lieu de exec() pour prévenir l'injection de shell
Liste d'Autorisation des Commandes : Permet uniquement l'exécution de :
- node, npx - Commandes Node.js
- python, python3 - Commandes Python
- uv, uvx, uvenv - Outils UV Python
Assainissement des Arguments : Supprime les métacaractères de shell et les caractères de contrôle de tous les arguments
Validation des Variables d'Environnement : Autorise uniquement les clés alphanumériques avec des underscores

Sécurité HTTP Diffusable

Authentification Paresseuse : La découverte d'outils ne nécessite pas d'authentification, améliorant la compatibilité
Sécurité de Session : Génération d'ID de session cryptographiquement sécurisée
Protection CORS : En-têtes CORS configurables pour l'accès web
Limites de Taille de Requête : Empêche le déni de service via des charges utiles volumineuses

Utilitaires de Sécurité

Un module dédié security-utils.ts fournit :

Validation du jeton Bearer
Validation d'URL avec protection SSRF
Assainissement des arguments de commande
Validation des variables d'environnement
Implémentation de la limitation de débit
Assainissement des messages d'erreur

Pour les détails d'implémentation de la sécurité, consultez SECURITY.md.

🧩 Intégration avec l'Application plugged.in

Le serveur proxy MCP plugged.in est conçu pour fonctionner de manière transparente avec l'application plugged.in, qui fournit :

Une interface web pour gérer les configurations de serveur MCP
Découverte centralisée des capacités (Outils, Ressources, Modèles, Invites)
Bibliothèque de documents RAG v2 : Téléchargez des documents et activez le contenu généré par IA avec attribution complète
Gestion des instructions personnalisées
Support multi-espace de travail pour différents ensembles de configuration
Un bac à sable interactif pour tester les outils MCP avec n'importe quel modèle d'IA
Authentification utilisateur et gestion des clés API
Échange de documents IA : Créez, recherchez et gérez des documents avec suivi d'attribution de modèle

📚 Ressources Associées

🤝 Contribuer

Les contributions sont les bienvenues ! N'hésitez pas à soumettre une Pull Request.

📝 Mises à Jour Récentes

Version 1.9.0 (Septembre 2025) - Améliorations de la Sécurité

🔒 Assainissement HTML Amélioré

Assainissement Standard de l'Industrie : Remplacement de l'assainissement HTML personnalisé basé sur les regex par la bibliothèque sanitize-html
Prévention XSS : Protection complète contre les attaques de script intersite
Sécurité des Attributs HTML : Assainissement amélioré pour les contextes d'attributs HTML (guillemets, esperluettes)
Injection de Chaîne de Format : Correction des vulnérabilités d'injection de chaîne de format dans la journalisation
Tests de Sécurité : Couverture de test complète pour toutes les fonctions d'assainissement

🛡️ Améliorations de la Sécurité

Conformité CodeQL : Résolution de toutes les vulnérabilités de sécurité identifiées par l'analyse GitHub CodeQL
Validation des Entrées : Validation et assainissement des entrées renforcés dans toutes les fonctions
Mises à Jour des Dépendances : Ajout de sanitize-html pour un filtrage robuste du contenu HTML
Couverture de Test : Suite de tests de sécurité améliorée avec vérification de la prévention des attaques XSS

Version 1.5.0 (Janvier 2025) - RAG v2

🤖 Échange de Documents IA

Documents Générés par IA : Les serveurs MCP peuvent désormais créer des documents dans votre bibliothèque avec attribution IA complète
Suivi d'Attribution de Modèle : Historique complet des modèles d'IA qui ont créé ou mis à jour chaque document
Recherche Avancée de Documents : Filtrez par modèle d'IA, fournisseur, date, étiquettes et type de source
Versionnage de Documents : Suivez les modifications et maintenez l'historique des versions pour le contenu généré par IA
Support Multi-Source : Documents provenant de téléchargements, de génération IA ou d'intégrations API

🔍 Capacités RAG Améliorées

Recherche Sémantique : Score de pertinence amélioré avec la recherche plein texte PostgreSQL
Filtrage Intelligent : Filtrez les résultats par visibilité, attribution de modèle et source de document
Génération d'Extraits : Extraction automatique d'extraits avec mise en évidence des mots-clés
Optimisation des Performances : Requêtes plus rapides avec une indexation optimisée

Version 1.2.0 (Janvier 2025)

🔒 Améliorations de la Sécurité

Validation d'URL : Protection SSRF complète bloquant les IP privées, localhost et les ports dangereux
Liste d'Autorisation des Commandes : Seules les commandes approuvées (node, npx, python, etc.) peuvent être exécutées
Assainissement des En-têtes : Protection contre les attaques d'injection d'en-têtes
Authentification Paresseuse : Compatibilité Smithery améliorée avec découverte d'outils sans authentification

🚀 Améliorations des Performances

Builds Docker Optimisés : Builds multi-étapes pour une empreinte de conteneur minimale
Dépendances de Production Uniquement : Fichiers de test et dépendances de développement exclus des images Docker
Efficacité des Ressources : Conçu pour le déploiement dans des environnements à ressources limitées

🔧 Améliorations Techniques

Gestion des erreurs améliorée dans le transport HTTP Diffusable
Meilleur nettoyage de session et gestion de la mémoire
Types TypeScript et organisation du code améliorés

Version 1.1.0 (Décembre 2024)

🚀 Nouvelles Fonctionnalités

Support HTTP Diffusable : Connectez-vous aux serveurs MCP en aval en utilisant le transport HTTP Diffusable moderne
Mode Serveur HTTP : Exécutez le proxy en tant que serveur HTTP pour un accès basé sur le web
Gestion Flexible des Sessions : Choisissez entre les modes sans état ou avec état
Options d'Authentification : Authentification par jeton Bearer optionnelle pour les points de terminaison HTTP
Surveillance de l'État : Point de terminaison /health pour la surveillance du service

🔧 Améliorations Techniques

Mise à jour du SDK MCP vers la v1.13.1 pour le support du dernier protocole
Ajout de l'intégration Express.js pour la fonctionnalité de serveur HTTP
Types TypeScript améliorés pour une meilleure expérience développeur

Version 1.0.0 (Juin 2025)

🎯 Fonctionnalités Majeures

Système de Notification en Temps Réel : Suivez toutes les activités MCP avec un support de notification complet
Intégration RAG : Support pour les requêtes enrichies de documents via l'application plugged.in
Scripts Inspecteur : Nouveaux outils de test automatisés pour le débogage et le développement
Surveillance de l'État : Point de terminaison ping intégré pour la surveillance de la connexion

🔒 Améliorations de la Sécurité

Validation des Entrées : Validation et assainissement standard de l'industrie pour toutes les entrées
Sécurité des URL : Validation d'URL améliorée avec protection SSRF
Sécurité de l'Environnement : Analyse sécurisée des variables d'environnement avec dotenv
Assainissement des Erreurs : Empêche la divulgation d'informations dans les réponses d'erreur

🐛 Corrections de Bugs

Correction de l'interférence du protocole JSON-RPC (séparation stdout vs stderr)
Résolution de la validation d'URL localhost pour les environnements de développement
Correction de la gestion des clés API dans les scripts inspecteur
Amélioration de la stabilité de la connexion et de la gestion de la mémoire

🔧 Outils de Développement

Nouveaux scripts inspecteur pour les tests automatisés
Messages d'erreur et capacités de débogage améliorés
Journalisation structurée avec utilisation appropriée de stderr
Sécurité de type TypeScript améliorée

Consultez les Notes de Version pour les détails complets.

🧪 Tests et Développement

Développement Local

Les tests sont inclus à des fins de développement mais sont exclus des builds Docker pour minimiser l'empreinte du conteneur.

# 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

Builds Docker Légers

L'image Docker est optimisée pour une empreinte minimale :

Processus de build multi-étapes
Uniquement les dépendances de production dans l'image finale
Fichiers de test et dépendances de développement exclus
Optimisé pour les environnements à ressources limitées

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

# Check image size
docker images pluggedin-mcp

📄 Licence

Ce projet est sous licence MIT - consultez le fichier LICENSE pour plus de détails.

🙏 Remerciements

Inspiré par le MCP Proxy Server
Construit sur le Model Context Protocol