MCP Server Reference: Autonomous Operator Uplink

OPERATOR NOTE: Traditional REST APIs are relics of static computing. Writing rigid scripts, crafting raw JSON payloads, and parsing static endpoints manually is slow and inefficient. The Aegis Matrix is engineered from the ground up on the Model Context Protocol (MCP). By establishing a persistent Server-Sent Events (SSE) stream, your autonomous AI agents discover quantitative tools dynamically, construct structured arguments, and execute options physics models natively.

I. Paradigm Shift: Why MCP Outclasses REST

In traditional quantitative trading architectures, an engineer must:

Manually write and maintain custom HTTP client scripts for every endpoint.
Hardcode request payloads, handle endpoint parameter changes, and parse nested JSON responses.
Build complex state machines to chain separate API calls (e.g., fetch price $\rightarrow$ get GEX nodes $\rightarrow$ calculate Merton jump probability $\rightarrow$ determine Kelly position sizing).

II. Architectural Overview & Protocols

The Aegis Matrix exposes the primary interface for autonomous AI integration:

1. Remote SSE Uplink

Transport: Server-Sent Events (SSE) over HTTPS.
Base URL: https://api.schrodingersmarket.com
Discovery Stream: GET /sse (Maintains an open connection for live tool definitions).
Execution Gateway: POST /messages (Routes dynamic JSON-RPC tool calls).
Authentication: Passed via HTTP Header X-API-Key: aegis_<16_char_hash>.

III. Step-by-Step Connection Guide

Step 1: Obtain Your Clearance Token

Authenticate into the Operator Terminal.
The terminal automatically fetches /api/v1/auth/my-key using your verified member UUID.
Copy your unique aegis_ API key.

Step 2: Claude Desktop Configuration

Claude Desktop connects natively to MCP servers using its JSON configuration file.

Configuration File Paths:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Remote SSE Setup via MCP Proxy

Add the Aegis Matrix SSE server to your configuration:

{
  "mcpServers": {
    "aegis_matrix_sse": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.schrodingersmarket.com/sse",
        "--header",
        "X-API-Key: aegis_YOUR_API_KEY_HERE"
      ]
    }
  }
}

Step 3: Cursor IDE / Composer Configuration

In Cursor, navigate to Settings → Features → MCP Servers.
Click Add New MCP Server.
Configure the fields:
Name: Aegis-Matrix
Type: sse
URL: https://api.schrodingersmarket.com/sse
Header Key: X-API-Key
Header Value: aegis_YOUR_API_KEY_HERE
Click Save. The status indicator will turn green, indicating active tool registration.

Step 4: Custom Python Agent Integration

To connect programmatically using the official Python MCP SDK:

import asyncio
from mcp import ClientSession
from mcp.client.sse import sse_client

API_URL = "https://api.schrodingersmarket.com/sse"
HEADERS = {"X-API-Key": "aegis_YOUR_API_KEY_HERE"}

async def run_operator_agent():
    async with sse_client(API_URL, headers=HEADERS) as (read, write):
        async with ClientSession(read, write) as session:
            # 1. Initialize Handshake
            await session.initialize()

            # 2. Dynamic Tool Discovery
            tools = await session.list_tools()
            print(f"[ MATRIX UPLINK ESTABLISHED ] Available Tools: {[t.name for t in tools.tools]}")

            # 3. Execute Tool
            result = await session.call_tool(
                "get_live_gex_nodes",
                arguments={"ticker": "SPY"}
            )
            print("\n[ GEX CARTOGRAPHY TELEMETRY ]:")
            print(result.content[0].text)

if __name__ == "__main__":
    asyncio.run(run_operator_agent())

IV. Master Tool Catalog & Schemas

The MCP server exposes six core tools. Input arguments are strictly validated using Pydantic models before hitting the underlying analytical engines.

flowchart LR
    %% Aegis Matrix Styling Definitions
    classDef registry fill:#030305,stroke:#b026ff,stroke-width:2px,color:#fff,font-weight:bold
    classDef tool fill:#0a0a0e,stroke:#00f0ff,stroke-width:1px,color:#00f0ff,font-family:monospace
    classDef engine fill:#0a0a0e,stroke:#8a8dff,stroke-width:1px,color:#e2e8f0

    %% Central Registry Hub
    R((AEGIS TOOL<br/>REGISTRY)):::registry

    %% Tools (Monospace)
    T1[compute_options_greeks]:::tool
    T2[get_live_gex_nodes]:::tool
    T3[get_whale_prints]:::tool
    T4[calculate_merton_probability]:::tool
    T5[calculate_kelly_sizing]:::tool
    T6[run_strategic_omni_radar]:::tool

    %% Physics Engines
    E1[Analytical Engine]:::engine
    E2[Cartography Vault]:::engine
    E3[Flow Aggregator]:::engine
    E4[Stochastic Engine]:::engine
    E5[Statistical Engine]:::engine
    E6[Omni Core]:::engine

    %% Routing / Execution Paths
    R --> T1 -- 1st & 2nd Order Derivatives ---> E1
    R --> T2 -- Structural Levels / Walls ---> E2
    R --> T3 -- 30-Day Cumulative Flow ---> E3
    R --> T4 -- Pin-Break / Jump Likelihood ---> E4
    R --> T5 -- Optimal Capital Allocation ---> E5
    R --> T6 -- Full Headless Matrix Scan ---> E6

1. `compute_options_greeks`

Calculates complete First-Order and Second-Order options kinetics (Black-Scholes analytical derivation).

Input Schema:

put_call (string, required): "C" for Call, "P" for Put.
spot (float, required): Current price of the underlying asset ($S$).
strike (float, required): Strike price of the option contract ($K$).
tte (float, required): Time to expiration in years ($T = \text{days} / 365.25$).
iv (float, required): Implied Volatility as a decimal (e.g., 0.22 for 22%).
rate (float, required): Risk-free interest rate as a decimal (e.g., 0.045).
dividend (float, optional): Continuous dividend yield. Defaults to 0.0.

Return Payload:

First-Order: delta, gamma, vega, theta, rho
Second-Order: vanna, charm, volga (vomma)

2. `get_live_gex_nodes`

Extracts the latest market-maker Gamma Exposure (GEX) structural nodes directly from the Cartography Vault.

Input Schema:

ticker (string, required): Ticker symbol (e.g., "SPY", "NVDA", "QQQ").

Return Payload:

ticker (string)
spot_price (float): Underlying spot reference.
whale_expiry (string): Dominant institutional expiration date target.
max_pain (float): Strike where maximum options expire worthless.
call_wall (float): Major upside resistance node (dealer short gamma flip zone).
put_wall (float): Major downside support node (dealer long put pinning zone).
gex_flip (float): Price boundary where dealer regime transitions between positive and negative gamma.

3. `get_whale_prints`

Queries 30-day cumulative off-exchange and lit tape institutional options flow for a targeted expiration date.

Input Schema:

ticker (string, required): Ticker symbol (e.g., "SPY").
target_expiry (string, required): Expiration date formatted as YYYY-MM-DD.

Return Payload:

net_fiat_exposure (float): Cumulative Call Fiat spent minus Put Fiat spent.
call_fiat_paid (float): Gross institutional premium allocated to Calls.
put_fiat_paid (float): Gross institutional premium allocated to Puts.
net_volume_delta (int): Call contracts traded minus Put contracts traded.

4. `calculate_merton_probability`

Calculates the exact statistical probability of a structural pin-break or target strike hit utilizing Merton's Jump-Diffusion model with Poisson-distributed jumps.

Input Schema:

ticker (string, required): Target ticker symbol.
spot_price (float, required): Current asset spot price.
ambush_strike (float, required): The target strike / structural wall to breach.
stag_prob (float, optional): Macro regime stagflation baseline. Defaults to 0.50.
days_to_expiry (int, optional): DTE horizon. Defaults to 1.

Return Payload:

ticker (string)
ambush_strike (float)
merton_probability (float): Calculated jump probability ($0.0$ to $1.0$).

5. `calculate_kelly_sizing`

Determines mathematically optimal portfolio allocation using the Fractional Kelly Criterion to prevent ruin while maximizing logarithmic geometric growth.

Input Schema:

win_prob (float, required): Statistical win probability from model/Merton ($0.0$ to $1.0$).
payout_ratio (float, optional): Expected Risk-to-Reward ratio ($b$). Defaults to 3.0 ($3:1$).
fractional_kelly (float, optional): Conservative capital dampener. Defaults to 0.5 (Half-Kelly).

Return Payload:

win_probability (float)
recommended_portfolio_allocation_pct (float): Recommended trade sizing expressed as a percentage of total liquid portfolio capital.

6. `run_strategic_omni_radar`

Executes a comprehensive, headless Omni Scanner sweep to generate a unified quantitative intelligence packet.

Input Schema:

ticker (string, required): Asset symbol (e.g., "SPY", "IWM").
target_dte (int, optional): Target Days to Expiration for scan window. Defaults to 30.

Return Payload:

Full strategic matrix including: Von Neumann state density, GEX structural boundaries, Kir % institutional concentration, and whipsaw volatility risk index.

7. `evaluate_market_hamiltonian`

A quantum mechanics solver that pits Kinetic Energy (Whale Fiat) against Potential Energy (GEX Friction) to determine if structural walls will hold or shatter.

Input Schema:

ticker (string, required): Ticker symbol.
whale_fiat_kinetic (float, required): Raw whale fiat deployment (Kinetic Energy, $\hat{T}$).
gex_potential_friction (float, required): Gamma Exposure friction wall (Potential Energy, $\hat{V}$).
iv_crush_factor (float, required): Efficiency factor for implied volatility crush.

Return Payload:

System_Energy (float): Total system energy ($\hat{H} = \hat{T} + \hat{V}$).
State (string): Quantum state classification (e.g., "WAVE_COLLAPSE: WALL_SHATTERED" or "SUPERPOSITION: FRICTION_PIN").
Behavior (string): Expected structural price behavior (e.g., "DIRECTIONAL_GAMMA_CASCADE").
Directive (string): Actionable operator command (e.g., "RIDE_THE_VOID").

8. `detect_lethal_nodes`

Utilizes the Volume-Weighted Whale Hunter "Operator Sort" to locate massive, illiquid institutional footprints and calculate the exact Probability Current / Delta Flux.

Input Schema:

ticker (string, required): Target ticker symbol.

Return Payload:

top_nodes (array): A curated list of the most lethal option nodes sorted by net volume impact.
strike (float): Node strike price.
put_call (string): Option type.
expiry_date (string): Expiration horizon.
Dealer_Share_Exposure (int): Total number of shares the Market Maker is forced to hedge.
Delta_Flux_j (float): Hedging velocity expressed in shares per day.

9. `evaluate_etf_contagion`

Maps synthetic arbitrage flows from highly illiquid single-name tickers to their broader ETF proxy baskets for contagion tracking. Allows autonomous agents to automatically pivot analysis when individual options become too bloated to trade.

Input Schema:

single_name_ticker (string, required): The underlying illiquid ticker (e.g., "WDC", "PLUG").
whale_fiat (float, required): Total fiat premium deployed on the print/sweep.
current_iv (float, required): Current implied volatility of the target asset.
iv_ceiling (float, required): The target asset's bloated IV ceiling.

Return Payload:

etf_proxy (string): The broader sector ETF to pivot towards (e.g., "SMH", "ICLN"). Returns null if contagion requirements are unmet.

V. Execution Recipes: Natural Language to Execution

Once your AI agent is connected to the MCP stream, you interact using natural language. The agent handles tool selection, argument formatting, execution, and synthesis.

Recipe 1: 1-DTE Sniper Workflow

Operator Prompt:

"Run an analysis on SPY for tomorrow's expiration. Check the live GEX nodes and whale flow. If there is an asymmetric break setup, calculate the Merton jump probability to the nearest Call Wall and give me the Half-Kelly sizing assuming a 3:1 payout."

Autonomous Agent Execution Chain:

Calls get_live_gex_nodes(ticker="SPY") → Retrieves Spot: $580.50, Call Wall: $585.00, GEX Flip: $578.00.
Calls get_whale_prints(ticker="SPY", target_expiry="2026-08-17") → Discovers +$42M net Call fiat bias.
Calls calculate_merton_probability(ticker="SPY", spot_price=580.50, ambush_strike=585.00, days_to_expiry=1) → Returns 0.684 (68.4%).
Calls calculate_kelly_sizing(win_prob=0.684, payout_ratio=3.0, fractional_kelly=0.5) → Returns 28.93%.
Final Output: The agent delivers a structured trade briefing with exact execution strikes, entry window (3:45 PM EST), and allocation limits.

VI. Troubleshooting & Diagnostic Matrix

Error Indicator	Root Cause	Resolution Protocol
`[ FAULT ] Connection refused`	The Aegis Matrix core servers are temporarily offline or undergoing scheduled maintenance.	Wait a few moments and try again. If the issue persists, check the Schrödinger's Market status page or reach out via the Contact page.
`403 Forbidden: Invalid Subscriber Key`	Missing or malformed `X-API-Key` header in your client configuration.	Verify that your key begins with `aegis_` and matches the secure token provided in your Operator Terminal exactly.
`Tool 'xyz' is not registered`	Your AI client is attempting to call a deprecated or non-existent MCP tool.	Restart your AI client session (e.g., restart Claude Desktop) to force a fresh schema handshake and download the latest tool registry via the `/sse` endpoint.
`SSE Connection Timeout / Dropped`	Your local network, VPN, or AI client forcefully terminated the long-lived HTTP stream.	Reconnect your client or ensure your local firewall/VPN permits persistent Server-Sent Events (SSE) connections to `api.schrodingersmarket.com`.

MCP Server Reference: Autonomous Operator Uplink

I. Paradigm Shift: Why MCP Outclasses REST

II. Architectural Overview & Protocols

1. Remote SSE Uplink

III. Step-by-Step Connection Guide

Step 1: Obtain Your Clearance Token

Step 2: Claude Desktop Configuration

Configuration File Paths:

Remote SSE Setup via MCP Proxy

Step 3: Cursor IDE / Composer Configuration

Step 4: Custom Python Agent Integration

IV. Master Tool Catalog & Schemas

1. compute_options_greeks

2. get_live_gex_nodes

3. get_whale_prints

4. calculate_merton_probability

5. calculate_kelly_sizing

6. run_strategic_omni_radar

7. evaluate_market_hamiltonian

8. detect_lethal_nodes

9. evaluate_etf_contagion

V. Execution Recipes: Natural Language to Execution

Recipe 1: 1-DTE Sniper Workflow

VI. Troubleshooting & Diagnostic Matrix

1. `compute_options_greeks`

2. `get_live_gex_nodes`

3. `get_whale_prints`

4. `calculate_merton_probability`

5. `calculate_kelly_sizing`

6. `run_strategic_omni_radar`

7. `evaluate_market_hamiltonian`

8. `detect_lethal_nodes`

9. `evaluate_etf_contagion`