[ 01 / 07 ]

[ MCP INTEGRATION ]

MCP INTEGRATION

[01/01]

Model Context Protocol · 1,576 Operators

Connect any AI client to
1,576 physics operators.

Connect Cursor, Windsurf, or Continue with one JSON paste. Claude Desktop works via a one-line npx wrapper. Or call the API directly — it's plain JSON-RPC over HTTPS.

POST /api/mcp · JSON-RPC 2.0 · Protocol v2024-11-05 · 7 tools · 64 domains

Get Your API Key → Connect in 60s

[ 00 / 07 ]

[ HOW IT WORKS ]

MODEL CONTEXT PROTOCOL · JSON-RPC 2.0 · CURSOR · WINDSURF · CLAUDE DESKTOP · CONTINUE · ANY MCP CLIENT

MCP Integration & SDK Reference

Paste one JSON config block, restart your AI client, and the full ZEQ physics operator library becomes native to your workflow. Works with Cursor, Windsurf, Claude Desktop, and Continue.

Paste one config block

Add the Zeq.dev MCP server entry to your AI client's config file with your API key. One file, one edit, done.

Restart your AI client

Claude Desktop, Cursor, or Windsurf will discover the server automatically at startup. No plugins, no extensions.

Ask any physics question

Your AI client now has 7 tools: zeq_compute, zeq_list_operators, zeq_pulse, zeq_verify, zeq_lattice, zeq_shift, and zeq_field_status. Every computation is grounded with KO42 and precision ≤ 0.1%.

MCP · JSON-RPC 2.0 · 7 TOOLS · CURSOR · WINDSURF · CLAUDE DESKTOP · CONTINUE · PHYSICS-POWERED AI

[ 00 / 07 ]

[ CONNECT IN 60 SECONDS ]

CURSOR · WINDSURF · CLAUDE DESKTOP · CONTINUE · CURL · PASTE CONFIG · REPLACE KEY · RESTART

Ready-to-paste config for every AI client

Pick your client below. Copy the config block, paste it into the right file, replace zeq_ak_YOUR_KEY_HERE with your actual key from your portal, and restart. That's it.

✓ Cursor — HTTP native ✓ Windsurf — HTTP native ✓ Continue — HTTP native ✓ Claude Desktop — stdio via mcp-remote ✓ Any client — direct curl / JSON-RPC

Step 1 of 3

Open ~/.cursor/mcp.json (or Cursor → Settings → MCP). Paste the block below.

~/.cursor/mcp.json

{
  "mcpServers": {
    "zeq-dev": {
      "type": "http",
      "url": "https://www.zeqsdk.com/api/mcp",
      "headers": {
        "Authorization": "Bearer zeq_ak_YOUR_KEY_HERE"
      }
    }
  }
}

Step 2 of 3

Replace zeq_ak_YOUR_KEY_HERE with the key from your portal.

Step 3 of 3

Save the file and accept the Cursor reload prompt. The 7 zeq-dev tools will appear in Composer and Agent mode.

Step 1 of 3

Go to Windsurf → Settings → AI → MCP Servers → Add. Paste the block below.

Windsurf MCP config

{
  "mcpServers": {
    "zeq-dev": {
      "type": "http",
      "url": "https://www.zeqsdk.com/api/mcp",
      "headers": {
        "Authorization": "Bearer zeq_ak_YOUR_KEY_HERE"
      }
    }
  }
}

Step 2 of 3

Replace zeq_ak_YOUR_KEY_HERE with the key from your portal.

Step 3 of 3

Click Save. Windsurf registers the server and all 7 zeq-dev tools become available in Cascade immediately.

Note: Claude Desktop uses stdio MCP servers, not HTTP. This config uses mcp-remote — a one-line npx wrapper that bridges the HTTP API to stdio. Node.js must be installed (nodejs.org).

Step 1 of 3

Open your Claude Desktop config file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "zeq-dev": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://www.zeqsdk.com/api/mcp",
        "--header",
        "Authorization:Bearer zeq_ak_YOUR_KEY_HERE"
      ]
    }
  }
}

Step 2 of 3

Replace zeq_ak_YOUR_KEY_HERE in the --header arg with your key from your portal.

Step 3 of 3

Save the file, quit Claude Desktop completely, and reopen it. On the next conversation, "zeq-dev" will appear in the tools panel. The first run downloads mcp-remote automatically via npx.

Step 1 of 3

Open ~/.continue/config.json (or Continue → Open Config). Paste the block below inside the root object.

~/.continue/config.json (add inside the root object)

"experimental": {
  "modelContextProtocolServers": [
    {
      "transport": {
        "type": "http",
        "url": "https://www.zeqsdk.com/api/mcp"
      },
      "requestOptions": {
        "headers": {
          "Authorization": "Bearer zeq_ak_YOUR_KEY_HERE"
        }
      }
    }
  ]
}

Step 2 of 3

Replace zeq_ak_YOUR_KEY_HERE with your key from your portal.

Step 3 of 3

Save the file and reload the Continue extension. All 7 ZEQ tools appear in the tool selector.

The MCP server is plain JSON-RPC 2.0 over HTTPS. You can call it from any language or tool.

1 — Test the live pulse (no key needed)

bash

curl https://www.zeqsdk.com/api/zeq/pulse

2 — List all 7 MCP tools

bash

curl -X POST https://www.zeqsdk.com/api/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tools/list","params":{},"id":1}'

3 — Call zeq_compute (requires your API key)

bash

curl -X POST https://www.zeqsdk.com/api/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer zeq_ak_YOUR_KEY_HERE" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "zeq_compute",
      "arguments": {
        "domain": "quantum",
        "inputs": { "mass": 9.11e-31, "velocity": 2.99e8 }
      }
    },
    "id": 2
  }'

CURSOR · WINDSURF · CLAUDE DESKTOP · CONTINUE · JSON-RPC 2.0 · MCP · PASTE CONFIG · REPLACE KEY · RESTART

[ 00 / 07 ]

[ AVAILABLE TOOLS ]

7 TOOLS · ZEQ_COMPUTE · ZEQ_LIST · ZEQ_PULSE · ZEQ_VERIFY · ZEQ_LATTICE · ZEQ_SHIFT · ZEQ_FIELD_STATUS

Seven tools become available automatically

Once connected, your AI client can call all 7 tools autonomously — you just describe what you want to compute in natural language. Two are public; five require your API key.

zeq_compute

Requires API key

Run a physics computation in any of 64 domains. Returns a ZeqState envelope with R(t), phase φ, Zeqond τ, precision ≤ 0.1%, and a zeqProof HMAC. KO42 is always included.

// Input schema
{
  domain:    string,    // required
  inputs:    object,    // required — numeric key/values
  operators: string[]  // optional — specific operator IDs
}

zeq_list_operators

Public — no key needed

List all 64 physics domains or show operator IDs for a specific domain. Use before zeq_compute to discover the right operators for your problem.

// Input schema
{
  domain: string  // optional — omit to list all 64 domains
}

// Returns operator IDs, equations, and domain group

zeq_pulse

Public — no key needed

Get the live HulyaPulse state — current Zeqond τ, phase φ, and R(t). Use to read the 1.287 Hz heartbeat, synchronise agent operations, or anchor any computation to a specific temporal moment.

// No input required — returns live pulse state
{} // empty arguments object

// Returns: zeqond, phase, R_t, pulseHz, timestamp

zeq_verify

Requires API key

Verify a ZeqState object — checks masterSum is within [0.999, 1.001], KO42 is present in operators, and precision is ≤ 0.001. Returns a boolean verdict and a full audit trail.

// Input schema
{
  zeqState: object  // the ZeqState envelope to verify
}

// Returns: valid (bool), masterSumCheck, ko42Check, precisionCheck

zeq_lattice

Requires API key

Project R(t) forward up to 64 Zeqond steps (49.7 s). Each step returns the future zeqond, phase φ, and exact R_t. Deterministic — not an approximation. For temporal forecasting.

// Input schema
{
  steps:  number, // 1–64, default 16
  domain: string, // optional
  inputs: object  // optional numeric inputs
}
// callsConsumed = steps count (each step = 1 quota deduction)

zeq_shift

Requires API key

Re-run a computation at a historical Zeqond. Pass a past zeqond index and inputs; get back the exact ZeqState that would have been produced at that moment. Full temporal reproducibility.

// Input schema
{
  zeqond: number,  // historical zeqond index
  domain: string,
  inputs: object
}

zeq_field_status

Public — no key needed

Query the ZeqField security system — cipher algorithm (AES-256-GCM), PBKDF2 parameters, ZEQ_FIELD_KEY configuration status, and the five active ZeqField protocol names. No key required.

// No input required
{}

// Returns: cipher, keyDerivation, ZEQ_FIELD_KEY status, protocols[]

Example — what the AI sees

// You say: "Compute the quantum energy for hydrogen at 13.6 eV"
// Claude calls zeq_compute internally and receives this result:

ZeqState — Quantum Mechanics
─────────────────────────────────────
masterSum  : 1.000514  (R(t) — grounded result)
operators  : KO42, QM01
zeqond     : 2283734512  (τ)
phase      : 0.3821  (φ ∈ [0,1])
precision  : 0.000663  (≤ 0.001 guaranteed)
pulseHz    : 1.287  (HulyaPulse carrier)
computedAt : 2026-03-25T12:34:56.789Z

Modulation : R(t) = S(t) × [1 + 0.00129 × sin(2π × 1.287 × t)]

result.S_t : 13.600000
result.R_t : 1.000514

7 TOOLS · ZEQ_COMPUTE · ZEQ_VERIFY · ZEQ_PULSE · ZEQ_LATTICE · ZEQ_SHIFT · ZEQ_FIELD_STATUS · KO42 · ≤0.1%

[ 00 / 07 ]

[ FULL SDK REFERENCE ]

30 REST ENDPOINTS · 1 WEBSOCKET · ZEQOND · HULYAPULSE · HULYAS PROTOCOL · ZEQCHAIN · CONSTANTS

30 REST endpoints + 1 WebSocket

The Zeq.dev Mathematical Framework exposes the full engine via HTTPS — Zeqond temporal system, HulyaPulse daemon, all 26 operator modules, HITE encryption, UDPDS detection, Zeq Chain, and more.

Method	Endpoint	Auth	Description
Health & System
GET	/health	—	Server health, version, uptime
HulyaPulse Daemon
GET	/daemon	—	Full daemon state — running, pulse count, Zeqond, phase, sin/cos
GET	/daemon/pulse-count	—	Live pulse count since daemon started
WS	/ws	—	Real-time 1.287 Hz tick stream — broadcasts Zeqond, phase, KO42, connections to all clients
Zeqond Temporal System
GET	/zeqond	—	Current Zeqond index, phase, phase radians, KO42, and Big Bang reference
GET	/zeqond/convert?unix=&zeqond=	—	Lossless bidirectional conversion: Unix ↔ Zeqond
GET	/zeqond/verify	—	Round-trip verification — confirms lossless mapping (error < 1e-9 s)
GET	/zeqond/bigbang	—	Zeqonds elapsed since the origin of the universe (4.35086×10¹&sup7; s reference)
7-Step HULYAS Protocol
POST	/process	Key	Full 7-step computation — domain, inputs → full ZeqState with all phase data
POST	/api/zeq/compute	Key	Run operators in any domain — returns result + ZeqState (main compute endpoint)
GET	/api/zeq/state	Key	Current ZeqState without a computation — zeqond, phase, masterSum, pulseHz
GET	/api/zeq/operators	Public	List all 1,576 operators. Filter with ?domain=classical-mechanics
POST	/api/zeq/wizard	Key	7-Step Wizard Protocol — sequential analysis passes with confidence intervals
POST	/api/mcp	Key	JSON-RPC 2.0 MCP endpoint — all 7 tools
GET	/api/zeq/pulse	Public	Live HulyaPulse SSE stream — one event per Zeqond (777 ms)
GET	/api/zeq/status	Public	System health + live operator count
UDPDS Sub-harmonics
GET	/udpds	—	Full UDPDS detection state — anomaly score, 7 sub-harmonic amplitudes
GET	/udpds/sub-harmonics	—	All 7 UDPDS sub-harmonic frequencies + proxy weights: 1.287, 0.6435, 0.32175 … 0.0201 Hz
Zeq Chain — Proof of Harmonic Convergence (PoHC)
POST	/chain/block	Key	Submit a block — SHA-256 hash, PLAT finality (FNV-1a), 1.554 s (2 Zeqonds) settlement
GET	/chain/height	—	Current chain height and latest PLAT hash
GET	/chain/clock	—	Chain clock — Zeqond-synchronised timestamp, energy per tx (~10¹&sup8; J Landauer minimum)
GET	/chain/consensus	—	Full PoHC 6-layer protocol description
Constants
GET	/constants	—	All 23 physical constants — k_B, ℏ, h, c, G, α, φ_golden, N_A, and Zeq-specific: T_Z = 0.777 s, f = 1.287 Hz, α_mod = 0.00129

Total: 30 REST endpoints + 1 WebSocket

30 REST ENDPOINTS · 1 WEBSOCKET · ZEQOND · DAEMON · PROCESS · UDPDS · CHAIN · CONSTANTS · ZEQSDK.REPLIT.APP

[ 00 / 07 ]

[ KEY CONCEPTS ]

KO42 PRIME DIRECTIVE · ZEQOND TEMPORAL UNIT · ZEQSTATE ENVELOPE · R(t) MASTER EQUATION

What makes every result different

KO42 — Prime Directive

Mandatory

Every computation is grounded by KO42 — the Metric Tensioner. It applies the HulyaPulse modulation R(t) = S(t) × [1 + α × sin(2πft)] to lock results to the universal 1.287 Hz carrier.

Zeqond — Temporal Unit

τ = 0.777 s

The Zeqond is the fundamental time unit: t_Zeq = t_Unix / 0.777. Every API response carries the Zeqond index at computation time, giving you a phase-locked timestamp traceable to the Big Bang.

ZeqState Envelope

≤ 0.1% precision

Every compute response wraps results in a ZeqState envelope containing R(t), phase φ, Zeqond τ, precision (always ≤ 0.001), and the synthesised master equation for your exact inputs.

Get your API key and connect in 60 seconds

Starter plan at $29/mo gives you 500 compute tokens/day — enough to power any AI assistant or agent with full physics grounding.

View Plans & Pricing → AI Reference (/llms.txt)

MCP Tool Schema Reference

Every ZEQ MCP tool follows a consistent schema. The tool name is composed as zeq_{domain}_{operator} — for example, zeq_mechanics_momentum or zeq_thermodynamics_entropy_change. Inputs are described in the MCP tool definition and validated by ZFK before any computation occurs.

{
  "name": "zeq_mechanics_momentum",
  "description": "Compute linear momentum p = mv. Certified by ZeqProof. ≤0.1% precision.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "mass_kg": {
        "type": "number",
        "description": "Object mass in kilograms"
      },
      "velocity_ms": {
        "type": "number",
        "description": "Object velocity in meters per second"
      }
    },
    "required": ["mass_kg", "velocity_ms"]
  }
}

Agent 4 + ZEQ: Production Patterns

When integrating ZEQ MCP with Agent 4 or any Replit Agent, three patterns cover most use cases. First, the single-operator pattern: the agent selects one tool, provides inputs, and cites the ZeqProof certificate in its response. Second, the multi-operator pattern: the agent chains multiple tools in a single reasoning step, using output from one as input to the next. Third, the verification pattern: the agent calls a computation tool, then calls the ZeqProof verification tool with the returned certificate to confirm the result before presenting it to the user.

The verification pattern is recommended for any agent that presents physics results to end users. It adds one additional tool call but provides an end-to-end certified computation chain that can be audited independently.

Pattern 1

Single operator, direct citation of ZeqProof certificate.

Pattern 2

Multi-operator chain — pipe outputs across domains in one reasoning step.

Pattern 3

Compute + verify — call computation tool then ZeqProof confirmation.

Self-Hosting the MCP Server

For enterprise deployments, the ZEQ MCP server can be self-hosted. The server is a lightweight Node.js process that proxies MCP protocol messages to the ZEQ API. Self-hosting allows: custom domain binding, internal network deployment without egress, integration with private model infrastructure, and custom tool schema extensions.

Self-hosted installations require an Enterprise API key with the mcp_server scope enabled. Contact the enterprise team for the server bundle and deployment documentation. The bundle includes Docker and bare-metal deployment guides for Linux x86_64 and ARM64.

MCP Integration Note

The ZEQ MCP server conforms to the Model Context Protocol specification. Any MCP-compatible host (Claude Desktop, Cursor, Windsurf, Zed, or custom Agent 4 integrations) can connect to the ZEQ MCP server using the configuration above. No additional SDK or library installation is required beyond the standard MCP host setup.

ZEQ MCP · KO42 · ZEQOND · ZEQSTATE · R(t) · 1.287 HZ HULYAPULSE · PHYSICS-AS-A-SERVICE · FROM $29/MO

Connect any AI client to1,576 physics operators.

MCP Integration & SDK Reference

Paste one config block

Restart your AI client

Ask any physics question

Ready-to-paste config for every AI client

Give this prompt to Claude, GPT-4, or any AI

Seven tools become available automatically

30 REST endpoints + 1 WebSocket

What makes every result different

Get your API key and connect in 60 seconds

MCP Tool Schema Reference

Agent 4 + ZEQ: Production Patterns

Self-Hosting the MCP Server

Connect any AI client to
1,576 physics operators.