Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/deskiziarecords/QUIMERIA-HYPERION/llms.txt

Use this file to discover all available pages before exploring further.

This guide walks you through getting the Sovereign Market Kernel running locally. By the end you will have the FastAPI backend serving the trading dashboard at http://localhost:8000, with a synthetic AMD cycle loaded and all 18 SMK modules active.
1

Clone the repository and install dependencies

Clone QUIMERIA-HYPERION and install the Python dependencies from requirements.txt. Python 3.10 or later is required; 3.12 is recommended.
git clone https://github.com/your-repo/QUIMERIA-HYPERION.git
cd QUIMERIA-HYPERION
pip install -r requirements.txt
The core dependencies — FastAPI, uvicorn, numpy, pandas, scipy, scikit-learn — install without any optional extras. JAX and FAISS are optional and can be added later.
If you plan to use GPU acceleration or topological analysis, also run: pip install jax jaxlib ripser faiss-cpu
2

Set the SMK_DIR environment variable

The kernel uses SMK_DIR to resolve module imports across the monorepo. Without it, the server starts in numpy fallback mode and most detectors are silently disabled.
# Linux / macOS — add to your shell profile to persist across sessions
export SMK_DIR=/path/to/QUIMERIA-HYPERION
export PYTHONPATH="$SMK_DIR:$SMK_DIR/backend:$PYTHONPATH"

:: Windows — set for the current terminal session
set SMK_DIR=C:\path\to\QUIMERIA-HYPERION
set PYTHONPATH=%SMK_DIR%;%SMK_DIR%\backend;%PYTHONPATH%
The launcher scripts (scripts/start.sh and scripts/start.bat) set SMK_DIR automatically. If you use a launcher you can skip this step.
3

Start the backend

Use the platform launcher or start uvicorn directly.
chmod +x scripts/start.sh
./scripts/start.sh
The Linux launcher accepts additional flags:
scripts/start.sh --port 8080    # Custom port
scripts/start.sh --status       # Check service status
scripts/start.sh --stop         # Stop all services
On a successful start you will see the module verification output confirming how many of the 10 core modules loaded, followed by the uvicorn startup line.
4

Open the dashboard and load data

Open http://localhost:8000 in your browser. The dashboard provides:
  • TradingView Lightweight Charts with candlestick visualization
  • 14 SMK sensor bars showing real-time λ scores
  • 6 plugin sensor bars from the forensic detector layer
  • Execution panel displaying veto authority status and AMD state
  • Log panels for events, veto decisions, and trades
To load the built-in synthetic AMD cycle — the fastest way to see the full pipeline in action — use the sample data endpoint:
curl -X POST http://localhost:8000/api/load/sample
The dashboard will immediately begin rendering bars and sensor scores as the pipeline processes each candle.

​
Load data via the API

After the backend is running you can load historical OHLCV data from any supported source. Here is a Python example using httpx to load data from Bitget and then stream it bar-by-bar over WebSocket: 
import httpx
import asyncio
import websockets
import json

BASE_URL = "http://localhost:8000"

# Load 200 bars of BTC/USDT hourly data from Bitget
with httpx.Client() as client:
    resp = client.post(
        f"{BASE_URL}/api/load/bitget",
        json={
            "symbol": "BTCUSDT",
            "granularity": "1H",
            "limit": 200
        }
    )
    print(resp.json())  # {"bars_loaded": 200, "symbol": "BTCUSDT"}


# Stream bars over WebSocket and print Ring 0 veto decisions
async def stream():
    uri = "ws://localhost:8000/ws/stream"
    async with websockets.connect(uri) as ws:
        # Start streaming at 100ms per bar
        await ws.send(json.dumps({"action": "run", "speed": 100}))

        async for message in ws:
            bar = json.loads(message)
            veto = bar.get("veto", {})
            allowed = veto.get("trade_allowed", None)
            reason = veto.get("reason", "")
            print(f"Bar {bar.get('bar_index'):>4} | allowed={allowed} | {reason}")

asyncio.run(stream())

​
Check system status

curl http://localhost:8000/api/status
The response shows the pipeline state, number of bars loaded, active module count, and whether the AEGIS bridge is connected.

​
Next steps

Installation

Full dependency details, optional packages, and the Rust hyperion subproject.

Configuration

Set up exchange API keys, trading parameters, and tune signal thresholds.

API reference

All REST and WebSocket endpoints documented with request and response schemas.

Plugin system

Extend the kernel with custom forensic detectors using the SMKPlugin contract.

Build docs developers (and LLMs) love

Get started for freeTalk to us