[!IMPORTANT]
Project status (October 2026): open source, community-driven.
plugged.in, the hosted service, is moving to a new, separately developed platform. After that move,
this repository will no longer run plugged.in. The code stays open source under its current license, and the
community is welcome to carry it on: issues, pull requests, forks and new maintainers are welcome, and
self-hosting remains supported. The cutover date will be announced here. At the cutover, the current service
moves to v1.plugged.in and keeps running there until December 31, 2026.
The Crossroads for AI Data Exchanges. A unified, self-hostable web interface for discovering, configuring, and managing Model Context Protocol (MCP) servers—bringing together AI tools, workspaces, prompts, and logs from multiple MCP sources (Claude, Cursor, etc.) under one roof.
🧩 Now Multi‑Arch Ready!
Plugged.in Docker images support both amd64 and arm64 architectures via a unified manifest.
🧭 v4.0.0 — Hubs, a hosted MCP connector, and a security pass:
Workspaces are Hubs now, one Workspace per Hub. /api/mcp serves a hosted connector behind an OAuth 2.1 server. Five reported advisories fixed and credited.
🎯 The Problem We Solve
Every day, you have brilliant conversations with AI - strategy sessions with GPT-4, code reviews with Claude, analysis with Gemini. But when you close that chat window, all that knowledge vanishes. This is the "AI knowledge evaporation" problem.
💡 The Solution
plugged.in is the world's first AI Content Management System (AI-CMS) - a platform that transforms ephemeral AI interactions into persistent, versioned, and searchable organizational knowledge.
Think of it as "Git for AI-generated content" meets "WordPress for AI interactions".
✨ What Makes plugged.in Special
🧠 AI Memory That Persists
Your AI conversations become permanent assets. Every document is versioned, attributed, and searchable.
🤝 Multi-Model Collaboration
Claude writes v1, GPT-4 adds technical specs in v2, Gemini refines in v3 - all tracked and attributed.
🔌 Universal MCP Integration
Works with 1,500+ MCP servers. Connect any tool, any AI, any workflow - all through one interface.
🔒 Enterprise-Grade Security
End-to-end encryption, OAuth 2.1, rate limiting, and sandboxed execution for your peace of mind.
📊 Real Platform Statistics
Documents Managed: 90+ (72% AI-generated)
Integrated MCP Servers: 1,568
Active Versioning: Documents with up to 4 iterations
Model Attributions: 17 different AI models tracked
RAG Engine: Embedded zvec (RocksDB + HNSW) — zero external dependencies
Search Performance: Sub-second semantic search with cosine similarity
Security: AES-256-GCM encryption, Redis rate limiting
🚀 Quick Start
Docker (Recommended - 2 minutes)
Self-hosting builds the image locally
The default docker-compose.ymlbuilds the app image from source (./Dockerfile) for your platform. There is intentionally no prebuilt self-host image: the embedded zvec vector engine needs build-time flags/bindings that a generic registry image can't carry, so the image is compiled locally with the right supportedArchitectures configuration.
The first docker compose up --build takes roughly 10–15 minutes (installing dependencies + next build). Subsequent starts are instant — the image is cached. Requirements: Docker with BuildKit (Docker Desktop, or docker buildx) and at least ~8 GB of memory allotted to the Docker engine — next build is memory-hungry and will abort with "JavaScript heap out of memory" on smaller limits (raise it in Docker Desktop → Settings → Resources).
# Clone and setup
git clone https://github.com/VeriTeknik/pluggedin-app.git
cd pluggedin-app
cp .env.example .env
# Edit .env and set these three. Compose refuses to start without the last two,
# so there is no way to end up running with a password this repository knows.
# NEXTAUTH_SECRET=$(openssl rand -base64 32)
# POSTGRES_PASSWORD=$(openssl rand -hex 32)
# REDIS_PASSWORD=$(openssl rand -hex 32)
#
# Use hex (or another URL-safe value) for the last two: they are interpolated
# into a postgresql:// / redis:// URL, so @ : / ? # would corrupt it.
# Compose builds DATABASE_URL and REDIS_URL from them — leave those alone.
# Build the app image and start the full stack (PostgreSQL 18 + pgvector,
# Redis, one-shot migration, then the app):
docker compose up --build -d
# Follow startup (migration runs first, then the app becomes healthy):
docker compose logs -f pluggedin-app
# Visit http://localhost:12005
Useful commands:
docker compose ps # service status
docker compose run --rm pluggedin-migrate # re-run database migrations
docker compose down # stop (keeps data)
docker compose down -v # stop + wipe all volumes
Production / hosted deployments use a different file — this docker-compose.yml is the self-host default, not the production stack:
docker-compose.production.yml — pulls the prebuilt veriteknik/pluggedin image (the hosted/cloud build)
infra/docker-compose.yml — the Traefik + SOPS production stack used by plugged.in
What's included:
✅ PostgreSQL 18 with pgvector extension for vector search
✅ Redis 7 for rate limiting / caching
✅ Embedded zvec vector engine for RAG (no external Milvus/Qdrant needed)
✅ Next.js 15 web application with optimized production build
✅ Persistent volumes for database, uploads, vectors, and logs
✅ Health checks and automatic restarts
Docker Architecture:
Services:
- pluggedin-migrate: One-shot DB migration; reuses the app image, then exits
- pluggedin-app: Main web application (host port 12005 → container 3000),
starts only after migration completes successfully
- pluggedin-postgres: PostgreSQL 18 + pgvector database (port 5432)
- pluggedin-redis: Redis 7 (port 6379)
Volumes:
- pluggedin-postgres: Database data (persistent)
- pluggedin-redis: Redis append-only data (persistent)
- zvec-data: Vector collections (persistent)
- app-uploads: User uploaded files (persistent)
- app-logs: Application logs (persistent)
- mcp-cache: MCP package cache (persistent)
Upgrading from older versions:
# If upgrading from PostgreSQL 16 or earlier
# Option 1: Fresh start (data loss)
docker compose down -v && docker compose up --build -d
# Option 2: Migrate existing data
docker exec pluggedin-postgres pg_dump -U pluggedin pluggedin > backup.sql
docker compose down -v
docker compose up -d
docker exec -i pluggedin-postgres psql -U pluggedin -d pluggedin < backup.sql
Cloud Version
Visit plugged.in for instant access - no installation required.
Multi-Hub Architecture: Organize projects into separate hubs
Workspace Isolation: Each hub contains multiple isolated workspaces
Smart Hub Switching: Automatic workspace selection when switching hubs
Data Scoping: Hub-level and workspace-level data isolation
Current Hub Display: Dashboard shows active hub for context awareness
📋 Clipboard & Memory System
Named Entries: Store key-value pairs with semantic names (e.g., customer_context, last_analysis)
Indexed Entries: Array-like storage with auto-incrementing indices for ordered data
Stack Operations: Push/pop functionality for LIFO workflows and pipelines
Rich Content Support: Store text, JSON, images (base64), and any content type up to 2MB
TTL Expiration: Optional time-to-live for automatic cleanup of temporary data
Visibility Controls: Private, workspace, or public visibility per entry
Model Attribution: Track which AI model created each clipboard entry
MCP Integration: Access clipboard via 6 built-in MCP tools from any AI client
🏗️ Architecture
Architecture Overview
plugged.in acts as the central hub connecting various AI clients, development tools, and programming languages with your knowledge base and the broader MCP ecosystem. The architecture is designed for maximum flexibility and extensibility.
🟢 Production-Ready Integrations (Solid Lines)
MCP Proxy Interface
The MCP Proxy serves as a unified gateway that aggregates multiple MCP servers into a single interface:
Claude Code - Official Anthropic CLI for Claude with native MCP support
Cline - VS Code extension for AI-assisted development
LM Studio - Local model execution with MCP integration
Claude Desktop - Anthropic's desktop application
How it works: Each AI client connects via STDIO, receiving access to all your configured MCP servers through one connection. The proxy handles:
Tool prefixing to prevent namespace conflicts
OAuth authentication for MCP servers
Activity logging and notifications
Unified error handling
SDK Support - Multi-Language Integration
Direct programmatic access through official SDKs:
JavaScript/TypeScript SDK (@pluggedin/sdk) - Full-featured SDK for Node.js and browser
Python SDK (pluggedin-sdk) - Pythonic interface for AI workflows
Go SDK (pluggedin-go) - High-performance Go implementation
In-process vector search via zvec (RocksDB + HNSW) — no external services
Automatic PDF/text chunking, embedding, and indexing
Project-scoped isolation with per-field filter validation
Sub-second cosine similarity search
Document Store
Version control for AI-generated content
Multi-model attribution tracking
Content hash deduplication
Support for uploads, AI-generated, and API sources
MCP Registry
1,500+ curated MCP servers
GitHub verification and claiming
Install tracking and trending
Auto-discovery from npm, GitHub, Smithery
Tools Management
Discover tools from all connected servers
Test tools in interactive playground
Custom instructions per server
Real-time debugging logs
🟡 In Development (Dashed Lines)
Native Connectors
Direct integrations bypassing the MCP Proxy for enhanced performance:
Plugged.in Connector for Claude Desktop - Native plugin architecture
Plugged.in Connector for ChatGPT - OpenAI plugin integration
Mobile App - iOS and Android native apps
Why Native Connectors?
Faster response times (no proxy overhead)
Richer UI integration
Platform-specific features
Offline capabilities
Advanced Memory System
Persistent memory across sessions:
Knowledge + Memory boxes in the diagram represent:
Session continuity across different AI clients
Automatic context injection based on conversation history
Cross-model memory sharing (Claude remembers what GPT discussed)
Smart context pruning to stay within token limits
Example Workflow:
Discuss architecture with Claude Desktop → Memory saved
Switch to ChatGPT connector → Previous context automatically available
Mobile app accesses same conversation history
RAG provides relevant documents automatically
📊 Data Flow Example
User Request Flow:
1. User asks question in Claude Desktop
2. MCP Proxy receives request
3. Proxy checks RAG for relevant context
4. Combines context + user question
5. Routes to appropriate MCP servers
6. Aggregates responses
7. Logs activity to database
8. Returns enriched response to user
Document Creation Flow:
1. AI generates document via SDK or user uploads PDF/text
2. Content processed, chunked, and sanitized
3. Model attribution recorded
4. Version created in Document Store
5. Chunks stored in PostgreSQL, embeddings indexed in zvec
6. Document searchable immediately via semantic search
Latest Release: v4.0.0 — Hubs, a hosted MCP connector, and a security pass
🎯 What's New in v4.0.0
Major by Semantic Versioning: two features were removed and the data model under
Hubs changed.
🧭 Workspaces are Hubs (Breaking Change)
Every Workspace is its own Hub, one Workspace per Hub; the Workspace switcher is gone
Existing Workspaces were promoted in place — no row of user data moved
mcp_servers.slug is untouched, so saved instructions naming {slug}__{tool} still resolve
🔌 Hosted MCP connector
/api/mcp serves the connector, with an OAuth 2.1 authorization server in front of it
PKCE, refresh-token rotation with reuse detection, RFC 9728 discovery
Library tools exposed over MCP, behind a Hub boundary a caller cannot step around
🔒 Security
Five advisories fixed and published, each credited to its reporter — see
Acknowledgements
Command injection in the pnpm/uv install path and in testMcpConnection
SSRF guards now classify the parsed address rather than matching hostname text,
and safeFetch connects to the address it validated instead of re-resolving
Server actions no longer trust a caller-supplied identity
🐳 Deployment
Docker + Traefik + SOPS; secrets are decrypted to tmpfs at deploy time
infra/scripts/deploy.sh is the entry point — running compose by hand skips decryption
Scheduled retention for build artefacts, after a 4 GB-per-push image build filled the disk
🗑️ Removed
Discover / AI Social. The sharing infrastructure underneath it stays
⚠️ Migration Notes
Run pnpm db:migrate after upgrading
Users who hit the duplicate-Hub race will see the second one renamed to
"Default Hub 2"; nothing is merged and nothing is deleted
If this project inspires you, please ⭐ Star it —
stars power the community and keep development momentum alive!
P
Pluggedin App
VeriTeknik·103 स्टार·
The Crossroads for AI Data Exchanges. A unified, self-hostable web interface for discovering, configuring, and managing Model Context Protocol (MCP) servers—bringing together AI tools, workspaces, pro
The Crossroads for AI Data Exchanges. A unified, self-hostable web interface for discovering, configuring, and managing Model Context Protocol (MCP) servers—bringing together AI tools, workspaces, prompts, and logs from multiple MCP sources (Claude, Cursor, etc.) under one roof.
टूल
टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
सवाल
Pluggedin App कैसे इंस्टॉल करें?
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
Pluggedin App कौन सा ट्रांसपोर्ट इस्तेमाल करता है?
Pluggedin App stdio पर लोकल चलता है।
Pluggedin App की पिछली जाँच कब हुई थी?
पिछली जाँच 2026-10-27 को हुई। The Crossroads for AI Data Exchanges. A unified, self-hostable web interface for discovering, configuring, and managing Model Context Protocol (MCP) servers—bringing together AI tools, workspaces, prompts, and logs from multiple MCP sources (Claude, Cursor, etc.) under one roof.