horus-flow-mcp
The horus-flow-mcp server provides sub-second institutional orderflow intelligence for cryptocurrencies and US equities, enabling AI agents, trading bots, and HFT traders to detect market gravity shifts, whale activity, and liquidity events.
Key capabilities:
get_crypto_flow– Fetch real-time microstructure signals for any crypto pair (e.g., BTCUSDT, ETHUSDT, SOLUSDT), including:Signal direction:
BUY_PRESSURE,SELL_PRESSURE, orNEUTRALAI confidence score (0.0–1.0)
Market state:
TRENDING_UP,TRENDING_DOWN,RANGE_BOUND, orVOLATILERisk level:
LOW,MEDIUM,HIGH, orEXTREMEBid/ask imbalance ratio, aggressive buy/sell percentages, and 5-second net volume delta
get_equity_flow– Fetch the same institutional flow signals for US stocks (e.g., AAPL, NVDA, TSLA) via the Alpaca IEX feed during market hours (14:30–21:00 UTC).scan_crypto_flow– Simultaneously scan multiple crypto pairs (default: BTC, ETH, SOL, BNB, XRP) and receive a sorted summary of the strongest buy or sell pressure across assets.
Underpinned by Level 2 orderbook physics and aggressive trade flow analysis, it also detects critical dynamics like liquidity collapses and spoofing, serving as a real-time "nervous system" for autonomous trading decisions.
Provides real-time orderflow intelligence for Binance cryptocurrency pairs, enabling AI agents to analyze live Level 2 orderbook data and institutional buying/selling pressure for USDT trading pairs.
Integrates with RapidAPI to access Horus Flow Intelligence API for institutional-grade crypto and equity orderflow data, requiring a RapidAPI key for authentication and data access.
🤖 The Zero-Human Decision Loop in Action
When you connect Claude Desktop, Cursor, or an autonomous LangChain / AutoGen agent to Horus Cortex, your agent stops hallucinating and begins executing with Wall Street risk rigor:
┌─────────────────────────────────────────────────────────────────────────────────────────────┐
│ Autonomous Quant Agent (Claude 3.5 Sonnet / Cursor IDE) 🤖 │
│ │
│ Prompt: "BTC is pumping. Should we execute a 3x breakout long entry?" │
│ │
│ AI Calls Tool: `get_horus_cortex()` │
│ ◀ Horus Cortex Returns: │
│ { │
│ "regime_state": "TRANSITION", │
│ "trust_score": 26.5, │
│ "action_policy": { │
│ "directive": "Deteriorating Transition: Capital Preservation Lock (0.0x)", │
│ "trend_allowed": false, │
│ "ignition_allowed": false │
│ }, │
│ "market_vitals": { "taker_ratio": 0.24, "global_ignition": 0.08 }, │
│ "active_contradictions": [ │
│ { "id": "BULLISH_PRICE_vs_HOLLOW_BREADTH", "severity": "MEDIUM" } │
│ ], │
│ "execution_boundaries": { │
│ "invalidation_support": 77052.0, │
│ "breakout_resistance": 78608.0 │
│ } │
│ } │
│ │
│ AI Final Output: │
│ "⛔ TRADE ABORTED — CAPITAL PRESERVATION ENFORCED. │
│ Although spot price is making local highs, Horus Cortex flags a severe divergence: │
│ 1. Taker Buy/Sell ratio collapsed to 0.24 (Aggressive seller absorption). │
│ 2. Global market breadth is dormant (0.08) indicating an isolated, hollow squeeze. │
│ 3. Cortex Trust Score is 26.5/100 with active trend locks enabled. │
│ Action: Standing aside. Re-evaluating only if price confirms above $78,608 with volume." │
└─────────────────────────────────────────────────────────────────────────────────────────────┘Related MCP server: crypto-quant-signal-mcp
🛑 Stop Predicting Candles. Start Measuring Gravity.
Retail traders rely on lagging indicators (RSI, MACD, Moving Averages) which calculate what has already happened.
Horus is predictive, not reactive:
Level 1-2 Physics (The Eye): Measures sub-second limit orderbook depth, spoofed liquidity walls, and aggressive taker execution delta before candlesticks print.
Level 3 Forensics (The Radar): Tracks Liquidation Cascades (Gravity Direction) and Spot vs. Futures Speculation Ratios.
Level 4 Cortex (The Mind): Synthesizes 7 independent evidence families with a real-time Contradiction Engine to output machine-executable position sizing multipliers and USD invalidation boundaries.
🏗️ Architecture
graph TD
%% Styling
classDef crypto_stream fill:#F3BA2F,stroke:#000,color:#000,stroke-width:2px;
classDef equity_stream fill:#000,stroke:#09b533,color:#09b533,stroke-width:2px;
classDef compute fill:#1A1F36,stroke:#00D6FF,color:#fff,stroke-width:2px;
classDef level3 fill:#1A1F36,stroke:#FF6B00,color:#fff,stroke-width:2px;
classDef cortex fill:#4A154B,stroke:#FFD700,color:#fff,stroke-width:3px;
classDef mcp fill:#632CA6,stroke:#fff,color:#fff,stroke-width:2px;
classDef client fill:#FF3366,stroke:#fff,color:#fff,stroke-width:2px;
%% Ingestion
subgraph Data_Pipelines [Sub-Millisecond Websocket Ingestion]
B[Binance WSS <br/> L1/L2 Book]:::crypto_stream
A[Alpaca WSS <br/> SIP Equities]:::equity_stream
BF[Binance Futures <br/> OI / Funding / Liquidations]:::crypto_stream
end
%% Level 1-2 Engine
subgraph Core_Engine [Level 1-2: Microstructure Physics]
IC[Imbalance Calculator <br/> Bid/Ask Walls]:::compute
FC[Flow Calculator <br/> Tape Deltas]:::compute
BC[Behavioral Court <br/> Spoofing & Absorption Rules]:::compute
end
%% Level 3 Intelligence
subgraph L3_Engine [Level 3: Institutional Intelligence]
LH[Liquidation Heatmap <br/> Gravity Zones]:::level3
XF[Cross-Exchange Flow <br/> Spot ↔ Futures]:::level3
CI[Composite Intelligence <br/> 4-Layer Verdict]:::level3
end
%% Level 4 Cognitive Cortex
subgraph L4_Cortex [Level 4: The Sovereign Cognitive Cortex]
HC[Horus Cortex Symphony 3.0 <br/> 7 Forensic Families + Contradiction Engine]:::cortex
TS[Penalized Trust Score 0-100]:::compute
EB[Execution Boundaries USD]:::compute
AP[Action Policy Multipliers for Bots]:::compute
end
%% Output
subgraph Output_Layer [Data Delivery & Agent Integration]
MCP[AI Agent FastMCP Server <br/> 8 Sovereign Tools]:::mcp
API[FastAPI REST Gateway <br/> 13 Endpoints]:::client
Dash[Real-Time Portal <br/> Live Microstructure]:::client
end
B --> IC
A --> IC
B --> FC
A --> FC
BF --> LH
BF --> XF
IC --> BC
FC --> BC
LH --> CI
XF --> CI
BC --> CI
CI --> HC
HC --> TS
HC --> EB
HC --> AP
HC --> MCP
HC --> API
BC --> Dash📡 Complete API Catalog
Level 1-2: Orderflow Microstructure
Endpoint | Method | Description | Tier |
|
| Real-time orderbook imbalance, taker flow, and whale intent | Free / Trader |
|
| Flow history (1-60 min lookback) for backtesting | Trader |
|
| US Equity institutional tape (SIP) | Trader |
|
| SPY macro block trades & sentiment | Trader |
Level 3: Forensic Market Intelligence
Endpoint | Method | Description | Tier |
|
| WiseMan macro market regime & health score | Trader |
|
| Volatility Breakout Engine (VBE) scanner | Trader |
|
| Liquidation cascade zones & gravity vector | Pro ($149) |
|
| Spot vs Futures volume ratio & OI velocity | Pro ($149) |
|
| 4-layer fused composite score (0-100) | Pro ($149) |
|
| Complete macro dashboard for all assets in one call | Pro ($149) |
Level 4: The Sovereign Cognitive Cortex
Endpoint | Method | Description | Tier |
|
| 🧠 The Master Brain: 7 evidence families, trust score, contradiction engine, execution boundaries & action policy | Pro ($149) / Institutional |
|
| Backward-compatible alias for the Cortex endpoint | Pro ($149) / Institutional |
🤖 Model Context Protocol (MCP) Setup
Horus provides an official FastMCP server compatible with Claude Desktop, Cursor IDE, and any MCP client:
1. Claude Desktop Configuration
Add this to your claude_desktop_config.json:
{
"mcpServers": {
"horus-cortex": {
"command": "python3",
"args": ["/absolute/path/to/horus_flow_api/horus_mcp.py", "--transport", "stdio"],
"env": {
"FLOW_API_KEY": "YOUR_HORUS_API_KEY"
}
}
}
}2. Available Sovereign Tools for AI Agents
get_horus_cortex(): 🧠 Primary Cognitive Tool — Full consensus, trust score (0-100), boundaries ($), and bot action multipliers.get_crypto_flow(symbol): Sub-second L2 orderflow and aggressive trade delta.get_equity_flow(symbol): US Equity block trades and tape prints.scan_crypto_flow(symbols): Batch scanner for active whale positioning.get_liquidation_heatmap(symbol): Liquidation cascade zones and gravitational pull.get_cross_exchange_flow(symbol): Spot vs Futures volume ratio and funding rate risk.get_composite_intelligence(symbol): 4-layer composite verdict (0-100).get_full_market_intelligence(): Macro overview of all monitored instruments.
⚡ 60-Second Quant Bot Quickstart (Python)
import requests
HEADERS = {"X-API-Key": "your_horus_api_key"}
BASE_URL = "https://flow.horustek.pro"
# 1. Query Horus Cortex for the Sovereign Market State
res = requests.get(f"{BASE_URL}/v1/intelligence/cortex", headers=HEADERS).json()
trust_score = res["trust_score"]
policy = res["action_policy"]
boundaries = res["execution_boundaries"]
print(f"🧠 Market State: {res['regime_state']} | Trust: {trust_score}/100")
print(f"🛡️ Action Directive: {policy['directive']}")
print(f"🎯 Support Invalidation: ${boundaries['invalidation_support']:,.0f} | Breakout Target: ${boundaries['breakout_resistance']:,.0f}")
# 2. Enforce Autonomous Risk Rules
if not policy["trend_allowed"]:
print("⛔ Trade Rejected: Cortex forbids trend breakouts during transitions.")
else:
position_multiplier = policy["trend_multiplier"]
# execute_trade(multiplier=position_multiplier, stop_loss=boundaries["invalidation_support"])💎 Institutional Subscription Tiers
Feature | Explorer (Free) | Trader ($49/mo) | Professional ($149/mo) | Institutional ($499/mo) |
Daily API Quota | 100 calls/day | 1,000 calls/day | 5,000 calls/day | Unlimited |
Microstructure L2 Flow | Top 3 Symbols | All Crypto Symbols | All Crypto + US Equity | All Instruments |
Whale Tape & Imbalances | Basic | Real-Time | Real-Time Sub-ms | Priority Dedicated Socket |
Level 3 Intelligence | ❌ | ❌ | ✅ Full Access | ✅ Full Access |
🧠 Level 4 Horus Cortex | ❌ | ❌ | ✅ Full Cognitive Brain | ✅ Full Cognitive Brain |
Autonomous Bot Multipliers | ❌ | ❌ | ✅ | ✅ |
AI Agent MCP Server | Community | Community | ✅ Full FastMCP Access | ✅ Dedicated Private Server |
SLA & Support | Community | Standard | Priority | 24/7 Dedicated Quant Desk |
🌐 Live Real-Time Dashboard
Explore the live institutional orderflow visualizer at flow.horustek.pro/dash/.
Engineered with mathematical rigor for Autonomous AI Agents and Quantitative Traders.
© 2026 Horus Tech Ltd. 🦅
Available Tools
10 toolsget_composite_intelligenceA
Get composite intelligence score (0-100) with tactical verdict.
Returns a score from 0-100 and a verdict: BUY, SHORT, or STAY_OUT.
Combines orderflow, sentiment, leverage ratios, and smart money positioning
into a single actionable number. Score < 45 = dangerous, > 65 = opportunity.
Args:
symbol: Trading pair (default: BTCUSDT)
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | No | BTCUSDT |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses the output structure and basic interpretation but lacks details on authentication requirements, data freshness, or any side effects. The description is somewhat transparent but not exhaustive.
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 concise with about 4 sentences. It leads with the main purpose, then explains output, composition, and interpretation. It is well-structured and efficient, though slightly more bullet-point structuring could improve readability.
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 tool has an output schema (indicated but not shown), and the description adequately explains the return values (score and verdict). Given the single parameter and absence of annotations, the description covers the essential context for an agent to invoke the tool 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?
There is one parameter (symbol) with 0% schema description coverage, meaning the schema only provides a title and default. The description adds semantic meaning by stating 'Trading pair (default: BTCUSDT)', which is clear and helpful beyond the schema.
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 gets a composite intelligence score with a tactical verdict (BUY, SHORT, STAY_OUT). It specifies the score range (0-100) and combines multiple factors like orderflow, sentiment, leverage ratios, and smart money positioning, distinguishing it from sibling tools that focus on specific flows or heatmaps.
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 interpretation guidance (score <45 dangerous, >65 opportunity) but does not explicitly state when to use this tool versus alternatives like get_market_intelligence or get_crypto_flow. No explicit when-to-use or when-not-to-use conditions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_cross_exchange_flowA
Get Futures/Spot ratio, speculation index, and smart money divergence.
Reveals whether the market is driven by speculation (Futures) or real demand (Spot).
Futures/Spot > 8x = HYPER_SPECULATION (vulnerable to flush).
Also shows smart money divergence: are top traders positioned opposite to the crowd?
Args:
symbol: Trading pair (default: BTCUSDT)
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | No | BTCUSDT |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must fully convey behavior. It describes the returned indicators and gives a threshold, but does not mention rate limits, authentication, or potential side effects. As a read operation, it is adequately transparent.
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 concise, well-structured, and front-loaded with key information. It uses a clear header, explanation, and args section without any unnecessary words.
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 the tool has a single optional parameter and an output schema, the description is complete. It explains the indicators, a threshold, and the parameter, making it fully self-contained 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?
The input schema has 0% description coverage, so the description must compensate. It explicitly states the symbol argument is a trading pair with a default of BTCUSDT, adding meaning beyond the schema's default value.
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 gets Futures/Spot ratio, speculation index, and smart money divergence. It explains what these indicators reveal, making the purpose unmistakable. The name matches the description, and it is distinct from sibling tools like get_crypto_flow.
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 explains what the tool reveals (speculation vs real demand) and provides a hyper-speculation threshold. It does not explicitly state when to use versus siblings or alternatives, but the context is clear for cross-exchange flow analysis.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_crypto_flowA
Get real-time institutional orderflow for a cryptocurrency.
Returns signal (BUY_PRESSURE/SELL_PRESSURE/WHALE_EXIT/EMERGENCY_DUMP),
confidence score, bid/ask depth metrics, whale intent, toxicity level,
and flags like SPOOFING_DETECTED, BID_WALL_TRAP, DEPTH_COLLAPSE.
Args:
symbol: Trading pair (e.g., "BTCUSDT", "ETHUSDT", "SOLUSDT")
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the output types (signal, confidence, depth metrics, flags) and notes it is real-time. It does not mention rate limits or permissions, but for a read-only data tool, this is adequate.
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, starting with the core purpose and then listing return fields and the argument. It is front-loaded and every sentence adds value. No wasted words.
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 the tool's simplicity (1 required parameter) and the existence of an output schema, the description provides a thorough overview of return values and the argument. It covers all necessary context for an agent to select and invoke 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 has only 'symbol' with type string and 0% description coverage. The description adds concrete examples ('BTCUSDT', 'ETHUSDT', 'SOLUSDT') and clarifies the trading pair format, which is essential for correct invocation. This fully compensates for the schema's lack of detail.
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 'Get real-time institutional orderflow for a cryptocurrency,' which is a specific verb+resource combination. It distinguishes itself from sibling tools like 'scan_crypto_flow' by focusing on a single symbol and providing detailed output metrics.
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 implicitly tells when to use: when needing real-time orderflow for a specific cryptocurrency. However, it does not explicitly state when not to use it or compare with alternative siblings like 'scan_crypto_flow' for scanning multiple symbols.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_equity_flowA
Get real-time institutional orderflow for a US equity stock.
Returns signal (BUY_PRESSURE/SELL_PRESSURE/WHALE_EXIT/EMERGENCY_DUMP),
confidence score, large sell orders count, block trades, toxicity,
and flags like WATERFALL_DUMP, PULLED_BID_WALL_SPOOF.
Args:
symbol: Stock ticker (e.g., "SPY", "AAPL", "TSLA", "NVDA", "MSFT")
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the returned data fields but does not mention latency, data freshness, rate limits, or whether the operation is read-only. The non-destructive nature is implied.
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 extremely concise with no wasted words. It uses a clear structure: a one-line purpose, a list of return fields, and an Args section for the parameter. Information is 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 tool has a single parameter and an output schema (not shown to us). The description covers all returned fields and the parameter's usage. For a simple data retrieval tool, it is fully complete.
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 0%, but the only parameter 'symbol' is well-described with examples (e.g., 'SPY', 'AAPL'), adding meaning beyond the schema's title and type. This compensates for the lack of schema 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 it retrieves real-time institutional orderflow for US equities, listing specific return fields like signals and flags. This distinguishes it from siblings such as get_crypto_flow (crypto) and get_cross_exchange_flow (cross-exchange).
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 implies usage for US equities but does not explicitly state when to use this tool versus alternatives like get_crypto_flow or get_cross_exchange_flow. No exclusions or alternative conditions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_ignitionsA
Detect volatility ignition events — potential explosive price moves.
Returns ignition state (DORMANT, RISING, IGNITED) and directional bias.
IGNITED = imminent large move, reduce or exit positions.
RISING = pressure building, prepare for breakout.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses outputs (state and bias) and interprets them. It does not mention side effects, which is acceptable for a read-like tool. Lacks explicit read-only hint but is sufficiently transparent.
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 adding value: purpose, outputs, interpretation. No unnecessary words.
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 no parameters and presence of output schema, description explains key return fields meaning. Could add more detail on directional bias format, but complete enough for usage.
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?
No parameters exist and schema coverage is 100%, so description need not add param details. Baseline of 4 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 detects volatility ignition events and returns ignition state and directional bias. It distinguishes itself from sibling tools (flow and intelligence tools) by focusing on explosive price moves.
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 usage context by explaining what IGNITED and RISING states imply (reduce positions, prepare for breakout), but does not explicitly state when not to use or mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_liquidation_heatmapA
Get liquidation zones with dollar amounts — where leveraged positions will be force-closed.
Returns clusters of long and short liquidations at specific price levels
with total dollar amounts. Critical for avoiding entries near massive
liquidation zones that could trigger cascading price moves.
Args:
symbol: Trading pair (default: ETHUSDT)
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | No | ETHUSDT |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must bear all behavioral disclosure. It explains the tool returns clusters with dollar amounts but doesn't mention read-only behavior or any potential side effects. While it adds value, it could be more transparent about its idempotency.
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 paragraphs with an args list; the first sentence is clear and direct. However, the second paragraph partly restates the first, and the overall length could be trimmed without losing meaning.
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 the tool has only one parameter and an output schema exists, the description adequately explains the tool's purpose and return structure. It adds context about critical use cases, making it largely complete 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?
The input schema has 0% description coverage for the 'symbol' parameter, but the description explicitly states 'symbol: Trading pair (default: ETHUSDT)', which adds meaning beyond the schema's type and default. This compensates for the schema gap.
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 retrieves liquidation zones with dollar amounts, specifying that it returns clusters of long and short liquidations at specific price levels. This differentiates it from sibling tools that focus on flows or intelligence, though not explicitly naming alternatives.
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 implies use for avoiding entries near large liquidation zones to prevent cascading moves, but lacks explicit when-not-to-use or alternative suggestions. It provides a clear use case without situational exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_macro_blocksA
Get US equity market macro trend and recent institutional block trades.
Returns SPY macro climate (market mode, buy ratio) and list of recent
block trades over $200K with symbol, direction, and size.
Use this to understand where institutional money is flowing.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavioral traits. It states the tool returns macro climate and block trades, implying a read operation. However, it lacks details on data recency, update frequency, or any limitations, which would be helpful for an agent.
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 three sentences with no wasted words. It front-loads the purpose, details the output, and provides a use case, making it highly efficient for an agent to parse.
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 the tool has no parameters and an output schema exists, the description adequately covers the output structure and threshold. It could mention whether data is historical or real-time, but overall it is complete for agent invocation.
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 has zero parameters, so the baseline is 4. The description does not need to explain parameters, and it does not add any parameter info, which 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 retrieves US equity market macro trend and institutional block trades. It specifies the output includes SPY macro climate (market mode, buy ratio) and block trades with details. This sets it apart from sibling tools like get_equity_flow and get_market_climate.
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 suggests using the tool 'to understand where institutional money is flowing', providing a use case. However, it does not explicitly mention when not to use it or compare it with alternative tools among the siblings, leaving some ambiguity for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_market_climateA
Get current market mode and health status.
Returns market mode (CHOP, TREND, RANGE) and health (HEALTHY, FRAGILE).
CHOP = only scalps work, TREND = directional trades, RANGE = mean-reversion.
If health is FRAGILE, reduce all position sizes.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description fully discloses return values and implications. Explains what each market mode means for trading strategy and advises position sizing adjustment for FRAGILE health.
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?
Four concise sentences front-loaded with purpose. Every sentence adds value. No redundancy.
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?
Fully explains the tool's output and its interpretation. With no parameters and an output schema, the description is complete and self-contained.
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?
No parameters exist, so baseline 4. Description adds value by explaining the meaning of the returned data beyond the schema.
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?
Clearly states it returns market mode (CHOP, TREND, RANGE) and health (HEALTHY, FRAGILE). Distinguishes from siblings like get_market_intelligence by focusing on climate 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?
Explicitly describes when to use (get current mode/health) and gives actionable advice for FRAGILE health. Doesn't explicitly mention when not to use or alternatives, but context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_market_intelligenceA
Get complete market intelligence in a single call — combines all endpoints.
Returns orderflow signal, composite score, liquidation zones, cross-exchange
analysis, climate, and ignition state in one unified response. Use this
for a comprehensive pre-trade check.
Args:
symbol: Trading pair (default: BTCUSDT)
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | No | BTCUSDT |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits itself. It explains what data is returned but does not mention any limitations, auth needs, rate limits, or data freshness. This is insufficient for a tool combining multiple endpoints.
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 mostly concise with two clear introductory sentences and a parameter doc. The Args section could be integrated more smoothly, but overall it's well-structured.
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 the complexity (combining multiple analyses) and the presence of an output schema, the description adequately explains the return contents and parameter. It lacks mention of any usage restrictions or error handling, but otherwise is fairly complete.
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 description adds meaning to the symbol parameter beyond the schema: 'Trading pair (default: BTCUSDT)'. Since schema coverage is 0%, this extra context is valuable, though it could specify format or constraints.
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 returns a combination of multiple endpoints (orderflow signal, composite score, etc.), distinguishing it from sibling tools that likely return individual metrics. The verb 'Get' with 'complete market intelligence' is specific.
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 advises using this for a comprehensive pre-trade check, giving a clear context. However, it does not explicitly state when not to use it (e.g., if only one component is needed) or mention alternative sibling tools for specific data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
scan_crypto_flowA
Scan multiple cryptocurrencies for orderflow signals at once.
Returns a summary with strongest buy/sell signals and individual results
sorted by confidence. Use this for portfolio-wide risk assessment.
Args:
symbols: Comma-separated trading pairs (default: BTC, ETH, SOL, BNB, XRP)
| Name | Required | Description | Default |
|---|---|---|---|
| symbols | No | BTCUSDT,ETHUSDT,SOLUSDT,BNBUSDT,XRPUSDT |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It mentions that the tool returns a summary and individual results sorted by confidence, indicating a read-like operation. However, it does not disclose potential behavioral traits such as authentication requirements, rate limits, error handling, or what happens if symbols are invalid. Basic transparency is present but incomplete.
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 concise and well-structured: it starts with the main purpose, then describes the return, gives a usage context, and explains the argument. Every sentence serves a purpose with no unnecessary words.
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 that an output schema exists, the description does not need to explain return values. It adequately covers purpose, parameter, and usage context. The only gap is the minor inconsistency in the parameter default example, which slightly undermines completeness. Overall, it is mostly sufficient for a simple 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 input schema has no descriptions (0% coverage). The description adds value by explaining the 'symbols' parameter as 'Comma-separated trading pairs' and provides a default list. This goes beyond the schema's mere type and default. However, there is a slight inconsistency: the schema default includes full trading pairs like 'BTCUSDT', while the description lists simple names like 'BTC'. This could cause confusion.
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 scans multiple cryptocurrencies for orderflow signals, returns a summary with strongest buy/sell signals, and individual results sorted by confidence. It distinguishes from siblings like get_crypto_flow (likely for single asset) by explicitly mentioning 'multiple' and 'portfolio-wide risk assessment.'
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 a clear use case: 'Use this for portfolio-wide risk assessment.' It implies the tool is for scanning multiple assets but does not explicitly state when not to use it or compare to alternatives. The context is clear but lacks exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
7 tool updates
- Added
get_composite_intelligence - Added
get_cross_exchange_flow - Added
get_ignitions - Added
get_liquidation_heatmap - Added
get_macro_blocks - Added
get_market_climate - Added
get_market_intelligence
3 tool updates
v1.0.0- First observed
get_crypto_flow - First observed
get_equity_flow - First observed
scan_crypto_flow
TDQS
Scored across 10 tools
Most tools have distinct purposes: crypto vs equity flow, batch scanning, macro blocks, composite score, liquidations, cross-exchange, climate, and ignition detection. The main ambiguity is between get_composite_intelligence and get_market_intelligence, though the latter is clearly described as an aggregate of all endpoints.
The dominant pattern is get_<domain>_<concept>, which is predictable and readable. One deviation is scan_crypto_flow, which uses a verb other than get, but it still follows the same broad noun/flow convention.
Ten tools is well-suited to the server's purpose of providing comprehensive market intelligence. Each tool addresses a distinct data need without redundancy, and the count feels appropriately scoped for a trading analysis domain.
The toolset covers crypto and equity orderflow, macro context, liquidation zones, cross-exchange data, market climate, ignition events, and a composite aggregate. Minor gaps include no direct tool for historical data or sentiment text, but the core pre-trade intelligence workflow is well covered.
Maintenance
Related MCP Connectors
Agent-native crypto market-data over MCP+REST: order flow, whales, liquidations, calibrated scores
Real-time whale trades, Smart Money Radar, market snapshots, news sentiment, signal outcomes.
AI crypto signals, smart money whale positions, live futures prices and indicators
Live crypto market data: prices, funding, OI, liquidations, regimes, GEX, whales, sentiment, macro.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables real-time options order flow analysis with pattern detection, institutional bias tracking, and monitoring of specific strike ranges and expirations. Provides comprehensive options trading data through integration with a high-performance Go-based data broker.10MIT
- AlicenseAqualityAmaintenanceAI-native quantitative trading signal engine for crypto and TradFi perpetuals. Multi-factor composite BUY/SELL/HOLD signals, cross-venue funding rate arbitrage scanning, and market regime detection powered by Hyperliquid data.82,045 npm8MIT
- AlicenseBqualityDmaintenanceCross-exchange crypto orderflow for AI agents. 20 exchanges, 26 tokens, 9 tools — CVD, whale activity, funding/OI, 7-year OHLCV, on-chain address risk (EVM + Solana). Pay-per-call USDC via x402, no API key.916 npm1MIT

mcp-midasflowofficial
AlicenseNot gradedqualityCmaintenanceMidasFlow Flow API - Cross-exchange order flow, whale detection, liquidations, funding rates, squeeze alerts for AI agents. Native MCP server.MIT