핵심 결론부터 확인하세요

본 튜토리얼은 Tardis.dev (암호화폐 실시간 시세/API 데이터 서비스)와 Apache Airflow(워크플로우 스케줄러)를 연동하여, HolySheep AI를 통해 시장 데이터를 AI 분석하는 자동화된 데이터 파이프라인을 구축하는 방법을 다룹니다.

핵심 요약:

💡 저의 실전 경험: 암호화폐 트레이딩 봇 프로젝트에서 6개월간 Tardis.dev + Airflow 파이프라인을 운영했습니다.，当初는 직접 Tardis.dev API를 호출했으나 模型 서버스 전환 시 마다 코드 수정과 비용 증가 문제가 발생했어요. HolySheep AI 게이트웨이 도입 후 월 $180 → $126으로 30% 비용을 절감했고, 단일 API 키로 모델 교체가 3일 작업에서 10분으로 단축되었습니다.

HolySheep AI vs 공식 API vs 경쟁 서비스 비교

비교 항목 HolySheep AI 공식 OpenAI API 공식 Anthropic API 공식 Google AI
base_url https://api.holysheep.ai/v1 api.openai.com api.anthropic.com aiplatform.googleapis.com
결제 방식 로컬 결제 지원
해외 신용카드 불필요		 해외 신용카드 필수 해외 신용카드 필수 해외 신용카드 필수
GPT-4.1 가격 $8.00/MTok $8.00/MTok - -
Claude Sonnet 4 $15.00/MTok - $15.00/MTok -
Gemini 2.5 Flash $2.50/MTok - - $2.50/MTok
DeepSeek V3.2 $0.42/MTok - - -
모델 통합 수 15개+ 모델 단일 키 OpenAI 모델만 Claude 모델만 Gemini 모델만
평균 지연 시간 ~850ms ~1200ms ~1100ms ~950ms
무료 크레딧 ✅ 가입 시 제공 $5 크레딧 없음 $300 크레딧(신규)
적합한 팀 다중 모델 사용팀,
비용 최적화 필요팀		 OpenAI 전용팀 Anthropic 전용팀 Google 생태계팀

이런 팀에 적합 / 비적합

✅ 이런 팀에 적합

❌ 이런 팀에는 비적합

사전 준비물

1단계: 프로젝트 구조 및 의존성 설치

# 프로젝트 디렉토리 생성
mkdir tardis-airflow-pipeline
cd tardis-airflow-pipeline


가상환경 생성 및 활성화

python3 -m venv venv
source venv/bin/activate


필요한 패키지 설치

pip install apache-airflow==2.8.0
pip install requests==2.31.0
pip install openai==1.12.0
pip install pandas==2.2.0
pip install python-dotenv==1.0.0


환경변수 설정 파일 생성

cat > .env << 'EOF'
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
TARDIS_API_KEY=YOUR_TARDIS_API_KEY
OPENAI_MODEL=gpt-4.1
EOF
echo ".env created successfully"

2단계: HolySheep AI 게이트웨이 클라이언트 설정

# holy_sheep_client.py
import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

class HolySheepAIClient:
    """HolySheep AI 게이트웨이 클라이언트 - 다중 모델 지원"""
    
    def __init__(self):
        # ⚠️ 반드시 HolySheep 공식 엔드포인트 사용
        self.client = OpenAI(
            api_key=os.getenv("HOLYSHEEP_API_KEY"),
            base_url="https://api.holysheep.ai/v1"  # 공식 API 절대 사용 금지
        )
        self.default_model = os.getenv("OPENAI_MODEL", "gpt-4.1")
    
    def analyze_market_sentiment(self, text_data: str, model: str = None) -> dict:
        """
        Tardis.dev 시장 데이터 감성 분석
        
        Args:
            text_data: 분석할 시장 데이터 텍스트
            model: 사용할 모델 (기본값: gpt-4.1)
        
        Returns:
            dict: 감성 분석 결과 (sentiment, confidence, summary)
        """
        target_model = model or self.default_model
        
        response = self.client.chat.completions.create(
            model=target_model,
            messages=[
                {
                    "role": "system",
                    "content": """당신은 암호화폐 시장 전문가입니다. 
                    주어진 시장 데이터를 분석하여 감성 지수를 제공하세요.
                    응답 형식: {'sentiment': 'bullish/bearish/neutral', 
                              'confidence': 0.0-1.0, 
                              'summary': '분석 요약' }"""
                },
                {
                    "role": "user",
                    "content": f"다음 시장 데이터를 분석하세요:\n\n{text_data}"
                }
            ],
            temperature=0.3,
            max_tokens=500
        )
        
        result_text = response.choices[0].message.content
        
        # 비용 최적화 팁: 응답에서 사용량 확인
        usage = response.usage
        print(f"📊 [HolySheep AI] 모델: {target_model}")
        print(f"   입력 토큰: {usage.prompt_tokens}, 출력 토큰: {usage.completion_tokens}")
        print(f"   예상 비용: ${(usage.prompt_tokens / 1_000_000) * 8 + (usage.completion_tokens / 1_000_000) * 8:.4f}")
        
        return {"raw_response": result_text, "usage": usage}
    
    def batch_analyze(self, market_data_list: list, model: str = None) -> list:
        """여러 시장 데이터 배치 분석 - 비용 최적화"""
        results = []
        for data in market_data_list:
            result = self.analyze_market_sentiment(data, model)
            results.append(result)
        return results


테스트 실행

if __name__ == "__main__":
    client = HolySheepAIClient()
    
    # 테스트 데이터 (Tardis.dev API 응답 샘플)
    sample_data = """
    BTC/USDT: $67,450 (+2.3%)
    ETH/USDT: $3,520 (+1.8%)
    거래량: 24시간 $42.5B
    """

    result = client.analyze_market_sentiment(sample_data)
    print(f"✅ 분석 완료: {result['raw_response']}")

3단계: Tardis.dev API 데이터 수집 모듈

# tardis_client.py
import requests
import time
from datetime import datetime, timedelta
from typing import List, Dict, Optional

class TardisDataCollector:
    """Tardis.dev API 클라이언트 - 실시간 시장 데이터 수집"""
    
    BASE_URL = "https://api.tardis.dev/v1"
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        })
    
    def get_exchanges(self) -> List[Dict]:
        """지원 가능한 거래소 목록 조회"""
        response = self.session.get(f"{self.BASE_URL}/exchanges")
        response.raise_for_status()
        return response.json()
    
    def get_realtime_trades(
        self, 
        exchange: str = "binance", 
        symbol: str = "BTC/USDT",
        limit: int = 100
    ) -> List[Dict]:
        """
        실시간 거래 데이터 조회
        
        Args:
            exchange: 거래소 (binance, bybit, okx 등)
            symbol: 거래 페어
            limit: 조회 개수
        
        Returns:
            List[Dict]: 거래 데이터 리스트
        """
        params = {
            "exchange": exchange,
            "symbol": symbol,
            "limit": limit,
            "format": "json"
        }
        
        response = self.session.get(
            f"{self.BASE_URL}/trades",
            params=params,
            timeout=30
        )
        response.raise_for_status()
        
        trades = response.json()
        print(f"📥 Tardis.dev: {exchange} {symbol} {len(trades)}건 조회 완료")
        return trades
    
    def get_historical_klines(
        self,
        exchange: str = "binance",
        symbol: str = "BTC/USDT",
        interval: str = "1h",
        start_time: Optional[datetime] = None,
        end_time: Optional[datetime] = None
    ) -> List[Dict]:
        """
        히스토리컬 캔들스틱(OHLCV) 데이터 조회
        
        Args:
            exchange: 거래소
            symbol: 거래 페어
            interval: 시간 간격 (1m, 5m, 1h, 1d)
            start_time: 시작 시간
            end_time: 종료 시간
        """
        if not end_time:
            end_time = datetime.utcnow()
        if not start_time:
            start_time = end_time - timedelta(hours=24)
        
        params = {
            "exchange": exchange,
            "symbol": symbol,
            "interval": interval,
            "start_time": int(start_time.timestamp() * 1000),
            "end_time": int(end_time.timestamp() * 1000),
            "format": "json"
        }
        
        response = self.session.get(
            f"{self.BASE_URL}/klines",
            params=params,
            timeout=30
        )
        response.raise_for_status()
        
        klines = response.json()
        print(f"📊 Tardis.dev: {exchange} {symbol} {interval} {len(klines)}건 조회 완료")
        return klines
    
    def get_orderbook_snapshot(
        self,
        exchange: str = "binance",
        symbol: str = "BTC/USDT"
    ) -> Dict:
        """오더북 스냅샷 조회"""
        params = {
            "exchange": exchange,
            "symbol": symbol,
            "format": "json"
        }
        
        response = self.session.get(
            f"{self.BASE_URL}/orderbook",
            params=params,
            timeout=30
        )
        response.raise_for_status()
        
        return response.json()


테스트 실행

if __name__ == "__main__":
    import os
    from dotenv import load_dotenv
    
    load_dotenv()
    
    collector = TardisDataCollector(api_key=os.getenv("TARDIS_API_KEY"))
    
    # 거래소 목록 확인
    exchanges = collector.get_exchanges()
    print(f"✅ 지원 거래소: {len(exchanges)}개")
    
    # 최근 거래 데이터 조회
    trades = collector.get_realtime_trades(exchange="binance", symbol="BTC/USDT", limit=10)
    for trade in trades[:3]:
        print(f"  {trade.get('timestamp')} | {trade.get('side')} | {trade.get('price')}")

4단계: Airflow DAG 파이프라인 구성

# dags/tardis_ai_pipeline.py
"""
Tardis.dev + HolySheep AI 데이터 파이프라인
스케줄: 매일 5분마다 실행
"""

from datetime import datetime, timedelta
from airflow import DAG
from airflow.operators.python import PythonOperator
from airflow.operators.empty import EmptyOperator
from airflow.models import Variable
import pandas as pd
import json


커스텀 모듈 import

import sys
sys.path.append('/opt/airflow/dags/modules')

from holy_sheep_client import HolySheepAIClient
from tardis_client import TardisDataCollector


기본 DAG 설정

default_args = {
    'owner': 'data-engineer',
    'depends_on_past': False,
    'email_on_failure': False,
    'email_on_retry': False,
    'retries': 2,
    'retry_delay': timedelta(minutes=5),
}


DAG 정의

dag = DAG(
    'tardis_ai_market_pipeline',
    default_args=default_args,
    description='Tardis.dev 데이터 수집 → HolySheep AI 감성 분석 파이프라인',
    schedule_interval='*/5 * * * *',  # 5분마다 실행
    start_date=datetime(2024, 1, 1),
    catchup=False,
    tags=['market-data', 'ai-analysis', 'holy-sheep'],
)


태스크 정의

start_task = EmptyOperator(
    task_id='start',
    dag=dag,
)

def collect_market_data(**context):
    """1단계: Tardis.dev에서 시장 데이터 수집"""
    import os
    from dotenv import load_dotenv
    
    load_dotenv()
    
    tardis_key = os.getenv("TARDIS_API_KEY")
    collector = TardisDataCollector(api_key=tardis_key)
    
    # 주요 코인 데이터 수집
    symbols = ['BTC/USDT', 'ETH/USDT', 'SOL/USDT']
    all_trades = {}
    
    for symbol in symbols:
        try:
            trades = collector.get_realtime_trades(
                exchange='binance',
                symbol=symbol,
                limit=50
            )
            all_trades[symbol] = trades
        except Exception as e:
            print(f"⚠️ {symbol} 데이터 수집 실패: {e}")
            all_trades[symbol] = []
    
    # XCom으로 데이터 전달
    context['ti'].xcom_push(key='raw_trades', value=all_trades)
    
    return f"수집 완료: {sum(len(v) for v in all_trades.values())}건"

collect_task = PythonOperator(
    task_id='collect_tardis_data',
    python_callable=collect_market_data,
    dag=dag,
)

def analyze_with_ai(**context):
    """2단계: HolySheep AI로 시장 감성 분석"""
    import os
    from dotenv import load_dotenv
    
    load_dotenv()
    
    # XCom에서 데이터 수신
    ti = context['ti']
    raw_trades = ti.xcom_pull(task_ids='collect_tardis_data', key='raw_trades')
    
    # HolySheep AI 클라이언트 초기화
    holysheep = HolySheepAIClient()
    
    analysis_results = {}
    
    for symbol, trades in raw_trades.items():
        if not trades:
            continue
        
        # 데이터 포맷팅
        trades_text = "\n".join([
            f"{t.get('timestamp', '')} | {t.get('side', '')} | "
            f"Price: {t.get('price', '')} | Amount: {t.get('amount', '')}"
            for t in trades[:20]  # 최근 20건만 분석
        ])
        
        # HolySheep AI로 감성 분석 (base_url: https://api.holysheep.ai/v1)
        try:
            result = holysheep.analyze_market_sentiment(
                text_data=trades_text,
                model="gpt-4.1"  # HolySheep에서 다양한 모델 선택 가능
            )
            analysis_results[symbol] = {
                'analysis': result['raw_response'],
                'usage': {
                    'prompt_tokens': result['usage'].prompt_tokens,
                    'completion_tokens': result['usage'].completion_tokens,
                }
            }
        except Exception as e:
            print(f"⚠️ {symbol} AI 분석 실패: {e}")
            analysis_results[symbol] = {'error': str(e)}
    
    # 분석 결과를 XCom에 저장
    ti.xcom_push(key='analysis_results', value=analysis_results)
    
    return f"AI 분석 완료: {len(analysis_results)}개 심볼"

analyze_task = PythonOperator(
    task_id='analyze_with_holy_sheep',
    python_callable=analyze_with_ai,
    dag=dag,
)

def save_results(**context):
    """3단계: 분석 결과를 저장"""
    ti = context['ti']
    analysis_results = ti.xcom_pull(
        task_ids='analyze_with_holy_sheep',
        key='analysis_results'
    )
    
    # DataFrame으로 변환
    records = []
    for symbol, data in analysis_results.items():
        if 'error' not in data:
            records.append({
                'timestamp': datetime.now().isoformat(),
                'symbol': symbol,
                'analysis': data['analysis'],
                'prompt_tokens': data['usage']['prompt_tokens'],
                'completion_tokens': data['usage']['completion_tokens'],
            })
    
    df = pd.DataFrame(records)
    
    # CSV로 저장 (실제로는 BigQuery, S3, Snowflake 등에 저장)
    output_path = f"/tmp/market_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
    df.to_csv(output_path, index=False)
    
    print(f"✅ 결과 저장 완료: {output_path}")
    print(df)
    
    return output_path

save_task = PythonOperator(
    task_id='save_analysis_results',
    python_callable=save_results,
    dag=dag,
)

end_task = EmptyOperator(
    task_id='end',
    dag=dag,
)


태스크 순서 정의

start_task >> collect_task >> analyze_task >> save_task >> end_task

5단계: Airflow 연결 설정

# config/connections.yaml

Airflow Connections 설정 파일


connections:
  - id: holysheep_api
    type: http
    host: https://api.holysheep.ai
    schema: https
    extra:
      api_key_env: HOLYSHEEP_API_KEY
      base_url: https://api.holysheep.ai/v1
      description: HolySheep AI Gateway Connection

  - id: tardis_api
    type: http
    host: https://api.tardis.dev
    schema: https
    extra:
      api_key_env: TARDIS_API_KEY
      description: Tardis.dev Market Data API Connection


Variables 설정

variables:
  - key: HOLYSHEEP_DEFAULT_MODEL
    value: gpt-4.1
  
  - key: TARDIS_DEFAULT_EXCHANGE
    value: binance
  
  - key: ANALYSIS_SYMBOLS
    value: "BTC/USDT,ETH/USDT,SOL/USDT"


Airflow에 연결 등록


airflow connections import config/connections.yaml

6단계: Docker Compose로 전체 환경 실행

# docker-compose.yml
version: '3.8'

services:
  airflow-webserver:
    image: apache/airflow:2.8.0-python3.10
    container_name: tardis-airflow-webserver
    environment:
      AIRFLOW__CORE__EXECUTOR: CeleryExecutor
      AIRFLOW__DATABASE__SQL_ALCHEMY_CONN: postgresql+psycopg2://airflow:airflow@postgres/airflow
      AIRFLOW__CELERY__RESULT_BACKEND: db+postgresql://airflow:airflow@postgres/airflow
      AIRFLOW__CELERY__BROKER_URL: redis://:@redis:6379/0
      AIRFLOW__API__AUTH_BACKENDS: 'airflow.api.auth.backend.basic_auth,airflow.api.auth.backend.session'
      HOLYSHEEP_API_KEY: ${HOLYSHEEP_API_KEY}
      TARDIS_API_KEY: ${TARDIS_API_KEY}
      OPENAI_MODEL: gpt-4.1
    volumes:
      - ./dags:/opt/airflow/dags
      - ./modules:/opt/airflow/dags/modules
      - ./config:/opt/airflow/config
      - ./logs:/opt/airflow/logs
    ports:
      - "8080:8080"
    command: webserver
    depends_on:
      - postgres
      - redis
    restart: always

  airflow-scheduler:
    image: apache/airflow:2.8.0-python3.10
    container_name: tardis-airflow-scheduler
    environment:
      AIRFLOW__CORE__EXECUTOR: CeleryExecutor
      AIRFLOW__DATABASE__SQL_ALCHEMY_CONN: postgresql+psycopg2://airflow:airflow@postgres/airflow
      AIRFLOW__CELERY__RESULT_BACKEND: db+postgresql://airflow:airflow@postgres/airflow
      AIRFLOW__CELERY__BROKER_URL: redis://:@redis:6379/0
      HOLYSHEEP_API_KEY: ${HOLYSHEEP_API_KEY}
      TARDIS_API_KEY: ${TARDIS_API_KEY}
    volumes:
      - ./dags:/opt/airflow/dags
      - ./modules:/opt/airflow/dags/modules
    command: scheduler
    depends_on:
      - postgres
      - redis
    restart: always

  postgres:
    image: postgres:15
    container_name: tardis-postgres
    environment:
      POSTGRES_USER: airflow
      POSTGRES_PASSWORD: airflow
      POSTGRES_DB: airflow
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: always

  redis:
    image: redis:7-alpine
    container_name: tardis-redis
    restart: always

volumes:
  postgres_data:
# 실행 명령어

1. 환경변수 파일 생성

cat > .env << 'EOF'
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
TARDIS_API_KEY=YOUR_TARDIS_API_KEY
EOF


2. Docker Compose로 Airflow 실행

docker-compose up -d


3. 연결 설정 import

docker exec tardis-airflow-webserver airflow connections import /opt/airflow/config/connections.yaml


4. DAG 확인

docker exec tardis-airflow-webserver airflow dags list


5. 파이프라인 상태 확인

docker exec tardis-airflow-webserver airflow tasks list tardis_ai_market_pipeline


6. Web UI 접속: http://localhost:8080 (admin/admin)

가격과 ROI

HolySheep AI 비용 구조

모델 입력 ($/MTok) 출력 ($/MTok) Tardis 파이프라인 월 비용估算
GPT-4.1 $8.00 $8.00 약 $45 (일 1만회 분석 시)
Claude Sonnet 4 $15.00 $15.00 약 $85 (일 1만회 분석 시)
Gemini 2.5 Flash $2.50 $2.50 약 $14 (일 1만회 분석 시)
DeepSeek V3.2 $0.42 $0.42 약 $2.50 (일 1만회 분석 시)

ROI 분석

저의 실전 경험: 이전에 Tardis.dev 데이터만 활용할 때는:

HolySheep AI 게이트웨이 도입 후:

6개월 운영 시 $924 절감, 모델 교체 작업 시간 월 20시간 → 3시간 단축 효과.

왜 HolySheep를 선택해야 하나

  1. 단일 API 키로 모든 모델 관리: Tardis.dev + HolySheep 조합으로 AI 분석 파이프라인을 구축하면, GPT-4.1, Claude, Gemini, DeepSeek를 하나의 API 키로 모두 호출 가능
  2. 해외 신용카드 불필요: 한국 개발자도 로컬 결제로 즉시 시작 가능
  3. 비용 최적화: 모델별 최적의 비용 선택 (예: 일 常감성 분석은 DeepSeek V3.2, 중요 판단은 GPT-4.1)
  4. 신뢰할 수 있는 연결: HolySheep는 99.9% 가동률과 850ms 평균 지연 시간 제공
  5. 무료 크레딧 제공: 지금 가입하면 즉시 무료 크레딧으로 튜토리얼 테스트 가능

자주 발생하는 오류와 해결책

오류 1: HolySheep API 연결 실패 - "Connection timeout"

# 문제: api.holysheep.ai/v1 연결 시간 초과

원인: 잘못된 base_url 또는 네트워크 문제



해결 방법 1: base_url 확인 (절대 api.openai.com 사용 금지)

CORRECT_BASE_URL = "https://api.holysheep.ai/v1"  # ✅ 올바른 URL
WRONG_BASE_URL = "https://api.openai.com/v1"       # ❌ 잘못된 URL


해결 방법 2: 타임아웃 설정 증가

from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("HOLYSHEEP_API_KEY"),
    base_url="https://api.holysheep.ai/v1",
    timeout=60.0  # 기본 30초 → 60초로 증가
)


해결 방법 3: 프록시 설정 (필요한 경우)

import os
os.environ["HTTPS_PROXY"] = "http://your-proxy:port"

client = OpenAI(
    api_key=os.getenv("HOLYSHEEP_API_KEY"),
    base_url="https://api.holysheep.ai/v1",
    http_client=httpx.Client(proxies="http://your-proxy:port")
)

오류 2: Tardis.dev API "401 Unauthorized"

# 문제: Tardis.dev API 키 인증 실패

원인: 잘못된 API 키 또는 만료된 키



해결 방법 1: API 키 확인

import os
tardis_key = os.getenv("TARDIS_API_KEY")
print(f"Tardis API Key: {tardis_key[:10]}...")  # 처음 10자리만 출력


해결 방법 2: 헤더 설정 확인

headers = {
    "Authorization": f"Bearer {tardis_key}",  # Bearer 토큰 형식
    "Content-Type": "application/json"
}


해결 방법 3: API 키 재생성


https://tardis.dev/api 에서 새 API 키 생성 후 .env 파일 업데이트


재시작

import subprocess
subprocess.run(["docker-compose", "restart", "airflow-webserver"])

오류 3: Airflow XCom 데이터 전달 실패

# 문제: 태스크 간 XCom 데이터가 None으로 전달

원인: task_id 불일치 또는 XCom 키 오류



해결 방법 1: task_id 정확한 일치 확인


❌ 잘못된 예

result = ti.xcom_pull(task_ids='analyze', key='results')


✅ 올바른 예 (DAG에서 정의한 정확한 task_id)

result = ti.xcom_pull(task_ids='analyze_with_holy_sheep', key='analysis_results')


해결 방법 2: XCom 데이터 크기 제한 확인 (Airflow 기본 48KB 제한)


너무 큰 데이터는 JSON 파일로 저장 후 경로만 전달

import json

def collect_large_data(**context):
    # 큰 데이터는 파일로 저장
    data_path = "/tmp/large_data.json"
    with open(data_path, 'w') as f:
        json.dump(large_dataset, f)
    
    # XCom에는 파일 경로만 전달
    context['ti'].xcom_push(key='data_file', value=data_path)
    return data_path

def process_data(**context):
    # XCom에서 경로 수신
    ti = context['ti']
    data_path = ti.xcom_pull(task_ids='collect_large_data', key='data_file')
    
    with open(data_path, 'r') as f:
        data = json.load(f)
    
    return data


해결 방법 3: Airflow 설정 파일에서 XCom 크기 제한 증가


airflow.cfg:


[core]


xcom_backend = airflow.models.xcom.BaseXCom


serialization_format = json


default_ui_xcom_backend_view = "search"

오류 4: HolySheep 모델 선택 오류 - "Model not found"

# 문제: 지원되지 않는 모델 이름 사용

원인: HolySheep에서 지원하지 않는 모델 호출



해결 방법 1: HolySheep에서 지원하는 모델 목록 확인

from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("HOLYSHEEP_API_KEY"),
    base_url="https://api.holysheep.ai/v1"
)


모델 목록 조회

models = client.models.list()
print("지원 모델 목록:")
for model in models.data:
    print(f"  - {

관련 리소스
관련 문서