MCP Depot

Connect your integrations to any AI assistant via Model Context Protocol (MCP)

MCP Depot is a self-hosted MCP server that exposes your integrations (Jira, GitHub, Confluence, Jenkins, custom APIs) as MCP tools. Connect once, use from Claude Code, Cursor, Windsurf, and more.

Website · Live Demo · Documentation

Features

• Unified API Gateway — Connect Jira, GitHub, Confluence, Jenkins, REST APIs, and more
• MCP Tool Server — Exposes integrations as MCP tools for AI assistants
• OpenAPI Import — Auto-generate tools from OpenAPI specs
• Composite Tools — Chain multiple API calls into single AI-invokable tools
• Response Field Selector — Pick exactly which JSON fields to return per tool
• Response Line Filter — Regex-based line filtering for large text responses (logs, diffs)
• Per-Integration SSL — Toggle self-signed certificate support per integration
• User Management — Admin UI for creating and managing users
• OAuth Login — Secure authentication with Google, GitHub, and custom OIDC
• Tags — Organize and filter integrations and skills with tags
• Session Contexts — Share AI working context across sessions and teammates
• Session Channels — Append-only logs shared across parallel AI sessions
• CLI Profiles — Support multiple MCP Depot instances via named profiles
• Workflow Automation — Chain tools into automated workflows
• Monitoring — Track tool usage, response times, and errors
• Encryption — Sensitive credentials encrypted at rest
• Secret Store — Optional integration with Infisical for enterprise secrets management

Quick Start

Option 1 — npm (zero config)

npx mcp-depot

Opens the admin UI at http://localhost:3000. Data stored in ~/.mcp-depot/data.db (SQLite). No database setup, no Docker required.

Admin credentials are printed to the console on first run. Look for the startup log block:

DEFAULT ADMIN USER CREATED
Email:    [email protected]
Password: <generated>
API Key:  <generated>

Option 2 — Docker Compose (recommended for teams)

git clone https://github.com/mcp-depot/mcp-depot
cd mcp-depot
docker compose up -d

# Get admin credentials from logs
docker compose logs server | grep -E "Email:|Password:|API Key:"

# Login at http://localhost:5173

Option 3 — Kubernetes (Helm)

git clone https://github.com/mcp-depot/mcp-depot
cd mcp-depot

# Install using published images
helm install mcp-depot ./helm/mcp-depot \
  --namespace mcp-depot \
  --create-namespace \
  --set server.image=ghcr.io/mcp-depot/mcp-depot-server:latest \
  --set client.image=ghcr.io/mcp-depot/mcp-depot-client:latest

# Access via port-forward
kubectl port-forward -n mcp-depot svc/mcp-depot-client 8080:80
# Open http://localhost:8080

See docs/KUBERNETES.md for ingress setup, production values, and full configuration reference.

Running more than one replica (Compose or Kubernetes)? See docs/HA-SCALING.md - rate limiting, the circuit breaker, and session notifications need a shared Redis to stay correct across replicas.

Connecting to Claude Code

stdio (recommended for npm installs)

1. Install and authenticate:

npm install -g mcp-depot
mcp-depot --login

Follow the prompts to enter your server URL and API key.

1. Register with Claude Code:

claude mcp add mcp-depot -- mcp-depot --mcp

Then use /mcp inside Claude Code to verify the connection.

HTTP (Docker / server with MCP_ENABLED=true)

{
  "mcpServers": {
    "mcp-depot": {
      "type": "http",
      "url": "http://localhost:3000/api/mcp"
    }
  }
}

See docs/connect/claude-code.md for full setup guide.

CLI Flags

Environment Variables

Using MCP Depot Without the UI

MCP Depot can run as a headless API server without the frontend UI.

Enable API-Only Mode

SERVE_CLIENT=false docker compose up -d

Or set in .env:

SERVE_CLIENT=false

API Reference

The REST API is available at http://localhost:3000/api/v1:

Authentication

1. Login to get access + refresh tokens:

curl -X POST http://localhost:3000/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]","password":"your-password"}'

1. Use access token in subsequent requests:

curl http://localhost:3000/api/v1/integrations \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

Connect to AI Clients

See docs/connect/README.md for detailed guides:

Architecture

┌─────────────┐     ┌─────────────┐     ┌──────────────────┐
│  AI Client  │────▶│  mcp-depot  │────▶│   Integration    │
│(Claude Code)│     │   Server    │     │(Jira, GitHub ...) │
└─────────────┘     │   :3000     │     └──────────────────┘
                    └─────────────┘
                          │
               ┌──────────┴──────────┐
               │                     │
        ┌──────────────┐    ┌─────────────────┐
        │  PostgreSQL  │    │  SQLite          │
        │  (Docker /   │    │  (npx / local)   │
        │   teams)     │    └─────────────────┘
        └──────────────┘

Tech Stack

• Backend: Node.js, Express, Sequelize
• Database: PostgreSQL (teams/Docker) or SQLite (local/npm)
• Frontend: React, Vite
• Protocol: Model Context Protocol (MCP)
• Logging: Pino
• Metrics: Prometheus

License

AGPL-3.0 — see LICENSE

Contributing

See CONTRIBUTING.md for development setup and contribution guidelines.
See GOVERNANCE.md for project governance and maintainer process.