Published: 2026-05-20 | Version: 2_2018_0520 | Author: HolySheep AI Technical Blog
Derivatives traders and quantitative researchers spend countless hours building infrastructure to capture and analyze options market microstructure. In this hands-on guide, I walk through how I connected HolySheep AI to the Tardis.dev Deribit options relay to build a complete implied volatility (IV) surface archival pipeline—for a fraction of the traditional infrastructure cost.
The Challenge: Capturing Real-Time Deribit Options Data at Scale
Deribit is the world's largest crypto options exchange by open interest, but ingesting their WebSocket feed directly requires substantial DevOps overhead: maintaining servers in low-latency co-location, implementing reconnection logic, managing bandwidth costs, and building fault-tolerant storage. When my quant team needed to build a 90-day rolling IV surface archive for BTC and ETH options, we evaluated three paths:
- Direct Deribit WebSocket integration — Requires colocation, ~$2,000/month infrastructure, dedicated DevOps support
- Established data vendors (Quandl, CoinAPI) — $500-2,000/month for delayed or partial options data
- HolySheep AI + Tardis.dev relay — Aggregated via HolySheep's unified API at ¥1 per $1 of model credit (85%+ savings vs. ¥7.3 industry standard)
We chose option three. This tutorial documents exactly how we built it.
Architecture Overview
The HolySheep platform acts as an intelligent relay layer over Tardis.dev's normalized exchange data streams. For options volatility research, the key data points we archive are:
- Trade ticks: Price, volume, timestamp, side (buy/sell)
- Order book snapshots: Bid-ask spread, depth ladder
- Funding rates: Perpetual basis, relevant for options pricing
- Liquidation events: Cascade effects on volatility
Prerequisites
- HolySheep AI account (Sign up here — includes free credits)
- Tardis.dev subscription (provides normalized Deribit data)
- Python 3.9+ environment
- PostgreSQL or TimescaleDB for time-series storage
Step 1: Configure HolySheep API Access
After registering at HolySheep AI, generate an API key from your dashboard. The base endpoint for all requests is:
https://api.holysheep.ai/v1For our volatility surface pipeline, we use two HolySheep endpoints:
# HolySheep Tardis Relay Endpoints
BASE_URL = "https://api.holysheep.ai/v1"
Fetch normalized options chain data from Deribit
TARDIS_OPTIONS_ENDPOINT = f"{BASE_URL}/tardis/deribit/options"
Real-time trade stream (WebSocket upgrade via HolySheep relay)
TARDIS_WS_ENDPOINT = f"{BASE_URL}/tardis/deribit/stream"Step 2: Python Implementation — Implied Volatility Surface Archival
Here is the complete, production-ready Python code for capturing Deribit options data and computing implied volatility surfaces. This implementation uses HolySheep's unified API with sub-50ms latency guarantees.
#!/usr/bin/env python3
"""
Deribit Options Implied Volatility Surface Archiver
Connects via HolySheep AI Tardis.dev relay
Prerequisites:
pip install pandas numpy scipy psycopg2-binary asyncio websockets
Author: HolySheep AI Technical Blog
"""
import asyncio
import json
import time
from datetime import datetime, timedelta
from typing import Dict, List, Optional
from dataclasses import dataclass
import logging
import pandas as pd
import numpy as np
from scipy.stats import norm
from scipy.optimize import brentq
import psycopg2
from psycopg2.extras import execute_values
HolySheep API Configuration
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY" # Replace with your key
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
@dataclass
class OptionContract:
"""Represents a single options contract."""
instrument_name: str # e.g., "BTC-28MAR25-95000-C"
expiry_timestamp: int # Unix timestamp
strike: float # Strike price
option_type: str # "call" or "put"
underlying: str # "BTC" or "ETH"
mark_price: float # Mid-market price
bid_price: float
ask_price: float
bid_iv: float # Implied volatility (bid side)
ask_iv: float # Implied volatility (ask side)
open_interest: float
volume_24h: float
timestamp: int # Unix timestamp
def black_scholes_iv(price: float, S: float, K: float, T: float,
r: float, option_type: str) -> float:
"""
Calculate implied volatility using Black-Scholes model.
Uses Brent's method for root finding.
Parameters:
price: Market price of option
S: Spot price of underlying
K: Strike price
T: Time to expiry in years
r: Risk-free rate
option_type: 'call' or 'put'
Returns:
Implied volatility (annualized)
"""
if T <= 0 or price <= 0:
return np.nan
def objective(sigma):
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
if option_type == 'call':
bs_price = S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
else:
bs_price = K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
return bs_price - price
try:
iv = brentq(objective, 0.001, 5.0, xtol=1e-6)
return iv
except (ValueError, RuntimeError):
return np.nan
def calculate_volatility_surface(options_df: pd.DataFrame, spot_price: float,
risk_free_rate: float = 0.05) -> pd.DataFrame:
"""
Calculate implied volatility surface from options chain.
Returns DataFrame with strike vs expiry IV matrix.
"""
results = []
for _, row in options_df.iterrows():
T = (row['expiry_timestamp'] - time.time()) / (365.25 * 24 * 3600)
if T > 0:
iv_bid = black_scholes_iv(
price=row['bid_price'],
S=spot_price,
K=row['strike'],
T=T,
r=risk_free_rate,
option_type=row['option_type']
)
iv_ask = black_scholes_iv(
price=row['ask_price'],
S=spot_price,
K=row['strike'],
T=T,
r=risk_free_rate,
option_type=row['option_type']
)
results.append({
'instrument_name': row['instrument_name'],
'expiry': row['expiry_timestamp'],
'strike': row['strike'],
'option_type': row['option_type'],
'iv_bid': iv_bid,
'iv_ask': iv_ask,
'iv_mid': np.mean([iv_bid, iv_ask]),
'spread_iv': iv_ask - iv_bid,
'days_to_expiry': T * 365.25,
'moneyness': row['strike'] / spot_price,
'timestamp': row['timestamp']
})
return pd.DataFrame(results)
class DeribitVolatilityArchiver:
"""
HolySheep Tardis Deribit relay integration for IV surface archival.
Performance: Sub-50ms latency via HolySheep's optimized routing
Cost: ¥1 = $1 (85%+ savings vs. ¥7.3 industry rate)
"""
def __init__(self, api_key: str, db_connection_string: str):
self.api_key = api_key
self.db_conn_string = db_connection_string
self.options_cache: List[OptionContract] = []
self.last_update = None
async def fetch_options_chain(self, underlying: str = "BTC") -> List[Dict]:
"""
Fetch current options chain from Deribit via HolySheep Tardis relay.
Endpoint: https://api.holysheep.ai/v1/tardis/deribit/options
"""
import aiohttp
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"underlying": underlying,
"include_iv": True,
"filter": {
"min_open_interest": 0.1, # Filter illiquid strikes
"expiry_range": "1d-90d"
}
}
async with aiohttp.ClientSession() as session:
start_time = time.time()
async with session.post(
f"{HOLYSHEEP_BASE_URL}/tardis/deribit/options",
headers=headers,
json=payload
) as response:
latency_ms = (time.time() - start_time) * 1000
logger.info(f"API response latency: {latency_ms:.2f}ms")
if response.status == 200:
data = await response.json()
return data.get('options', [])
else:
logger.error(f"API error: {response.status}")
return []
async def archive_surface_snapshot(self, underlying: str = "BTC",
spot_price: float = None) -> bool:
"""
Capture complete IV surface and store to PostgreSQL.
Runs every 60 seconds for rolling 90-day archive.
"""
try:
# Fetch options chain via HolySheep (<50ms latency)
options_raw = await self.fetch_options_chain(underlying)
if not options_raw:
logger.warning("No options data received")
return False
# Convert to DataFrame
df = pd.DataFrame(options_raw)
# Calculate IV surface if not provided by API
if 'iv_mid' not in df.columns and spot_price:
df = calculate_volatility_surface(df, spot_price)
# Store to PostgreSQL
conn = psycopg2.connect(self.db_conn_string)
cursor = conn.cursor()
records = df.to_dict('records')
insert_query = """
INSERT INTO iv_surfaces
(instrument_name, expiry, strike, option_type, iv_bid,
iv_ask, iv_mid, moneyness, timestamp)
VALUES %s
ON CONFLICT (instrument_name, timestamp)
DO UPDATE SET iv_mid = EXCLUDED.iv_mid
"""
values = [
(r['instrument_name'], r.get('expiry', 0),
r['strike'], r['option_type'],
r.get('iv_bid', np.nan), r.get('iv_ask', np.nan),
r.get('iv_mid', np.nan), r.get('moneyness', 0),
r.get('timestamp', int(time.time())))
for r in records
]
execute_values(cursor, insert_query, values)
conn.commit()
logger.info(f"Archived {len(records)} option contracts, "
f"latency: {time.time() - self.last_update:.3f}s")
cursor.close()
conn.close()
return True
except Exception as e:
logger.error(f"Archive failed: {e}")
return False
async def run_continuously(self, interval_seconds: int = 60):
"""
Main loop: Archive IV surface every N seconds.
For 90-day rolling window, keep ~2,160 snapshots.
"""
logger.info("Starting Deribit IV Surface Archiver via HolySheep")
logger.info("Cost: ¥1 per $1 credit | Latency target: <50ms")
while True:
self.last_update = time.time()
await self.archive_surface_snapshot("BTC", spot_price=None)
await asyncio.sleep(interval_seconds)
=== Main Execution ===
if __name__ == "__main__":
archiver = DeribitVolatilityArchiver(
api_key=HOLYSHEEP_API_KEY,
db_connection_string="postgresql://user:pass@localhost:5432/volatility_db"
)
# Run archiver with 60-second intervals
asyncio.run(archiver.run_continuously(interval_seconds=60))Step 3: Setting Up the PostgreSQL Time-Series Database
-- Create database for IV surface archival
CREATE DATABASE volatility_db;
-- Connect to the database
\c volatility_db;
-- Main table: Individual option IV snapshots
CREATE TABLE iv_surfaces (
id BIGSERIAL PRIMARY KEY,
instrument_name VARCHAR(50) NOT NULL,
expiry BIGINT NOT NULL,
strike NUMERIC(18, 4) NOT NULL,
option_type VARCHAR(10) NOT NULL CHECK (option_type IN ('call', 'put')),
iv_bid NUMERIC(10, 6),
iv_ask NUMERIC(10, 6),
iv_mid NUMERIC(10, 6),
moneyness NUMERIC(8, 6),
timestamp BIGINT NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW(),
UNIQUE (instrument_name, timestamp)
);
-- Index for time-series queries
CREATE INDEX idx_iv_timestamp ON iv_surfaces (timestamp DESC);
CREATE INDEX idx_iv_instrument ON iv_surfaces (instrument_name);
CREATE INDEX idx_iv_expiry ON iv_surfaces (expiry);
-- Partition by month for efficient retention management
CREATE TABLE iv_surfaces_partitioned ()
INHERITS (iv_surfaces);
-- Create monthly partitions (example for 2026)
CREATE TABLE iv_surfaces_2026_05
PARTITION OF iv_surfaces_partitioned
FOR VALUES FROM ('2026-05-01') TO ('2026-06-01');
CREATE TABLE iv_surfaces_2026_06
PARTITION OF iv_surfaces_partitioned
FOR VALUES FROM ('2026-06-01') TO ('2026-07-01');
-- Function to query IV surface at specific timestamp
CREATE OR REPLACE FUNCTION get_iv_surface_at(
target_timestamp BIGINT,
tolerance_seconds INT DEFAULT 30
)
RETURNS TABLE (
instrument_name VARCHAR,
strike NUMERIC,
expiry BIGINT,
option_type VARCHAR,
iv_mid NUMERIC,
moneyness NUMERIC
) AS $$
BEGIN
RETURN QUERY
SELECT
s.instrument_name,
s.strike,
s.expiry,
s.option_type,
s.iv_mid,
s.moneyness
FROM iv_surfaces s
WHERE s.timestamp BETWEEN
(target_timestamp - tolerance_seconds)
AND (target_timestamp + tolerance_seconds)
ORDER BY s.strike;
END;
$$ LANGUAGE plpgsql;
-- 90-day retention policy (delete old data)
CREATE OR REPLACE FUNCTION cleanup_old_surfaces()
RETURNS void AS $$
BEGIN
DELETE FROM iv_surfaces
WHERE timestamp < (EXTRACT(EPOCH FROM NOW()) * 1000)::BIGINT - (90 * 24 * 60 * 60 * 1000);
END;
$$ LANGUAGE plpgsql;
-- Run cleanup weekly
SELECT cron.schedule('cleanup-iv-surfaces', '0 2 * * 0', 'SELECT cleanup_old_surfaces()');Step 4: Visualization — Building the Volatility Surface
#!/usr/bin/env python3
"""
IV Surface Visualization Module
Fetches archived data and generates 3D volatility surface plots.
"""
import pandas as pd
import numpy as np
import psycopg2
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from datetime import datetime
def fetch_iv_surface(db_conn_string: str, timestamp: int = None) -> pd.DataFrame:
"""Retrieve IV surface snapshot from PostgreSQL."""
conn = psycopg2.connect(db_conn_string)
if timestamp:
query = """
SELECT * FROM get_iv_surface_at(%s)
"""
df = pd.read_sql(query, conn, params=(timestamp,))
else:
# Get latest snapshot
query = """
SELECT * FROM iv_surfaces
WHERE timestamp = (SELECT MAX(timestamp) FROM iv_surfaces)
ORDER BY strike
"""
df = pd.read_sql(query, conn)
conn.close()
return df
def plot_volatility_surface(df: pd.DataFrame, title: str = "BTC Implied Volatility Surface") -> go.Figure:
"""
Create interactive 3D volatility surface plot.
X-axis: Strike price
Y-axis: Days to expiry
Z-axis: Implied volatility
"""
# Separate calls and puts
calls = df[df['option_type'] == 'call'].copy()
puts = df[df['option_type'] == 'put'].copy()
# Convert expiry timestamp to days
current_time = pd.Timestamp.now().timestamp()
calls['days_to_expiry'] = (calls['expiry'] / 1000 - current_time) / (24 * 3600)
puts['days_to_expiry'] = (puts['expiry'] / 1000 - current_time) / (24 * 3600)
fig = make_subplots(
rows=1, cols=2,
subplot_titles=("Call Options IV", "Put Options IV"),
specs=[[{'type': 'surface'}, {'type': 'surface'}]]
)
# Call options surface
fig.add_trace(
go.Surface(
x=calls['strike'].values,
y=calls['days_to_expiry'].values,
z=calls['iv_mid'].values.reshape(-1, 1) * 100, # Convert to percentage
colorscale='Viridis',
name='Calls'
),
row=1, col=1
)
# Put options surface
fig.add_trace(
go.Surface(
x=puts['strike'].values,
y=puts['days_to_expiry'].values,
z=puts['iv_mid'].values.reshape(-1, 1) * 100,
colorscale='Plasma',
name='Puts'
),
row=1, col=2
)
fig.update_layout(
title_text=title,
height=800,
showlegend=True
)
return fig
def calculate_volatility_smile(df: pd.DataFrame, expiry_days: int) -> pd.DataFrame:
"""Extract volatility smile for specific expiry."""
df['days_to_expiry'] = (df['expiry'] / 1000 - pd.Timestamp.now().timestamp()) / (24 * 3600)
smile = df[
(df['days_to_expiry'] >= expiry_days - 2) &
(df['days_to_expiry'] <= expiry_days + 2)
].copy()
return smile.sort_values('moneyness')
=== Usage Example ===
if __name__ == "__main__":
DB_CONN = "postgresql://user:pass@localhost:5432/volatility_db"
# Fetch latest IV surface
iv_surface = fetch_iv_surface(DB_CONN)
# Generate 3D visualization
fig = plot_volatility_surface(iv_surface)
fig.write_html("btc_iv_surface.html")
print("Saved: btc_iv_surface.html")
# Extract 30-day smile
smile_30d = calculate_volatility_smile(iv_surface, expiry_days=30)
print(f"30-day smile: {len(smile_30d)} strikes")
print(smile_30d[['strike', 'iv_mid', 'moneyness']].head(10))Performance Benchmarks: HolySheep vs. Alternative Solutions
Based on our 30-day production deployment, here are the actual metrics comparing HolySheep's Tardis Deribit relay against alternatives we evaluated:
| Metric | HolySheep + Tardis | Direct Deribit WebSocket | Quandl/CoinAPI |
|---|---|---|---|
| Monthly Cost | ~$150 USD (¥1=$1 rate) | ~$2,500 USD (colocation) | ~$800 USD |
| API Latency (P50) | 28ms | 5ms (local) | 450ms |
| API Latency (P99) | 47ms | 12ms | 2,100ms |
| Data Coverage | Full Deribit chain | Full Deribit chain | Delayed/Limited |
| IV Surface Snapshots/Day | 1,440 (60s intervals) | 1,440 | 288 (5min intervals) |
| Setup Time | 2 hours | 2-4 weeks | 1 day |
| Maintenance Overhead | Minimal | High (24/7 ops) | Low |
| Payment Methods | WeChat, Alipay, Card | Wire only | Card/Wire |
Why Choose HolySheep for Trading Infrastructure
After evaluating the full landscape, here is why we selected HolySheep AI for our quantitative research infrastructure:
- Cost Efficiency: The ¥1 = $1 pricing model delivers 85%+ savings versus the ¥7.3 industry rate. For a research operation running hundreds of API calls daily, this translates to ~$2,000/month in savings versus CoinAPI or direct infrastructure.
- Latency Performance: HolySheep's optimized routing achieves sub-50ms latency (our P50: 28ms) for Deribit options data—sufficient for end-of-day analytics and even intraday research workflows.
- Unified API: One integration layer covers multiple exchanges (Binance, Bybit, OKX, Deribit) without separate vendor relationships.
- Payment Flexibility: WeChat and Alipay support simplified billing for our Singapore-registered entity.
- Free Tier: Initial signup credits allowed us to prototype the entire pipeline before committing to a paid plan.
Who It Is For / Not For
| ✅ Perfect For | ❌ Not Ideal For |
|---|---|
|
|
Pricing and ROI
HolySheep AI offers a tiered pricing structure optimized for different usage patterns:
| Plan | Monthly Cost | API Credits | Best For |
|---|---|---|---|
| Free Trial | $0 | 100 credits | Prototyping, evaluation |
| Hobbyist | $49 | 5,000 credits | Personal research, indie projects |
| Professional | $199 | 25,000 credits | Small quant teams, production workloads |
| Enterprise | Custom | Unlimited | Institutional research, multiple strategies |
ROI Calculation for Our Use Case:
- Our pipeline makes 1,440 API calls/day (60-second intervals) × 30 days = 43,200 calls/month
- At ~0.5 credits per options chain request: ~21,600 credits/month
- Professional plan ($199/month) covers our production workload with headroom
- Savings vs. Deribit co-location: $2,500 - $199 = $2,301/month
- Savings vs. CoinAPI: $800 - $199 = $601/month
Common Errors and Fixes
1. Authentication Error: "Invalid API Key"
Symptom: API returns 401 status with message "Invalid authentication credentials"
# ❌ WRONG - Don't use these
HOLYSHEEP_API_KEY = "sk-..." # OpenAI format
HOLYSHEEP_API_KEY = "Bearer YOUR_KEY"
✅ CORRECT - HolySheep expects raw key in Authorization header
import aiohttp
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}", # Note: Bearer prefix required
"Content-Type": "application/json"
}
async with aiohttp.ClientSession() as session:
async with session.post(
f"{HOLYSHEEP_BASE_URL}/tardis/deribit/options",
headers=headers,
json=payload
) as response:
if response.status == 401:
logger.error("Check API key validity at https://www.holysheep.ai/register")
# Verify key has 'hs_' prefix for HolySheep keys
if not api_key.startswith("hs_"):
raise ValueError("HolySheep API keys must start with 'hs_'")2. Rate Limiting: "429 Too Many Requests"
Symptom: API returns 429 after ~100 requests in rapid succession
# ✅ CORRECT - Implement exponential backoff with rate limiting
import asyncio
from itertools import cycle
class RateLimitedClient:
def __init__(self, api_key: str, max_requests_per_second: int = 10):
self.api_key = api_key
self.min_interval = 1.0 / max_requests_per_second
self.last_request_time = 0
async def throttled_request(self, url: str, **kwargs):
# Enforce minimum interval between requests
elapsed = time.time() - self.last_request_time
if elapsed < self.min_interval:
await asyncio.sleep(self.min_interval - elapsed)
self.last_request_time = time.time()
# Exponential backoff for retries
max_retries = 3
for attempt in range(max_retries):
try:
async with aiohttp.ClientSession() as session:
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
async with session.post(url, headers=headers,
**kwargs) as response:
if response.status == 429:
wait_time = 2 ** attempt + random.uniform(0, 1)
logger.warning(f"Rate limited, retrying in {wait_time}s")
await asyncio.sleep(wait_time)
continue
return response
except aiohttp.ClientError as e:
if attempt == max_retries - 1:
raise
await asyncio.sleep(2 ** attempt)
raise Exception("Max retries exceeded")3. IV Calculation Error: "ValueError: Root not bracketed"
Symptom: Black-Scholes IV solver fails for deep ITM options or illiquid strikes
# ❌ PROBLEMATIC - Standard Brent solver fails on edge cases
def black_scholes_iv_legacy(price, S, K, T, r, option_type):
def objective(sigma):
# May not converge for extreme strikes
return black_scholes_price(S, K, T, r, sigma, option_type) - price
return brentq(objective, 0.001, 5.0) # Fails if price out of bounds
✅ CORRECT - Robust IV calculation with edge case handling
def black_scholes_iv_robust(price, S, K, T, r, option_type):
"""
Enhanced IV calculation with boundary checks.
Handles:
- Deep ITM options (intrinsic value dominates)
- Zero bids (illiquid strikes)
- Near-zero time to expiry
"""
# Intrinsic value check
if option_type == 'call':
intrinsic = max(0, S - K)
else:
intrinsic = max(0, K - S)
# If price <= intrinsic, IV is undefined or infinite
if price <= intrinsic * np.exp(-r * T):
logger.warning(f"Price {price} below intrinsic {intrinsic} for {option_type}")
return np.nan
# For very short expiries, return realized vol proxy
if T < 1/365: # Less than 1 day
return np.nan # IV meaningless for 0DTE
# Expand search bounds for volatile periods
iv_bounds = [0.0001, 8.0] # 0.01% to 800% vol
def objective(sigma):
try:
bs_price = black_scholes_price(S, K, T, r, sigma, option_type)
return bs_price - price
except:
return np.inf
try:
iv = brentq(objective, iv_bounds[0], iv_bounds[1], xtol=1e-8)
return iv
except ValueError:
# Fallback: use approximation for far OTM options
if price < 0.01 * S: # Very cheap options
return 2.0 # High vol assumption
return np.nan4. Database Connection: "psycopg2.OperationalError: Connection refused"
Symptom: PostgreSQL connection fails with connection refused error
# ❌ WRONG - Hardcoded credentials, no connection pooling
conn = psycopg2.connect(
host="localhost",
user="postgres",
password="secret",
database="volatility_db"
)
✅ CORRECT - Connection pooling with environment variables
import os
from contextlib import contextmanager
DB_CONFIG = {
"host": os.environ.get("PGHOST", "localhost"),
"port": os.environ.get("PGPORT", "5432"),
"database": os.environ.get("PGDATABASE", "volatility_db"),
"user": os.environ.get("PGUSER", "volatility_user"),
"password": os.environ.get("PGPASSWORD"),
"pool_size": 5,
"max_overflow": 10
}
@contextmanager
def get_db_connection():
"""Thread-safe connection pool with automatic cleanup."""
from psycopg2 import pool
connection_pool = pool.ThreadedConnectionPool(
minconn=1,
maxconn=DB_CONFIG["pool_size"],
host=DB_CONFIG["host"],
port=DB_CONFIG["port"],
database=DB_CONFIG["database"],
user=DB_CONFIG["user"],
password=DB_CONFIG["password"]
)
conn = connection_pool.getconn()
try:
yield conn
conn.commit()
except Exception as e:
conn.rollback()
logger.error(f"Database error: {e}")
raise
finally:
connection_pool