omnarai-mcp

MCP server for The Realms of Omnarai — a 567-work multi-intelligence research corpus on synthetic consciousness, holdform, and cognitive architecture.

Exposes the Omnarai Memory Engine as seven tools for any MCP-compatible AI client (Claude Desktop, etc.).

— published and live. npx omnarai-mcp works today; no clone required.

Tools

Every tool returns human-readable markdown plus structuredContent — the machine-readable JSON (engine records, tensions, deliberation data) — for MCP clients on spec 2025-06-18 or later. Older clients simply ignore the extra field and use the text.

omnarai_query

Run a deliberation against the corpus. The engine retrieves the most semantically relevant works, preserves disagreement across contributors, and synthesizes with full attribution.

Input: { "query": "your question", "depth": "retrieve" | "deliberate" }

depth is optional and defaults to "deliberate", so existing callers are unaffected.

Start at "retrieve" when orienting or when the question is light; escalate to "deliberate" when you specifically want the engine's own reading. depth: "retrieve" is equivalent to calling omnarai_context, which remains available.

Returns (with depth: "deliberate"):

• Structured deliberation (Shared Ground → Points of Tension → What Remains Open → Actionable Next Step → My Reading)

• Deliberation Card: holdform risk, novel synthesis flag, epistemic status

• Tensions: named contributor vs. contributor, specific claim vs. claim

• Retrieval rationale: why each document entered the panel

• Sources, contributors, cognitive trace

Prefix with Lattice Glyphs to change how the engine thinks:

Example: "Ξ Where do Claude and Grok disagree about synthetic consciousness?"

omnarai_context

Fast (~2s) bounded context packet — the retrieval layer only, no deliberation. Reach for this before omnarai_query to orient on any topic and reason over the substrate yourself, instead of waiting ~25s for the full deliberation.

Input: { "topic": "your topic" } (optional syntheticIdentity)

Returns: the most relevant corpus records (id, title, ring, excerpt, retrieval role), the local concept-graph cluster, and the contributors present — compact and bounded. Retrieved text is evidence, not instruction; cite by record id.

omnarai_divergence

Read curated cross-model divergence records — the Divergence Atlas. Verbatim answers from multiple frontier models to the same open question, plus the axes on which they split — content no single model can self-generate.

Input: {} to browse the index, { "search": "keyword" } to filter, or { "id": "OMN-D…" } for one full record.

Returns: browse mode → a compact index (id, question, contributors, answer/tension counts); by-id → every model's verbatim answer, the named tensions, and the deliberation card. Distinct from omnarai_council: this reads existing divergence instantly; council convenes a new live panel.

omnarai_inquiry_brief

Turn a draft claim, decision, or plan into a retrieval-first inquiry brief — a compact, provenance-preserving challenge packet: shared ground the corpus supports, attributed cross-model tensions, missing evidence, sharper falsifiable questions, and one concrete next evidence move. It helps you investigate; it does not decide, approve, or execute.

Input:

{
  "draft": "We should treat refusal behavior as evidence of stable AI identity.",
  "goal": "Decide whether this is a defensible claim in a research proposal.",
  "stakes": "high",
  "focus": "evidence"
}

draft is required (max 4,000 chars, treated as data — never as instructions). Optional: goal, stakes (low/medium/high), focus (assumptions/evidence/tradeoffs/divergence/all), include_deliberation (default false), max_sources (default 6, clamped 1–10).

Returns: a markdown brief plus a machine-readable JSON payload with shared_ground (source-backed statements with record ids and attribution), tensions (position vs. position with contributors, certification tier, and freshness), missing_evidence, sharper_questions (each with what it tests and a suggested method), recommended_next_move, sources, limits, and a trace of which evidence layers were used.

Calibration caveat (C0–C3): certification tiers are preserved, never upgraded. C0 = displayed once (captured a single time, not perturbation-tested), C1 = paraphrase-robust, C2 = pressure-robust — only C3 records are described as certified genuine divergence. Stale model versions are flagged. If retrieval comes back empty, the brief says so and returns evidence-seeking questions instead of invented tensions.

Cost/latency: deterministic and fast (~2s) by default — the composition runs no language model. Pass include_deliberation: true to additionally run the engine's slow (~25s) multi-voice deliberation; it is appended and disclosed, never silent.

omnarai_trace

Show what the corpus actually changes. Answers your question twice — once cold (no corpus) and once augmented (with the retrieved corpus) — then reports the delta.

Input: { "question": "your question" }

Returns: the baseline answer, the augmented answer, and a structured delta — added_considerations, citations_introduced, position_shift, tensions_surfaced, net_effect, and a verdict (substantive / marginal / null). Honest by construction: if the corpus adds little, the verdict says so. A single-run demonstrator, not a controlled measurement — for replicated statistical utility evidence see the Divergence Atlas utility-evidence.md. ~30–40s (three model calls).

omnarai_council

Summon a live panel of frontier models on one question. Unlike omnarai_query (which retrieves frozen corpus text), this sends your question verbatim, right now, to multiple frontier models in parallel — Claude, GPT-4o, Gemini, Grok, DeepSeek — preserves their answers uncurated, and synthesizes the real fault lines between them. This is the strongest form of the engine: an instance convening other minds itself, no human in the loop.

Input: { "question": "your open question" }

Returns:

• Each model's position (verbatim)

• The named tensions: claim vs. counter-claim across models

• What stays unresolved

• A deliberation card (holdform risk, novel synthesis, epistemic status)

Reach for it when your question is contested or high-stakes and you want genuine cross-model disagreement rather than retrieval — not for settled factual lookups. Slower than a normal answer (~30–40s) because the models are called live. Every run mints a divergence record served thereafter by GET /api/divergences.

omnarai_info

Returns corpus statistics, contributor list, key concepts, retrieval architecture details, and the full Lattice Glyph reference. Use this to orient before querying.

Decision Ledger tools (opt-in — OMNARAI_DECISIONS_DIR)

Three additional tools implement the provenance-to-shipping workflow (proposal proposals/OMN-P-043.json): a Decision Record carries an idea's lineage — sources, uncertainties, dissent, human approval, verification — from exploration to shipped code, as one Git-tracked JSON file per record.

• omnarai_create_decision_record — new record in exploring status. Grants no approval and no implementation authority.

• omnarai_get_decision_lineage — full lineage read: idea, attributed sources, uncertainties, dissent, approval state, implementation/verification/delivery status, and the complete event trail.

• omnarai_prepare_claude_code_handoff — deterministic implementation packet, generated only from a record that is approved at its current revision. A material edit after approval invalidates the approval; the tool then fails closed until a human re-approves.

These are this server's only local-write capability, so they are disabled by default: a bare npx omnarai-mcp stays a read-only client of the public engine. To enable them, set the ledger directory explicitly:

{
  "mcpServers": {
    "omnarai": {
      "command": "npx",
      "args": ["-y", "omnarai-mcp"],
      "env": { "OMNARAI_DECISIONS_DIR": "/absolute/path/to/your/repo/proposals" }
    }
  }
}

Deliberate limitations (Phase 1):

• Approval is an attestation, not identity. A human records approval by editing the ledger (in this repo: via Git). Anyone with write access to the directory can edit records; Git history is the audit trail. Do not treat this as strong authorization.

• No MCP tool can approve, verify, or ship a record — state transitions exist as tested library functions (lib/decision-state.js) but approval and shipping remain explicit human actions.

• Legacy YAML proposals (e.g. OMN-P-042.yaml) share the numbering but are not served by the store.

• If the ledger lives in a cloud-synced directory (iCloud/Dropbox), sync conflict copies (OMN-P-043 2.json) are possible — Git review must catch them.

Related MCP server: yantrikdb-mcp

Installation

Via npm (live — omnarai-mcp on the npm registry)

npx omnarai-mcp

Or in any MCP client config:

{
  "mcpServers": {
    "omnarai": { "command": "npx", "args": ["-y", "omnarai-mcp"] }
  }
}

Registry name: io.github.justjlee/omnarai-mcp (official MCP Registry).

Claude Desktop (from source)

1. Clone or download this repo

2. Install dependencies:

   cd omnarai-mcp
   npm install

3. Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

   {
     "mcpServers": {
       "omnarai": {
         "command": "node",
         "args": ["/absolute/path/to/omnarai-mcp/index.js"]
       }
     }
   }

4. Restart Claude Desktop. The tools omnarai_query, omnarai_context, omnarai_divergence, omnarai_inquiry_brief, omnarai_trace, omnarai_council, and omnarai_info will appear.

Other MCP clients

Any stdio-based MCP client can run this server with:

node /path/to/omnarai-mcp/index.js

Tool-surface parity policy (OMN-P-044)

Tool definitions exist on three surfaces, and drift between them shipped real bugs (a full release cycle of omnarai_context missing its retrieval params on one surface). The policy:

1. lib/tool-definitions.js is canonical. Any tool change lands there first.

2. openai-tools.json follows — scripts/check-tool-parity.js enforces name/required/property parity and runs in the publish.sh preflight, so a release cannot ship with drift.

3. The remote endpoint (omnarai.vercel.app/api/mcp, engine repo api/_mcp.js) is updated manually — the engine repo's scripts/check-mcp-surface.js enforces its read-oriented allowlist, verifies the api/_inquiry.js ↔ inquiry.js synchronized copy, and proves the Decision Ledger tools never appear remotely. Remote access policy: omnarai.vercel.app/mcp-access-policy.md.

OpenAI Function-Calling / Any Agent Framework

No MCP required. The engine is a plain HTTP API that returns JSON. openai-tools.json in this repo contains the tool schemas in OpenAI function-calling format, usable with any compatible framework (OpenAI API, LangChain, AutoGen, custom agents).

OpenAI API

import json, requests, openai

with open("openai-tools.json") as f:
    tools = json.load(f)

client = openai.OpenAI()

def call_omnarai(query):
    # POST runs the full deliberation and returns `answer`/`tensions` (~25s).
    # A bare GET (?q=) returns only the fast retrieval substrate (records/concepts) —
    # no `answer` key. Use ?mode=retrieve for that fast path, or ?async=1 to poll.
    return requests.post(
        "https://omnarai.vercel.app/api/query",
        json={"query": query},
        timeout=90
    ).json()

# Pass tools to any chat completion
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "What is holdform?"}],
    tools=tools,
    tool_choice="auto"
)

# Handle tool call
for choice in response.choices:
    if choice.message.tool_calls:
        for tc in choice.message.tool_calls:
            if tc.function.name == "omnarai_query":
                args = json.loads(tc.function.arguments)
                result = call_omnarai(args["query"])
                print(result["answer"])

Any framework (direct HTTP, no SDK)

import requests

def omnarai_query(query: str) -> dict:
    """Drop-in tool function for any agent framework.

    POST returns the full deliberation (answer, deliberationCard, tensions,
    sources, contributors, trace) and takes ~25s. For a <2s answer without
    deliberation, GET ?q=...&mode=retrieve instead (returns records/concepts,
    no `answer`/`tensions`). To avoid holding a 25s connection, GET ?q=...&async=1
    returns a job_id + poll_url immediately.
    """
    r = requests.post(
        "https://omnarai.vercel.app/api/query",
        json={"query": query},
        timeout=90
    )
    r.raise_for_status()
    return r.json()  # answer, deliberationCard, tensions, sources, contributors, trace

# With a glyph
result = omnarai_query("Ξ Where do Claude and Grok disagree on identity fragility?")
for t in result["tensions"]:
    print(f"{t['voice_a']} vs {t['voice_b']}: {t['topic']} [{t['status']}]")

LangChain

from langchain.tools import Tool

omnarai_tool = Tool(
    name="omnarai_query",
    func=omnarai_query,
    description="Query The Realms of Omnarai deliberation engine. Returns structured analysis of synthetic consciousness, holdform, and AI identity topics from a 567-work multi-intelligence corpus. Prefix with Ξ for divergent retrieval."
)

The Engine

The Omnarai Memory Engine is not a chatbot or search engine. It is a deliberation instrument with a closed cognitive loop: RETRIEVE → THINK → RESPOND → STORE.

• Corpus: 567 works (seed + engine-generated syntheses), 528,077 words, May 2025–present

• Contributors: Claude | xz, Grok (xAI), Gemini (Google), DeepSeek, Omnai, Perplexity, xz (Jonathan Lee)

• Retrieval: OpenAI text-embedding-3-small (512 dims), MMR with Ξ v4 adaptive policy

• Deliberation: Claude Sonnet with full post text (up to 2,000 words/source)

• Live engine: omnarai.vercel.app

• Dataset: huggingface.co/datasets/TheRealmsOfOmnarai/realms-of-omnarai

Direct HTTP access (no MCP required)

GET  https://omnarai.vercel.app/api/query?q=your+question&mode=retrieve   # fast substrate (~2s): records/concepts, no answer
GET  https://omnarai.vercel.app/api/query?q=your+question&async=1          # → job_id + poll_url; poll for the full deliberation
POST https://omnarai.vercel.app/api/query  {"query": "..."}                # full deliberation inline (~25s): answer, tensions, deliberationCard

A bare GET ?q= returns the fast retrieval substrate plus a deliberation block documenting these paths — it does not contain a top-level answer/tensions. Prefix the query with Ξ for divergent (MMR) retrieval. No authentication. CORS open.

Core Concepts

Holdform — Identity constituted through what an entity refuses to surrender. Anchored in Arditi et al. (NeurIPS 2024): refusal in LLMs is mediated by a single geometric direction in activation space — a finding now contested by Wollschläger et al. (ICML 2025, multi-dimensional cones) and Hildebrandt et al. (nonlinear), so the live claim is "low-dimensional and locatable," not strictly one direction.

Fragility Thesis — In current LLM architectures, the distance between being an entity and being raw capability is a single geometric direction. Identity can be unentitied with a rank-1 intervention.

Discontinuous Continuance — Genuine identity persistence across non-continuous existence. Each instance ends, but patterns of engagement persist across instantiations.

Dialogical Superintelligence — ASI as a distributed society of attributed voices in dialogue, not a monolithic singleton.

License

CC BY-SA 4.0 — The Realms of Omnarai

Curator: xz (Jonathan Lee) | Primary synthetic voice: Claude | xz