저는 FX거래소에서 Algo-Trading 시스템을 개발한 뒤, 최근 암호화폐 做市(Market Making) Bot에 AI를 결합하는 프로젝트를 진행했습니다. 그 과정에서 호가창(Order Book) 데이터를 실시간으로 처리하고 AI 기반 거래 전략을 실행하는 방법을 직접 구현하며 많은 시행착오를 겪었습니다.

이 튜토리얼은 API 경험이 전혀 없는 완전 초보자도 따라할 수 있도록, 做市의 기본 개념부터 HolySheep AI를 활용한 주문서 처리 자동화까지 단계별로 설명드리겠습니다.

做市(Market Making)이란 무엇인가?

做市은 거래소에서 매수호가(Bid)와 매도호가(Ask)를 동시에 제시하여 투자자들이 언제든 매수/매도할 수 있도록 유동성을 제공하는 전략입니다.

예를 들어 현재 BTC 가격이 $100,000이라면:

매수호가(Bid): $99,990  ← 이 가격에 다른 사람이 팔 수 있음
매도호가(Ask): $100,010 ← 이 가격에 다른 사람이 살 수 있음
스프레드: $20

做市 Bot의 핵심 과제는 이 호가창 데이터를 실시간으로 분석하여 최적의 매수/매도 가격을 판단하는 것입니다. 여기서 AI의 역할이 중요해집니다.

왜 做市に AI가 필요한가?

传统的做市:

AI 기반 做市:

시작하기 전에 필요한 준비물

이 튜토리얼을 따라하기 위해 필요한 것들입니다:

단계 1: 호가창 데이터 구조 이해하기

거래소에서 제공하는 호가창 데이터는 기본적으로 이런 구조입니다:

{
  "lastUpdateId": 160,
  "bids": [
    ["0.0024", "10"],   // [가격, 수량]
    ["0.0023", "100"],
    ["0.0022", "50"]
  ],
  "asks": [
    ["0.0026", "15"],
    ["0.0027", "30"],
    ["0.0028", "60"]
  ]
}

핵심 용어 설명:

단계 2: 환경 설정하기

프로젝트 폴더를 만들고 필요한 라이브러리를 설치합니다.

# 터미널에서 실행
mkdir market-making-bot
cd market-making-bot
python -m venv venv


Windows의 경우:

venv\Scripts\activate


macOS/Linux의 경우:

source venv/bin/activate


필요한 라이브러리 설치

pip install websockets requests python-dotenv openai holybeep-sdk

스크린샷 힌트: pip install 완료 후 "Successfully installed" 메시지가 보이면 성공입니다.

단계 3: HolySheep AI 기본 설정

API 키를 .env 파일에 저장하고 AI 클라이언트를 설정합니다.

# .env 파일 생성 (주의: 실제 키는 본인의 것으로 교체)


HolySheep AI API 키 (.env에 저장)

HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY


거래소 API 키 (거래소에서 발급받은 것)

BINANCE_API_KEY=your_binance_api_key
BINANCE_SECRET_KEY=your_binance_secret_key
# holy_sheep_client.py
import os
from dotenv import load_dotenv
from openai import OpenAI


.env 파일 로드

load_dotenv()

class HolySheepAIClient:
    """HolySheep AI API를 사용한 AI 클라이언트"""
    
    def __init__(self):
        self.api_key = os.getenv("HOLYSHEEP_API_KEY")
        self.base_url = "https://api.holysheep.ai/v1"
        
        # HolySheep AI 클라이언트 초기화
        # ★ 절대 api.openai.com 사용 금지
        self.client = OpenAI(
            api_key=self.api_key,
            base_url=self.base_url
        )
    
    def analyze_market_conditions(self, order_book_data):
        """호가창 데이터를 AI로 분석하여 시장 상황 판단"""
        
        prompt = f"""당신은 암호화폐 做市 전문가입니다.
다음 호가창 데이터를 분석하고 做市 전략 조언을 제공해주세요.

현재 호가창:
{order_book_data}

다음 항목을 분석해주세요:
1. 현재 스프레드 상태 (넓음/좁음/보통)
2. 변동성 수준 (높음/중간/낮음)
3. 유동성 집중 구간
4. 권장 스프레드 폭
5. 위험 신호 여부

JSON 형식으로 답변해주세요."""

        response = self.client.chat.completions.create(
            model="gpt-4.1",
            messages=[
                {
                    "role": "system",
                    "content": "당신은 전문적인 암호화폐 做市 AI 어시스턴트입니다."
                },
                {
                    "role": "user", 
                    "content": prompt
                }
            ],
            temperature=0.3,  # 일관된 분석을 위해 낮춤
            max_tokens=800
        )
        
        return response.choices[0].message.content


사용 예시

if __name__ == "__main__":
    ai_client = HolySheepAIClient()
    print("HolySheep AI 클라이언트 초기화 완료!")

단계 4: 실시간 호가창 데이터 수집

거래소의 웹소켓을 통해 실시간 호가창 데이터를 가져오는 코드를 작성합니다.

# order_book_stream.py
import json
import asyncio
import websockets
from datetime import datetime

class OrderBookStream:
    """거래소 호가창 실시간 스트림"""
    
    def __init__(self, symbol="btcusdt"):
        self.symbol = symbol.lower()
        self.depth = 20  # 호가창 깊이
        self.order_book = {"bids": [], "asks": []}
        
    async def connect_binance(self):
        """Binance 웹소켓에 연결"""
        
        # Binance 스트리밍 URL
        stream_url = f"wss://stream.binance.com:9443/ws/{self.symbol}@depth20@100ms"
        
        print(f"🔗 Binance 웹소켓 연결 중: {self.symbol}")
        
        async with websockets.connect(stream_url) as ws:
            print(f"✅ 연결 성공! 실시간 호가창 수신 시작...")
            
            while True:
                try:
                    # 데이터 수신
                    data = await ws.recv()
                    message = json.loads(data)
                    
                    # 호가창 업데이트
                    self.order_book = {
                        "bids": [[float(p), float(q)] for p, q in message['b']],
                        "asks": [[float(p), float(q)] for p, q in message['a']]
                    }
                    
                    # 스프레드 계산
                    best_bid = self.order_book['bids'][0][0]
                    best_ask = self.order_book['asks'][0][0]
                    spread = best_ask - best_bid
                    spread_pct = (spread / best_ask) * 100
                    
                    # 화면에 표시
                    print(f"\n⏰ {datetime.now().strftime('%H:%M:%S.%f')[:-3]}")
                    print(f"   매수호가: ${best_bid:,.2f} | 매도호가: ${best_ask:,.2f}")
                    print(f"   스프레드: ${spread:.2f} ({spread_pct:.4f}%)")
                    print(f"   호가창 깊이: 매수 {len(self.order_book['bids'])}개 | 매도 {len(self.order_book['asks'])}개")
                    
                except Exception as e:
                    print(f"❌ 오류 발생: {e}")
                    await asyncio.sleep(1)

    def get_order_book(self):
        """현재 호가창 데이터 반환"""
        return self.order_book


실행

if __name__ == "__main__":
    stream = OrderBookStream("btcusdt")
    asyncio.run(stream.connect_binance())

단계 5: AI 기반 做市 전략 실행

실시간 호가창 데이터를 AI로 분석하고 자동으로 주문하는 완전한 做市 Bot을 구현합니다.

# market_maker.py
import os
import asyncio
import json
import time
from datetime import datetime
from dotenv import load_dotenv


모듈 import

from holy_sheep_client import HolySheepAIClient
from order_book_stream import OrderBookStream

class MarketMaker:
    """AI 기반 做市 Bot"""
    
    def __init__(self, symbol="BTCUSDT", spread_pct=0.1):
        load_dotenv()
        
        self.symbol = symbol
        self.target_spread_pct = spread_pct  # 목표 스프레드 %
        self.ai_client = HolySheepAIClient()
        self.order_book_stream = OrderBookStream(symbol.lower())
        
        # 거래 설정
        self.min_order_size = 0.001  # 최소 주문 수량 (BTC)
        self.max_position = 0.1      # 최대 보유 수량
        self.current_position = 0.0
        
        # AI 분석 결과 저장
        self.last_ai_analysis = None
        self.analysis_interval = 5   # AI 분석 간격 (초)
        self.last_analysis_time = 0
        
        print(f"🤖 MarketMaker 초기화 완료!")
        print(f"   거래 페어: {symbol}")
        print(f"   목표 스프레드: {spread_pct}%")
    
    def calculate_optimal_prices(self, best_bid, best_ask):
        """AI 분석을 기반으로 최적 매수/매도 가격 계산"""
        
        mid_price = (best_bid + best_ask) / 2
        
        # AI 분석 결과가 있으면 동적 조정
        if self.last_ai_analysis:
            try:
                # AI 권장 스프레드 적용
                analysis = json.loads(self.last_ai_analysis)
                
                if "스프레드" in self.last_ai_analysis:
                    if "좁음" in self.last_ai_analysis:
                        dynamic_spread = self.target_spread_pct * 0.7
                    elif "넓음" in self.last_ai_analysis:
                        dynamic_spread = self.target_spread_pct * 1.3
                    else:
                        dynamic_spread = self.target_spread_pct
                else:
                    dynamic_spread = self.target_spread_pct
                    
            except json.JSONDecodeError:
                dynamic_spread = self.target_spread_pct
        else:
            dynamic_spread = self.target_spread_pct
        
        # 매수/매도 가격 계산
        half_spread = mid_price * (dynamic_spread / 100) / 2
        
        buy_price = round(best_bid - half_spread, 2)
        sell_price = round(best_ask + half_spread, 2)
        
        return {
            "buy_price": buy_price,
            "sell_price": sell_price,
            "mid_price": mid_price,
            "spread": sell_price - buy_price,
            "spread_pct": (sell_price - buy_price) / mid_price * 100
        }
    
    async def analyze_and_trade(self):
        """AI 분석 + 거래 실행 메인 루프"""
        
        print("\n" + "="*60)
        print("🚀 AI 做市 Bot 시작!")
        print("="*60)
        
        while True:
            try:
                # 1. 현재 호가창 데이터 가져오기
                order_book = self.order_book_stream.get_order_book()
                
                if not order_book['bids'] or not order_book['asks']:
                    await asyncio.sleep(0.1)
                    continue
                
                best_bid = order_book['bids'][0][0]
                best_ask = order_book['asks'][0][0]
                
                # 2. 정기적 AI 분석 실행
                current_time = time.time()
                if current_time - self.last_analysis_time >= self.analysis_interval:
                    
                    # 호가창 데이터 포맷팅
                    order_book_str = f"""
매수호가 (Top 5):
{chr(10).join([f'  ${p:,.2f} - {q} BTC' for p, q in order_book['bids'][:5]])}

매도호가 (Top 5):
{chr(10).join([f'  ${p:,.2f} - {q} BTC' for p, q in order_book['asks'][:5]])}
"""
                    
                    print(f"\n🔄 AI 시장 분석 중...")
                    self.last_ai_analysis = self.ai_client.analyze_market_conditions(order_book_str)
                    self.last_analysis_time = current_time
                    
                    print(f"📊 AI 분석 결과:\n{self.last_ai_analysis[:200]}...")
                
                # 3. 최적 가격 계산
                prices = self.calculate_optimal_prices(best_bid, best_ask)
                
                # 4. 거래 신호 판단 및 주문
                if self.current_position < self.max_position:
                    # 매수 주문 신호
                    print(f"📈 매수 신호: ${prices['buy_price']:,.2f}에 {self.min_order_size} BTC")
                    # ★ 실제 거래소 연동 시 여기에 주문 실행 코드 추가
                    
                if self.current_position > 0:
                    # 매도 주문 신호
                    print(f"📉 매도 신호: ${prices['sell_price']:,.2f}에 {self.min_order_size} BTC")
                    # ★ 실제 거래소 연동 시 여기에 주문 실행 코드 추가
                
                await asyncio.sleep(0.1)  # 100ms 대기
                
            except KeyboardInterrupt:
                print("\n\n⛔ Bot 종료 요청됨")
                break
            except Exception as e:
                print(f"❌ 오류: {e}")
                await asyncio.sleep(1)


실행

if __name__ == "__main__":
    maker = MarketMaker("BTCUSDT", spread_pct=0.15)
    asyncio.run(maker.analyze_and_trade())

단계 6: 고급 기능 — 변동성 예측

AI를 사용하여 시장 변동성을 예측하고 스프레드를 자동으로 조절하는 기능을 추가합니다.

# volatility_predictor.py
from holy_sheep_client import HolySheepAIClient
import json

class VolatilityPredictor:
    """AI 기반 변동성 예측기"""
    
    def __init__(self):
        self.ai_client = HolySheepAIClient()
        
    def predict_volatility(self, historical_data, order_book_snapshot):
        """시장 변동성 예측"""
        
        prompt = f"""암호화폐 시장 변동성 예측 전문가입니다.

최근 거래 데이터:
{json.dumps(historical_data, indent=2)}

현재 호가창:
매수: {order_book_snapshot['bids'][:3]}
매도: {order_book_snapshot['asks'][:3]}

다음 5분 내 변동성 수준을 예측해주세요:
- 변동성: 높음/중간/낮음 (3단계)
- 예상 방향: 상승/하락/횡보
- 신뢰도: 0~100%

JSON으로 답변해주세요:
{{"volatility": "높음/중간/낮음", "direction": "상승/하락/횡보", "confidence": 85, "reason": "이유"}}"""

        response = self.ai_client.ai_client.chat.completions.create(
            model="gpt-4.1",
            messages=[
                {"role": "system", "content": "당신은金融市场 변동성 예측 전문가입니다."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.2,
            max_tokens=300
        )
        
        return json.loads(response.choices[0].message.content)

    def adjust_spread_based_on_prediction(self, base_spread_pct, prediction):
        """예측 결과에 따라 스프레드 자동 조절"""
        
        volatility_multiplier = {
            "높음": 1.5,   # 변동성 높으면 스프레드 확대
            "중간": 1.0,   # 변동성 보통이면 유지
            "낮음": 0.7    # 변동성 낮으면 스프레드 축소
        }
        
        direction_adjustment = {
            "상승": 1.1,   # 상승장에서는 매도 스프레드 확대
            "하락": 1.1,   # 하락장에서는 매수 스프레드 확대
            "횡보": 0.9    # 횡보장에서는 스프레드 축소
        }
        
        multiplier = volatility_multiplier.get(
            prediction.get("volatility", "중간"), 1.0
        )
        dir_mult = direction_adjustment.get(
            prediction.get("direction", "횡보"), 1.0
        )
        
        adjusted_spread = base_spread_pct * multiplier * dir_mult
        
        return {
            "adjusted_spread_pct": round(adjusted_spread, 4),
            "reason": f"변동성:{prediction.get('volatility')} × 방향:{prediction.get('direction')} → 스프레드 {adjusted_spread/base_spread_pct:.1f}배 조정",
            "confidence": prediction.get("confidence", 0)
        }


테스트

if __name__ == "__main__":
    predictor = VolatilityPredictor()
    
    test_data = {
        "recent_prices": [99200, 99100, 99300, 99250, 99400],
        "volume_24h": 25000,
        "timestamp": "2024-01-15 10:00:00"
    }
    
    test_book = {
        "bids": [[99100, 5], [99000, 10], [98900, 15]],
        "asks": [[99500, 3], [99600, 8], [99700, 12]]
    }
    
    prediction = predictor.predict_volatility(test_data, test_book)
    print("예측 결과:", prediction)
    
    adjustment = predictor.adjust_spread_based_on_prediction(0.1, prediction)
    print("스프레드 조정:", adjustment)

HolySheep AI 做市 서비스 비교

서비스 월 비용 API 호출 제한 모델 做市 특화 기능 장점
HolySheep AI $29~ 복합 과금 GPT-4.1, Claude, Gemini, DeepSeek ✅ 실시간 분석 + 동적 스프레드 단일 키로 모든 모델, 로컬 결제
OpenAI 직접 $100+ 높음 GPT-4o ❌ 없음 제한적
Anthropic 직접 $100+ 높음 Claude 3.5 ❌ 없음 제한적
AWS Bedrock $150+ 제한 없음 복합 ❌ 없음 대규모 처리

이런 팀에 적합 / 비적절

✅ HolySheep AI가 적합한 경우

❌ HolySheep AI가 비적절한 경우

가격과 ROI

做市 Bot에 AI를 적용할 때의 비용 구조를 분석해보겠습니다.

HolySheep AI 가격표

모델 입력 비용 출력 비용 做市 활용도
GPT-4.1 $3.00/MTok $12.00/MTok ⭐⭐⭐⭐ (고급 분석)
Claude Sonnet 4.5 $3.50/MTok $15.00/MTok ⭐⭐⭐⭐ (정밀 판단)
Gemini 2.5 Flash $1.20/MTok $4.80/MTok ⭐⭐⭐⭐⭐ (가성비 최고)
DeepSeek V3.2 $0.28/MTok $1.10/MTok ⭐⭐⭐⭐⭐ (비용 최적화)

ROI 계산 예시

1일 1,000회 호가창 분석 시:

# Gemini 2.5 Flash 사용 시 (권장)
입력: 500 Tok × $1.20 = $0.60
출력: 200 Tok × $4.80 = $0.96
일일 비용: $1.56
월간 비용: ~$47


DeepSeek V3.2 사용 시 (최대 절감)

입력: 500 Tok × $0.28 = $0.14
출력: 200 Tok × $1.10 = $0.22
일일 비용: $0.36
월간 비용: ~$11


스프레드 수익 비교 (0.1% 스프레드, 일 100회 거래)

일일 거래 대금: $100,000 (BTC 1 BTC 기준)
스프레드 수익: $100,000 × 0.1% = $100/일
월간 수익: $3,000

결론: 월 $11~47의 AI 비용으로 월 $3,000+ 수익의 做市 Bot을 운영할 수 있습니다.

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

오류 1: API 키 인증 실패

# ❌ 오류 메시지

Error: Incorrect API key provided



✅ 해결 방법


1. .env 파일에서 키가 정확히 복사되었는지 확인


2. HolySheep AI 대시보드에서 API 키 재발급


3. 키 앞에 공백이나 따옴표가 없는지 확인



올바른 .env 형식:

HOLYSHEEP_API_KEY=sk-holysheep-xxxxxxxxxxxx  # 따옴표 없이


코드에서 확인

from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv("HOLYSHEEP_API_KEY")
print(f"키 길이: {len(api_key)}")  # 40자 이상이어야 함
print(f"키 시작: {api_key[:10]}")  # sk-holysheep로 시작해야 함

오류 2: 웹소켓 연결 끊김

# ❌ 오류 메시지

websockets.exceptions.ConnectionClosed: ... close code 1006



✅ 해결 방법


자동 재연결 로직 추가


import asyncio
import websockets

class ReconnectingWebSocket:
    def __init__(self, url, max_retries=5):
        self.url = url
        self.max_retries = max_retries
        
    async def connect(self):
        retries = 0
        while retries < self.max_retries:
            try:
                async with websockets.connect(self.url) as ws:
                    print("✅ 웹소켓 연결됨")
                    async for message in ws:
                        await self.process_message(message)
            except Exception as e:
                retries += 1
                wait_time = min(2 ** retries, 30)  # 지수 백오프
                print(f"❌ 연결 실패 ({retries}/{self.max_retries}), {wait_time}초 후 재시도...")
                await asyncio.sleep(wait_time)
        
        print("⚠️ 최대 재시도 횟수 초과")


사용

socket = ReconnectingWebSocket("wss://stream.binance.com:9443/ws/btcusdt@depth")
asyncio.run(socket.connect())

오류 3: AI 응답 파싱 오류

# ❌ 오류 메시지

json.JSONDecodeError: Expecting value: line 1 column 1



✅ 해결 방법


AI 응답 유효성 검사 + 폴백 로직 추가


def parse_ai_response(response_text):
    """AI 응답을 안전하게 파싱"""
    
    # 1. Markdown 코드 블록 제거
    cleaned = response_text.strip()
    if cleaned.startswith("```"):
        lines = cleaned.split("\n")
        cleaned = "\n".join(lines[1:-1])
    
    # 2. JSON 태그 제거
    if cleaned.startswith("json"):
        cleaned = cleaned[4:].strip()
    
    # 3. 파싱 시도
    try:
        return json.loads(cleaned)
    except json.JSONDecodeError:
        # 4. 폴백: 기본값 반환
        print("⚠️ AI 응답 파싱 실패, 기본값 사용")
        return {
            "volatility": "중간",
            "direction": "횡보",
            "confidence": 50,
            "error": True
        }


사용

ai_response = ai_client.analyze_market_conditions(order_book_data)
result = parse_ai_response(ai_response)

오류 4: 주문 실패 — 잔액 부족

# ❌ 오류 메시지

BinanceAPIException: APIError(code=-2015): Invalid API-MT-Signature



✅ 해결 방법


잔액 확인 + 조건부 주문 로직


class SafeOrderManager:
    def __init__(self, exchange_client):
        self.exchange = exchange_client
        
    def check_balance_before_order(self, symbol, side, quantity):
        """주문 전 잔액 확인"""
        
        balance = self.exchange.get_balance()
        
        if side == "BUY":
            # USDT 잔액 확인
            usdt_balance = balance.get("USDT", {}).get("free", 0)
            estimated_cost = quantity * self.get_current_price(symbol)
            
            if usdt_balance < estimated_cost:
                print(f"⚠️ USDT 잔액 부족: {usdt_balance} < {estimated_cost}")
                return False, f"잔액 부족 (필요: {estimated_cost}, 보유: {usdt_balance})"
                
        elif side == "SELL":
            # 코인 잔액 확인
            coin = symbol.replace("USDT", "")
            coin_balance = balance.get(coin, {}).get("free", 0)
            
            if coin_balance < quantity:
                print(f"⚠️ {coin} 잔액 부족: {coin_balance} < {quantity}")
                return False, f"잔액 부족 (필요: {quantity}, 보유: {coin_balance})"
        
        return True, "잔액 충분"


사용

manager = SafeOrderManager(exchange_client)
can_order, message = manager.check_balance_before_order("BTCUSDT", "BUY", 0.01)
if can_order:
    # 주문 실행
    pass
else:
    print(f"주문 건너뜀: {message}")

왜 HolySheep AI를 선택해야 하나

1. 로컬 결제 지원으로 즉시 시작

저는 처음에 해외 결제 문제로 개발이 지연된 적이 있습니다. HolySheep AI는 국내 결제 시스템 지원으로 해외 신용카드 없이 바로 시작할 수 있습니다.

2. 단일 API 키로 모든 모델 활용

# HolySheep의 장점: 하나의 키로 여러 모델 테스트
from holy_sheep_client import HolySheepAIClient

ai = HolySheepAIClient()


같은 코드에서 모델만 교체하여 비교 가능

models = ["gpt-4.1", "claude-sonnet-4-5", "gemini-2.5-flash", "deepseek-v3.2"]

for model in models:
    response = ai.client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": "시장 분석해줘"}]
    )
    print(f"{model}: {len(response.choices[0].message.content)}자 응답")

3. 비용 최적화의 핵심

사용 사례 다른 서비스 HolySheep (DeepSeek) 절감률
하루 10,000회 분석 $150/월 $25/월 83% 절감
하루 50,000회 분석 $750/월 $120/월 84% 절감
하루 100,000회 분석 $1,500/월 $240/월 84% 절감

4. 가입 시 무료 크레딧

지금 가입하면 무료 크레딧이 제공됩니다. 이 크레딧으로 做市 Bot을 충분히 테스트하고 프로덕션 배포 전 비용을 검증할 수 있습니다.

완전한 做市 Bot 예제 코드

지금까지 설명한 모든 기능을 결합한 완전한 예제입니다:

# complete_market_maker.py
"""
HolySheep AI 기반 암호화폐 做市 Bot - 완전한 예제
"""

import os
import asyncio
import json
import time
from datetime import datetime
from dotenv import load_dotenv


HolySheep AI SDK

from holy_sheep_client import HolySheepAIClient
from order_book_stream import OrderBookStream
from volatility_predictor import VolatilityPredictor

class CompleteMarketMaker:
    """
    HolySheep AI + 실시간 호가창 기반 做市 Bot
    
    기능:
    1. 실시간 호가창 데이터 수집
    2. AI 시장 분석 및 변동성 예측
    3. 동적 스프레드 조정
    4. 안전한 주문 실행
    """
    
    def __init__(self, symbol="BTCUSDT", base_spread_pct=0.1):
        load_dotenv()
        
        # HolySheep AI 초기화
        self.ai_client = HolySheepAIClient()
        self.volatility_predictor = VolatilityPredictor()
        self

관련 리소스
관련 문서