저는 최근 암호화폐_quantitative trading_ 시스템을 구축하면서 여러 데이터 소스와 백테스팅 엔진을 테스트했습니다. 그 과정에서 Tardis API와 Backtrader의 조합이 가장 안정적이고 유연하다는 결론에 도달했습니다. 이 튜토리얼에서는 HolySheep AI를 활용한 최적화된 아키텍처로 확장성 있는 백테스팅 프레임워크를 구축하는 방법을 상세히 설명드리겠습니다.

HolySheep AI vs 공식 API vs 기타 릴레이 서비스 비교

특징 HolySheep AI 공식 OpenAI API 공식 Anthropic API 기타 릴레이 서비스
결제 방식 로컬 결제 지원 ✓ 해외 신용카드 필수 해외 신용카드 필수 다양하나 복잡
GPT-4.1 가격 $8/MTok $15/MTok - $10-12/MTok
Claude Sonnet 4.5 $15/MTok - $18/MTok $15-17/MTok
Gemini 2.5 Flash $2.50/MTok - - $3-5/MTok
DeepSeek V3.2 $0.42/MTok - - $0.50-0.80/MTok
다중 모델 통합 단일 API 키 ✓ 개별 키 필요 개별 키 필요 다소 가능
무료 크레딧 가입 시 제공 ✓ $5 크레딧 $5 크레딧 제한적
한도 제한 유연한 한도调节 엄격한 제한 엄격한 제한 불안정

이런 팀에 적합 / 비적용

✓ 이런 팀에 적합

✗ 이런 팀에는 비적용

아키텍처 개요


┌─────────────────────────────────────────────────────────────────────┐
│                     암호화폐量化回测系统 아키텍처                         │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌──────────────┐     ┌──────────────┐     ┌──────────────────┐    │
│  │   Tardis API │────▶│  Data Fetcher │────▶│   Backtrader     │    │
│  │  (历史OHLCV)  │     │   계층         │     │   Engine         │    │
│  └──────────────┘     └──────────────┘     └────────┬─────────┘    │
│                                                      │               │
│                                                      ▼               │
│  ┌──────────────┐     ┌──────────────┐     ┌──────────────────┐    │
│  │ HolySheep AI │◀───▶│ Signal Gen   │◀────│  Strategy Logic  │    │
│  │ (LLM Signals)│     │   (AI 기반)   │     │                  │    │
│  └──────────────┘     └──────────────┘     └──────────────────┘    │
│         │                                              │              │
│         ▼                                              ▼              │
│  ┌──────────────────────────────────────────────────────────────┐   │
│  │                      분석 & 리포트 계층                         │   │
│  └──────────────────────────────────────────────────────────────┘   │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

사전 준비물



필수 패키지 설치

pip install backtrader pandas requests python-dotenv


프로젝트 구조 생성

mkdir crypto_backtest
cd crypto_backtest
mkdir strategies data models utils
touch strategies/__init__.py data/__init__.py models/__init__.py utils/__init__.py

1단계: Tardis API 데이터 패처 구현

저는 Tardis API의 가장 큰 장점이 다중 거래소 데이터를 동일한 포맷으로 제공한다는 점입니다. Binance, Bybit, Coinbase의 1분봉 데이터를 같은 코드로 가져올 수 있어 매우 편리합니다.



data/tardis_client.py

"""
Tardis API 클라이언트 - 암호화폐 历史데이터 수집
 Docs: https://tardis.dev/docs
"""

import requests
import pandas as pd
from datetime import datetime, timedelta
from typing import Optional, List
import time


class TardisDataFetcher:
    """Tardis API를 통해加密货币历史数据获取类"""
    
    BASE_URL = "https://tardis-dev1back-v2.staging.tardis.dev/v1"
    
    def __init__(self, api_token: str):
        self.api_token = api_token
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_token}",
            "Content-Type": "application/json"
        })
    
    def get_symbols(self, exchange: str) -> List[str]:
        """거래소에서 사용 가능한 심볼 목록 조회"""
        url = f"{self.BASE_URL}/exchanges/{exchange}/symbols"
        response = self.session.get(url)
        response.raise_for_status()
        data = response.json()
        return [item["symbol"] for item in data.get("symbols", [])]
    
    def fetch_ohlcv(
        self,
        exchange: str,
        symbol: str,
        start_date: datetime,
        end_date: datetime,
        timeframe: str = "1m"
    ) -> pd.DataFrame:
        """
        指定时间段OHLCV数据获取
        
        Args:
            exchange: 거래소 (binance, bybit, okex, coinbase)
            symbol: 심볼 (BTCUSDT, ETHUSDT 등)
            start_date: 시작 시간
            end_date: 종료 시간
            timeframe: 시간프레임 (1m, 5m, 1h, 1d)
        
        Returns:
            DataFrame with columns: timestamp, open, high, low, close, volume
        """
        # Tardis는 날짜 범위가 넓으면 자동 페이징
        all_candles = []
        current_start = start_date
        
        while current_start < end_date:
            # 단일 요청의 최대 범위 (30일로 제한)
            chunk_end = min(current_start + timedelta(days=30), end_date)
            
            params = {
                "from": current_start.isoformat(),
                "to": chunk_end.isoformat(),
                "symbols": symbol,
                "timeframe": timeframe
            }
            
            url = f"{self.BASE_URL}/exchanges/{exchange}/historical/candles"
            
            try:
                response = self.session.get(url, params=params)
                response.raise_for_status()
                data = response.json()
                
                if "candles" in data and symbol in data["candles"]:
                    all_candles.extend(data["candles"][symbol])
                
                print(f"✓ {exchange}/{symbol}: {current_start.date()} ~ {chunk_end.date()} "
                      f"({len(data.get('candles', {}).get(symbol, []))}개 봉)")
                
            except requests.exceptions.HTTPError as e:
                print(f"✗ HTTP 오류: {e}")
                if response.status_code == 429:
                    print("요청 한도 초과. 60초 대기...")
                    time.sleep(60)
                    continue
                break
            
            current_start = chunk_end
            time.sleep(0.5)  # 속도 제한 방지
        
        if not all_candles:
            return pd.DataFrame()
        
        # DataFrame 변환
        df = pd.DataFrame(all_candles)
        df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
        df = df.set_index("timestamp").sort_index()
        df = df.astype({
            "open": float, "high": float, "low": float,
            "close": float, "volume": float
        })
        
        return df
    
    def fetch_trades(
        self,
        exchange: str,
        symbol: str,
        start_date: datetime,
        end_date: datetime,
        limit: int = 10000
    ) -> pd.DataFrame:
        """트레이드 데이터 조회 (고급 백테스팅용)"""
        params = {
            "from": start_date.isoformat(),
            "to": end_date.isoformat(),
            "symbols": symbol,
            "limit": limit
        }
        
        url = f"{self.BASE_URL}/exchanges/{exchange}/historical/trades"
        response = self.session.get(url, params=params)
        response.raise_for_status()
        data = response.json()
        
        if "trades" not in data or symbol not in data["trades"]:
            return pd.DataFrame()
        
        df = pd.DataFrame(data["trades"][symbol])
        df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
        return df.set_index("timestamp").sort_index()



테스트 실행

if __name__ == "__main__":
    from dotenv import load_dotenv
    import os
    
    load_dotenv()
    TARDIS_TOKEN = os.getenv("TARDIS_API_TOKEN")
    
    if TARDIS_TOKEN:
        fetcher = TardisDataFetcher(TARDIS_TOKEN)
        
        # BTC/USDT 2024년 1월 데이터 조회
        btc_data = fetcher.fetch_ohlcv(
            exchange="binance",
            symbol="BTCUSDT",
            start_date=datetime(2024, 1, 1),
            end_date=datetime(2024, 1, 31),
            timeframe="1h"
        )
        
        print(f"\n데이터 샘플:\n{btc_data.head()}")
        print(f"총 {len(btc_data)}개 봉 수집 완료")

2단계: Backtrader 데이터 스토어 구현

Backtrader는 원래inance 데이터용으로 설계되어 있어 암호화폐 데이터를 직접 로드하려면 약간의 어댑터 계층이 필요합니다. 저는 TardisDataStore 클래스를 만들어解决这个问题。



data/backtrader_store.py

"""
Backtrader용 Tardis数据存储类
 Backtrader의原生数据加载方式と統合
"""

import backtrader as bt
import pandas as pd
from datetime import datetime
from typing import Optional
from .tardis_client import TardisDataFetcher


class TardisData(bt.feeds.PandasData):
    """Backtrader에 최적화된 Tardis 데이터 피드"""
    
    params = (
        ("datetime", 0),      # timestamp 列索引
        ("open", 1),          # open 열
        ("high", 2),          # high 열
        ("low", 3),           # low 열
        ("close", 4),         # close 열
        ("volume", 5),        # volume 열
        ("openinterest", -1), # 未使用
    )


class TardisDataStore:
    """
    Tardis API와 Backtrader를 연결하는 데이터 저장소
    
    使用例:
        store = TardisDataStore("YOUR_TARDIS_TOKEN")
        data = store.get_data(
            exchange="binance",
            symbol="BTCUSDT",
            start=datetime(2024, 1, 1),
            end=datetime(2024, 3, 1),
            timeframe="1h"
        )
        cerebro.adddata(data)
    """
    
    def __init__(self, tardis_token: str):
        self.fetcher = TardisDataFetcher(tardis_token)
        self._cache = {}
    
    def get_data(
        self,
        exchange: str,
        symbol: str,
        start: datetime,
        end: datetime,
        timeframe: str = "1h",
        compress: bool = True
    ) -> TardisData:
        """
        Backtrader에 바로 사용할 수 있는 데이터 피드 반환
        
        Args:
            exchange: 거래소명
            symbol: 심볼 (BTCUSDT 형식)
            start: 시작일
            end: 종료일
            timeframe: 시간프레임 (1m, 5m, 15m, 1h, 4h, 1d)
            compress: Trueなら低いtimeframeから高いものに压缩
        """
        # キャッシュ 키生成
        cache_key = f"{exchange}_{symbol}_{start.date()}_{end.date()}_{timeframe}"
        
        if cache_key not in self._cache:
            # Tardisからデータを取得
            df = self.fetcher.fetch_ohlcv(
                exchange=exchange,
                symbol=symbol,
                start_date=start,
                end_date=end,
                timeframe=timeframe
            )
            
            if df.empty:
                raise ValueError(f"{exchange}/{symbol} 데이터가 없습니다")
            
            self._cache[cache_key] = df
        
        df = self._cache[cache_key].copy()
        
        # Backtrader 列名にマッピング
        df.columns = ["open", "high", "low", "close", "volume"]
        
        return TardisData(
            dataname=df,
            datetime=None,  # インデックス使用
            open=0, high=1, low=2, close=3, volume=4
        )
    
    def get_multiple_timeframes(
        self,
        exchange: str,
        symbol: str,
        start: datetime,
        end: datetime
    ) -> dict:
        """複数時間枠のデータを一括取得"""
        return {
            "1h": self.get_data(exchange, symbol, start, end, "1h"),
            "4h": self.get_data(exchange, symbol, start, end, "4h"),
            "1d": self.get_data(exchange, symbol, start, end, "1d"),
        }



使用例

if __name__ == "__main__":
    import os
    from dotenv import load_dotenv
    
    load_dotenv()
    
    store = TardisDataStore(os.getenv("TARDIS_API_TOKEN"))
    
    btc_hourly = store.get_data(
        exchange="binance",
        symbol="BTCUSDT",
        start=datetime(2024, 1, 1),
        end=datetime(2024, 2, 1),
        timeframe="1h"
    )
    
    print(f"데이터 피드 생성 완료: {btc_hourly._name}")

3단계: HolySheep AI 시그널 생성 모델 통합

여기서 HolySheep AI의 진가가 발휘됩니다. 저는 여러 번의 테스트 끝에 DeepSeek V3.2의 비용 효율성과 Claude Sonnet 4.5의 분석 품질을 모두 활용하는 전략을 수립했습니다. HolySheep의 단일 API 키로 두 모델을 빠르게 전환하며 비교 분석할 수 있었습니다.



models/ai_signal_generator.py

"""
HolySheep AI를 활용한 LLM 기반 트레이딩 시그널 생성
"""

import os
import json
import requests
from typing import Dict, List, Optional, Tuple
from datetime import datetime
from dataclasses import dataclass



HolySheep AI 설정

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = os.getenv("HOLYSHEEP_API_KEY")  # HolySheep API 키


@dataclass
class TradingSignal:
    """트레이딩 시그널 데이터 클래스"""
    timestamp: datetime
    action: str  # "BUY", "SELL", "HOLD"
    confidence: float  # 0.0 ~ 1.0
    reasoning: str
    model_used: str
    tokens_used: int
    cost_usd: float


class HolySheepAIClient:
    """
    HolySheep AI 게이트웨이 클라이언트
    단일 API 키로 GPT-4.1, Claude Sonnet, Gemini, DeepSeek 통합
    """
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = HOLYSHEEP_BASE_URL
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        })
        self._token_counts = {}
    
    def _calculate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
        """토큰 사용량 기반 비용 계산 (HolySheep 가격)"""
        pricing = {
            "gpt-4.1": {"input": 8.0, "output": 8.0},      # $8/MTok
            "claude-sonnet-4-5": {"input": 15.0, "output": 15.0},  # $15/MTok
            "gemini-2.5-flash": {"input": 2.50, "output": 2.50},  # $2.50/MTok
            "deepseek-v3.2": {"input": 0.42, "output": 0.42},  # $0.42/MTok
        }
        
        if model not in pricing:
            model = "gpt-4.1"  # 기본값
        
        p = pricing[model]
        cost = (input_tokens / 1_000_000 * p["input"] + 
                output_tokens / 1_000_000 * p["output"])
        return round(cost, 6)
    
    def chat_completion(
        self,
        model: str,
        messages: List[Dict],
        temperature: float = 0.7,
        max_tokens: int = 500
    ) -> Tuple[str, int, float]:
        """
        HolySheep AI 채팅 완료 API 호출
        
        Args:
            model: 모델명 (deepseek-v3.2, gpt-4.1, claude-sonnet-4-5, gemini-2.5-flash)
            messages: 메시지 목록
            temperature: 창의성 레벨
            max_tokens: 최대 출력 토큰
        
        Returns:
            (응답 텍스트, 총 토큰 수, 비용 USD)
        """
        url = f"{self.base_url}/chat/completions"
        
        payload = {
            "model": model,
            "messages": messages,
            "temperature": temperature,
            "max_tokens": max_tokens
        }
        
        response = self.session.post(url, json=payload)
        response.raise_for_status()
        data = response.json()
        
        usage = data.get("usage", {})
        total_tokens = usage.get("total_tokens", 0)
        cost = self._calculate_cost(model, 
            usage.get("prompt_tokens", 0),
            usage.get("completion_tokens", 0)
        )
        
        self._token_counts[model] = self._token_counts.get(model, 0) + total_tokens
        
        return data["choices"][0]["message"]["content"], total_tokens, cost


class AISignalGenerator:
    """
    AI 기반 트레이딩 시그널 생성기
    HolySheep AI를 활용하여 시장 분석 및 시그널 생성
    """
    
    SYSTEM_PROMPT = """당신은 전문 암호화폐 트레이딩 분석가입니다.
    
역할:
- 제공된 기술적 지표와 가격 데이터를 분석
- 매수/매도/유지 신호 생성
- 신호 신뢰도 평가 (0.0 ~ 1.0)
- 명확한 투자 근거 제시

출력 형식 (JSON):
{
    "action": "BUY|SELL|HOLD",
    "confidence": 0.0~1.0,
    "reasoning": "분석 근거 (100자 이내)",
    "risk_level": "LOW|MEDIUM|HIGH"
}

주의:
- 반드시 유효한 JSON만 출력
- 다른 텍스트 없이 JSON만 응답""""
    
    def __init__(self, api_key: str):
        self.client = HolySheepAIClient(api_key)
        self.total_cost = 0.0
        self.signal_history: List[TradingSignal] = []
    
    def generate_signal(
        self,
        price_data: Dict,
        indicators: Dict,
        model: str = "deepseek-v3.2"  # 기본값: 저비용 고성능
    ) -> TradingSignal:
        """
        시장 데이터 기반 트레이딩 시그널 생성
        
        Args:
            price_data: {"current": float, "change_24h": float, "volume_24h": float}
            indicators: {"rsi": float, "macd": dict, "bollinger": dict}
            model: 사용할 AI 모델
        
        Returns:
            TradingSignal 객체
        """
        user_message = self._build_analysis_prompt(price_data, indicators)
        
        messages = [
            {"role": "system", "content": self.SYSTEM_PROMPT},
            {"role": "user", "content": user_message}
        ]
        
        try:
            response, tokens, cost = self.client.chat_completion(
                model=model,
                messages=messages,
                temperature=0.3,  # 일관된 분석을 위해 낮춤
                max_tokens=300
            )
            
            # JSON 파싱
            signal_data = json.loads(response)
            
            signal = TradingSignal(
                timestamp=datetime.now(),
                action=signal_data["action"],
                confidence=signal_data["confidence"],
                reasoning=signal_data["reasoning"],
                model_used=model,
                tokens_used=tokens,
                cost_usd=cost
            )
            
            self.signal_history.append(signal)
            self.total_cost += cost
            
            return signal
            
        except json.JSONDecodeError:
            # JSON 파싱 실패 시 HOLD 기본값
            return TradingSignal(
                timestamp=datetime.now(),
                action="HOLD",
                confidence=0.0,
                reasoning="AI 응답 파싱 실패",
                model_used=model,
                tokens_used=tokens if 'tokens' in dir() else 0,
                cost_usd=cost if 'cost' in dir() else 0.0
            )
    
    def _build_analysis_prompt(self, price_data: Dict, indicators: Dict) -> str:
        """분석용 프롬프트 구성"""
        prompt = f"""현재 시장 데이터:
- 현재가: ${price_data.get('current', 0):,.2f}
- 24시간 변동: {price_data.get('change_24h', 0):+.2f}%
- 24시간 거래량: ${price_data.get('volume_24h', 0):,.0f}

기술적 지표:
- RSI(14): {indicators.get('rsi', 'N/A')}
- MACD: {indicators.get('macd', 'N/A')}
- 볼린저밴드: {indicators.get('bollinger', 'N/A')}

위数据进行技术分析，制定交易决策。"""
        
        return prompt
    
    def get_cost_report(self) -> Dict:
        """비용 보고서 반환"""
        return {
            "total_signals": len(self.signal_history),
            "total_cost_usd": round(self.total_cost, 6),
            "by_model": self._aggregate_by_model(),
            "avg_cost_per_signal": round(self.total_cost / max(len(self.signal_history), 1), 6)
        }
    
    def _aggregate_by_model(self) -> Dict:
        """모델별 비용 집계"""
        result = {}
        for signal in self.signal_history:
            model = signal.model_used
            if model not in result:
                result[model] = {"count": 0, "cost": 0.0}
            result[model]["count"] += 1
            result[model]["cost"] += signal.cost_usd
        return result



테스트 실행

if __name__ == "__main__":
    from dotenv import load_dotenv
    
    load_dotenv()
    
    generator = AISignalGenerator(os.getenv("HOLYSHEEP_API_KEY"))
    
    # 샘플 데이터로 테스트
    sample_price = {
        "current": 67432.50,
        "change_24h": 2.34,
        "volume_24h": 28_500_000_000
    }
    
    sample_indicators = {
        "rsi": 58.5,
        "macd": {"value": 150.2, "signal": 120.5},
        "bollinger": {"upper": 68500, "lower": 66000}
    }
    
    # DeepSeek V3.2로 테스트 (저비용)
    signal = generator.generate_signal(sample_price, sample_indicators, "deepseek-v3.2")
    
    print(f"\n{'='*50}")
    print(f"생성된 시그널:")
    print(f"  액션: {signal.action}")
    print(f"  신뢰도: {signal.confidence:.2%}")
    print(f"  근거: {signal.reasoning}")
    print(f"  사용 모델: {signal.model_used}")
    print(f"  토큰 사용량: {signal.tokens_used}")
    print(f"  비용: ${signal.cost_usd:.6f}")
    print(f"{'='*50}")
    
    print(f"\n비용 보고서: {generator.get_cost_report()}")

4단계: 완전한 백테스팅 시스템 통합



main_backtest.py

"""
암호화폐量化回测系统 - 메인 실행 파일
 Tardis API + Backtrader + HolySheep AI 통합
"""

import os
import json
import backtrader as bt
import matplotlib
matplotlib.use('Agg')  # GUI 없이 백그라운드 실행
import matplotlib.pyplot as plt
from datetime import datetime
from dotenv import load_dotenv

from data.backtrader_store import TardisDataStore
from models.ai_signal_generator import AISignalGenerator


class AITradingStrategy(bt.Strategy):
    """
    HolySheep AI 시그널 기반 트레이딩 전략
    
    HolySheep AI의 LLM이 생성한 시그널을 기반으로
    BTC/USDT 자동 매매 수행
    """
    
    params = (
        ("signal_generator", None),  # AI 시그널 생성기
        ("model_name", "deepseek-v3.2"),  # 사용할 AI 모델
        ("signal_interval", 4),  # N개 봉마다 시그널 생성
        ("position_size", 0.95),  # 잔고의 N% 사용
        ("rsi_period", 14),
        ("printlog", True),
    )
    
    def __init__(self):
        self.dataclose = self.datas[0].close
        self.dataopen = self.datas[0].open
        self.datahigh = self.datas[0].high
        self.datalow = self.datas[0].low
        
        self.order = None
        self.bar_count = 0
        self.last_signal = None
        
        # RSI 지표
        self.rsi = bt.indicators.RSI(
            self.dataclose, period=self.params.rsi_period
        )
        
        # 볼린저밴드
        self.boll = bt.indicators.BollingerBands(
            self.dataclose, period=20, devfactor=2
        )
        
        # MACD
        self.macd = bt.indicators.MACD(
            self.dataclose, period_me1=12, period_me2=26, period_signal=9
        )
    
    def log(self, txt, dt=None):
        if self.params.printlog:
            dt = dt or self.datas[0].datetime.datetime(0)
            print(f"[{dt.strftime('%Y-%m-%d %H:%M')}] {txt}")
    
    def notify_order(self, order):
        if order.status in [order.Submitted, order.Accepted]:
            return
        
        if order.status in [order.Completed]:
            if order.isbuy():
                self.log(f"매수 완료: 가격 {order.executed.price:.2f}, "
                        f"수량 {order.executed.size:.6f}, "
                        f"수수료 {order.executed.comm:.4f}")
            else:
                self.log(f"매도 완료: 가격 {order.executed.price:.2f}, "
                        f"수량 {order.executed.size:.6f}, "
                        f"수수료 {order.executed.comm:.4f}")
        
        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
            self.log("주문 실패/취소")
        
        self.order = None
    
    def next(self):
        self.bar_count += 1
        
        # 미체결 주문 있으면 대기
        if self.order:
            return
        
        current_price = self.dataclose[0]
        current_time = self.datas[0].datetime.datetime(0)
        
        # N개 봉마다 AI 시그널 생성
        if self.bar_count % self.params.signal_interval == 0:
            self.last_signal = self._generate_ai_signal(current_price, current_time)
        
        if self.last_signal is None:
            return
        
        # 포지션 없으면 매수 검토
        if not self.position:
            if self.last_signal.action == "BUY" and self.last_signal.confidence > 0.6:
                self._open_position()
        else:
            # 포지션 있으면 매도 검토
            if self.last_signal.action == "SELL" and self.last_signal.confidence > 0.5:
                self._close_position()
    
    def _generate_ai_signal(self, current_price: float, current_time: datetime):
        """HolySheep AI 시그널 생성"""
        if self.params.signal_generator is None:
            return None
        
        price_data = {
            "current": current_price,
            "change_24h": ((current_price - self.dataclose[-24]) / 
                          self.dataclose[-24] * 100) if len(self) > 24 else 0,
            "volume_24h": sum(self.datas[0].volume[-i] for i in range(24)) * current_price
        }
        
        indicators = {
            "rsi": self.rsi[0],
            "macd": {
                "value": self.macd.macd[0],
                "signal": self.macd.signal[0]
            },
            "bollinger": {
                "upper": self.boll.lines.top[0],
                "lower": self.boll.lines.bot[0]
            }
        }
        
        signal = self.params.signal_generator.generate_signal(
            price_data=price_data,
            indicators=indicators,
            model=self.params.model_name
        )
        
        self.log(f"AI 시그널: {signal.action} (신뢰도: {signal.confidence:.2%}) "
                f"[{signal.model_used}]")
        
        return signal
    
    def _open_position(self):
        """포지션 개설"""
        size = (self.broker.getcash() * self.params.position_size) / self.dataclose[0]
        
        self.order = self.buy(size=size)
        self.log(f"매수 주문: {size:.6f} BTC @ {self.dataclose[0]:.2f}")
    
    def _close_position(self):
        """포지션 청산"""
        self.order = self.close()
        self.log(f"매도 주문: {self.position.size:.6f} BTC @ {self.dataclose[0]:.2f}")


def run_backtest(
    tardis_token: str,
    holySheep_key: str,
    start_date: datetime,
    end_date: datetime,
    model_name: str = "deepseek-v3.2",
    initial_cash: float = 10000.0
):
    """
    백테스트 실행 함수
    
    Args:
        tardis_token: Tardis API 토

관련 리소스
관련 문서