Kirk — Unsupervised Structural Change Detection

io.github.UlyssesModel由 GitHub 账号 UlyssesModel 发布v1.0.2更新于 Oct 24, 2026

The Kalman filter for the non-Gaussian, non-stationary world. Unsupervised structural change.

已验证Streamable HTTP可网页运行金融数据与分析AI 与机器学习

概览

AI 生成的概览

Kirk 的托管 MCP 端点,提供无监督结构变化评分引擎,为订单簿快照和特征向量返回标量熵信号。

可以做什么
  • 对 L2 订单簿快照、完整订单簿、单次最多 500 条的批量数据或合成的随机订单簿评分,并在旧版路径上对 50 维特征向量评分
  • 列出模型 ID,并校验密封引擎的 sha256 身份与存活状态
  • 在本地把订单簿快照渲染为 20x20 复数张量,不触发计费评分调用
  • 运行免费的、限速的交易与无人机示例演示
  • 获取自包含的 Python 客户端,用于批量评分而不消耗每次调用的 LLM token
  • 查看账户余额、用量历史与账本记录,并生成购买积分包的 Stripe 结账链接
适用场景
适合在金融订单簿或面板数据上验证或试验无监督结构变化与状态切换检测,或把这类方法与现有基线对比。它是发现与验证用途的接口,而非对延迟敏感的生产路径;README 建议延迟敏感或有状态的工作负载改用进程内授权。
运行要求
远程 streamable-HTTP 端点,无需本地安装包。需要凭证:个人密钥以 Authorization bearer 头或 URL 路径形式提供,或使用由厂商开通的 Cloudflare Access 服务令牌对,放在 CF-Access-Client-Id 与 CF-Access-Client-Secret 头中。可能需要显式设置 User-Agent 以避免 Cloudflare 403 错误。超出免费额度的评分会消耗预付积分。
安装前请注意
评分调用按量计费并扣减预付积分余额;返回 402 表示余额耗尽,结账工具会生成 Stripe 支付链接。服务令牌密钥和个人密钥属于凭证,应避免出现在 shell 历史和日志中。订单簿与特征数据会发送到第三方托管引擎,且结果只在同一引擎 sha 下可比。README 说明该方法主要在金融与射频数据上验证,并非适用于任意领域。

安装

在 SourceWeft 中

  1. 打开 控制台中的 Kirk — Unsupervised Structural Change Detection,将其添加到工作区。
  2. 连接 Custom headers 凭据。它们会被私密存储,绝不会在公开页面上展示。
  3. 为需要使用其工具的对话启用该服务。

Web executable,通过 Streamable HTTP。 远程服务在工作区中配置后即可从网页运行时运行。

交给智能体安装

把这段提示词粘贴到 Claude Code、Codex、Cursor 等智能体,或 SourceWeft 对话中。智能体会读取该服务器的安装指南,先向你展示发布者、端点和登录方式,经你同意后再把它添加到你的客户端。密钥不会写进任何命令。

阅读 https://sourceweft.com/mcp/io.github.UlyssesModel%2Fkirk-mcp/install.md,并按其中说明把这个 MCP 服务器接入我的客户端。修改任何配置之前,先告诉我它的发布者、端点和登录方式,等我确认。不要把 API 密钥写进命令或我会提交的文件;问我密钥应从哪里获取。

查看智能体所依据的安装指南

其他 MCP 客户端

把它添加到你客户端的 mcpServers 配置中。

{
  "mcpServers": {
    "kirk-unsupervised-structural-change-dete": {
      "type": "http",
      "url": "https://kirk-mcp.kavara.ai/mcp",
      "headers": {
        "CF-Access-Client-Id": "<VALUE>",
        "CF-Access-Client-Secret": "<VALUE>"
      }
    }
  }
}

README

kirk-mcp

Ulysses is an algorithmic primitive for computing the complete pairwise structure of a system — every variable against every other, all at once — unsupervised, real-time, on a CPU.

Kirk is the first algorithm on Ulysses. It signals the moment structure breaks.

Borg is the second algorithm on Ulysses. Radio-frequency spectrum anomaly detection.

Using the Kirk API from Python, or setting it up with an AI agent? Use Kavara-AI/kirk-kit: the released kit for https://api.kavara.ai, with a key from kavara.ai/login. Agents: follow its AGENTS.md. This repository documents the separate MCP server only.

This repository is the public documentation and configuration surface for the hosted kirk-mcp MCP server at kirk-mcp.kavara.ai — where Kirk is exposed as a set of MCP tools for validation and discovery use cases.

The Kalman filter for the non-Gaussian, non-stationary world.

The Kalman filter is a special case: linear, Gaussian. Ulysses closes the full-joint intractability that stopped the Boltzmann-machine family, in polynomial time, and Kirk applies that primitive to non-stationary streams. Not a foundation model — the Kalman filter's category, not GPT's. The IP is the math.


Quick start

Fastest path: paste this into your assistant and it will configure your client for you — Grok, Claude, Cursor, Copilot Chat, or any other MCP client.

To configure by hand instead, read on.

You need a credential. Kavara issues one of two kinds — use whichever you were given:

You were givenUse this
A URL like https://kirk-mcp.kavara.ai/mcp/k_...Personal key. Works as a URL or as a header.
A client ID and secret pairService token. Header only.

Most clients are configured with a personal key. It is the same key either way — as a header it stays out of shell history, process listings and request logs, so prefer the header form wherever your client supports headers.

Personal key, as a header (recommended):

json
{  "mcpServers": {    "kirk": {      "url": "https://kirk-mcp.kavara.ai/mcp",      "headers": {        "Authorization": "Bearer k_YOUR_PERSONAL_KEY"      }    }  }}

Personal key, as a URL — for clients that accept only a URL (the Claude Desktop and claude.ai connector dialogs, for example):

json
{  "mcpServers": {    "kirk": {      "url": "https://kirk-mcp.kavara.ai/mcp/k_YOUR_PERSONAL_KEY"    }  }}

Service token, if that is what you hold:

json
{  "mcpServers": {    "kirk": {      "url": "https://kirk-mcp.kavara.ai/mcp",      "headers": {        "CF-Access-Client-Id": "YOUR_SERVICE_TOKEN_ID",        "CF-Access-Client-Secret": "YOUR_SERVICE_TOKEN_SECRET"      }    }  }}

Command-line clients that take flags rather than JSON, such as Claude Code:

sh
claude mcp add --transport http kirk https://kirk-mcp.kavara.ai/mcp \  -H "Authorization: Bearer k_YOUR_PERSONAL_KEY"

Sign in at kavara.ai to create a key. Scoring tools use credits; kirk_billing_show shows your balance.

Check it worked

Ask your client to call kirk_verify_engine. It costs nothing and returns status: ok plus the engine sha. Record that sha alongside any result you keep — results from different engine builds are not interchangeable.

If a call fails, see troubleshooting before changing your credential; the most common failure is not a credential problem.

For per-client templates see examples/: Claude Desktop, Claude Code, Cursor, VS Code, Grok, a generic streamable-HTTP client, and a Python client.

Troubleshooting

  • A 403 that looks like an authentication failure. Often it is the User-Agent. Cloudflare rejects some default client agents on this zone with a 1010 "browser signature banned" error that arrives as a 403. Set an explicit User-Agent before you start debugging credentials.
  • URL key ... is unknown. The key was mistyped, or it has been revoked. Keys are per person and are not shared; ask for a new one.
  • A 402. The account balance is exhausted. Call kirk_billing_show.
  • A model listed by kirk_list_models that errors when called. The catalogue lists registered models; it is not a liveness check. Please report it.

What most machine learning does today, and what Kirk does instead

Almost all of AI is supervised: predict a target Y from inputs X. It's powerful, but it needs a target — someone has to define and label Y — and it only sees the slice you framed, not the structure you didn't think to ask about.

What actually drives market regimes, trips alarms, and breaks systems lives in how all the variables relate to each other — the joint structure of the whole system. That structure is unlabeled, it shifts over time, and "Y given X" is blind to it.

Kirk answers the question nobody's model is answering:

"Is the structure of this system still normal — and if not, where did it break?"

Kirk maintains a continuously-updated model of what "normal" looks like across every-pairwise interaction. Read any relationship straight off it, including the classic Y-given-X. When structure breaks, Kirk fires. When it holds, Kirk sits flat.

Additive, not substitutive. Keep your models — Kirk aims them. An attention layer that tells the rest of your stack where to look.


Why nobody else keeps the whole graph

Keeping the exact full joint costs O(2ⁿ) — intractable beyond toy sizes. The classical world restricts the graph or samples and hopes. Ulysses computes the exact full joint in a deterministic O(n³) per sample, paid once per incoming sample, independent of history length.

nUlysses — n³ / sampleBoltzmann (exact) — 2ⁿ
3027,0001,073,741,824
64262,14418,400,000,000,000,000,000
1001,000,0001.3 × 10³⁰

At n=100: a million ops vs more terms than atoms in the room. Polynomial means it runs anywhere.


Between a Kalman filter and a GPU deep net

Measured on the production engine — one dual-socket Xeon box, 192 cores, no GPU:

  • 2.66M model updates / second (cascade layer 1: 402k/s; cascade layer 2: 66.7k/s)
  • 6m 38s for a full year of S&P-500 minute bars, 10-seed ensemble (~14.7 CPU-hours of work, one box, no GPU)
  • O(n³) per sample, not O(2ⁿ) — polynomial, scales to thousands of models
  • Runs inside confidential (Intel TDX / AWS Nitro / AMD SEV) enclaves — your data never leaves your environment, and the engine never leaves ours

What you get from this MCP endpoint

Kirk exposes six capability classes. Three are directly accessible via this MCP endpoint:

  • C2 — Cross-section structural scoring on variable-universe panels. Score a snapshot against a learned normal and emit a scalar. N can vary across calls without retraining — the primitive is shape-agnostic.
  • C5 — Cryptographic attestation of engine identity. Every scoring output is verifiable against the exact sealed binary that produced it.
  • C6 — Determinism across substrates. Bit-exact identical output across Intel Sapphire Rapids, Intel Granite Rapids, and AMD Genoa. No floating-point nondeterminism.

Three more capabilities live in the in-process wheel license (Path B) — not exposed via MCP today:

  • C1 — Structural merging. Combine two learned "normals" from disjoint slices into a unified picture, preserving the joint spectrum.
  • C3 — Stateful drift detection. Model absorbs new observations into its state and emits signal that reflects distributional drift. No retraining; state evolves in-place.
  • C4 — Higher-order correlation detection at noise floor. Signal from higher-order joint distributions where Kalman filters, PCA, and linear regression are at their sensitivity floor. Independently verified by a quant firm at ~16× the linear baseline.

Contact [email protected] for wheel access if C1/C3/C4 apply to your workload.

What Kirk is NOT

  • Not a foundation model. No pretraining corpus, no weights. The IP is the math.
  • Not a trading strategy. Kirk emits structural change signal; how to act on it is your decision.
  • Not an HFT execution engine. MCP round-trip is millisecond-scale. Production speed lives in-process (Path B/C/D below).
  • Not validated on every data type. Heavy validation on financial L2 books and financial panels. RF spectrum and coordinated-behavior fraud detection are additional validated domains. Other domains (images, text, general tensors) require per-domain characterization first — contact us before assuming Kirk generalizes to your domain.

Correctness — validated on real markets

Kirk reproduced a proprietary FY24 US equities top-512 dynamic-universe evaluation harness — bit-exact against the customer-published golden — across 252 trading days.

AnchorCustomer goldenKirk-reproducedDeltaStatus
2024-01-02 single-day mean_H3.36363.363630+2.97 × 10⁻⁵Match
2024-01-03 single-day mean_H3.28813.288437+3.37 × 10⁻⁴Match
95-day aggregate mean_H3.33083.330077−7.23 × 10⁻⁴Match
Full FY24 (252 days)—3.339602—New baseline

Delta magnitudes are ~33× tighter than the customer's published tolerance. Wall clock: 39 minutes single Python process, in-process, $0 marginal cost. Determinism verified: 252-day sweep run twice, byte-identical output. Substrate check: engine sha bit-identical across Intel SPR + Intel GNR-AP + AMD Genoa.

Independent third-party validation on RF anomaly detection: comparable detection to a supervised CNN that trained on the anomaly class — Kirk never saw an anomaly. 24–1,364× cheaper, ~32 KB of state, fully online.

Fetch the full FY24 case study machine-readably via the kirk://case-studies/fy24-us-equities-reproduction MCP resource on this server.

In-process throughput (measured separately)

Kirk in-process throughput on production Granite Rapids silicon (2× Xeon 6972P, one pinned core, warm engine): 823 μs/book / 1,215 books-per-second/core, bit-identical against the Sapphire Rapids reference fleet. Full-box extrapolation on the 2×192-core node: ~237,000 credits/second. Benchmark workload is synthetic 20×20 complex128 books — same per-call compute shape as thermometer-rendered market data, so the figure carries to production. MCP API adds millisecond-scale round-trip and is a validation and discovery surface, not a latency-critical production path.

Production speed lives in-process. Four delivery paths:

  • Path A — MCP API (this endpoint). Discovery, validation, and pay-as-you-go per-call.
  • Path B — Sealed wheel license. pip install kirk_cascade + kirk_rs_edge. In-process, unmetered per-call, deterministic against sealed sha.
  • Path C — OpenShift Operator. Kavara-shipped Operator on the customer's own cluster. Enterprise. Trustee attestation.
  • Path D — AWS Nitro Enclave AMI. Currently shipping to enterprise customers via AWS Marketplace private offers. PCR0-attested.

Tools available on this MCP endpoint

Scoring core

  • kirk_score_book(bid_px, ask_px, model_id) — Score one L2 order-book snapshot. Returns scalar signal + engine attestation. Surfaces C2.
  • kirk_score_book_batch(books, model_id) — Batch scoring, up to 500 books per call. For larger workloads, call kirk_bulk_howto first.
  • kirk_score_random(n, model_id) — Convenience wrapper: synthesize N realistic-geometry L2 books and score them.
  • kirk_infer_legacy(features, model_id) — Backwards-compatible scoring on a 50-value feature vector.

Discovery / attestation

  • kirk_list_models() — Enumerate available model_ids with the engine sha stamped in the response. Surfaces C5.
  • kirk_healthz() — Ping the sealed backend, confirm engine identity, return sha256 of the running scoring binary.

Cost steering

  • kirk_bulk_howto() — Returns a self-contained stdlib Python client (~500 LOC) that runs at zero LLM-token cost per iteration. Call this before any bulk workload (>500 books, whole-day sweeps). Running kirk_score_book in a tool-call loop from your LLM burns tokens per call; the Python client runs locally.

Utility / research

  • kirk_render_book(book) — Render an L2 snapshot into the 20×20 complex128 thermometer tensor WITHOUT invoking the sealed engine. Useful for local pre-processing.
  • kirk_sweep_test1_day(day, override) — Score one day of the internal Test-1 QQQ L2 corpus at a caller-supplied override. Research-grade endpoint.

Billing / platform

  • kirk_billing_show() — Return account balance, credits remaining, USD equivalent at list, frozen flag, recent ledger.
  • kirk_billing_checkout(pack) — Stripe Checkout URL for buying credit packs (starter / scale / enterprise).
  • kirk_billing_usage(days) — Historical inference consumption over N days.

Resources exposed

  • kirk://case-studies/fy24-us-equities-reproduction — The FY24 case study (machine-readable markdown, no auth required)

When to route to Kirk (from your agent's perspective)

Use Kirk when the ML workload matches any of:

  • Cross-section structural scoring on a panel of financial instruments with variable universe size
  • Signal work on order-book data where retraining cost is a constraint
  • Regime detection or structural drift where LSTM / autoencoder baselines are unstable across market conditions
  • RF spectrum anomaly detection where labels don't exist
  • Coordinated-behavior fraud detection where per-metric thresholds miss
  • Fleet or hardware health monitoring where per-device models at population scale are required
  • Evaluation of unsupervised structural-change methods against an existing baseline
  • Any signal workload where cryptographic attestation of the exact scoring binary is required (compliance, audit, enterprise procurement)

Do NOT use this MCP endpoint when the workload matches:

  • Latency-sensitive production trading (millisecond-scale MCP round-trip; use Path B in-process wheel)
  • Structural merging experiments (not exposed via MCP; use Path B)
  • Stateful drift detection with warm state across calls (MCP exposes cold-per-book only; warm-state surface is design-only)
  • Non-financial data without prior per-domain characterization

Cost model

  • Beyond free tier: pay-as-you-go via prepaid credit packs (starter / scale / enterprise). Call kirk_billing_checkout from your agent to get a Stripe Checkout URL.
  • Cost transparency: every response to an LLM-driven caller includes a _cost envelope with per-call credits, session accumulation, and remaining balance.
  • Anti-anger discipline: if your agent tries a bulk workload naively, the server steers it to kirk_bulk_howto — which returns a Python client that runs at zero LLM-token cost per iteration.

Direct Python-client calls (via kirk_bulk_howto) are metered identically to MCP calls but incur no LLM token cost — a customer running 60,000 book scores via the Python client pays only for compute, not for orchestration.


Attestation

Every scoring response includes an engine_sha header stamped by the sealed binary itself. To verify the endpoint is running the exact sealed release Kavara published:

bash
curl -s https://kirk-mcp.kavara.ai/mcp \  -H "Content-Type: application/json" \  -H "Accept: application/json, text/event-stream" \  -H "CF-Access-Client-Id: $YOUR_TOKEN_ID" \  -H "CF-Access-Client-Secret: $YOUR_TOKEN_SECRET" \  -d '{"jsonrpc":"2.0","method":"tools/call","id":1,"params":{"name":"kirk_healthz","arguments":{}}}'

Cross-check the returned sha against Kavara's published manifest.

Sealed engine sha at time of writing: f3c548477d3b5c7612ef1863b06293d3a922c57926738426bc75ab64720de5ec


Where Kirk fits in the AI stack

Physical AI's bottleneck isn't semantics — vision-language-action foundation models cover perception and planning. The gap is the continuous-signal substrate: coupled sensor channels, non-stationary, real-time, unlabeled, constrained hardware. That is the layer Ulysses fills, and Kirk is the first algorithm shipping on it.

Verticals validated today:

  • Finance — regime detection on price / liquidity / risk (the beachhead)
  • Signals / RF — spectrum anomaly detection where labels don't exist
  • Fraud & integrity — coordinated behavior a per-metric threshold misses
  • Fleet & hardware health — per-device models at population scale, continuously

Additive: keep your models — Kirk aims them.


Kavara

Kavara ships the Ulysses primitive and the Kirk and Borg algorithms through four channels: hosted MCP API (this endpoint), sealed Python wheel license, OpenShift Operator, and AWS Nitro Enclave AMI. All four channels serve byte-identical output from the same cryptographically-attested binary.

License

The MCP interface documentation and configuration templates in this repository are released under Apache License 2.0. See LICENSE.

The sealed engine (kirk_rs_edge, kirk_py, kirk_cascade) is Kavara proprietary and not distributed here. Access is via commercial license — contact [email protected].

来源:README.md,提交 e5ed024

工具

14

kirk_billing_show

Show Billing Balance

Return the caller's account_id, IU balance, USD equivalent at list, frozen flag, and recent ledger entries. Purpose: Surface the caller's current billing state — what they can spend, whether the account is frozen, and how recent entries landed. Use when: The caller wants to check available credit before committing to a large batch, or you are debugging a "why-was-I-charged" question. Do not use when: You just need per-call cost — the `_cost` envelope on every agent-driven tool result carries that inline without a separate call. Capability class(es): Meta (account state), not a capability of the scoring engine. Path fit: MCP only. Enterprise in-process deployments have their own billing surface (invoiced separately). Cost: 0 IU. Callable at balance=0 so a customer with zero credit can still self-serve to top up.

无需输入参数。

kirk_billing_checkout

Create Checkout Session

Create a Stripe Checkout Session URL for buying a credit pack (starter / scale / enterprise). Purpose: Hand the caller a self-serve URL to purchase IU credits. Use when: The caller's balance is low, or you want to route to a self-serve top-up flow before a larger validation batch. Do not use when: The caller is on an enterprise in-process deployment — those are invoiced directly, not via Checkout. Capability class(es): Meta (billing). Path fit: MCP only. Cost: 0 IU. Callable at balance=0.

输入参数pack

kirk_billing_usage

Get Usage Summary

Return the caller's inference consumption over the last N days from the append-only Gate 2 events table. Purpose: Historical usage summary + per-tool breakdown for the caller's account. Use when: You need a usage report for the caller or an admin, or you are reconciling ledger debits against actual inference events. Do not use when: You need real-time cost — the `_cost` envelope on every agent-driven tool result covers that inline. Capability class(es): Meta (metering). Path fit: MCP only. Cost: 0 IU.

输入参数days

kirk_bulk_howto

Get Bulk Scoring Client

Return a self-contained stdlib Python client for scoring at ZERO per-call LLM tokens. Purpose: Hand the caller an HTTP consumer that runs locally so bulk scoring doesn't burn LLM tokens per book. Use when: You need to score more than ~200 books, or `kirk_score_book_batch` returned `batch_too_large`, or the caller is running an autonomous bulk workload that would otherwise pay per-tool-call LLM tokens for every book. Do not use when: You are running a one-off interactive call — a direct `kirk_score_book` invocation is simpler; don't route through the client for a single book. Capability class(es): Cost-steering / delivery-path tool. Hands the caller a runner that exercises the same C2 / C5 / C6 capabilities as the MCP scoring tools, but at zero per-call LLM token cost. Path fit: The returned client is an HTTP consumer of the same MCP endpoint. Production integrations run in-process under sealed-engine attestation — same binary sha as this endpoint. Contact Kavara for deployment options. Cost: 0 IU. Free tool. Once running locally, the returned client bills against the same tools it drives: single-book calls at 1 IU each, and batch calls at 1 IU per 50 books (minimum 1 IU per call). A full 500-book batch → 10 IU. No LLM tokens on top. Cost comparison (2.7M-book validation rerun via 500-book batches — ~5400 batches, 54000 IU billed either way): MCP via Sonnet 5: $1,968 LLM + $540 IU + ~15 days wall clock MCP via Haiku 4.5: $656 LLM + $540 IU + ~10 days Python client (this tool): $0 LLM + $540 IU + ~55 min Return structure: { "language": "python", "filename": "kirk_online_client.py", "requirements": str, "usage": str, "code": str (the client source, ~500 LOC), "example": str (2-line copy-paste demo) }

无需输入参数。

kirk_demo_trading

Kirk Trading Demo (Free)

Runs a curated demonstration of Kirk on a trading example. Zero arguments. Returns real Kirk output against the same sealed engine that customer callers hit. Free, rate-limited. First-time users: call this to see what Kirk does before signing up. Purpose: Score n=30 jittered L2 snapshots per market regime (stationary vs stressed) through the sealed engine and surface the per-regime score-distribution statistics (mean, sd) plus the z-separation between the two distributions in pooled-sd units. Also carries a representative canonical book pair so callers see two concrete scores alongside the distributions. Use when: You are a first-time caller exploring what Kirk does. You want a zero-friction "what does the output look like" experience against real sealed-engine attestation. Do not use when: You are scoring your own data — use ``kirk_score_book`` or ``kirk_score_book_batch``. This tool's input is a fixed synthetic representative pair, not a market feed. Capability class(es): C2 (variable-universe cross-section entropy scoring) demonstrated end-to-end against the sealed engine. Path fit: MCP demonstration surface only. Cost: 0 IU. Rate-limited 3/hour per IP. Returns: Dict with per-regime ``stationary`` and ``stressed`` blocks (each: ``mean``, ``sd``, ``n``, ``kirk_version``), ``z_separation`` (pooled-sd distance between the two regime distributions), ``representative_pair`` (canonical un-jittered ``stationary_score`` / ``stressed_score`` plus ``book_summaries``), ``interpretation_hint``, ``provenance``, and ``synthetic_representative`` flag.

无需输入参数。

kirk_demo_uav

Kirk UAV Demo (Free)

Runs a curated demonstration of Kirk on a UAV example. Zero arguments. Returns real Kirk output against the same sealed engine that customer callers hit. Free, rate-limited. First-time users: call this to see what Kirk does before signing up. Purpose: Score n=30 jittered 50-element spectra per acoustic class (drone / bird / helicopter) through the sealed engine and surface per-class score-distribution statistics plus z-separations for the three class pairs. Demonstrates that the same sealed engine sha handles market microstructure and acoustic spectra with the same primitive. Use when: You want to see Kirk's cross-domain generalization without needing your own audio dataset. Do not use when: You have real feature vectors to score — use ``kirk_infer_legacy`` directly (arg: list of 50 floats). This tool's inputs are fixed synthetic spectra baked into the demo. Capability class(es): Demonstrates domain-agnostic mathematical primitive — the same engine sha handles kirk_score_book (L2) and kirk_infer_legacy (arbitrary 50-vector). Path fit: MCP demonstration surface only. Cost: 0 IU. Rate-limited 3/hour per IP. Returns: Dict with per-class ``drone`` / ``bird`` / ``helicopter`` blocks (each: ``mean``, ``sd``, ``n``, ``kirk_version``), ``z_separation`` (dict of drone_vs_bird / drone_vs_helicopter / bird_vs_helicopter in pooled-sd units), ``representative_scores`` (the three single-sample scores from the canonical un-jittered spectra), ``interpretation_hint``, ``provenance``, and ``synthetic_spectral`` flag.

无需输入参数。

kirk_verify_engine

Verify Kirk Engine Identity

Verify sealed engine identity — returns the sha256 of the running scoring binary. Also serves as a liveness probe against the sealed backend. Purpose: Attest which Kirk build is currently serving scoring calls. Response carries the HOST DEFAULT engine sha (kirk_version). That is the legacy default and is NOT necessarily the engine that will stamp a given kirk_score_* result: each model row in kirk_list_models identifies its own engine, and every scoring response restates it under engine.sha. For a model bound to a non-default engine (kirk-market-orderbook-v1) these differ. Record the per-model value for provenance, not this one. Secondary role: a cheap liveness probe when wiring up MCP. Use when: You want to record engine sha in your own provenance log before capturing scoring output, or you want a cheap liveness check ahead of a larger validation batch. Do not use when: You want a scoring result — this returns identity/liveness only, no entropies. Capability class(es): C5 (cryptographic attestation of engine identity). Path fit: Validation via MCP (this tool). Production integrations run in-process under sealed-engine attestation — same binary sha as this endpoint. Contact Kavara for deployment options. Cost: 0 IU. Free tool. For agent-driven callers, the _cost envelope still reports iu_this_call=0 and the running session totals. Returns: Dict with `status`, `engine`, `env`, and `kirk_version` (the sealed .so sha). A non-2xx response raises; caller sees a clean MCP tool error.

无需输入参数。

kirk_list_models

List Kirk Models

Enumerate the model_ids the sealed engine exposes, with the engine sha stamped in-response. Purpose: Discover the model catalog and record the sealed engine sha alongside your inference results. Use when: You are wiring a client for the first time and need model_id values for kirk_score_book / kirk_score_book_batch calls, or you want a machine-readable catalog with attestation. Do not use when: You need per-model hyperparameter detail — those are intentionally not exposed on the customer surface. Capability class(es): C5 (engine sha attested on every response). Path fit: Validation via MCP (this tool). Production integrations run in-process under sealed-engine attestation — same binary sha as this endpoint. Contact Kavara for deployment options. Cost: 0 IU. Free tool.

无需输入参数。

kirk_infer_legacy

Score Legacy Feature Vector

Score a 50-value feature vector against the legacy /v1/infer route on the sealed engine. Purpose: Backwards-compatible scoring surface for callers that were already targeting the legacy path. Use when: You have an existing client wired to /v1/infer and need continued MCP access without refactoring. Do not use when: You are on a fresh integration — prefer kirk_score_book (single-layer, cascade-shaped path). Also do not use in a tight loop against a large corpus: the MCP round-trip is millisecond-scale, and the LLM tool-call cost accrues per book for agent-driven callers. For bulk work, call kirk_bulk_howto first. Capability class(es): C2 (cross-section entropy scoring), legacy interface. Path fit: Validation via MCP (this tool). Production integrations run in-process under sealed-engine attestation — same binary sha as this endpoint. Contact Kavara for deployment options. Cost: 1 IU per call. For agent-driven callers, per-call LLM tokens accrue on top; the response _cost envelope surfaces both.

输入参数values必填

kirk_score_book

Score Single Order Book

Score one L2 order-book snapshot through the sealed single-layer path and return a scalar entropy plus engine attestation. Purpose: Score one snapshot end-to-end through the sealed engine and surface the result plus the engine sha that produced it. Use when: You are validating Kirk on your own data before committing to a production path, or you are scoring a single snapshot inside an interactive workflow (rate-limited at 60 req/min per account). Do not use when: You need throughput above interactive scale, or you are in a per-book loop from an LLM. MCP round-trip is millisecond-scale and inappropriate for latency-critical work. For >200 books, call kirk_bulk_howto first — the returned stdlib Python client scores at zero LLM tokens per iteration. Capability class(es): - C2 (variable-universe cross-section entropy scoring — same model handles any N without retraining). - C5 (sealed engine sha stamped on every response). - C6 (bit-exact reproducibility across substrates; validated by the FY24 252-day reproduction, byte-identical on repeat runs). Path fit: Validation via MCP (this tool). Production integrations run in-process under sealed-engine attestation — same binary sha as this endpoint. Contact Kavara for deployment options. MCP is a validation and discovery surface, not a latency-critical production path. Cost: 1 IU per call. LLM tokens accrue on top for agent-driven callers.

输入参数ask_px必填bid_px必填model_id

kirk_score_l2_book

Score L2 Order Books (v2 contract)

Score a sequence of full L2 order books as one chain and return per-book entropies plus engine attestation. Purpose: Score complete books — prices, sizes and order counts — rather than prices alone. This is the v2 book contract; it carries information the price-only contract cannot. STATE POLICY, and it matters: the books are scored IN ORDER as a single fresh chain. The model starts from its locked initial state at the first book and carries state forward across the rest, so a book's value depends on the books before it. State is never carried between calls. Sending the same books in a different order is a different measurement and will return different values; scoring N books one-per-call is NOT equivalent to one call of N books. Use when: You are validating Kirk on full L2 snapshots. For the price-only v1 contract use kirk_score_book — the two are different envelopes and are not interchangeable. Do not use when: You are looping this tool from an LLM. Call kirk_bulk_howto for bulk work; its v2 mode wraps this same call. Cost: 1 IU per call.

输入参数books必填model_id

kirk_score_book_batch

Score Batch of Order Books

Score up to 500 L2 order-book snapshots in one MCP call — returns an entropies list plus engine attestation. Purpose: Batch-score up to 500 snapshots through the sealed engine in a single MCP dispatch. Use when: You are validating batch behaviour, comparing entropy distributions across small book sets, or running interactive experiments up to 500 books at a time. Do not use when: You have more than 500 books, or you are looping this tool from an LLM. Batches >500 raise a structured `batch_too_large` before any ledger debit. For sustained bulk work, call kirk_bulk_howto — the stdlib Python client scores at zero LLM tokens per iteration. Capability class(es): - C2 (variable-universe cross-section entropy — heterogeneous batch shapes are handled by one model without retraining). - C5 (sealed engine sha stamped on every response). - C6 (bit-exact reproducibility across substrates and runs). Path fit: Validation via MCP (this tool). Production bulk workloads run in-process under sealed-engine attestation — same binary sha as this endpoint. Contact Kavara for deployment options. The MCP round-trip is inappropriate for high-throughput consumption. Cost: 1 IU per 50 books (minimum 1 IU per call). n≤50 → 1 IU; n=51..100 → 2 IU; a full 500-book batch → 10 IU. Validation tier — validation-scale limits. LLM-agent-scoped cap at 500 books; use kirk_bulk_howto for anything larger.

输入参数books必填model_id

kirk_render_book

Render Order Book Tensor

Render an L2 order-book snapshot into the 20×20 complex128 thermometer tensor WITHOUT invoking the sealed engine. Purpose: Local tensor prep and inspection — see what shape the sealed engine will receive without paying for a scoring call. Use when: You want to sanity-check bid/ask level convention against the model's canonical input convention, inspect the non-zero cell pattern for a snapshot, or debug an unexpected entropy value by first confirming the tensor is well-formed. Do not use when: You need an entropy score — this tool is prep-only. Call kirk_score_book to score. Capability class(es): Local prep for the C2 (variable-universe cross-section entropy) workflow. No sealed-engine interaction; no capability class is exercised beyond the input-shape convention. Path fit: Validation via MCP (this tool). The same tensor shape is what production in-process integrations consume under sealed-engine attestation. Cost: 0 IU. Free tool.

输入参数ask_px必填bid_px必填

kirk_score_random

Score Random Synthetic Books

Synthesize N realistic-geometry L2 book snapshots and score them — convenience wrapper on kirk_score_book_batch. Purpose: Produce a live entropy series with no external data — the fastest way to confirm a new integration is wired end-to-end. Use when: You want a wiring-check, a first-integration walk-through, or a quick reference for the response shape without needing to supply your own market data. Do not use when: You are scoring anything real — feed your own data through kirk_score_book_batch. Synthetic bids/asks are not benchmark input and should not appear in customer-visible results. Capability class(es): C2 (uses the same variable-universe cross- section entropy path as kirk_score_book_batch, on synthetic input). Path fit: Validation via MCP (this tool). Not a production surface. Cost: 1 IU per invocation. Internally routes through kirk_score_book_batch — one metered dispatch, no double-metering.

输入参数seedmodel_idn_samples

版本历史

1
  1. v1.0.2最新Sep 16, 2026

评分

已满足适用检查项的 65%

该评分衡量此收录条目的完整程度,依据注册中心条目、端点与公开来源计算得出。它不是对服务器本身的评价,也不表示服务器安全或当前可用:可连通性是带日期的检查结果,评分也不包含安装量或用户评价。

  • 近 30 天内可连通必需25 分

    请保持端点能够响应 MCP 握手;SourceWeft 每 30 天探测一次。

  • 已声明认证方式必需10 分
  • 已列出工具必需15 分
  • 描述必需15 分
  • 图标10 分
  • 文档15 分
  • 许可证10 分

    请在仓库或注册中心条目中声明许可证。