Skip to content
Back to search

pluggedin-app

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.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/VeriTeknik/pluggedin-app with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/VeriTeknik/pluggedin-app'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/veriteknik--pluggedin-app/badge.svg)](/listings/veriteknik--pluggedin-app)

HTML

<a href="/listings/veriteknik--pluggedin-app"><img src="/api/listings/veriteknik--pluggedin-app/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Docker (Recommended - 2 minutes)

**Self-hosting builds the image locally**

The default `docker-compose.yml` **builds 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

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 620 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # plugged.in 🔌
  2. > [!IMPORTANT]
  3. > **Project status (October 2026): open source, community-driven.**
  4. > plugged.in, the hosted service, is moving to a new, separately developed platform. After that move,
  5. > this repository will no longer run plugged.in. The code stays open source under its current license, and the
  6. > community is welcome to carry it on: issues, pull requests, forks and new maintainers are welcome, and
  7. > self-hosting remains supported. The cutover date will be announced here. At the cutover, the current service
  8. > moves to v1.plugged.in and keeps running there until December 31, 2026.
  9. > [What this means](https://github.com/VeriTeknik/pluggedin-app/blob/main/PROJECT_STATUS.md)
  10. <div align="center">
  11. ![plugged.in Logo](https://plugged.in/_next/image?url=%2Fpluggedin-wl.png&w=256&q=75)
  12. **Turn your AI conversations into permanent organizational memory**
  13. [![Version](https://img.shields.io/badge/version-4.1.0-blue?style=for-the-badge)](https://github.com/VeriTeknik/pluggedin-app/releases)
  14. [![GitHub Stars](https://img.shields.io/github/stars/VeriTeknik/pluggedin-app?style=for-the-badge)](https://github.com/VeriTeknik/pluggedin-app/stargazers)
  15. [![License](https://img.shields.io/badge/license-MIT-green?style=for-the-badge)](LICENSE)
  16. [![Docker](https://img.shields.io/badge/docker-ready-blue?style=for-the-badge&logo=docker)](https://hub.docker.com/r/veriteknik/pluggedin)
  17. [🚀 Get Started](#-quick-start) • [📚 Documentation](#-documentation) • [🌟 Features](#-key-features) • [💬 Community](#-community--support)
  18. ---
  19. 🧩 **Now Multi‑Arch Ready!**
  20. Plugged.in Docker images support both `amd64` and `arm64` architectures via a unified manifest.
  21. 🧭 **v4.0.0 — Hubs, a hosted MCP connector, and a security pass:**
  22. 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.
  23. ---
  24. </div>
  25. ## 🎯 The Problem We Solve
  26. 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.**
  27. ## 💡 The Solution
  28. **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.
  29. Think of it as **"Git for AI-generated content"** meets **"WordPress for AI interactions"**.
  30. ---
  31. ## ✨ What Makes plugged.in Special
  32. ### 🧠 **AI Memory That Persists**
  33. Your AI conversations become permanent assets. Every document is versioned, attributed, and searchable.
  34. ### 🤝 **Multi-Model Collaboration**
  35. Claude writes v1, GPT-4 adds technical specs in v2, Gemini refines in v3 - all tracked and attributed.
  36. ### 🔌 **Universal MCP Integration**
  37. Works with 1,500+ MCP servers. Connect any tool, any AI, any workflow - all through one interface.
  38. ### 🔒 **Enterprise-Grade Security**
  39. End-to-end encryption, OAuth 2.1, rate limiting, and sandboxed execution for your peace of mind.
  40. ---
  41. ## 📊 Real Platform Statistics
  42. ```yaml
  43. Documents Managed: 90+ (72% AI-generated)
  44. Integrated MCP Servers: 1,568
  45. Active Versioning: Documents with up to 4 iterations
  46. Model Attributions: 17 different AI models tracked
  47. RAG Engine: Embedded zvec (RocksDB + HNSW) — zero external dependencies
  48. Search Performance: Sub-second semantic search with cosine similarity
  49. Security: AES-256-GCM encryption, Redis rate limiting
  50. ```
  51. ---
  52. ## 🚀 Quick Start
  53. ### Docker (Recommended - 2 minutes)
  54. #### **Self-hosting builds the image locally**
  55. The default `docker-compose.yml` **builds 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.
  56. > 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).
  57. ```bash
  58. # Clone and setup
  59. git clone https://github.com/VeriTeknik/pluggedin-app.git
  60. cd pluggedin-app
  61. cp .env.example .env
  62. # Edit .env and set these three. Compose refuses to start without the last two,
  63. # so there is no way to end up running with a password this repository knows.
  64. # NEXTAUTH_SECRET=$(openssl rand -base64 32)
  65. # POSTGRES_PASSWORD=$(openssl rand -hex 32)
  66. # REDIS_PASSWORD=$(openssl rand -hex 32)
  67. #
  68. # Use hex (or another URL-safe value) for the last two: they are interpolated
  69. # into a postgresql:// / redis:// URL, so @ : / ? # would corrupt it.
  70. # Compose builds DATABASE_URL and REDIS_URL from them — leave those alone.
  71. # Build the app image and start the full stack (PostgreSQL 18 + pgvector,
  72. # Redis, one-shot migration, then the app):
  73. docker compose up --build -d
  74. # Follow startup (migration runs first, then the app becomes healthy):
  75. docker compose logs -f pluggedin-app
  76. # Visit http://localhost:12005
  77. ```
  78. Useful commands:
  79. ```bash
  80. docker compose ps # service status
  81. docker compose run --rm pluggedin-migrate # re-run database migrations
  82. docker compose down # stop (keeps data)
  83. docker compose down -v # stop + wipe all volumes
  84. ```
  85. > **Production / hosted deployments use a different file** — this `docker-compose.yml` is the self-host default, not the production stack:
  86. > - `docker-compose.production.yml` — pulls the prebuilt `veriteknik/pluggedin` image (the hosted/cloud build)
  87. > - `infra/docker-compose.yml` — the Traefik + SOPS production stack used by plugged.in
  88. **What's included:**
  89. - ✅ PostgreSQL 18 with pgvector extension for vector search
  90. - ✅ Redis 7 for rate limiting / caching
  91. - ✅ Embedded zvec vector engine for RAG (no external Milvus/Qdrant needed)
  92. - ✅ Next.js 15 web application with optimized production build
  93. - ✅ Persistent volumes for database, uploads, vectors, and logs
  94. - ✅ Health checks and automatic restarts
  95. **Docker Architecture:**
  96. ```yaml
  97. Services:
  98. - pluggedin-migrate: One-shot DB migration; reuses the app image, then exits
  99. - pluggedin-app: Main web application (host port 12005 → container 3000),
  100. starts only after migration completes successfully
  101. - pluggedin-postgres: PostgreSQL 18 + pgvector database (port 5432)
  102. - pluggedin-redis: Redis 7 (port 6379)
  103. Volumes:
  104. - pluggedin-postgres: Database data (persistent)
  105. - pluggedin-redis: Redis append-only data (persistent)
  106. - zvec-data: Vector collections (persistent)
  107. - app-uploads: User uploaded files (persistent)
  108. - app-logs: Application logs (persistent)
  109. - mcp-cache: MCP package cache (persistent)
  110. ```
  111. **Upgrading from older versions:**
  112. ```bash
  113. # If upgrading from PostgreSQL 16 or earlier
  114. # Option 1: Fresh start (data loss)
  115. docker compose down -v && docker compose up --build -d
  116. # Option 2: Migrate existing data
  117. docker exec pluggedin-postgres pg_dump -U pluggedin pluggedin > backup.sql
  118. docker compose down -v
  119. docker compose up -d
  120. docker exec -i pluggedin-postgres psql -U pluggedin -d pluggedin < backup.sql
  121. ```
  122. ### Cloud Version
  123. Visit [plugged.in](https://plugged.in) for instant access - no installation required.
  124. ---
  125. ## 🌟 Key Features
  126. ### 📚 Document Management & RAG
  127. - **Embedded Vector Search**: In-process zvec engine (RocksDB + HNSW) — no external services needed
  128. - **Automatic Indexing**: Upload PDFs or text, automatically chunked, embedded, and indexed
  129. - **Version Control**: Track every change with Git-style history
  130. - **Model Attribution**: Know which AI contributed what
  131. - **Semantic Search**: Query your knowledge base with natural language
  132. - **Re-index Recovery**: One-click re-indexing from the library UI for corrupted vectors
  133. ### 🔧 MCP Server Hub
  134. - **1,500+ Integrations**: Connect to any MCP-compatible tool
  135. - **Advanced Multi-Select Filtering**: Filter by multiple package types simultaneously (npm, PyPI, Docker, MCPB, NuGet)
  136. - **Smart Search**: Intelligent filtering with real-time result counts and validation
  137. - **Auto-Discovery**: Find and configure servers from GitHub, npm, Smithery
  138. - **Registry Integration**: Claim and manage servers with GitHub credentials
  139. - **Unified Interface**: One API key, all your tools
  140. - **Tool Prefixing**: Automatic namespace management prevents conflicts
  141. - **OAuth Support**: Server-side OAuth handling for MCP servers
  142. ### 🎮 Interactive Playground
  143. - **Test Any Model**: Claude, GPT-4, Gemini, and more
  144. - **Live Debugging**: See real-time MCP interactions
  145. - **RAG Integration**: Use your documents as context
  146. - **Custom Instructions**: Per-server configuration
  147. - **Extensive Logging**: Detailed debugging capabilities
  148. ### 🔔 Real-Time Intelligence
  149. - **Activity Tracking**: Monitor all MCP operations
  150. - **Email Notifications**: Stay informed about important events
  151. - **Trending Analytics**: See what tools are popular
  152. - **Audit Logs**: Complete activity history
  153. - **Bidirectional Notifications**: Send, receive, mark as read
  154. ### 🔐 Security First
  155. - **End-to-End Encryption**: AES-256-GCM for all sensitive data
  156. - **Per-Profile Encryption**: Isolated encryption keys per workspace
  157. - **OAuth 2.1**: Modern authentication flows
  158. - **Sandboxed Execution**: Firejail isolation on Linux
  159. - **Redis Rate Limiting**: Advanced DDoS protection with fallback
  160. - **LRU Cache**: Memory-efficient caching with automatic eviction
  161. - **Enhanced Password Security**: Bcrypt cost factor 14 (16,384 iterations)
  162. - **Dynamic CSP Nonces**: Cryptographically secure Content Security Policy
  163. - **Security Headers**: HSTS, X-Frame-Options, X-Content-Type-Options
  164. ### 🏢 Hub & Workspace Management
  165. - **Multi-Hub Architecture**: Organize projects into separate hubs
  166. - **Workspace Isolation**: Each hub contains multiple isolated workspaces
  167. - **Smart Hub Switching**: Automatic workspace selection when switching hubs
  168. - **Data Scoping**: Hub-level and workspace-level data isolation
  169. - **Current Hub Display**: Dashboard shows active hub for context awareness
  170. ### 📋 Clipboard & Memory System
  171. - **Named Entries**: Store key-value pairs with semantic names (e.g., `customer_context`, `last_analysis`)
  172. - **Indexed Entries**: Array-like storage with auto-incrementing indices for ordered data
  173. - **Stack Operations**: Push/pop functionality for LIFO workflows and pipelines
  174. - **Rich Content Support**: Store text, JSON, images (base64), and any content type up to 2MB
  175. - **TTL Expiration**: Optional time-to-live for automatic cleanup of temporary data
  176. - **Visibility Controls**: Private, workspace, or public visibility per entry
  177. - **Model Attribution**: Track which AI model created each clipboard entry
  178. - **MCP Integration**: Access clipboard via 6 built-in MCP tools from any AI client
  179. ---
  180. ## 🏗️ Architecture
  181. <div align="center">
  182. ![plugged.in Architecture](./docs/images/pluggedin-architecture.png)
  183. </div>
  184. ### Architecture Overview
  185. 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.
  186. ### 🟢 Production-Ready Integrations (Solid Lines)
  187. #### **MCP Proxy Interface**
  188. The MCP Proxy serves as a unified gateway that aggregates multiple MCP servers into a single interface:
  189. - **Claude Code** - Official Anthropic CLI for Claude with native MCP support
  190. - **Cline** - VS Code extension for AI-assisted development
  191. - **LM Studio** - Local model execution with MCP integration
  192. - **Claude Desktop** - Anthropic's desktop application
  193. **How it works**: Each AI client connects via STDIO, receiving access to all your configured MCP servers through one connection. The proxy handles:
  194. - Tool prefixing to prevent namespace conflicts
  195. - OAuth authentication for MCP servers
  196. - Activity logging and notifications
  197. - Unified error handling
  198. #### **SDK Support - Multi-Language Integration**
  199. Direct programmatic access through official SDKs:
  200. - **JavaScript/TypeScript SDK** (`@pluggedin/sdk`) - Full-featured SDK for Node.js and browser
  201. - **Python SDK** (`pluggedin-sdk`) - Pythonic interface for AI workflows
  202. - **Go SDK** (`pluggedin-go`) - High-performance Go implementation
  203. **Use Cases**:
  204. ```javascript
  205. // Create documents programmatically
  206. const doc = await client.documents.create({
  207. title: "API Analysis",
  208. content: "...",
  209. source: "api"
  210. });
  211. // Query RAG knowledge base
  212. const results = await client.rag.query("How do we handle auth?");
  213. ```
  214. #### **Platform Core Features**
  215. The plugged.in web platform provides:
  216. 1. **Knowledge Base (Embedded RAG)**
  217. - In-process vector search via zvec (RocksDB + HNSW) — no external services
  218. - Automatic PDF/text chunking, embedding, and indexing
  219. - Project-scoped isolation with per-field filter validation
  220. - Sub-second cosine similarity search
  221. 2. **Document Store**
  222. - Version control for AI-generated content
  223. - Multi-model attribution tracking
  224. - Content hash deduplication
  225. - Support for uploads, AI-generated, and API sources
  226. 3. **MCP Registry**
  227. - 1,500+ curated MCP servers
  228. - GitHub verification and claiming
  229. - Install tracking and trending
  230. - Auto-discovery from npm, GitHub, Smithery
  231. 4. **Tools Management**
  232. - Discover tools from all connected servers
  233. - Test tools in interactive playground
  234. - Custom instructions per server
  235. - Real-time debugging logs
  236. ### 🟡 In Development (Dashed Lines)
  237. #### **Native Connectors**
  238. Direct integrations bypassing the MCP Proxy for enhanced performance:
  239. - **Plugged.in Connector for Claude Desktop** - Native plugin architecture
  240. - **Plugged.in Connector for ChatGPT** - OpenAI plugin integration
  241. - **Mobile App** - iOS and Android native apps
  242. **Why Native Connectors?**
  243. - Faster response times (no proxy overhead)
  244. - Richer UI integration
  245. - Platform-specific features
  246. - Offline capabilities
  247. #### **Advanced Memory System**
  248. Persistent memory across sessions:
  249. - **Knowledge + Memory** boxes in the diagram represent:
  250. - Session continuity across different AI clients
  251. - Automatic context injection based on conversation history
  252. - Cross-model memory sharing (Claude remembers what GPT discussed)
  253. - Smart context pruning to stay within token limits
  254. **Example Workflow**:
  255. 1. Discuss architecture with Claude Desktop → Memory saved
  256. 2. Switch to ChatGPT connector → Previous context automatically available
  257. 3. Mobile app accesses same conversation history
  258. 4. RAG provides relevant documents automatically
  259. ### 📊 Data Flow Example
  260. **User Request Flow**:
  261. ```
  262. 1. User asks question in Claude Desktop
  263. 2. MCP Proxy receives request
  264. 3. Proxy checks RAG for relevant context
  265. 4. Combines context + user question
  266. 5. Routes to appropriate MCP servers
  267. 6. Aggregates responses
  268. 7. Logs activity to database
  269. 8. Returns enriched response to user
  270. ```
  271. **Document Creation Flow**:
  272. ```
  273. 1. AI generates document via SDK or user uploads PDF/text
  274. 2. Content processed, chunked, and sanitized
  275. 3. Model attribution recorded
  276. 4. Version created in Document Store
  277. 5. Chunks stored in PostgreSQL, embeddings indexed in zvec
  278. 6. Document searchable immediately via semantic search
  279. ```
  280. ### 🔒 Security Architecture
  281. All connections use:
  282. - **End-to-end encryption** (AES-256-GCM)
  283. - **Per-profile encryption keys** (workspace isolation)
  284. - **Redis rate limiting** with memory fallback
  285. - **Sandboxed execution** (Firejail on Linux)
  286. - **OAuth 2.1** for external services
  287. ### 📈 Scalability
  288. The architecture supports:
  289. - **Horizontal scaling** of MCP Proxy instances
  290. - **Database connection pooling** for PostgreSQL
  291. - **Redis caching** for frequently accessed data
  292. - **CDN integration** for static assets
  293. - **Background job processing** for heavy operations
  294. ---
  295. ## 📚 Documentation
  296. Visit our comprehensive documentation at [docs.plugged.in](https://docs.plugged.in)
  297. ### For Users
  298. - [Getting Started](https://docs.plugged.in/introduction) - Platform overview and quick start
  299. - [Installation Guide](https://docs.plugged.in/quickstart/installation) - Step-by-step setup instructions
  300. - [Document Library](https://docs.plugged.in/platform/document-library) - Managing your AI knowledge base
  301. - [RAG Knowledge Base](https://docs.plugged.in/tutorials/rag-knowledge-base) - Setting up RAG for AI context
  302. - [Team Collaboration](https://docs.plugged.in/tutorials/team-collaboration) - Working with your team
  303. ### For Developers
  304. - [API Reference](https://docs.plugged.in/api/reference) - Complete API documentation
  305. - [API Authentication](https://docs.plugged.in/api/authentication) - API key and authentication guide
  306. - [Self-Hosting Guide](https://docs.plugged.in/tutorials/self-hosting) - Deploy your own instance
  307. - [Docker Deployment](https://docs.plugged.in/deployment/docker) - Container-based deployment
  308. - [Security Overview](https://docs.plugged.in/security/overview) - Security best practices
  309. ### MCP Integration
  310. - [MCP Proxy Overview](https://docs.plugged.in/mcp-proxy/overview) - Understanding the proxy architecture
  311. - [MCP Proxy Installation](https://docs.plugged.in/mcp-proxy/installation) - Setting up the proxy
  312. - [Custom MCP Servers](https://docs.plugged.in/tutorials/custom-mcp-server) - Building your own servers
  313. ---
  314. ## 🛠️ Installation Options
  315. ### Requirements
  316. - Node.js 18+ (20+ recommended)
  317. - PostgreSQL 15+ (18+ recommended)
  318. - Redis (optional, for rate limiting)
  319. - Docker & Docker Compose (for containerized deployment)
  320. ### Environment Variables
  321. Create a `.env` file with:
  322. ```bash
  323. # Core (Required)
  324. DATABASE_URL=postgresql://user:pass@localhost:5432/pluggedin
  325. NEXTAUTH_URL=http://localhost:12005
  326. NEXTAUTH_SECRET=your-secret-key # Generate: openssl rand -base64 32
  327. # Security (Required)
  328. NEXT_SERVER_ACTIONS_ENCRYPTION_KEY= # Generate: openssl rand -base64 32
  329. # Features (Optional)
  330. ENABLE_RAG=true
  331. ENABLE_NOTIFICATIONS=true
  332. ENABLE_EMAIL_VERIFICATION=true
  333. REDIS_URL=redis://localhost:6379 # For Redis rate limiting
  334. # RAG / Vector Search
  335. ZVEC_DATA_PATH=./data/vectors # Path to zvec collection files
  336. EMBEDDING_MODEL= # OpenAI model (default: text-embedding-3-small)
  337. RAG_SEARCH_TOP_K=5 # Chunks returned per query
  338. RAG_CACHE_TTL_MS=60000 # Storage stats cache TTL
  339. # Email (For notifications)
  340. EMAIL_SERVER_HOST=smtp.example.com
  341. EMAIL_SERVER_PORT=587
  342. EMAIL_FROM=noreply@example.com
  343. ```
  344. ### Manual Installation
  345. ```bash
  346. # Install dependencies
  347. pnpm install
  348. # Setup database
  349. pnpm db:migrate:auth
  350. pnpm db:generate
  351. pnpm db:migrate
  352. # Build for production
  353. NODE_ENV=production pnpm build
  354. # Start the server
  355. pnpm start
  356. ```
  357. ---
  358. ## 🔌 MCP Proxy Integration
  359. Connect your AI clients to plugged.in:
  360. ### Claude Desktop
  361. ```json
  362. {
  363. "mcpServers": {
  364. "pluggedin": {
  365. "command": "npx",
  366. "args": ["-y", "@pluggedin/pluggedin-mcp-proxy@latest"],
  367. "env": {
  368. "PLUGGEDIN_API_KEY": "YOUR_API_KEY"
  369. }
  370. }
  371. }
  372. }
  373. ```
  374. ### Cursor IDE
  375. ```bash
  376. npx -y @pluggedin/pluggedin-mcp-proxy@latest --pluggedin-api-key YOUR_API_KEY
  377. ```
  378. ---
  379. ## 🎯 Use Cases
  380. ### For Developers
  381. - **Code Review Memory**: Keep AI code reviews across sessions
  382. - **Documentation Generation**: Auto-generate and version technical docs
  383. - **Bug Analysis Archive**: Store AI debugging sessions for future reference
  384. ### For Teams
  385. - **Knowledge Base**: Build institutional memory from AI interactions
  386. - **Meeting Summaries**: AI-generated summaries with full attribution
  387. - **Strategy Documents**: Collaborative AI-assisted planning with version control
  388. ### For Enterprises
  389. - **Compliance Tracking**: Full audit trail of AI-generated content
  390. - **Multi-Model Workflows**: Orchestrate different AIs for complex tasks
  391. - **Secure Deployment**: Self-host with complete data control
  392. ---
  393. ## 📊 Why Teams Choose plugged.in
  394. | Feature | plugged.in | Traditional AI Chat | MCP Clients Alone |
  395. |---------|------------|-------------------|-------------------|
  396. | Persistent Memory | ✅ Full versioning | ❌ Session only | ❌ No storage |
  397. | Multi-Model Support | ✅ All models | ⚠️ Single vendor | ✅ Multiple |
  398. | Document Management | ✅ Complete CMS | ❌ None | ❌ None |
  399. | Attribution Tracking | ✅ Full audit trail | ❌ None | ❌ None |
  400. | Team Collaboration | ✅ Built-in | ❌ None | ❌ Limited |
  401. | Self-Hostable | ✅ Yes | ⚠️ Varies | ✅ Yes |
  402. | RAG Integration | ✅ Native | ⚠️ Limited | ❌ None |
  403. ---
  404. ## 🤝 Community & Support
  405. - **GitHub Discussions**: [Join the conversation](https://github.com/orgs/VeriTeknik/discussions)
  406. - **GitHub Issues**: [Bug reports and feature requests](https://github.com/VeriTeknik/pluggedin-app/issues)
  407. - **Reddit**: [r/plugged_in](https://www.reddit.com/r/plugged_in/)
  408. - **Twitter/X**: [@PluggedIntoAI](https://x.com/PluggedIntoAI)
  409. - **Email**: team@plugged.in
  410. ### Contributing
  411. We love contributions! See our [Contributing Guide](CONTRIBUTING.md) for details.
  412. ```bash
  413. # Fork the repo, then:
  414. git clone https://github.com/YOUR_USERNAME/pluggedin-app.git
  415. cd pluggedin-app
  416. pnpm install
  417. pnpm dev
  418. ```
  419. ---
  420. ## 📜 License
  421. MIT License - see [LICENSE](LICENSE) for details.
  422. ---
  423. ## 🙏 Acknowledgments
  424. Built on top of these amazing projects:
  425. - [Model Context Protocol](https://modelcontextprotocol.io/) by Anthropic
  426. - [Next.js](https://nextjs.org/) for the web framework
  427. - [PostgreSQL](https://www.postgresql.org/) for reliable data storage
  428. - All the MCP server creators in our community
  429. ---
  430. ## 📝 Release Notes
  431. **Latest Release: v4.0.0** — Hubs, a hosted MCP connector, and a security pass
  432. ### 🎯 What's New in v4.0.0
  433. Major by Semantic Versioning: two features were removed and the data model under
  434. Hubs changed.
  435. **🧭 Workspaces are Hubs** (Breaking Change)
  436. - Every Workspace is its own Hub, one Workspace per Hub; the Workspace switcher is gone
  437. - Existing Workspaces were promoted in place — no row of user data moved
  438. - `mcp_servers.slug` is untouched, so saved instructions naming `{slug}__{tool}` still resolve
  439. **🔌 Hosted MCP connector**
  440. - `/api/mcp` serves the connector, with an OAuth 2.1 authorization server in front of it
  441. - PKCE, refresh-token rotation with reuse detection, RFC 9728 discovery
  442. - Library tools exposed over MCP, behind a Hub boundary a caller cannot step around
  443. **🔒 Security**
  444. - Five advisories fixed and published, each credited to its reporter — see
  445. [Acknowledgements](SECURITY.md#acknowledgements)
  446. - Command injection in the pnpm/uv install path and in `testMcpConnection`
  447. - SSRF guards now classify the parsed address rather than matching hostname text,
  448. and `safeFetch` connects to the address it validated instead of re-resolving
  449. - Server actions no longer trust a caller-supplied identity
  450. **🐳 Deployment**
  451. - Docker + Traefik + SOPS; secrets are decrypted to tmpfs at deploy time
  452. - `infra/scripts/deploy.sh` is the entry point — running compose by hand skips decryption
  453. - Scheduled retention for build artefacts, after a 4 GB-per-push image build filled the disk
  454. **🗑️ Removed**
  455. - Discover / AI Social. The sharing infrastructure underneath it stays
  456. **⚠️ Migration Notes**
  457. - Run `pnpm db:migrate` after upgrading
  458. - Users who hit the duplicate-Hub race will see the second one renamed to
  459. "Default Hub 2"; nothing is merged and nothing is deleted
  460. View the full changelog at [GitHub Releases](https://github.com/VeriTeknik/pluggedin-app/releases/latest)
  461. ---
  462. <div align="center">
  463. **Ready to give your AI permanent memory?**
  464. [🚀 **Start Now**](https://plugged.in) • [⭐ **Star on GitHub**](https://github.com/VeriTeknik/pluggedin-app/stargazers)
  465. *If this project inspires you, please ⭐ Star it —
  466. stars power the community and keep development momentum alive!*
  467. </div>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.