Correctover MCP Server - Real-Time AI Output Validation in 97ms

The first MCP server that verifies AI outputs in real-time with 6-dimension contract validation and automatic self-healing failover across 9 LLM providers.

title: Correctover MCP Server - Real-Time AI Output Validation in 97ms published: true description: The first MCP server that verifies AI outputs in real-time with 6-dimension contract validation and automatic self-healing failover across 9 LLM providers. tags: mcp, ai, llm, cursor

The Problem: MCP Tool Calls Fail Silently

You're using Cursor or Claude Desktop, relying on MCP tools to query docs, call APIs, run tests.

But the LLM providers behind those MCP tools fail constantly:

• DeepSeek returns 429 (rate limit)
• Claude throws 503 (server error)
• DashScope times out mid-generation

Your AI IDE doesn't tell you "the provider is down." It just hangs or returns garbage output. You waste time debugging something that was never your fault.

The Solution: A Reliability Layer for MCP

I built Correctover — an MCP Server that doesn't expose new tools. Instead, it enhances every existing call with real-time output validation and automatic failover.

Your IDE → MCP Call → Correctover → Pick Best Provider → Call API
                                                          ↓
                                              6-Dimension Validation
                                                          ↓
                                              ✅ Pass → Return Result
                                              ❌ Fail → Auto-Retry Next Provider

If a provider fails? It automatically switches and retries. You never notice. Your tools just work.

What Does 6-Dimension Validation Mean?

It's not "did it run without errors?" — it's "did it run correctly?"

Real benchmark: DeepSeek API call → 97ms response time → 6/6 dimensions passed.

3-Layer Self-Healing

When something breaks, Correctover doesn't just fail — it heals:

1. L1 — Auto Retry: Transient errors (429, 503, timeout) → retry with backoff
2. L2 — Semantic Degradation: Primary provider unhealthy → switch to fallback model
3. L3 — Cross-Provider Failover: All models down for a provider → route to different provider entirely

The key insight: Failover ≠ Correctover. Regular failover switches providers but doesn't verify the output. Correctover switches AND validates before delivering.

Installation: One Line of JSON

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "correctover": {
      "command": "npx",
      "args": ["-y", "correctover-mcp-server"],
      "env": {
        "DEEPSEEK_API_KEY": "sk-...",
        "MOONSHOT_API_KEY": "sk-...",
        "DASHSCOPE_API_KEY": "sk-..."
      }
    }
  }
}

Restart Cursor. Done.

That's it. No server to deploy. No Docker. No Redis. No PostgreSQL. Just npx and your API keys.

Supported Providers

9 providers out of the box, all BYOK (API keys never leave your machine):

Each provider also supports base URL override for proxies/mirrors.

Technical Details

• Language: Go (7.3MB single binary, zero dependencies)
• Protocol: Full MCP compliance (stdio transport)
• Tools exposed: chat, verify, providers, health
• Diagnostic latency: P50 22μs (pure code decision, no network)
• L3 Failover: tested across all 9 providers
• npm package: correctover-mcp-server@1.0.3

Where to Get It

• Official MCP Registry: Listed and searchable in VS Code 1.102+
• GitHub: github.com/Correctover/mcp-server
• npm: npm install correctover-mcp-server
• Smithery: smithery.ai/server/correctover/correctover-mcp-server (score: 82/100)
• Glama: glama.ai/mcp/servers/Correctover/mcp-server

What's Free vs Enterprise

Free (Open Core):

• Basic failover (L1 + L3)
• Structure + Schema validation
• 9 provider support
• BYOK, zero data leaves your machine

Enterprise (coming soon):

• Full 6-dimension validation
• Custom validation rules
• Team dashboard + audit logs
• SLA guarantee
• Private deployment

Why I Built This

Every developer using AI tools has experienced: API hangs, garbage output, silent failures. The MCP ecosystem is growing fast, but nobody was checking if the outputs are actually correct.

Correctover fills that gap. It's the reliability layer that MCP was missing.

Built by Correctover — Because failover switches. Correctover verifies.™

Have questions? Drop a comment or reach out on GitHub.