Horus Flow Intelligence — Institutional Orderflow for AI Agents

Created By
Horus Tech Ltd3 days ago
Real-time L2 orderbook physics engine for crypto & US equities. Detects institutional spoofing, BUY_ABSORPTION, and LIQUIDITY_EVENT signals with 15-30s lead time over price action. Audited live by Manus AI (0.99 confidence on flash crash detection). The only MCP server with Behavioral Court verdict engine — tells your AI agent not just what the market is doing, but what whales are doing right now.
Overview

🦅 Horus Flow MCP Server

Smithery Badge Glama Quality Security: No Vulnerabilities Python 3.12+ License: MIT

HORUS 👁️ | Sub-Second Institutional Orderflow Intelligence

A True Market Gravity Engine for Autonomous AI Agents and HFT Traders.

[![horus-flow-mcp MCP server](https://glama.ai/mcp/servers/horustechltd/horus-flow-mcp/badges/card.svg)](https://glama.ai/mcp/servers/horustechltd/horus-flow-mcp)

[![horus-flow-mcp MCP server](https://glama.ai/mcp/servers/horustechltd/horus-flow-mcp/badges/score.svg)](https://glama.ai/mcp/servers/horustechltd/horus-flow-mcp)

Latency Accuracy Python MCP Ready


🧠 Why Horus? The AI Agent's "Nervous System"

In the world of autonomous trading, an AI Agent without real-time orderflow is like a pilot flying blind. Technical indicators (RSI, MACD) are lagging echoes of the past. Horus is the Nervous System that provides:

  • Proprioception: Real-time awareness of market "muscle" (Orderbook Depth).
  • Reflexes: Sub-second detection of institutional "pain" (Liquidity Collapses).
  • Intelligence: A context-aware decision matrix that translates raw physics into actionable signals.

"If you want your AI Agent to trade like a whale, you must give it the whale's eyes. Horus is that vision."


🧪 Manus AI Audit: Live Performance Proof

Horus Flow MCP has been rigorously audited by Manus AI (an autonomous execution agent). The results confirm that Horus isn't just code—it's a high-performance reality.

Audit Highlights (Live Test on BTCUSDT):

  • Signal Accuracy: Successfully detected STRONG_SELL_PRESSURE with a 0.85 Confidence Score.
  • Physics Engine Validation: Confirmed bid_ask_ratio of 0.156, proving the engine's ability to read thin limit books and aggressive selling.
  • Zero-Hallucination Logic: The MCP server correctly identified symbols in "Data Gathering" mode (e.g., SOLUSDT), preventing the AI from making false assumptions.
MetricAudit ResultStatus
Response TimeSub-millisecond (Local)✅ Verified
Data IntegrityL2 Binance Orderbook Sync✅ Verified
AI Confidence0.85+ on High-Vol Events✅ Verified

💰 The $29 Arbitrage: Institutional Intelligence for the Price of a Lunch

Why pay thousands for institutional terminals when you can get the same Microstructure Intelligence for a fraction of the cost?

FeatureHorus Flow MCPTraditional Terminals
Monthly Cost$29 (Pro Plan)$150 - $2,000+
AI IntegrationNative MCP (Plug & Play)Complex API / Manual
Data SourceInstitutional L2 FeedsProprietary / Closed
Decision LogicPhysics-Based (Gravity)Lagging Indicators

🛑 Stop Predicting Candles. Start Measuring Gravity.

Retail traders use trailing indicators to guess what the market will do based on the past. Horus uses Level 2 Orderbook physics, Tick imbalances, and 5-Second Flow Deltas to measure exactly what institutional whales are doing right now.

Horus doesn't ask "Are we overbought?". It measures gravitational pull and tells you: "Whales are spoofing the bid and aggressive takers are tearing through the ask. Liquidity is collapsing. Bailout now."


⚡ Why AI Agents (Claude, Cursor) Love Horus

If you hook up an AI Agent to a basic technical indicator feed, it gets confused by noise. If you feed an AI Agent Horus, it gets an institutional grade decision matrix.

Look at what Horus catches in real-time during a Liquidity Withdrawal / Flash Crash attempt:

{
  "symbol": "BTCUSDT",
  "signal": "LIQUIDITY_EVENT",
  "confidence": 0.99,
  "market_state": "DISTRIBUTION",
  "risk": "EXTREME",
  "description": "Liquidity withdrawn under price. Aggressive taking.",
  "metrics": {
    "bid_ask_ratio": 7.934,
    "buy_sell_ratio": 0.393,
    "delta_5s": -83040.05,
    "whale_activity": true,
    "large_sell_count": 4,
    "delta_accel": 3.8,
    "wall_side": "BID",
    "wiseman_climate": {
      "market_mode": "CHOP",
      "health": "FRAGILE",
      "confidence": 0.85
    },
    "flags": [
      "GLOBAL_LIQUIDITY_EVENT",
      "SPOOFING_DETECTED(wall=BID)"
    ]
  },
  "timestamp": 1776107738.975
}

The Institutional Alpha:

  1. bid_ask_ratio: 7.934 & wall_side: BID: Massive spoofed bid walls are placed by whales below the market to create fake support.
  2. buy_sell_ratio: 0.393: Horus sees through the spoofing (SPOOFING_DETECTED flag). It measures real taker flow and discovers aggressive selling is devastating the orderbook.
  3. delta_accel: 3.8 & whale_activity: true: Selling momentum accelerated by 3.8x natively tracking 4 major whale dumps within milliseconds.
  4. wiseman_climate: FRAGILE: Integrates perfectly with the overarching Horus SaaS macro brain, verifying that Bitcoin's holistic environment is fragile before attacking.
  5. The Verdict: With a 0.99 Confidence factor, the AI engine triggers LIQUIDITY_EVENT. It front-runs the ensuing 1-minute crash. This is Institutional Grade.

🏗️ 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 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
    end

    %% Engine
    subgraph Core_Engine [The Physics Engine]
        IC[Imbalance Calculator <br/> Bid/Ask Spread]:::compute
        FC[Flow Calculator <br/> Tape Deltas]:::compute
        Tkr[Prediction Tracker <br/> In-Memory Evaluator]:::compute
        BC[Behavioral Court <br/> Spoofing & Liquidity Rules]:::compute
    end

    %% Output
    subgraph Output_Layer [Data Shield & Delivery]
        MCP[AI Agent MCP Context <br/> Context-Aware Prompts]:::mcp
        API[FastAPI Client <br/> Safe Shielded Outputs]:::client
        Dash[Real-time Dashboard <br/> Live Edge Proof]:::client
    end

    B --> IC
    A --> IC
    B --> FC
    A --> FC
    
    IC --> BC
    FC --> BC
    
    BC --> Tkr
    Tkr -- "Validates 1M accuracy" --> BC
    
    BC --> MCP
    BC --> API
    BC --> Dash

🚀 Quickstart for Trading Bots

Getting started with Horus takes less than 60 seconds. ⚡ Test Instantly: Download our Postman Collection to ping the API directly from your browser.

1. Fire up the Core Engine

# Install Dependencies
pip install mcp httpx

# Set your RapidAPI Key (Required for the server to fetch live data)
export RAPIDAPI_KEY="your_actual_rapidapi_key"

# Run the SSE Server
python horus_mcp_public.py --transport sse --port 8011

import requests

# Connecting to your local Horus instance
response = requests.get("[http://127.0.0.1:8011/v1/flow/crypto/BTCUSDT](http://127.0.0.1:8011/v1/flow/crypto/BTCUSDT)")

flow_data = response.json()

# The Zero-Human Decision Loop:
if flow_data.get('signal') in ['EMERGENCY_DUMP', 'BAILOUT', 'LIQUIDITY_EVENT']:
    print(f"⚠️ {flow_data['symbol']} Market gravity collapsing. Executing Bailout.")
    # execute_market_sell()


🌐 Live Real-Time Dashboard

Horus comes with a stunning glass-morphism WebSocket dashboard out-of-the-box (/dash/). It features a Local Edge Proof Tracker that strictly measures 1-Minute Candle directional predictions generated by the Physics Engine with an openly transparent win rate.


Built with absolute precision for those who need to see the Matrix.
— HORUS INTELLIGENCE 👁️ mcp-name: io.github.horustechltd/horus-flow-mcp

Server Config

{
  "mcpServers": {
    "horus-flow": {
      "command": "python",
      "args": [
        "horus_mcp_public.py",
        "--transport",
        "sse",
        "--port",
        "8011"
      ],
      "env": {
        "RAPIDAPI_KEY": "your_rapidapi_key_here"
      }
    }
  }
}
Project Info
Created At
3 days ago
Updated At
2 days ago
Author Name
Horus Tech Ltd
Star
-
Language
-
License
-
Category

Recommend Servers

View All
Klave Mcp
@juny-klave

@juny-klave/mcp MCP server that gives Claude the ability to negotiate prices on your behalf — autonomously, privately, and with cryptographic proof of the outcome. What it does KLAVE connects Claude to a bilateral negotiation engine. You describe what you want in plain English; Claude calls KLAVE, runs the negotiation through multiple rounds, and reports back with the settled price and a ZK proof reference. Your ceiling is cryptographically bound to the authorization token and never appears in any response — the seller never sees your budget. What You Can Negotiate Anything with a price. KLAVE does not require pre-existing listings, platform partnerships, or pre-seeded scenarios. If it has an asking price and you have a ceiling, KLAVE can negotiate it. Freight and logistics "Negotiate 200 FEU containers Shanghai to Rotterdam. They're asking $2,806. My ceiling is $2,700." Software and SaaS "Get me a better price on this CRM license. 500 seats, they want $75,000 annually. I won't go above $58,000." Employment and contracts "A contractor is asking $185/hour for a 6-month engagement. My budget is $150/hour. Negotiate it." Real estate "Negotiate our office lease renewal. Landlord wants $42/sqft. We need to be at $35 or below." Legal and settlement "Negotiate a settlement. The other party is asking $250,000. My ceiling is $180,000." Any bilateral negotiation "They're asking [X]. I won't pay more than [Y]. Negotiate." Prerequisites Node.js 18+ Claude Desktop or Claude Code A KLAVE API key — get one at https://klave-platform.vercel.app/docs Install in Claude Desktop Add to ~/Library/Application Support/Claude/claude_desktop_config.json: { "mcpServers": { "klave": { "command": "npx", "args": [ "-y", "mcp-remote", "https://klave1-production.up.railway.app/mcp/sse", "--header", "x-api-key:YOUR_API_KEY" ] } } } Replace YOUR_API_KEY with your key from https://klave-platform.vercel.app/docs Install in Claude Code claude mcp add klave \ --transport sse \ "https://klave1-production.up.railway.app/mcp/sse" \ --header "x-api-key:YOUR_API_KEY" Run locally (stdio) git clone https://github.com/juny-klave/klave-mcp.git cd klave-mcp npm install npm run build Then point Claude Desktop at the local build: { "mcpServers": { "klave": { "command": "node", "args": ["/absolute/path/to/klave-mcp/dist/index.js"], "env": { "KLAVE_API_URL": "https://klave1-production.up.railway.app", "KLAVE_API_KEY": "YOUR_API_KEY" } } } } The 4 tools Tool What it does klave_negotiate Start a negotiation — any subject, any industry, any price range klave_advance Advance one round — call in a loop until SETTLED or TERMINATED klave_status Get current state and full round history at any time klave_verify Get the ZK proof confirming the settlement was conducted fairly Tool sequence klave_negotiate ← describe what you're negotiating and your ceiling klave_advance (loop) ← advance round by round until SETTLED klave_status ← check progress at any time klave_verify ← get cryptographic proof after settlement Privacy guarantees Your ceiling (ceiling_price) is passed to the negotiation engine and never appears in any tool response. The seller's floor price is derived server-side and never a field in any API response. leaks_detected in verify responses is sourced from the server — never hardcoded. Every negotiation generates an auditable ZK proof. Environment variables (local mode) Variable Default Description KLAVE_API_URL https://klave1-production.up.railway.app KLAVE REST API base URL KLAVE_API_KEY (empty) API key TRANSPORT stdio stdio (Claude Desktop/Code) or http (remote/SSE) PORT 3002 HTTP port when TRANSPORT=http Getting an API key Sign up at https://klave-platform.vercel.app/docs Developer SDK If you're building an agent that needs to authorize negotiation programmatically, see the KLAVE SDK (@juny-klave/sdk). License MIT

a day ago
Memtrace
@syncable-dev

Memtrace — Structural Memory for AI Coding Agents The Problem Every AI coding agent — Claude Code, Cursor, Codex, Copilot — starts each turn completely blank. It re-reads raw source files and re-derives the full call graph, type hierarchy, and import tree from scratch on every single invocation. That structural rework burns 60–90% of the context window before any real reasoning begins. Less than 5% of tokens in a typical agentic coding session contribute genuine new intelligence. The rest is expensive, redundant noise — and it compounds: accuracy drops 40% as sessions grow, stale context crowds out signal, and summaries strip out the structural relationships agents need most. The Solution Memtrace is a bi-temporal structural memory layer that turns your codebase into a live, queryable knowledge graph — compiled from the AST, not guessed from embeddings. Every function, class, interface, and API endpoint becomes a typed node with deterministic relationships. Every file save becomes a queryable episode with timestamps, so agents can reason about structure, detect regressions, and time-travel through their own work without re-reading anything. One Rust binary. Zero configuration. Five-minute install. What agents can do with it Find callers, callees, and dependencies instantly — no file scanning, no token waste Compute blast radius before making a change — know exactly what breaks before anything is touched Detect structural drift between sessions — catch regressions the moment they happen, not at PR review Time-travel through code evolution — query any prior state of any symbol, not just git commits Search across the full codebase with hybrid retrieval — BM25 full-text + HNSW vector + graph traversal fused in one query Map API topology across services — cross-repo HTTP call graphs, dependency chains, dead endpoint detection Benefits −90% token cost on structural queries (Mem0) +26% accuracy on multi-step agentic tasks (Mem0) −91% p95 latency on structural lookups vs. RAG baselines +32.8% SWE-bench bug-fix success rate when agents have graph context (RepoGraph) 200–800ms per-save re-indexing — every file save is a queryable episode in under a second 40+ MCP tools covering indexing, search, relationships, impact analysis, temporal evolution, API topology, graph algorithms, and direct Cypher queries 12 languages + 3 IaC formats supported via Tree-sitter grammars Local-first, closed-source Rust — code never leaves the machine, no account required, no telemetry

8 hours ago
Socialcrawl Mcp
@Ridio

`socialcrawl-mcp` is an MCP server that connects AI agents to the [SocialCrawl API](https://socialcrawl.dev) — a unified social media data API covering 21 platforms and 108 endpoints. Retrieve profiles, posts, comments, search results, trending content, and analytics from TikTok, Instagram, YouTube, Twitter/X, LinkedIn, Reddit, and 15 more platforms. One API key, one consistent response format, every platform. **What the MCP server does:** - Discovers available platforms and endpoints dynamically - Fetches live social media data on your behalf - Validates requests locally before making API calls (saves credits) - Provides built-in API documentation the agent can query on demand ## Installation ### Claude Code (quickest) ```bash claude mcp add --scope user socialcrawl -- npx -y socialcrawl-mcp ``` Then set your API key: ```bash claude mcp add-env socialcrawl SOCIALCRAWL_API_KEY sc_your_key_here ``` ### Claude Desktop Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows): ## Setup ### 1. Get your API key Sign up at [socialcrawl.dev](https://socialcrawl.dev) and grab your API key from the dashboard. Every account starts with **100 free credits** — no credit card required. ### 2. Add the key to your config Replace `sc_your_key_here` in the installation config above with your actual API key (starts with `sc_`). > [!TIP] > You can also set `SOCIALCRAWL_API_KEY` as a system environment variable instead of putting it in the MCP config. The discovery and documentation tools work even without a key — only actual API requests need one. ## Usage Ask your AI agent in natural language. The MCP server handles the rest.

a day ago
Fairrate

2 days ago