MCP SERVER APACHE 2.0 NumPy ONLY

RGI MCP Server

Score decisions with conservation-bounded learning from Claude Desktop, Cursor, or any MCP client. One install. Zero infrastructure.

Why This Matters

Every MCP server today retrieves — documents, data, search results
None of them judge whether a decision is good and learn from the outcome
This one does: scores against learned centroids, checks a conservation law, compounds accuracy over time
Decision #500 is measurably better than #1 — the model didn't change, the decision infrastructure learned

Three capabilities no other MCP server provides:

Decision scoring — factor-weighted scoring against centroids shaped by verified outcomes
Conservation-bounded learning — won't update judgment from insufficient evidence (α·q·V ≥ θ_min)
Compounding trajectory — track how accuracy improves; the curve is the proof

1 · Install

2 · Launch

stdio transport (Claude Desktop, Cursor)

$ rgi-mcp-server \
    --categories alert_triage,incident_response,threat_detection \
    --actions investigate,escalate,mitigate,monitor \
    --factors severity,confidence,blast_radius,recurrence,time_sensitivity

HTTP transport (remote / hosted)

$ rgi-mcp-server --http --port 8080 \
    --categories alert_triage,incident_response \
    --actions investigate,escalate,mitigate \
    --factors severity,confidence,blast_radius

Categories, actions, and factors define your decision space. The server creates a ProfileScorer with centroid geometry matching your domain's tensor shape.

What the parameters mean

Categories — types of decisions (alert triage, incident response, threat detection). Each develops its own centroid geometry. No cross-contamination.
Actions — possible recommendations (investigate, escalate, mitigate). Scorer returns calibrated probabilities across all actions, not just top-1.
Factors — dimensions evaluated (severity, confidence, blast radius). Each decision is a point in factor space. Centroids = learned "ideal" position per action per category.
Tensor shape — (categories × actions × factors) = centroid geometry. Security with 3×4×5 = 60 centroid values evolving from verified outcomes.

3 · Claude Desktop Config

{
  "mcpServers": {
    "graph-attention-engine": {
      "command": "rgi-mcp-server",
      "args": [
        "--categories", "alert_triage,incident_response",
        "--actions", "investigate,escalate,mitigate",
        "--factors", "severity,confidence,blast_radius"
      ]
    }
  }
}

4 · Docker

$ docker build -f Dockerfile.mcp -t gae-mcp .
$ docker run -p 8080:8080 gae-mcp

5 · MCP Tools Exposed

⚡

score_decision

Score a decision using cross-graph attention. Returns recommended action, calibrated confidence, full probability distribution, entropy, and confidence gap.

📈

get_trajectory

Retrieve the learning trajectory — how scoring accuracy compounds over verified decisions. Shows the curve from cold-start to current state.

🛡

get_conservation_status

Check whether the system has sufficient evidence to learn. Returns α (coverage), q (quality), V (volume), θ_min (threshold), and the gate status.

The Loop: Score → Verify → Learn → Score Better

1. Score — factor vector → distances to every centroid → calibrated probability distribution
2. Act — agent or human takes the recommended action
3. Verify — outcome confirmed or overridden
4. Conservation check — enough evidence? α·q·V ≥ θ_min
5. Learn — gate open → centroids update (η_confirm = 0.05, η_override = 0.01)
6. Score better — next decision scored against centroids shaped by one more verified outcome

This is RGI. The model doesn't change. The decision infrastructure compounds from every verified outcome.

6 · How It Works

7 · The Conservation Law

Every scored decision is bounded by a conservation law — prevents learning from insufficient evidence:

Category coverage

Are you seeing all categories, or just the easy ones?

Observed quality

Accuracy on verified decisions within the sliding window

Verified volume

How many outcomes have been checked by a human or oracle?

# The conservation check inside the MCP server
from gae import compute_theta_min

threshold = compute_theta_min(
    alpha=0.72,       # coverage across 3 categories
    volume=47,        # verified decisions so far
    n_categories=3,  # alert_triage, incident_response, threat_detection
    n_actions=4,     # investigate, escalate, mitigate, monitor
    n_factors=5,     # severity, confidence, blast_radius, ...
)

can_learn = (0.72 * 0.83 * 47) >= threshold
# True  → centroids update from this outcome
# False → scoring continues, learning pauses

8 · Decisions Compound

9 · What You Can Do Now That You Couldn't Before

Ask Claude "should I escalate this alert?" — and get a scored recommendation with calibrated confidence, not a guess
Verify the outcome, and the next recommendation is better — centroids update from your verified decisions, not from generic training
Know when the system doesn't know enough — conservation gate tells you "not enough evidence yet" instead of confidently learning the wrong lesson
Track whether your AI is actually getting smarter — compounding trajectory shows the curve, not a dashboard number someone picked
Switch LLM vendors without losing judgment — the centroids, conservation state, and trajectory live in your system, not in the model
Run it on your laptop with your data — NumPy only, no cloud, no API key, no vendor lock-in

10 · Who This Is For

AI Engineers

Agents that decide, not just retrieve
One pip install, any MCP client
Decision scoring + learning built in

Enterprise Teams

Procurement, security, trading, operations
Decisions that repeat, outcomes that are verifiable
Compounds from your data, not generic training

Researchers

Decision systems, conservation laws, centroid scoring
Evaluation harness included
~194 experiments, every claim has an ID