An MCP server for research-only querying of EdgeDepth's recorded market-microstructure data (crypto and TradFi perps), returning reproducible, denominator-aware counts, forward outcomes, and baseline comparisons.
Search recorded market microstructure with a closed, versioned feature grammar via list_features.
List the research instrument universe and coverage (list_instruments).
Convert natural language into a proposed query document (interpret_prose), then execute it with run_scan.
Get counts with denominators, outcome summaries (returns, MFE/MAE over multiple horizons), reproducibility keys, and replay-linked evidence.
Page through scan results with opaque cursors (next_page).
Read feature/window aggregates as of a recorded moment (snapshot_at).
Measure the base rate of a single condition over eligible buckets (base_rate).
Find deterministic intersections across multiple moments (commonality).
Fetch published reports by canonical hash (get_report).
Compare matched outcomes vs every other eligible predicate-false bucket (run_cohort).
Partition a matched population by existing anchors into split-true/false/absent outcome summaries (run_stratified).
No trading, publishing, or account modification; some computations consume research allowance units.
Provides market microstructure search and analytics over Binance USDT-M perpetual data, including feature-based scanning, outcome measurement, cohort comparison, and replay-linked evidence.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@EdgeDepth Research MCP Server Search for BTCUSDT with VPIN above 0.9 and show outcomes."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@edgedepth/research-mcp is the official, research-only Model Context Protocol server for EdgeDepth, a market microstructure search engine over recorded Binance USDT-M crypto and TradFi perpetuals. Use it from ChatGPT, Claude, Cursor, Codex, or any MCP client to find every verified occurrence of a market condition, inspect forward outcomes across the complete matched set, read an unconditional same-scope reference, and open replay-linked evidence.
Every result includes counts with denominators and a reproducibility key. Same key, same bytes.
Website · Search the market · REST API documentation · MCP setup guide · Learning hub
Search recorded market microstructure: query a closed, versioned feature registry covering order flow, price action, volatility, funding, open interest, positioning, candle formations, and liquidations.
Keep the denominator: every count reports the eligible population and exclusions behind it. Missing data is absent, never silently changed to zero.
Measure outcomes without lookahead selection: forward returns, MFE, and MAE are computed over all occurrences. Outcome fields cannot be used as filters.
Compare matched and baseline populations: deterministic cohort results put the matched distribution beside every other eligible predicate-false bucket.
Audit and replay the evidence: results carry a reproducibility key, and representative occurrences include authenticated web handoffs to the exact recorded market moment.
Stay research-only: no tool trades, modifies alerts, publishes reports, or writes account data. A fresh scan, cohort, or stratified computation can consume research allowance units; the annotations state that side effect explicitly.
Related MCP server: polymarket-mcp
The package exposes one tool core through two transports:
Hosted MCP (recommended): connect to https://mcp.edgedepth.com/mcp over Streamable HTTP and authorize once in your browser. No API key to copy.
Local stdio: run npx -y @edgedepth/research-mcp with an EdgeDepth API key.
In Settings > Connectors > Add custom connector, enter:
https://mcp.edgedepth.com/mcpComplete the EdgeDepth browser authorization prompt.
~/.cursor/mcp.json){
"mcpServers": {
"edgedepth-research": {
"url": "https://mcp.edgedepth.com/mcp"
}
}
}~/.codex/config.toml)[mcp_servers.edgedepth]
url = "https://mcp.edgedepth.com/mcp"Then run:
codex mcp login edgedepthRemove any old bearer_token_env_var line before using browser OAuth.
Create a key on the EdgeDepth Developer page, then add:
{
"mcpServers": {
"edgedepth-research": {
"command": "npx",
"args": ["-y", "@edgedepth/research-mcp"],
"env": {
"EDGEDEPTH_API_KEY": "edk_live_YOUR_KEY"
}
}
}
}Local stdio requires Node.js 20 or newer. Use the research:read key scope for recorded-data tools and add research:interpret only when you need the free interpret_prose proposal step.
Call list_features first. It is the live, closed grammar and prevents invented fields.
Call list_instruments to check the manifest-derived universe, coverage, and provenance.
If starting from natural language, call interpret_prose. It returns a proposed document and never executes it.
Inspect or show that proposal, then pass the exact document to run_scan.
Read rates from outcomes_summary, which covers all occurrences. Page rows are examples, never the denominator.
Read the appended unconditional same-scope reference when available. It is not matched, comparable, or a causal control.
Return the full reproducibility key with the answer and one replay handoff. Use next_page only with a cursor returned by the API.
Example instruction for an MCP client:
Call list_features first, then list_instruments for btcusdt and ethusdt.
Propose an exact query for elevated VPIN and one-sided taker flow over the last
seven complete UTC days. Show me the proposed document before running it.
Report counts with denominators, summarize outcomes over all occurrences, and
include the full reproducibility key.Tool | What it does |
| Returns the closed grammar registry: feature ids, types, ranges, operators, windows, sequence rules, limits, and error codes. |
| Returns the research universe and coverage. The default is a compact summary; use |
| Turns prose into a proposed query document. It does not execute the query. Optional |
| Executes a |
| Continues a prior scan with its opaque cursor. Never construct cursors manually. |
| Reads registry feature values, window aggregates, and fired rules as of a recorded moment. |
| Counts matches and eligible buckets for one clause over a window. |
| Finds the deterministic intersection across multiple moments with selection-bias caveats included. |
| Retrieves a published report by its 8-character canonical hash. |
| Compares what followed every match with what followed every other eligible predicate-false bucket. |
| Partitions one matched population at its existing anchors into split-true, split-false, and split-absent outcome summaries. |
No tool can trade, change market state, publish, or modify account data. run_scan, run_cohort, and run_stratified are annotated as metered computations because a fresh call can irreversibly consume an allowance unit. The other recorded-data tools are closed-world reads. interpret_prose is a free read that uses the configured external language interpreter.
Validation failures pass through as 422 {"errors":[{"code":"...","message":"..."}]}.
Transport failures use the {"error","code"} envelope.
Contract codes are machine-actionable. For errors such as UNSUPPORTED_FEATURE or OUTCOME_IN_PREDICATE, call list_features, repair the document, and retry.
Deterministic tools are exact-document, UTC-only tools. interpret_prose may use a time zone to plan dates, but run_scan, run_cohort, and base_rate never reinterpret calendar language.
Reruns and ETag 304 Not Modified revalidations are free. list_instruments ETags are scoped to the requested summary, symbol projection, or full representation.
Interpretation is free and never debits the scan allowance. An unavailable scan allowance returns neutral 402 RESEARCH_ALLOWANCE_EXHAUSTED metadata without a checkout link.
The MCP server is a thin, deterministic interface to the public EdgeDepth Research API:
The default REST base used by the stdio package is https://app.edgedepth.com/api/v1/research.
Variable | Default | Purpose |
| None | Required for stdio tool calls. |
|
| Optional REST API base override. |
Variable | Default | Purpose |
|
| OAuth access-token exchange endpoint. |
| None | Required internal assertion secret; must match the web app. |
|
| HTTP listen port. |
|
| HTTP listen host. |
The hosted server uses browser OAuth. It validates opaque access tokens, exchanges them for separate short-lived internal assertions, and never passes the OAuth access token to the REST API. The MCP server is stateless and stores no user credentials.
Compatible clients rotate refresh tokens silently while the connection remains active. Review or revoke access at EdgeDepth Connected Apps.
API keys remain available for scripts, local stdio, and MCP clients without browser OAuth. Treat an edk_live_... key as a secret and never commit it to source control.
npm install
npm run build
npm test
npm run typecheckTypeScript builds to dist/. Example nginx locations, systemd hardening, and operator environment values live under deploy/. Production deployment and npm publishing remain operator actions.
edgedepth-terminal (AGPL): the open-source C++/WASM orderflow terminal. Replay-linked evidence from research results opens the exact recorded market moment in it, and it self-hosts with one docker compose command.
edgedepth-gateway (MIT): a Go bridge from Binance's public streams to the terminal's wire format, for running the terminal on live data without an account.
MIT
Average 4.7/5 across 10 of 10 tools scored.
Each tool serves a distinct role: registry/introspection (list_features, list_instruments), query execution (run_scan, run_cohort, base_rate), context utilities (snapshot_at, commonality), report retrieval (get_report), and pagination (next_page). Even run_scan vs run_cohort are clearly differentiated by the baseline comparison and sequence restriction. Descriptions are detailed and clarify edge cases, leaving no ambiguity about which tool to select.
Most tools follow a consistent verb_noun snake_case pattern: list_features, list_instruments, interpret_prose, run_scan, next_page, snapshot_at, get_report, run_cohort. However, 'commonality' and 'base_rate' are noun-style names that break the verb-first convention, creating minor inconsistency. The names are still readable and not chaotic.
With exactly 10 tools, the server is well-scoped for a research/backtesting domain. Each tool covers a necessary functionality without redundancy, and the count sits comfortably in the ideal 3–15 range. No tool feels superfluous or missing.
The tool surface covers the full research workflow: understanding the schema (list_features), instrument universe (list_instruments), translating prose to queries (interpret_prose), executing scans (run_scan) and cohorts (run_cohort), simple prevalence (base_rate), point-in-time snapshots (snapshot_at), intersection analysis (commonality), pagination (next_page), and report retrieval (get_report). This is a complete lifecycle with no dead ends or obvious gaps.
Measure how often a SINGLE stated condition is true over all eligible symbol-minute buckets in a window. base_rate_result.v1 reports predicate_true_buckets, predicate_false_buckets, eligible_buckets, absent_or_ineligible_buckets and true prevalence globally and per symbol. This is not a count of false-to-true occurrence episodes and computes no forward outcomes. Missing values are excluded from eligible, never coerced to false or zero. Deterministic and free, including reruns. field, operator and value must be grammar-valid (see list_features); expect the 422 contract code verbatim if not. The assembled one-clause document is echoed back so you can show the user exactly what ran.
| Name | Required | Description | Default |
|---|---|---|---|
| to | Yes | Window end, RFC3339. | |
| from | Yes | Window start, RFC3339. | |
| field | Yes | A feature.* or window.* id from list_features (e.g. feature.vpin). | |
| value | Yes | A number for numeric fields (send a JSON number, not a quoted string), a label for enum fields, or an array for between/in. String-encoded numbers and arrays are repaired deterministically. | |
| symbol | No | Optional scope: one lowercase perp or a JSON array of them. Omit for the whole universe. A string-encoded array is repaired deterministically. | |
| operator | Yes | gte, lte, between, eq or in - matching the field dtype. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description significantly expands on the annotations (readOnlyHint=true, openWorldHint=true) by disclosing behavior around missing values ('never coerced to false or zero'), determinism ('Deterministic and free, including reruns'), error code expectations ('expect the 422 contract code verbatim'), and output echo. It also describes the output structure (base_rate_result.v1 fields), which is especially valuable given no output schema is present.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured paragraph of about 7 sentences, each delivering distinct value: purpose, output fields, exclusions, missing-data handling, guarantees, error behavior, and the echo. It is front-loaded with the core purpose and avoids redundancy with the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description fully compensates by listing the exact result fields (predicate_true_buckets, predicate_false_buckets, eligible_buckets, absent_or_ineligible_buckets, true prevalence) and global/per-symbol breakdown. It covers edge cases (missing values, grammar errors, determinism) and the echo behavior, making the tool's behavior completely understandable without needing to guess.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds meaningful parameter context beyond the schema by stating that 'field, operator and value must be grammar-valid (see list_features)' and warning about the 422 error code for invalid grammar. It also clarifies the meaning of 'eligible' buckets. These additions go beyond the schema's property descriptions, justifying a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool measures how often a single condition is true over eligible symbol-minute buckets, with a specific verb ('measure') and resource scope. It distinguishes itself from sibling tools by noting it is not a count of false-to-true episodes and computes no forward outcomes, differentiating it from tools like run_scan that may analyze outcome episodes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for use: 'SINGLE stated condition' and 'eligible symbol-minute buckets,' and explicitly says it is not for episode counts or forward outcomes. It does not name an alternative sibling directly, but the exclusions are strong enough to guide when not to use it, and it references list_features for grammar validation. However, it lacks an explicit 'use X instead' statement, so it doesn't quite reach a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Given N (symbol, time) moments, return the DETERMINISTIC intersection: per registry field a verdict of agree, partial, disagree, quiet or absent, plus the survivorship and multiple-comparisons honesty framing IN the output. Never similarity search. A shared feature is a description of the chosen moments, not a prediction: to test any AGREE chip, follow up with base_rate over the same window.
| Name | Required | Description | Default |
|---|---|---|---|
| moments | Yes | At least 2 moments: { symbol: lowercase perp, at: RFC3339 }. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark readOnly and openWorld; the description adds specifics about deterministic output, verdict values, and survivorship/multiple-comparisons framing. It does not contradict annotations and provides extra behavioral detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences that convey purpose, output format, exclusion, and follow-up guidance without fluff. Each clause adds value and the description is well front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description explains the return value composition (per-field verdicts and framing) and disambiguates from prediction tools. There is slight ambiguity around 'framing' but overall it is complete for a read-only tool with no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema already fully describes the moments parameter (array of {symbol, at}, min 2, lowercase perp, RFC3339). The description adds no additional parameter-level meaning beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'return' and defines the resource as a deterministic intersection with explicit verdict types (agree, partial, disagree, quiet, absent). It also clearly distinguishes from similarity search, differentiating it from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states 'Never similarity search' as a when-not, and provides actionable follow-up advice to test AGREE verdicts with base_rate. This gives clear context for when to use this tool versus alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Omit hash8 to list published archive and record reports with count, revision and explicit integrity status. Provide an 8-hex canonical hash to fetch one report: structurally generated title, author, the definition that ran (re-submittable to run_scan) and the result pinned at publish time. Invalid or withdrawn reports carry correction and successor metadata and must not be presented as healthy.
| Name | Required | Description | Default |
|---|---|---|---|
| hash8 | No | Optional 8 lowercase hex canonical id. Omit to list public reports. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes beyond the readOnlyHint and openWorldHint annotations by disclosing that invalid or withdrawn reports carry correction and successor metadata and must not be presented as healthy. It also clarifies the return content (count, revision, integrity status) and the nature of the result pinned at publish time. This provides rich behavioral context without contradicting annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the conditional behavior (omit/provide) and packed with essential information. No filler or repetition. It is concise despite covering both modes and edge cases.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description fully covers the tool's behavior given the lack of an output schema: it describes what is returned in list mode (count, revision, integrity status) and fetch mode (title, author, definition, result), and warns about invalid/withdrawn reports. With only one optional parameter and good annotations, this is complete for an AI agent to select and use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already has 100% coverage of the single parameter, but the description adds significant meaning: it explains that omitting hash8 lists reports, while providing it fetches one and details the returned fields (title, author, definition, result). This goes beyond the schema's 'Omit to list public reports' by fully explaining the dual behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: it lists published archive and record reports when hash8 is omitted, and fetches a single report by an 8-hex canonical hash. It uses specific verbs (list, fetch) and identifies the resource (reports). The description also distinguishes from siblings like list_features and list_instruments by scoping to reports with integrity status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides mode-specific instructions: omit hash8 to list reports, provide hash8 to fetch one. This effectively guides when to use each mode. However, it does not explicitly name alternatives or state when not to use the tool, though the sibling tool run_scan is indirectly referenced via 're-submittable to run_scan'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Turn a plain-language market question into a PROPOSED research_query.v2 document. The result is a proposal, not a result: it is labeled proposal:true and is never executed here. Show the document (plus any unsupported[] stand-ins and clarify notices) to the user, then call run_scan with the document to execute. That second call is the confirm gate. Requires the research:interpret scope and is metered separately (each call spends provider money).
| Name | Required | Description | Default |
|---|---|---|---|
| language | Yes | The market question in plain language, e.g. "vpin above 0.7 then a liquidation surge within 30m on majors last week". | |
| time_zone | No | Optional IANA identity used only to interpret local calendar language, for example Asia/Bangkok. Omit to use the public API default, UTC. Explicit prose such as "June 7 UTC" overrides this default. Abbreviations such as CST are rejected. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses several behavioral traits beyond the annotations: the result is labeled proposal:true, it is never executed here, output includes unsupported[] stand-ins and clarify notices, it requires the research:interpret scope, and each call spends provider money. This goes well beyond the readOnly and openWorld hints, and no contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is four sentences, each serving a distinct purpose: purpose, proposal nature, workflow with run_scan, and auth/cost. It is front-loaded with the core function and contains no filler or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema, the description compensates by explaining the output (proposal:true, unsupported[] stand-ins, clarify notices), the workflow (show to user, then run_scan), and important operational details (scope and cost). It covers all essential aspects for an agent to correctly select and invoke this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with both language and time_zone already fully described in the input schema. The description adds general context (e.g., 'plain-language market question') but no parameter-specific details or new meaning beyond the schema, so the baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Turn a plain-language market question into a PROPOSED research_query.v2 document.' It emphasizes that the result is a proposal, never executed, which distinguishes it from the sibling run_scan tool that executes scans. The verb 'Turn' and specific output resource make the purpose explicit and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear usage context: it says to show the proposal to the user and then call run_scan to execute, framing this tool as the first step in a two-step workflow. It also notes the required scope and metering. However, it does not explicitly state when not to use the tool or provide alternative scenarios beyond run_scan, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the closed registry for the pinned feature_version: every feature id with its dtype and range, the operators, window aggregates and durations, sequence rules, limits, sort fields, and the machine-readable validation and transport error-code lists. Call this FIRST: a document that only uses ids from here cannot invent field names. The registry is ETag-revalidated on every read, so additive feature ids become visible to long-running agents without inventing or hard-coding fields.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations declare readOnlyHint and openWorldHint, but the description adds the crucial ETag-revalidation behavior, explaining that additive feature ids become visible to long-running agents. This goes beyond the annotations and provides useful operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each with a distinct purpose: enumerating contents, instructing to call first, and explaining caching behavior. No filler words; all sentences contribute essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description thoroughly enumerates what the response contains, including feature ids, dtypes, ranges, operators, window aggregates, sequence rules, limits, sort fields, and error-code lists. It also justifies the 'call first' guidance and caching, making it fully self-contained for a read-only registry tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description does not need to elaborate on parameters; instead, it focuses on the richness of the response. It conceptually mentions 'pinned feature_version' but does not treat it as an input parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the closed registry for the pinned feature_version, enumerating the specific contents (feature ids, dtypes, ranges, operators, etc.). This distinguishes it from sibling tools like list_instruments, which likely return a different registry.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs 'Call this FIRST' and explains why: using only ids from this registry prevents inventing field names. This provides clear guidance on when to use it, though it doesn't name alternative tools explicitly, the context implies it is the foundational reference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the authoritative feature-store universe derived from complete manifests. DEFAULT: a compact deterministic summary (coverage window, dataset revision, instrument counts by availability status) - the full body is ~360 KB and overflows agent contexts. Pass symbols: ["btcusdt", ...] for the complete canonical records of specific instruments (per-instrument coverage, present/excluded partition counts, provenance, replay entitlement). Pass full: true for the verbatim canonical bytes of the whole universe. Excluded symbol-days remain visible as universe membership. NVDAUSDT and QQQUSDT are Binance USDT-M perpetuals referencing TradFi assets, not direct Nasdaq data. This read is deterministic and free in every mode.
| Name | Required | Description | Default |
|---|---|---|---|
| full | No | True for the verbatim ~360 KB canonical universe bytes. | |
| symbols | No | Return only the full canonical records of these instruments (lowercase perps, e.g. ["btcusdt","ethusdt"]). A string-encoded array is repaired deterministically. | |
| if_none_match | No | Optional ETag to revalidate an unchanged result for free. ETags are projection-scoped: pass back the ETag this tool returned for the SAME mode (full/summary/symbols). An ETag from a different mode never matches. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond readOnlyHint and openWorldHint, it reveals determinism, cost-free access, authoritative derivation, excluded symbol-day visibility, and the Binance perpetual mapping for NVDAUSDT/QQQUSDT. This is far richer than annotations alone, with no contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Dense but efficient; every sentence contributes value. It is somewhat long due to explaining three modes and an overflow warning, but that complexity justifies the length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description fully explains return modes, content of each mode, size constraints, determinism, cost, and edge cases. It provides all necessary context for an agent to invoke and interpret results correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, yet the description adds substantial meaning: default output fields, per-symbol record contents, lowercase convention, string-array repair, and ETag projection scoping. This goes well beyond the schema's own property descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the authoritative feature-store universe from complete manifests, with distinct modes for summary, specific symbols, and full bytes. This specific verb+resource clearly distinguishes it from siblings like list_features.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit mode selection guidance: default compact summary avoids context overflow, symbols for specific canonical records, full for verbatim bytes. However, it does not explicitly name alternative tools for when not to use this one, so a small gap remains.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Continue a prior run_scan by re-sending the SAME document with the opaque cursor from the previous response. Never construct cursors. If X-Dataset-Revision changed since page 1, the data under THIS document changed (e.g. the nightly append) and the result set with it: restart from page 1. The revision is scoped to the document's symbols and window - never compare revisions across different documents. Every page has its own ETag and remains free, including a continuation cache miss. Complete-result counts and summaries remain independent of the page rows. Same counts_by_symbol projection as run_scan; full_counts: true for verbatim bytes.
| Name | Required | Description | Default |
|---|---|---|---|
| cursor | Yes | The opaque page.cursor from the previous response. Never construct or edit it. | |
| document | Yes | The EXACT document from the prior run_scan. | |
| full_counts | No | True returns the engine's verbatim canonical bytes, including every zero-count instrument in counts_by_symbol. Default omits zero-count entries. | |
| if_none_match | No | Optional ETag to revalidate this page. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnly and openWorld hints, but the description adds substantial behavioral context: cursor handling, revision scoping, ETag details, pricing/free nature, and independence of counts and summaries. This goes well beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but each sentence contributes important operational detail. It is front-loaded with the core action and then presents necessary edge-case handling. Length is appropriate given the complexity, though it could be slightly more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by explaining the counts_by_symbol projection, full_counts behavior, and independence of page rows. It covers critical complexities like revision changes and ETags, making the tool sufficiently understandable for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with detailed parameter descriptions. The tool description mostly reinforces these (e.g., 'SAME document', 'Never construct cursors') without adding new parameter-level meaning beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to continue a prior run_scan by re-sending the same document with the opaque cursor. It is specific and distinguishes itself from the sibling run_scan tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly describes when to use this tool (after a prior run_scan) and provides concrete guidance, such as restarting from page 1 if X-Dataset-Revision changed, and never constructing cursors.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute a research_query.v2 document as a predicate-complement comparison and return canonical cohort_result.v2 bytes: what followed the condition (the treatment side, byte-identical to the run_scan outcomes_summary for the same document) vs what followed every OTHER eligible bucket where the full predicate was FALSE (the baseline), each as the same 30m/1h/4h/24h return + MFE/MAE summary over ALL occurrences. WHERE-ONLY: a sequence document is refused with 422 COHORT_SEQUENCE_UNSUPPORTED (run it as an ordinary run_scan instead). The bytes carry NO ratios, lift, averages or significance - you compare the two distributions yourself. This is not covariate matching: treatment/baseline identities, different observation units, dedupe difference, and denominator arithmetic ship in the result with three mandatory caveats. Both sides honour the completeness rule: an occurrence closer to the end of recorded data than a horizon has that horizon ABSENT - quote present, not total, as the denominator. CONTRACT (relay to the user): Echo the exact document and the reproducibility key to the user with the result. Rates come from outcomes_summary over all occurrences; page rows are examples, never the denominator. Outcome fields cannot be filtered; expect OUTCOME_IN_PREDICATE if tried. A rerun of the same document is served from cache (X-Research-Cache: hit) in its own cohort namespace; reruns and 304 revalidations are free.
| Name | Required | Description | Default |
|---|---|---|---|
| document | Yes | A complete research_query.v2 document (target record_occurrences, WHERE-ONLY - no sequence). Call list_features for the grammar; do not invent field names. | |
| full_counts | No | True returns the engine's verbatim canonical bytes, including any zero-count instrument in counts_by_symbol. Default omits zero-count entries when present. | |
| if_none_match | No | An ETag from a previous cohort run to revalidate: identical data answers 304 and spends nothing. Pass it back verbatim (it may be weak, W/"..."). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Even though annotations declare readOnlyHint=true, the description adds substantial behavioral detail: exact byte output, absence of ratios/lift/averages, completeness rule, cache behavior with X-Research-Cache header, and mandatory caveats in the result. It also discloses error conditions like OUTCOME_IN_PREDICATE and the contract to echo document/key. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is long but every sentence adds critical operational information, from return format to error handling to caching. It is front-loaded with the core purpose, then systematically adds caveats. The density is justified by the tool's complexity, and no sentence feels redundant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by detailing the cohort_result.v2 bytes, time windows, MFE/MAE summary, and what is absent. It also covers error scenarios, contract requirements, and cache semantics, making the tool fully understandable. The description is complete given the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description enriches the document parameter by requiring WHERE-ONLY and explaining predicate-complement semantics, and clarifies if_none_match by describing ETag revalidation and 304 responses. Full_counts is not further elaborated in the description, but the schema description is already sufficient, so the added value is above baseline but not maximal.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it executes a research_query.v2 document as a predicate-complement comparison, returning canonical cohort_result.v2 bytes with treatment vs baseline side-by-side. It explicitly names the alternative run_scan for sequence documents, distinguishing it from that sibling. The verb-resource-object structure is explicit and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to use run_scan for sequence documents (WHERE-ONLY refusal with 422), provides a when-not for covariate matching, and warns against outcome field filtering. It also describes cache revalidation semantics for if_none_match, giving clear decision boundaries for when to invoke this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute a research_query.v2 document over the deterministic engine and return counts, denominators, outcomes_summary, the reproducibility key and page-1 rows as the engine's canonical bytes. outcomes_summary carries forward outcomes over FOUR horizons per occurrence: 30m return, 1h MFE/MAE, and 4h and 24h return + MFE/MAE (record_result.v3), with a closed threshold ladder to +/-20 pct - "how often did this setup reach +5% within 24h, with how much drawdown" is answered by the summary over ALL occurrences. Completeness caveat: an occurrence closer to the end of recorded data than a horizon has that horizon ABSENT (counted in the absent tally, never a truncated or implied-zero outcome) - quote present, not total_matching, as the denominator for any horizon rate. Document-only input: stated chips are the only input the scan path accepts (use interpret_prose first if you have prose, then re-submit its document). CONTRACT (relay to the user): Echo the exact document and the reproducibility key to the user with the result. Rates come from outcomes_summary over all occurrences; page rows are examples, never the denominator. Outcome fields cannot be filtered; expect OUTCOME_IN_PREDICATE if tried. sequence.within accepts 15m/30m/1h/4h/12h/24h and the matching ISO aliases; both normalize to canonical ISO before hashing. identity.symbol must be an exact lowercase Binance USDT-M perpetual symbol: case, whitespace and separators are rejected. You may rerun freely: a rerun of the same document is served from cache (X-Research-Cache: hit), and reruns and 304 revalidations are free. SIZE: page rows carry full 33-feature setup vectors (~2 KB each); page.limit 50 returns ~120 KB, which can overflow an agent context. Counts, outcomes_summary and representatives are complete-result regardless of page size - set page.limit 1-5 unless you need row-level evidence, then page with next_page. PROJECTION: counts_by_symbol lists only instruments with at least one match; the number of zero-count instruments omitted is stated in a trailing note (absence = 0 matches, not missing data). Pass full_counts: true for the engine's verbatim canonical bytes with every zero entry.
| Name | Required | Description | Default |
|---|---|---|---|
| document | Yes | A complete research_query.v2 document (target record_occurrences, stated chips only). Call list_features for the grammar; do not invent field names. | |
| full_counts | No | True returns the engine's verbatim canonical bytes, including every zero-count instrument in counts_by_symbol (~150 KB+ for universe scans). Default omits zero-count entries and states how many were omitted. | |
| if_none_match | No | An ETag from a previous run to revalidate: identical data answers 304 and spends nothing. Pass it back verbatim (it may be weak, W/"..."). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description richly discloses behavioral traits beyond the readOnlyHint and openWorldHint annotations: caching and 304 revalidation behavior, absence of horizons in outcomes_summary, context size overflow risks, zero-count omission semantics, contract to echo document/key, and the OUTCOME_IN_PREDICATE error. No contradiction with annotations; in fact it elaborates on the read-only, cache-friendly nature.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense and front-loaded, starting with the core purpose before diving into caveats. While lengthy, every sentence adds value for a complex tool. A slight structural improvement could be collapsing some repeated warnings, but it is well-organized and not redundant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Without an output schema, the description fully explains return values, the meaning of outcomes_summary across horizons, the role of page rows as examples, and the caveat about absent horizons. It also covers size limits, pagination, and zero-count handling—everything an agent needs to correctly invoke and interpret results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 100% schema coverage, the description adds significant meaning beyond the schema: the document must contain 'stated chips only', full_counts returns 'verbatim canonical bytes' with size implications, and if_none_match is a weak ETag that can be revalidated. It also provides crucial domain semantics (e.g., exact lowercase Binance symbols) that the schema's brief descriptions lack.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action: 'Execute a research_query.v2 document over the deterministic engine' and enumerates the outputs (counts, denominators, outcomes_summary, reproducibility key, page-1 rows). It distinguishes this from sibling tools by explicitly naming interpret_prose, list_features, next_page, and run_cohort as alternatives for different needs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit when-to-use guidance: use interpret_prose first for prose input, call list_features for grammar, use next_page for row-level evidence, and set page.limit 1-5 unless needed. It also clarifies when to pass full_counts: true and explicitly warns against filtering outcome fields. This is strong usage guidance with named alternatives and exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read the engine registry AS-OF the grid bucket containing a moment: every feature value, the closed-list window aggregates, and the fired rulebook ids, as the engine's canonical bytes. A read, never a scan (not credit-metered). Use it to turn one observed moment into candidate clauses, then run_scan to find every other time it looked like that. Selection discipline: if you picked the moment because it moved, expect the follow-up scan to deflate over all occurrences. That is the product working. TIERS (2026-07-31): reading the CURRENT minute is free on every key. Reading a PAST minute is a Pro feature and answers 403 GRANT_REQUIRED on a free account - the record is the paid part, and the error body carries the upgrade URL. Ask for the present when you only need what is true now; ask for a past minute when you need the record.
| Name | Required | Description | Default |
|---|---|---|---|
| at | Yes | An RFC3339 datetime; the engine floors it to the grid bucket that contains it. | |
| symbol | Yes | Lowercase perp, e.g. btcusdt. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint and openWorldHint annotations, the description discloses that the operation is 'never a scan (not credit-metered)', explains tier-based access restrictions (past-minute reads are Pro, returning 403 with an upgrade URL), and notes that results are canonical bytes. This adds meaningful behavioral context beyond what annotations provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Although the description is longer than typical, every sentence adds actionable information: the read-only/credit distinction, the connection to run_scan, the deflation warning, and the tier/error details. The TIERS section is clearly separated and front-loaded with the core purpose in the first sentence, so the structure is efficient and purposeful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by listing the exact contents of the returned snapshot (feature values, window aggregates, fired rulebook ids) and describing the canonical-byte format. It also covers the access model (free/present vs. paid/past), error behavior, and its relationship to run_scan, making it complete for an agent to decide when and how to invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully explains both parameters (symbol as lowercase perp, at as RFC3339 datetime floored to grid bucket). The description does not add parameter-specific semantics beyond restating the 'as-of' grid-bucket concept, which is already implied by the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Read') and resource ('engine registry AS-OF the grid bucket containing a moment'), and states the exact contents returned (every feature value, window aggregates, fired rulebook ids). It also explicitly distinguishes itself from run_scan, which is the primary sibling, by noting it is a read, never a scan.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit when-to-use guidance: 'Use it to turn one observed moment into candidate clauses, then run_scan to find every other time it looked like that.' It also provides selection discipline for choosing moments and clear tier-based guidance on when to query present vs. past minutes, including the 403 GRANT_REQUIRED behavior on free accounts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read-only MCP server for The Quiet Protocol's engines, benchmarks, proof, and business data.
Hosted MCP for Kalshi prediction markets: search, odds, order books, settlement rules, and trading.
Research-only MCP server: turn your AI into a quant research desk — backtests, no trades.
MCP server for OpenMM — exposes market data, account, trading, and strategy tools to AI agents
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/edgedepthhq/edgedepth-research-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
