mcp-orchestrator by youhavethepower2025 - MCP Server

MCP Orchestrator

Local AI agent platform with 70+ integrated tools. Built when Claude Code launched in May 2024.

What It Does

Personal MCP server that connects Claude Desktop to your entire development and business stack:

Memory: PostgreSQL-backed persistent context across sessions
Communication: Gmail intelligence, GoHighLevel CRM automation
Voice: VAPI.ai call management and transcripts
Infrastructure: Docker orchestration, Railway deployment, DigitalOcean management
Self-Expansion: Install new MCP servers programmatically

Not just tools - a platform for tools. The orchestrator can install other MCP servers, expanding its own capabilities autonomously.

Quick Start

Prerequisites

Docker Desktop
Claude Desktop
Cloudflare HTTP-to-MCP bridge (or similar transport)

1. Clone and Configure

git clone https://github.com/youhavethepower2025/mcp-orchestrator.git
cd mcp-orchestrator

# Copy environment template
cp .env.example .env

# Edit with your API keys
vim .env

2. Start the Stack

# Start PostgreSQL, Redis, and MCP server
docker-compose -f docker-compose.postgres.yml up -d

# Verify services are running
docker ps
# Should show: devmcp-brain, devmcp-postgres, devmcp-redis

# Check health
curl http://localhost:8080/health
# Expected: {"status":"healthy"}

3. Configure Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "orchestrator": {
      "command": "http-bridge",
      "args": ["http://localhost:8080"],
      "description": "MCP Orchestrator - 70+ tools for development and business automation"
    }
  }
}

Important: If using Cloudflare's HTTP bridge, disable "AI request detection" in bridge settings to prevent false positives.

4. Test in Claude Desktop

Open Claude Desktop and try:

User: "Remember that my primary project is the MCP orchestrator"
Claude: [Uses remember tool] ✅ Stored in persistent memory

User: "What did I just tell you to remember?"
Claude: [Uses recall tool] "Your primary project is the MCP orchestrator"

User: "Search my Gmail for conversations with John"
Claude: [Uses Gmail tools] Found 3 conversations...

Architecture

System Overview

┌─────────────────────────────────────────┐
│ Claude Desktop (via HTTP Bridge)        │
└──────────────┬──────────────────────────┘
               │ HTTP/MCP (Port 8080)
               ▼
┌─────────────────────────────────────────┐
│ MCP Orchestrator (FastAPI)              │
│  ├─ Tool Registry (70+ tools)           │
│  ├─ Memory Layer (PostgreSQL)           │
│  ├─ Cache Layer (Redis)                 │
│  └─ Platform Integrations               │
└──────────────┬──────────────────────────┘
               │
       ┌───────┼───────┬───────┬──────┬────────┐
       ▼       ▼       ▼       ▼      ▼        ▼
    VAPI    GHL     Gmail   RevOps Docker  Railway

Data Flow

Request from Claude Desktop → HTTP bridge
MCP server parses JSON-RPC request
Tool registry dispatches to appropriate handler
Handler queries PostgreSQL or external API
Response cached in Redis (where applicable)
SSE stream back to Claude Desktop

Key Design Decisions

PostgreSQL over SQLite:

Better concurrency for multiple Claude sessions
Full-text search for memory queries
Production-ready scaling

Redis Caching:

Reduce API calls to external platforms (VAPI, GHL)
5-minute TTL balances freshness vs performance
Edge-case: Cache invalidation on write operations

Modular Tools:

Each platform in separate file (vapi_tools.py, ghl_tools.py, etc.)
Easy to add new integrations
Independent testing per module

Docker Compose:

Easy local development
Production-ready deployment pattern
Health checks and auto-restart

Tool Catalog

Memory & Context (3 tools)

remember - Store key-value data with metadata in PostgreSQL
recall - Retrieve by key with full context
search_memory - Full-text search across all stored memories

Gmail Intelligence (8 tools)

search_contacts - Find contacts by relationship temperature (hot/warm/cold)
get_contact_intelligence - Full context on person (threads, topics, relationship notes)
generate_outreach_drafts - AI-powered email generation (3 approaches)
send_email - Send via Gmail API with automatic logging
Plus 4 more for thread management, labeling, search

GoHighLevel CRM (15 tools)

Contact Management:

ghl_search_contact - Caller ID lookup by phone number
ghl_get_contact - Full profile retrieval
ghl_update_contact - Update with custom fields
ghl_create_contact - New lead creation

Calendar & Tasks:

ghl_create_appointment - Book calendar slots
ghl_get_calendar_slots - Check availability
ghl_create_task - Auto follow-ups
ghl_add_note - Track interactions

Pipeline & Automation:

ghl_create_opportunity - Sales tracking
ghl_move_opportunity - Stage progression
ghl_trigger_workflow - Full workflow automation
ghl_webhook_received - Process webhook events

VAPI Voice (5 tools)

vapi_list_calls - Get call history with filters
vapi_get_call - Retrieve transcript + recording URL
Plus call creation, update, and analytics tools

Infrastructure (12 tools)

Docker Orchestration:

docker_compose_up/down - Stack management
docker_build - Create images
docker_logs - Real-time monitoring
docker_exec - Run commands in containers
docker_restart - Service recovery
docker_prune - Cleanup unused resources

Deployment:

deploy_brain - One-command deployment to production
terminal_execute - Run any shell command
python_execute - Execute Python code snippets

RevOps OS (20 tools)

Lead management and scoring
Campaign creation and tracking
Outreach automation
Contact enrichment from Gmail

Job Hunt Automation (15 tools)

Application tracking
Company research automation
Interview scheduling
Follow-up workflows

MCP Meta Tools (Self-Expansion!)

mcp_install_server - Install new MCP servers programmatically
mcp_list_servers - See available MCP servers
mcp_configure_server - Add to Claude Desktop config
mcp_restart_server - Reload connections

Example Self-Expansion:

// Install GitHub MCP for code operations
await mcp_install_server("@modelcontextprotocol/server-github")

// Now you have GitHub tools too!

Integration Examples

Caller ID Workflow

Incoming call → vapi_webhook → ghl_search_contact(phone)
  → remember(caller_context) → ghl_create_task(follow_up)

Smart Appointment Booking

User: "Schedule a meeting with John next week"
  → ghl_get_calendar_slots(next_week)
  → ghl_create_appointment(selected_slot)
  → ghl_trigger_workflow(send_confirmation)

Full Call Processing

vapi_get_call(call_id) → extract_transcript
  → ghl_update_contact(notes) → ghl_add_note(summary)

Development

Project Structure

mcp-orchestrator/
├── brain_server.py              # Main MCP server (3,113 lines)
├── tools_registry.py            # Unified tool registry
├── vapi_tools.py                # VAPI voice integration
├── ghl_tools.py                 # GoHighLevel CRM (placeholder - integrated in brain_server)
├── gmail_tools.py               # Gmail intelligence
├── revops_tools.py              # RevOps OS integration
├── job_hunt_tools.py            # Job hunt automation
├── enhanced_tools.py            # Infrastructure tools
├── docker-compose.postgres.yml  # Production stack
└── schema files (*.sql)         # Database schemas

Adding New Tools

Create tool file (e.g., notion_tools.py)
Define MCP tool schema:

NOTION_TOOLS = [{
    "name": "notion_create_page",
    "description": "Create a new Notion page",
    "inputSchema": {
        "type": "object",
        "properties": {
            "title": {"type": "string"},
            "content": {"type": "string"}
        },
        "required": ["title"]
    }
}]

Implement handler function
Register in brain_server.py

Running Tests

# Test individual integrations
python test_gmail_quick.py
python test_revops_integration.py

# Test database connection
python -c "import asyncpg; asyncpg.connect('postgresql://...')"

Viewing Logs

# Real-time logs
docker logs devmcp-brain --tail 50 -f

# Database queries
docker exec -it devmcp-postgres psql -U brain brain_mcp

Security

Authentication

All external APIs use environment variable keys
No hardcoded credentials in codebase
.env in .gitignore

Cloudflare Bridge Configuration

IMPORTANT: If using Cloudflare's HTTP-to-MCP bridge:

Open bridge settings
Disable "AI request detection"
This prevents false positives that block Claude requests

Without this, the bridge may incorrectly flag Claude's requests as automated traffic.

Database Security

PostgreSQL with password authentication
Connection only exposed on localhost (Docker network)
Default password should be changed in production use

API Key Management

Each platform has separate API key in .env
Use .env.example as template (never commit .env)
Rotate keys regularly for production deployments

What Makes This Special

Built from Scratch

Started when Claude Code launched (May 2024)
3,113 lines of Python in main server
70+ tools across 6 platforms
PostgreSQL-backed persistent memory

Self-Expanding Architecture

Can install new MCP servers programmatically
Metacognitive capabilities (knows about MCP ecosystem)
Not just tools - a platform for tool orchestration

Production-Ready

Docker Compose deployment
Health checks and auto-restart
Redis caching for performance
Comprehensive logging and error handling

Business Context

Voice agent integration (VAPI for calls)
CRM automation (GoHighLevel workflows)
Email intelligence (Gmail relationship tracking)
Infrastructure management (Docker, Railway, DigitalOcean)

Not a toy project. Not a tutorial. Production MCP orchestration built for real workflows.

Roadmap

Completed

✅ Core MCP server with 70+ tools
✅ PostgreSQL persistent memory
✅ Multi-platform integrations (VAPI, GHL, Gmail, etc.)
✅ Docker Compose deployment
✅ Self-expansion via MCP meta tools

In Progress

🔄 WebSocket transport (in addition to HTTP)
🔄 Multi-tenant support (separate contexts per user)
🔄 Advanced caching strategies

Future

⏳ Agent collaboration framework (multiple MCP servers working together)
⏳ Tool marketplace (discover and install community tools)
⏳ Visual tool builder (create tools via UI)

Built With

Python 3.11+ - Core language
FastAPI - MCP server framework
PostgreSQL 15 - Persistent memory and audit logs
Redis 7 - Caching layer
Docker Compose - Orchestration
MCP Protocol - Model Context Protocol specification

Contributing

This is a personal MCP orchestrator, but the patterns here can be adapted for your own use:

Fork for your use case - Adapt the integrations to your platforms
Add your tools - Follow the modular tool pattern
Share learnings - Open an issue to discuss interesting patterns

License

MIT License - See LICENSE file for details

Acknowledgments

Built for use with Claude Code
Follows MCP Protocol specification
Inspired by the vision of AI agents with persistent memory and real-world integrations

Questions or want to discuss MCP architecture? Open an issue or reach out.