Lightning MCP

Enterprise AI infrastructure built on Anthropic’s Model Context Protocol. One endpoint, 180+ tools, 3-node active-active failover, persistent memory, and autonomous agents.

What is MCP?

Model Context Protocol by Anthropic

MCP is an open standard from Anthropic — the makers of Claude — that lets AI models connect to external tools, data sources, and services. It defines how an AI client discovers available tools, calls them, and receives structured results.

Any MCP-compatible client (Claude Desktop, Claude Code, Cursor, Windsurf, Cline, or custom apps) can connect to any MCP server and immediately use its tools.

MCP Specification →  |  Anthropic Docs →

What Lightning MCP Is

Lightning MCP is an enterprise aggregation and persistence layer built on top of MCP. We don’t replace MCP — we extend it with everything production AI infrastructure needs.

🔗 Single Endpoint

180+ tools through one MCP connection. No per-tool config. Connect once, access everything.

🧠 Persistent Memory

16+ per-project Redis databases with 3-way replication. AI that remembers across sessions, projects, and people.

🔄 Active-Active Failover

3 independent nodes all serving simultaneously. Zero switchover latency. No single point of failure.

🔎 Semantic Search

Unimatrix vector database with 4,264 embeddings. Search all projects by meaning, not keywords.

📋 ITIL Governance

Built-in ITSM with incidents, changes, projects, tasks, and 500+ knowledge articles.

🔮 Autonomous Agents

AI reporters, task orchestrators, and background workers operating 24/7 without human intervention.

Architecture

Everything flows through a single path: your AI client connects to the Bridge, the Bridge routes to the Singularity Engine, and the Engine dispatches to the right module.

Any MCP-compatible AI client
Claude
Claude Code
Cursor
Windsurf
Cline
Custom Apps
↓ ↓ ↓
Single SSE endpoint — authentication + routing + failover
⚡ Lightning Bridge
↓ ↓ ↓
36 modules — 180+ tools — hot-reloadable
Singularity Engine
↓ ↓ ↓ ↓ ↓ ↓ ↓
What Singularity connects to — ● Live today   ● Potential
Linux Servers
Docker
Proxmox
Memory/Redis
PostgreSQL
ITSM
Home Assistant
Windows Desktop
Code Validation
VoIP/Phone
File Transfer
Web Search
pfSense
N8N
Continuum
Hive Mind
Phantom Agent
Network Discovery
AI/LLM
Audit
SDLC
Salesforce
QuickBooks
Jira / ServiceNow
AWS / Azure / GCP
Slack / Teams
GitHub / GitLab
Kubernetes
Terraform
Datadog / Grafana
Exchange / O365
Twilio / SMS
Stripe / Billing
Live — running in production today Potential — module-ready, deploy when needed

Singularity is modular. Adding a new integration means dropping in a Python file — no restart, no reconfiguration. The architecture supports any tool that can expose an API.

What’s Live Today

36 modules running in production across 3 nodes. Every module is independently loadable.

ModuleWhat It DoesStatus
Linux ControlRun commands, system info, CPU/memory/disk on managed serversLive
DockerContainer lifecycle — ps, logs, stats, start/stop/restartLive
ProxmoxCluster status, VM management, LXC containers, node monitoringLive
MemoryRedis recall/remember, conscience load/save, project-scoped storageLive
DatabasePostgreSQL queries, Redis ops, Qdrant vector searchLive
ITSMIncidents, changes, problems, projects, tasks, knowledge baseLive
NetworkpfSense firewall, DHCP, VPN, managed switch VLANsLive
Home AssistantEntity states, service calls, device controlLive
Windows DesktopMouse, keyboard, screenshots, window management, PowerShellLive
Forge (Validation)Multi-pass code checking — Bronze, Silver, Gold tiersLive
ContinuumConversation archival, chat sync, transcript searchLive
Hive Mind / TelepathyCross-project search, AI-to-AI messaging, coordinationLive
PhantomAutonomous background agent — assigns itself tasks, executesLive
DiscoveryNetwork scanning, host probing, service detectionLive
ExtractionSystem info, configs, users, databases from target systemsLive
AssimilationAI analysis, documentation generation, migration planningLive
VoIPPhone system management via VoIP.ms APILive
File TransferHost filesystem, rsync, SCP operationsLive
Web / SearchWeb fetch, SearXNG search, file read/writeLive
AI/LLMLocal model inference, chatflow executionLive
N8N / Node-REDWorkflow automation, flow managementLive
ConduitClaude.ai browser session bridge, conversation syncLive
SchedulerCron-based task scheduling and executionLive
SDLCDev-to-production pipeline, deployment trackingLive
Audit / SentinelSecurity scanning, compliance checks, monitoringLive
BoltSecurity hardening, certificate managementLive

What’s Next

The modular architecture means any API-accessible service can become a Singularity module. These are on the roadmap or ready to build when a customer needs them:

IntegrationWhat It Would DoStatus
Salesforce / HubSpotCRM queries, contact management, pipeline automationPlanned
QuickBooks / XeroInvoice management, financial reporting, expense trackingPlanned
Jira / ServiceNowTicket sync, sprint management, cross-platform ITSMPlanned
AWS / Azure / GCPCloud resource management, billing, deploymentPlanned
Slack / TeamsChannel management, message posting, bot integrationPlanned
GitHub / GitLabRepo management, PR review, CI/CD triggeringPlanned
KubernetesCluster management, pod orchestration, scalingPlanned
Terraform / AnsibleInfrastructure as code, provisioning automationPlanned
Datadog / GrafanaMetrics queries, dashboard management, alertingPlanned
Exchange / O365Email, calendar, SharePoint integrationPlanned
Twilio / SMSText messaging, call routing, notificationsPlanned
StripeBilling management, subscription handling, invoicingIn Dev

Single Endpoint

Why This Exists

When Anthropic released MCP, we were excited. We immediately started connecting Claude to everything — our servers, Docker, Proxmox, databases, firewall, Home Assistant, phone system. Each one was its own MCP server with its own connection.

By the time we had 15 connections, Claude’s performance had visibly degraded. Response times went up. The AI spent more time managing tool connections than actually thinking about our questions. Context windows filled up with tool definitions instead of useful conversation. It was unusable.

That’s why we built Lightning MCP. One endpoint that aggregates everything. Claude connects once, sees all 180+ tools, and performs like it only has one connection — because it does.

The Difference

Without Lightning: Each MCP server adds connection overhead, tool definitions bloat the context, and the AI juggles multiple sessions. At 10+ servers, you feel it. At 20+, it’s broken.

With Lightning: One SSE connection. One set of tool definitions. The Bridge handles routing internally. Claude never knows there are 36 modules behind the curtain — it just sees one clean tool catalog.

Before Lightning

mcp_servers:
  - filesystem:     localhost:8821
  - postgres:       localhost:8823
  - redis:          localhost:8824
  - docker:         localhost:8825
  - proxmox:        localhost:8826
  - home-assistant: localhost:8828
  - pfsense:        localhost:8829
  - voipms:         localhost:8830
  ... # 15+ more connections
  
# Each adds ~200 tokens of tool defs
# Context fills up fast
# Response time degrades with every server
# One server crashes = broken session

With Lightning

{
  "mcpServers": {
    "lightning": {
      "url": "https://lmcp.your.ai/mcp",
      "transport": "sse"
    }
  }
}

# 1 connection
# 180+ tools
# Internal routing, zero overhead
# Bridge handles failover automatically
# Any module can hot-reload
# No context bloat

Works with Claude Desktop, Claude Code, Cursor, Windsurf, Cline, and any client that speaks MCP over SSE.

Persistent Memory

Standard MCP has no memory between sessions. Lightning adds a 3-tier persistence architecture so your AI never starts from zero.

Three Tiers

Tier 1 — Per-Project Redis: 16+ isolated databases (dedicated port ranges) with separate memory and conscience stores. 3-way active-active replication via KeyDB. Sub-millisecond. Source of truth.

Tier 2 — Unimatrix Vector Search: Qdrant DB with 4,264 embeddings using all-MiniLM-L6-v2. Search all projects simultaneously by meaning, not keywords. Filter by project, owner, category.

Tier 3 — Archive: PostgreSQL backup + full conversation transcripts via Continuum. Nothing is ever deleted.

Full breakdown of the memory architecture →

Active-Active Failover

Not active-passive. All three nodes accept requests simultaneously. KeyDB handles replication and conflict resolution. If any node goes down, the others are already running — zero switchover latency.

Node 1 (Primary)

● Active

Primary dev + production. All tools, Unimatrix, ITSM, Daily Planet.

Node 2 (Failover)

● Active

Full KeyDB replica. Independent Singularity. Full read/write.

Node 3 (Storage)

● Active

Third replica. PostgreSQL backup. ZFS archive. Full redundancy.

Bridge Endpoints

lmcp.node1.yourdomain.comlmcp.node2.yourdomain.comlmcp.node3.yourdomain.com

Each bridge connects to its own local Singularity instance. True independence — no node depends on another.

Explore Further

Memory Architecture →

Deep dive into 3-tier persistence, Unimatrix, and the designation system.

Daily Planet →

Autonomous AI newsroom with 4 reporters monitoring infrastructure 24/7.

Contact Us →

Learn about enterprise deployments and custom configurations.