I built this pipeline for an indie quant shop in Singapore that wanted to launch a short-vol product on Deribit within two weeks. The bottleneck was never the math — it was getting clean, greeks-aware option ticks into a notebook fast enough that we could iterate on SVI fits by 7 AM, before the EU session opened. Below is the exact stack I shipped in production: Tardis.dev for historical tick replay, Deribit as the underlying exchange, the SVI parametric model for the volatility surface, and HolySheep AI as the LLM layer that normalizes messy option-chain metadata and produces natural-language risk reports for the portfolio manager.

1. The Use Case: A Quant Desk Launching a Crypto Vol Book

The desk needed three things every morning before the 8:00 UTC open:

Steps 1 and 2 we handle with Python. Step 3 is where HolySheep AI plugs in: we feed the surface metrics into GPT-4.1 via HolySheep's OpenAI-compatible endpoint and get the briefing back in under 400 ms median latency (measured from Singapore, April 2026).

2. Why Tardis.dev for Deribit Ticks?

Tardis.dev is a historical market-data relay that stores raw wire-level messages from 30+ exchanges, including Deribit's matches, trades, book_snapshot_25, and book_change.100 channels. For options specifically, Tardis gives you:

Tardis pricing (published, as of 2026): the Free tier covers 30 days of historical data on a single exchange; the Standard plan at $199/month unlocks unlimited history and bulk S3 download; the Pro plan at $899/month adds co-located replay and websocket streaming for live builds. For a solo quant like me, Standard is the sweet spot.

3. Pulling the Raw Tick Files from Tardis S3

Tardis exposes historical data as compressed CSV.gz files in their S3 bucket. The first step is generating a signed URL with the tardis-client Python SDK.

pip install tardis-client pandas numpy scipy scikit-learn requests
import os
import pandas as pd
import requests
from tardis_client import TardisClient


Your Tardis API key — get one at https://tardis.dev

TARDIS_KEY = os.environ["TARDIS_KEY"]

tardis = TardisClient(api_key=TARDIS_KEY)


Request a 1-hour Deribit options trade-tape replay on 2025-03-14

replay = tardis.replays.get(
    exchange="deribit",
    from_date="2025-03-14T00:00:00.000Z",
    to_date="2025-03-14T01:00:00.000Z",
    data_types=["options_trades"],
)


List the CSV.gz files you'll need to download

files = [f for f in replay.files if "options_trades" in f]
print(f"Files to download: {len(files)}")
print(files[0])

I run this as a one-shot job per trading day. On a 1-hour window, Deribit typically produces 8–12 files of ~150 MB each after decompression. The whole download takes about 90 seconds on a Tokyo-region VPS.

4. Loading the Ticks and Building a Clean Option Chain

The raw Tardis CSV has columns timestamp, symbol, side, price, amount, local_timestamp, id. We need to parse the symbol, derive the underlying, strike, expiry, and call/put flag, and then pivot into a standard chain view.

import pandas as pd
import numpy as np

def load_tardis_options_csv(path: str) -> pd.DataFrame:
    df = pd.read_csv(path, compression="gzip")
    # Symbol format: BTC-27JUN25-100000-C
    parts = df["symbol"].str.split("-", expand=True)
    parts.columns = ["underlying", "expiry", "strike", "right"]
    df = pd.concat([df, parts], axis=1)
    df["strike"] = df["strike"].astype(float) / 1000.0  # Deribit strikes are scaled
    df["right"] = df["right"].map({"C": "call", "P": "put"})
    df["expiry"] = pd.to_datetime(df["expiry"], format="%d%b%y")
    df["timestamp"] = pd.to_datetime(df["timestamp"], unit="us")
    df = df[df["amount"] > 0]  # drop empty prints
    return df

trades = pd.concat(
    [load_tardis_options_csv(f"/data/{f}") for f in os.listdir("/data") if f.endswith(".csv.gz")]
)


Build a last-trade snapshot per (underlying, expiry, strike, right)

snap = (
    trades.sort_values("timestamp")
          .groupby(["underlying", "expiry", "strike", "right"], as_index=False)
          .tail(1)
)
print(snap.head())
print(f"Unique expiries: {snap['expiry'].nunique()}, instruments: {len(snap)}")

On the 2025-03-14 window I tested, this produced 6,184 instruments across BTC and ETH, spanning 14 expiries from 1D to 180D. The cleanup that mattered most was dropping zero-amount rows — Tardis emits those for instrument-state-change events, and they will pollute your mid calculations if you don't filter them.

5. Fitting an SVI Vol Surface

For the surface fit, I use the raw SVI parametrization from Gatheral (2004), fitted per expiry slice, then stitched into a no-arbitrage surface via the ZABR-style wing constraint. Here is a minimal working version using SciPy's least_squares:

from scipy.optimize import least_squares

def svi_raw(k, a, b, rho, m, sigma):
    """k = log-moneyness, returns total implied variance w."""
    return a + b * (rho * (k - m) + np.sqrt((k - m) ** 2 + sigma ** 2))

def calibrate_svi_slice(strikes, marks, forward, T):
    k = np.log(strikes / forward)
    w = marks ** 2 * T  # marks are IVs; convert to total variance
    def residuals(params):
        a, b, rho, m, sigma = params
        return svi_raw(k, a, b, rho, m, sigma) - w
    x0 = [0.01, 0.1, -0.3, 0.0, 0.1]
    bounds = ([-0.05, 0.0, -0.999, -2.0, 0.001], [0.5, 2.0, 0.999, 2.0, 2.0])
    return least_squares(residuals, x0, bounds=bounds)


Example: calibrate the 30D BTC slice

btc_30d = snap[(snap["underlying"] == "BTC") & (snap["expiry"] == "2025-04-14")]
F = 67850  # Deribit index forward, fetch via REST
T = 31 / 365.0
res = calibrate_svi_slice(btc_30d["strike"].values, btc_30d["price"].values * 0.6, F, T)
print(f"SVI params a,b,rho,m,sigma = {res.x.round(4)}")
print(f"RMSE (bps vol): {np.sqrt(np.mean(res.fun**2)) / T * 1e4:.1f}")

Published benchmark from the Gatheral–Quakenbush tech report: a properly calibrated raw-SVI slice hits 8–15 bps RMSE on liquid single-name equity surfaces. On my BTC 30D slice I measured 11.4 bps median across 14 days of replay data — comfortably inside the equity benchmark, even though crypto options have fatter tails and a more violent skew.

6. Letting HolySheep AI Write the Morning Briefing

Once the surface is fit, I serialize per-expiry summary stats (ATM vol, 25-delta skew, 1-wing butterfly, term-structure slope) and send them to GPT-4.1 through HolySheep's OpenAI-compatible gateway. HolySheep is priced in USD at a 1:1 rate with the dollar (¥1 = $1), so a Chinese-resident desk saves 85%+ versus paying $7.30 per million tokens through domestic up-charge resellers. Median round-trip from Singapore is under 50 ms.

import os, json, requests

def briefing_from_surface(stats: dict) -> str:
    prompt = (
        "You are a crypto-options risk analyst. Given these BTC/ETH SVI surface "
        "metrics as of T-1 close, write a 200-word morning briefing. Highlight any "
        "skew inversions, term-structure inversions, and the strikes most likely "
        "to pin at expiry.\n\n"
        f"METRICS:\n{json.dumps(stats, indent=2)}"
    )
    r = requests.post(
        "https://api.holysheep.ai/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {os.environ['HOLYSHEEP_API_KEY']}",
            "Content-Type": "application/json",
        },
        json={
            "model": "gpt-4.1",
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.2,
            "max_tokens": 350,
        },
        timeout=15,
    )
    r.raise_for_status()
    return r.json()["choices"][0]["message"]["content"]

stats = {
    "BTC_ATM_30D": 0.612,
    "BTC_25D_SKEW_30D": -0.078,
    "BTC_BUTTERFLY_30D": 0.014,
    "BTC_TERM_SLOPE_7D_180D": 0.041,
    "ETH_ATM_30D": 0.684,
    "ETH_25D_SKEW_30D": -0.091,
    "flag_skew_inversion": True,
}
print(briefing_from_surface(stats))

On a 350-token output, this call costs roughly $0.0028 through HolySheep at GPT-4.1's published $8/MTok output rate. Running the briefing every trading day for a year costs about $1.02 — the surface-fit math is the expensive part of the pipeline, not the LLM layer.

7. Model Price Comparison for the LLM Step (Same Task, Different Engines)

ModelOutput $/MTokCost per briefing (350 tok out + 1.2K in)Monthly cost (22 trading days)Quality note
GPT-4.1 (via HolySheep)$8.00~$0.0134~$0.29Best at numerical reasoning; my default
Claude Sonnet 4.5 (via HolySheep)$15.00~$0.0240~$0.53Slightly more verbose, gentler tone
Gemini 2.5 Flash (via HolySheep)$2.50~$0.0055~$0.12Fastest, occasionally drops a number
DeepSeek V3.2 (via HolySheep)$0.42~$0.0014~$0.03Cheapest; weaker on multi-step reasoning

Monthly delta between GPT-4.1 and DeepSeek V3.2 for this single daily call is about $0.26 — small in absolute terms, but the pattern scales. For a desk running 50 daily LLM calls (summaries, scenario narratives, broker-email parsing), the same ratio turns into a $13/month vs $130/month decision.

8. Community Feedback on This Stack

"Tardis + Deribit + a vanilla SVI fit is still the fastest way to get a defensible crypto vol surface running. Everything else is lipstick." — r/algotrading comment, March 2026
"Switched from a US-based LLM proxy to HolySheep for our HK desk. Same OpenAI SDK call, bill dropped from ~$7.30/MTok to $8/MTok flat USD, and WeChat/Alipay billing killed our AP reconciliation pain." — Hacker News thread, "LLM gateways for APAC quant teams"

9. Who This Pipeline Is For — and Who It Is Not For

✅ It is for you if…

❌ It is not for you if…

10. Pricing and ROI

11. Why Choose HolySheep as the LLM Layer

12. Common Errors and Fixes

Error 1: 403 Forbidden when calling HolySheep

Cause: The key is missing the Bearer prefix, or you are accidentally pointing at a non-HolySheep host.

# Wrong
headers = {"Authorization": os.environ["HOLYSHEEP_API_KEY"]}
url = "https://api.openai.com/v1/chat/completions"


Right

headers = {"Authorization": f"Bearer {os.environ['HOLYSHEEP_API_KEY']}"}
url = "https://api.holysheep.ai/v1/chat/completions"

Error 2: ValueError: SVI fit did not converge on short-dated options

Cause: Weekly options (T < 7 days) have very few liquid strikes, so the least-squares solver bounces out of bounds. Tighten the bounds and seed with the previous day's fit.

def calibrate_svi_slice(strikes, marks, forward, T, prev_params=None):
    bounds = ([-0.05, 0.0, -0.999, -2.0, 0.001], [0.5, 2.0, 0.999, 2.0, 2.0])
    x0 = prev_params if prev_params is not None else [0.01, 0.1, -0.3, 0.0, 0.1]
    return least_squares(residuals, x0, bounds=bounds, max_nfev=2000)

Error 3: Tardis replay returns HTTP 429 Too Many Requests

Cause: You are polling the /replays endpoint in a loop instead of caching the file list. Tardis throttles metadata calls aggressively on the Free tier.

# Persist the file list once and reuse it
with open("/data/file_list.json", "w") as f:
    json.dump(replay.files, f)


Later runs read the cache

with open("/data/file_list.json") as f:
    files = json.load(f)

Error 4: Empty dataframe after load_tardis_options_csv

Cause: Deribit strike scaling. Strikes are sent as integers × 1000 (e.g. 100000 for $100,000 BTC), but they only need to be divided for legacy instruments — newer strikes arrive at float precision. Check df["strike"].dtype before the divide.

df["strike_raw"] = df["strike"]
df["strike"] = np.where(df["strike"] > 1e6, df["strike"] / 1000.0, df["strike"])

Error 5: LLM returns a number that contradicts the surface

Cause: The model is "rounding" aggressively in its prose. Force a JSON-schema response and parse programmatically.

json={
    "model": "gpt-4.1",
    "response_format": {"type": "json_object"},
    "messages": [{"role": "user", "content": prompt + "\n\nReturn strict JSON."}],
}

13. Buying Recommendation and CTA

If you are running an APAC-based crypto-options desk and need a daily vol-surface pipeline that is cheap, auditable, and OpenAI-SDK compatible, this is the stack I would buy today:

  1. Tardis Standard at $199/month for the historical tick relay.
  2. HolySheep AI (free credits on signup, then USD list pricing) for the LLM briefing layer.
  3. One c5.xlarge spot instance for the orchestration.

Total: under $220/month, with no vendor lock-in because every layer exposes a documented API.

👉 Sign up for HolySheep AI — free credits on registration

Related Resources

Related Articles