작성자: HolySheep AI 기술 문서팀 | 최종 업데이트: 2025년 6월
AI API를 실무에 도입한 후 가장 큰 고민이 무엇인가요? 저는 HolySheep AI를 통해 수백 개의 프로젝트를 모니터링하면서 토큰 사용량 폭증, 응답 지연 문제, API 실패율, 그리고 모델 공급업체별 성능 편차가 비용을 초과하는 가장 큰 원인이라는 걸 확인했습니다. 이 가이드에서는 HolySheep AI의 내장 모니터링 도구를 활용하여这些问题를 조기에 감지하고 해결하는 방법을 단계별로 설명드리겠습니다.
목차
- API 모니터링이란 무엇인가요?
- HolySheep 대시보드 초기 설정
- 토큰 사용량暴涨 감지와 분석
- 慢请求(느린 요청) 추적 방법
- 失败率(실패율) 모니터링
- 모델 공급업체별 성능 비교
- 실전 모니터링 코드 예제
- 자주 발생하는 오류 해결
- 이런 팀에 적합 / 비적합
- 가격과 ROI
- 왜 HolySheep를 선택해야 하나
API 모니터링이란 무엇인가요?
API 모니터링이란 AI API를 호출할 때 발생하는 모든 데이터를 실시간으로 추적하고 기록하는 작업입니다. 예를 들어:
- 📊 요청 수: 오늘 몇 번이나 API를 호출했나요?
- 💰 토큰 소비: 입력 토큰 + 출력 토큰은 각각 얼마인가요?
- ⏱️ 응답 시간: 요청 후 답변이 오는 데 몇 밀리초(ms)가 걸리나요?
- ❌ 실패율: 요청 중 오류가 발생한 비율은 얼마인가요?
- 🏭 모델별 성능: GPT-4.1과 Claude 중 어떤 것이 더 빠른가요?
모니터링 없이 API를 사용하면 영수증不看不知道, 비용이 막상상없이 늘어날 수 있습니다. HolySheep AI는 이런 모니터링을 기본으로 제공하여您의 비용을 투명하게 관리할 수 있게 해줍니다.
HolySheep 대시보드 초기 설정
HolySheep AI에 가입하면 바로 사용할 수 있는 대시보드를 제공합니다. 지금 가입하고 시작해 봅시다.
1단계: API 키 발급받기
HolySheep 대시보드에 로그인한 후:
- Settings 메뉴로 이동합니다.
- API Keys 탭을 클릭합니다.
- Create New Key 버튼을 클릭합니다.
- 키 이름 입력 후 생성합니다. (예:
production-monitor)
[스크린샷 힌트: API Keys 페이지에서 새 키 생성 버튼이 강조 표시된 화면]
2단계: 기본 모니터링 활성화
기본적으로 모든 요청이 자동으로 로깅됩니다. 추가 설정:
- Usage 메뉴로 이동합니다.
- Real-time Monitoring 토글을 ON으로 설정합니다.
- 시간대(Timezone)를
Asia/Seoul으로 변경합니다.
토큰 사용량暴涨 감지와 분석
왜 토큰이暴涨하나요?
토큰 사용량이 급증하는 주요 원인은:
- 반복 요청: 같은 프롬프트를 여러 번 호출
- 긴 컨텍스트: 대화 히스토리를 매 요청마다 전송
- 비효율적 프롬프트: 불필요한 지시사항 포함
- 배치 처리 오류: 한 번에 대량 데이터 전송
HolySheep에서 토큰 추적하기
Usage 대시보드에서:
- Token Usage 차트를 확인합니다.
- Input vs Output 비율을 확인합니다.
- 하루, 주간, 월간 뷰를切り替え할 수 있습니다.
[스크린샷 힌트: Token Usage 차트에서 주간 추이 그래프가 표시된 화면]
실전 코드: 토큰 사용량 로깅
import requests
import time
from datetime import datetime
HolySheep API 설정
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
def chat_completion_with_logging(prompt, model="gpt-4.1"):
"""토큰 사용량을 로깅하는 API 호출 함수"""
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": model,
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 1000
}
start_time = time.time()
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=headers,
json=payload
)
end_time = time.time()
response_data = response.json()
# 토큰 사용량 추출
usage = response_data.get("usage", {})
input_tokens = usage.get("prompt_tokens", 0)
output_tokens = usage.get("completion_tokens", 0)
total_cost_msat = usage.get("cost_msat", 0) # 밀리센트 단위
# 로깅
print(f"[{datetime.now()}]")
print(f" 모델: {model}")
print(f" 입력 토큰: {input_tokens}")
print(f" 출력 토큰: {output_tokens}")
print(f" 응답 시간: {(end_time - start_time) * 1000:.2f}ms")
print(f" 비용: ${total_cost_msat / 1000:.4f}")
return response_data
테스트 실행
result = chat_completion_with_logging(
"한국의 수도는 어디인가요?",
model="gpt-4.1"
)
출력 예시:
[2025-06-19 14:32:15.123]
모델: gpt-4.1
입력 토큰: 23
출력 토큰: 15
응답 시간: 1245.67ms
비용: $0.000384慢请求(느린 요청) 추적 방법
응답 시간 기준 설정
HolySheep에서는 您의 SLA(서비스 수준 계약)에 따라 응답 시간 기준을 설정할 수 있습니다:
- 양호 (Good): 1000ms 이하
- 주의 (Warning): 1000ms ~ 3000ms
- 危险 (Critical): 3000ms 이상
응답 시간 모니터링 대시보드
Analytics > Latency 메뉴에서:
- P50, P95, P99 지연 시간 분포를 확인합니다.
- 모델별 평균 응답 시간을 비교합니다.
- 시간대별 패턴을 분석합니다.
[스크린샷 힌트: Latency 분포 차트에서 P95값이 강조된 화면]
실전 코드: 자동 재시도 로직
import requests
import time
import json
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
class HolySheepClient:
def __init__(self, api_key):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.max_retries = 3
self.timeout = 30 # 초 단위
def _make_request(self, payload, model="gpt-4.1"):
"""응답 시간을 기록하는 내부 메서드"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
start_time = time.time()
try:
response = requests.post(
f"{self.base_url}/chat/completions",
headers=headers,
json={"model": model, **payload},
timeout=self.timeout
)
elapsed_ms = (time.time() - start_time) * 1000
# 응답 시간 로깅
print(f"[{model}] 응답 시간: {elapsed_ms:.2f}ms")
# 3초 이상 걸리면 경고
if elapsed_ms > 3000:
print(f"⚠️ 경고: 응답 시간이 3초를 초과했습니다!")
response.raise_for_status()
return response.json(), elapsed_ms
except requests.exceptions.Timeout:
print(f"❌ 타임아웃: {model} 모델 응답이 {self.timeout}초 내에 완료되지 않았습니다.")
return None, None
except requests.exceptions.RequestException as e:
print(f"❌ 요청 오류: {e}")
return None, None
def chat(self, messages, model="gpt-4.1", use_fallback=True):
"""자동 폴백이 포함된 채팅 메서드"""
payload = {"messages": messages, "max_tokens": 2000}
result, latency = self._make_request(payload, model)
if result:
return result
elif use_fallback:
# GPT-4.1이 실패하면 Gemini Flash로 폴백
print("🔄 GPT-4.1 실패. Gemini Flash로 폴백합니다...")
return self._make_request(payload, model="gemini-2.5-flash")
return None
사용 예제
client = HolySheepClient("YOUR_HOLYSHEEP_API_KEY")
messages = [
{"role": "system", "content": "당신은 친절한 도우미입니다."},
{"role": "user", "content": "파이썬으로 API 모니터링 코드를 작성하는 방법을 알려주세요."}
]
response = client.chat(messages, model="gpt-4.1")
출력 예시:
[gpt-4.1] 응답 시간: 2845.32ms
⚠️ 경고: 응답 시간이 3초를 초과했습니다!
🔄 GPT-4.1 실패. Gemini Flash로 폴백합니다...
[gemini-2.5-flash] 응답 시간: 892.15ms失败率(실패율) 모니터링
HolySheep 대시보드에서 실패율 확인
Analytics > Reliability 메뉴에서:
- Error Rate: 전체 요청 중 오류 비율
- Status Code 분포: 4xx, 5xx 에러 현황
- 모델별 실패율: 각 모델의 안정성 비교
[스크린샷 힌트: Reliability 대시보드에서 오류율이 파이 차트로 표시된 화면]
흔한 오류 유형
- 401 Unauthorized: API 키가 유효하지 않거나 만료됨
- 429 Rate Limit: 요청 빈도가 제한 초과
- 500 Internal Server Error: HolySheep 또는 공급업체 서버 문제
- 503 Service Unavailable: 모델 일시적 사용 불가
실전 코드: 실패율 추적 데코레이터
import requests
import time
from datetime import datetime, timedelta
from collections import defaultdict
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
class APIMonitor:
"""API 모니터링 및 실패율 추적 클래스"""
def __init__(self):
self.stats = defaultdict(lambda: {
"total": 0,
"success": 0,
"errors": defaultdict(int),
"latencies": []
})
self.window_minutes = 60 # 1시간 윈도우
def track_request(self, model, start_time, status_code, error_type=None):
"""요청 통계 추적"""
stats = self.stats[model]
stats["total"] += 1
if 200 <= status_code < 300:
stats["success"] += 1
else:
stats["errors"][error_type or f"HTTP_{status_code}"] += 1
latency = (time.time() - start_time) * 1000
stats["latencies"].append(latency)
def get_failure_rate(self, model):
"""특정 모델의 실패율 반환 (%)"""
stats = self.stats[model]
if stats["total"] == 0:
return 0.0
return ((stats["total"] - stats["success"]) / stats["total"]) * 100
def get_average_latency(self, model):
"""평균 응답 시간 반환 (ms)"""
stats = self.stats[model]
if not stats["latencies"]:
return 0.0
return sum(stats["latencies"]) / len(stats["latencies"])
def print_report(self):
"""모니터링 리포트 출력"""
print("=" * 60)
print(f"📊 API 모니터링 리포트 - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print("=" * 60)
for model, stats in self.stats.items():
failure_rate = self.get_failure_rate(model)
avg_latency = self.get_average_latency(model)
# 실패율 색상 표시
if failure_rate < 1:
status = "🟢 양호"
elif failure_rate < 5:
status = "🟡 주의"
else:
status = "🔴 위험"
print(f"\n🏭 모델: {model}")
print(f" 총 요청: {stats['total']}")
print(f" 성공: {stats['success']}")
print(f" 실패율: {failure_rate:.2f}% {status}")
print(f" 평균 지연: {avg_latency:.2f}ms")
if stats["errors"]:
print(" 주요 오류:")
for error_type, count in stats["errors"].items():
print(f" - {error_type}: {count}회")
모니터링 데코레이터 함수
def monitor_api(monitor, model):
"""API 호출을 모니터링하는 데코레이터"""
def decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
status_code = 200
error_type = None
try:
result = func(*args, **kwargs)
return result
except requests.exceptions.HTTPError as e:
status_code = e.response.status_code
error_type = e.__class__.__name__
raise
except Exception as e:
status_code = 500
error_type = e.__class__.__name__
raise
finally:
monitor.track_request(model, start_time, status_code, error_type)
return wrapper
return decorator
사용 예제
monitor = APIMonitor()
@monitor_api(monitor, "gpt-4.1")
def call_api(prompt):
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-4.1",
"messages": [{"role": "user", "content": prompt}]
}
response = requests.post(f"{BASE_URL}/chat/completions", headers=headers, json=payload)
response.raise_for_status()
return response.json()
테스트 실행
try:
call_api("안녕하세요!")
except:
pass
monitor.print_report()
출력 예시:
============================================================
📊 API 모니터링 리포트 - 2025-06-19 15:30:00
============================================================
🏭 모델: gpt-4.1
총 요청: 1
성공: 1
실패율: 0.00% 🟢 양호
평균 지연: 1523.45ms모델 공급업체별 성능 비교
HolySheep AI의 가장 큰 장점 중 하나는 다양한 AI 모델을 단일 API 키로 사용할 수 있다는 것입니다. 각 모델의 성능을 비교하여 최적의 선택을 할 수 있습니다.
모델별 성능 비교표
| 모델 | 입력 비용 ($/MTok) | 출력 비용 ($/MTok) | 평균 지연 (ms) | 적합한 용도 | 안정성 |
|---|---|---|---|---|---|
| GPT-4.1 | $8.00 | $8.00 | 1,200 ~ 2,500 | 복잡한推理, 코드 생성 | ★★★★☆ |
| Claude Sonnet 4.5 | $15.00 | $15.00 | 1,500 ~ 3,000 | 긴 컨텍스트, 분석 | ★★★★★ |
| Gemini 2.5 Flash | $2.50 | $2.50 | 800 ~ 1,500 | 빠른 응답, 대화형 | ★★★★☆ |
| DeepSeek V3.2 | $0.42 | $0.42 | 600 ~ 1,200 | 비용 최적화, 간단한 작업 | ★★★★☆ |
모델 선택 가이드
- 💰 비용 최적화 우선: DeepSeek V3.2 (톤당 $0.42)
- ⚡ 속도 우선: Gemini 2.5 Flash (평균 1,000ms)
- 🧠 품질 우선: Claude Sonnet 4.5 (긴 컨텍스트)
- 🔧 범용: GPT-4.1 (균형 잡힌 성능)
실전 코드: 자동 모델 선택
import requests
import time
from enum import Enum
from dataclasses import dataclass
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
class ModelPriority(Enum):
SPEED = "speed"
COST = "cost"
QUALITY = "quality"
BALANCED = "balanced"
@dataclass
class ModelInfo:
name: str
input_cost: float # $/MTok
output_cost: float
avg_latency: float # ms
quality_score: int # 1-5
HolySheep에서 사용 가능한 모델 정보
MODELS = {
"gpt-4.1": ModelInfo("gpt-4.1", 8.0, 8.0, 1800, 5),
"claude-sonnet-4.5": ModelInfo("claude-sonnet-4.5", 15.0, 15.0, 2200, 5),
"gemini-2.5-flash": ModelInfo("gemini-2.5-flash", 2.5, 2.5, 1000, 4),
"deepseek-v3.2": ModelInfo("deepseek-v3.2", 0.42, 0.42, 900, 4),
}
class SmartModelSelector:
"""작업 유형에 따라 최적의 모델을 자동 선택"""
def __init__(self, api_key):
self.api_key = api_key
self.usage_history = {} # 모델별 사용량 추적
def estimate_tokens(self, text):
"""한국어 기준 토큰 추정 (약 2글자 = 1토큰)"""
return len(text) // 2
def estimate_cost(self, model_name, input_tokens, output_tokens):
"""추정 비용 계산"""
model = MODELS[model_name]
input_cost = (input_tokens / 1_000_000) * model.input_cost
output_cost = (output_tokens / 1_000_000) * model.output_cost
return input_cost + output_cost
def select_model(self, prompt, priority=ModelPriority.BALANCED, context_length=0):
"""작업에 맞는 최적 모델 선택"""
# 긴 컨텍스트 필요 시 Claude 권장
if context_length > 100000:
return "claude-sonnet-4.5"
# 복잡한推理 필요 시 GPT-4.1
if any(keyword in prompt for keyword in ["분석", "비교", "추론", "논리"]):
return "gpt-4.1"
# 빠른 응답 필요 시 Gemini Flash
if priority == ModelPriority.SPEED:
return "gemini-2.5-flash"
# 비용 최적화 시 DeepSeek
if priority == ModelPriority.COST:
return "deepseek-v3.2"
# 균형 잡힌 선택
return "gemini-2.5-flash" # 대부분의 경우 적합
def execute_with_model_selection(self, prompt, priority=ModelPriority.BALANCED):
"""모델을 자동 선택하여 API 호출"""
selected_model = self.select_model(prompt, priority)
estimated_input = self.estimate_tokens(prompt)
estimated_output = estimated_input * 0.5 # 출력은 입력의 약 50%
estimated_cost = self.estimate_cost(
selected_model,
estimated_input,
estimated_output
)
print(f"선택된 모델: {selected_model}")
print(f"예상 비용: ${estimated_cost:.6f}")
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": selected_model,
"messages": [{"role": "user", "content": prompt}]
}
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
사용 예제
selector = SmartModelSelector("YOUR_HOLYSHEEP_API_KEY")
비용 최적화 예제
result1 = selector.execute_with_model_selection(
"한국의 수도는 어디인가요?",
priority=ModelPriority.COST
)
품질 우선 예제
result2 = selector.execute_with_model_selection(
"AI와 전통산업의 융합이 가져올 사회적 변화에 대해 깊이 있는 분석을 제공해주세요.",
priority=ModelPriority.QUALITY
)
출력 예시:
선택된 모델: deepseek-v3.2
예상 비용: $0.000004
선택된 모델: claude-sonnet-4.5
예상 비용: $0.000092실전 모니터링 대시보드 구성
프로덕션 환경에서는 HolySheep 대시보드와 함께 자체 모니터링 시스템을 구축하는 것을 권장합니다.
추천 모니터링 지표 (KPIs)
- P50 Latency: 중간 응답 시간
- P95 Latency: 95번째百分위 응답 시간
- P99 Latency: 99번째百分위 응답 시간
- Error Rate: 시간당 오류 비율
- Cost per Hour: 시간당 비용
- Token Utilization: 토큰 활용률
자주 발생하는 오류 해결
오류 1: 401 Unauthorized - API 키 인증 실패
문제: API 호출 시 401 Unauthorized 오류가 발생합니다.
원인:
- API 키가 잘못되었거나 복사 시 공백 포함
- API 키가 만료되었거나 삭제됨
- Base URL이 잘못됨
해결 코드:
import os
❌ 잘못된 방법: 공백이나 따옴표 포함
API_KEY = " YOUR_HOLYSHEEP_API_KEY " # 공백 포함
API_KEY = "'YOUR_HOLYSHEEP_API_KEY'" # 따옴표 포함
✅ 올바른 방법
API_KEY = os.environ.get("HOLYSHEEP_API_KEY") # 환경 변수에서 가져오기
또는
API_KEY = "YOUR_HOLYSHEEP_API_KEY" # 정확한 값만
Base URL 확인
BASE_URL = "https://api.holysheep.ai/v1" # 절대 api.openai.com 사용 금지!
headers = {
"Authorization": f"Bearer {API_KEY.strip()}", # strip()으로 공백 제거
"Content-Type": "application/json"
}
오류 2: 429 Rate Limit - 요청 제한 초과
문제: 429 Too Many Requests 오류가 발생하며 요청이 거부됩니다.
원인:
- 短時間에 너무 많은 요청
- 계정 등급의 요청 한도 초과
해결 코드:
import time
import requests
from requests.exceptions import HTTPError
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
def call_with_retry(payload, max_retries=5, initial_delay=1):
"""지수 백오프를 사용한 재시도 로직"""
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
delay = initial_delay
for attempt in range(max_retries):
try:
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=headers,
json=payload
)
if response.status_code == 429:
# Rate Limit 시 지수 백오프
wait_time = delay * (2 ** attempt)
print(f"⏳ Rate Limit 도달. {wait_time}초 후 재시도... ({attempt + 1}/{max_retries})")
time.sleep(wait_time)
continue
response.raise_for_status()
return response.json()
except HTTPError as e:
if attempt == max_retries - 1:
raise Exception(f"최대 재시도 횟수 초과: {e}")
time.sleep(delay)
raise Exception("요청 실패")
사용 예제
payload = {
"model": "gpt-4.1",
"messages": [{"role": "user", "content": "안녕하세요!"}]
}
try:
result = call_with_retry(payload)
print("✅ 요청 성공!")
except Exception as e:
print(f"❌ 실패: {e}")
오류 3: 500 Internal Server Error - 서버 오류
문제: 500 Internal Server Error 또는 503 Service Unavailable 오류가 발생합니다.
원인:
- HolySheep 서버 일시적 문제
- 모델 공급업체(GPT, Claude 등) 서버 문제
- 네트워크 연결 불안정
해결 코드:
import requests
import time
from typing import Optional
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
class APIClient:
def __init__(self, api_key):
self.api_key = api_key
self.models = ["gpt-4.1", "gemini-2.5-flash", "deepseek-v3.2"]
def call_with_fallback(self, messages, primary_model="gpt-4.1"):
"""기본 모델 실패 시 폴백 모델 자동 사용"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
# 폴백 순서: primary -> gemini -> deepseek
models_to_try = [primary_model]
for model in self.models:
if model != primary_model:
models_to_try.append(model)
last_error = None
for model in models_to_try:
try:
payload = {
"model": model,
"messages": messages
}
print(f"🔄 {model} 모델 시도 중...")
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=headers,
json=payload,
timeout=30
)
# 5xx 오류면 다음 모델로 폴백
if 500 <= response.status_code < 600:
print(f"⚠️ {model} 서버 오류 (HTTP {response.status_code}). 다음 모델 시도...")
time.sleep(1) # 1초 대기 후 재시도
continue
response.raise_for_status()
result = response.json()
print(f"✅ {model} 모델 성공!")
return result, model
except requests.exceptions.RequestException as e:
last_error = e
print(f"❌ {model} 실패: {e}")
time.sleep(1)
continue
raise Exception(f"모든 모델 실패. 마지막 오류: {last_error}")
사용 예제
client = APIClient("YOUR_HOLYSHEEP_API_KEY")
messages = [{"role": "user", "content": "단기간에财富을 불리는 방법을 알려주세요."}]
try:
result, used_model = client.call_with_fallback(messages)
print(f"사용된 모델: {used_model}")
print(f"응답: {result['choices'][0]['message']['content'][:100]}...")
except Exception as e:
print(f"모든 모델 호출 실패: {e}")
오류 4: 토큰 초과 - Context Length 초과
문제: 400 Bad Request 오류가 발생하며 "maximum context length" 메시지가 표시됩니다.
원인:
- 입력 텍스트가 모델의 최대 컨텍스트 길이를 초과
- 대화 히스토리가 누적되어 토큰 제한 초과
해결 코드:
```python
import requests
import tiktoken # 토큰 카운팅 라이브러리
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
모델별 최대 컨텍스트 (토큰)
MAX_CONTEXTS = {
"gpt-4.1": 128000,
"claude-sonnet-4.5": 200000,
"gemini-2.5-flash": 1000000,
"deepseek-v3.2": 64000,
}
class ConversationManager:
"""대화 히스토리를 자동으로 관리하는 클래스"""
def __init__(self, api_key, model="gpt-4.1"):
self.api_key = api_key
self.model = model
self.max_context = MAX_CONTEXTS.get(model, 128000)
# 안전 마진: 최대 context의 80%까지만 사용
self.safe_limit = int(self.max_context * 0.8)
self.messages = []
def count_tokens(self, text):
"""대략적인 토큰 수 계산 (한국어 기준)"""
# 정확한 계산을 위해 tiktoken 권장
# 여기서는 간략한 추정치 제공
return len(text) // 2
def count_messages_tokens(self):
"""전체 메시지의 토큰 수 계산"""
total = 0
for msg in self.messages:
# role, content, 각 메시지 형식 overhead
total += self.count_tokens(msg["content"]) + 10
return total
def add_message(self, role, content):
"""메시지 추가 (자동 트리밍)"""
self.messages.append({"role": role, "content": content})
# 토큰 제한 초과 시 오래된 메시지 제거
while self.count_messages_tokens() > self.safe_limit:
if len(self.messages) > 2:
# 가장 오래된 메시지 2개 제거 (system + 첫 user)
self.messages.pop(0)
self.messages.pop(0)
else:
break
def get_safe_messages(self):
"""안전한 길이의 메시지 반환