저는 현재 이커머스 플랫폼에서 AI 고객 서비스 시스템을 구축 중인 개발자입니다. 최근 AI API를 활용한 프로젝트가 급증하면서 많은同僚들이 API 문서를 읽어도 용어의 의미를 정확히 이해하지 못하는 상황을 경험했습니다. 오늘은 AI API를 사용하면서 반드시 알아야 할 핵심 용어들을 실제 코드 예제와 함께 정리해 드리겠습니다.

왜 AI API 용어를 알아야 하는가?

이커머스 AI 고객 서비스 시스템을 구축하면서 저는 처음에 API 응답 속도가 예상보다 느리다는 문제를 겪었습니다. 원인은 간단했습니다. streaming과 batch processing의 차이를 이해하지 못해 잘못된 설정を使った 것입니다. AI API를 효과적으로 활용하려면 기본 용어의 정확한 이해가 필수적입니다.

1. API 호출 구조 기본 용어

Base URL과 Endpoint

AI API를 호출할 때 가장 먼저 설정해야 하는 것이 Base URL입니다. HolySheep AI를 사용하면 단일 API 키로 여러 모델을 통합 관리할 수 있습니다:

# HolySheep AI 기본 호출 구조
import openai

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)


모델 선택만으로 다양한 AI 제공자 사용 가능

response = client.chat.completions.create(
    model="gpt-4.1",  # 또는 claude-3-5-sonnet, gemini-2.5-flash 등
    messages=[
        {"role": "system", "content": "당신은 친절한 고객 서비스 담당자입니다."},
        {"role": "user", "content": "배송 查询方法를 알려주세요."}
    ],
    temperature=0.7,
    max_tokens=500
)

print(response.choices[0].message.content)

Endpoint는 API 서버의 특정 기능에 접근하기 위한 URL 경로입니다. HolySheep AI는 /v1/chat/completions, /v1/embeddings 등 표준 엔드포인트를 제공합니다.

Request와 Response 구조

API 호출은 요청(Request)과 응답(Response)의 쌍으로 구성됩니다:

# HolySheep AI API 응답 구조 확인
import openai

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)

response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "user", "content": "안녕하세요"}
    ]
)


응답 구조 분석

print(f"모델: {response.model}")
print(f"사용 토큰: {response.usage.prompt_tokens}")
print(f"생성 토큰: {response.usage.completion_tokens}")
print(f"총 토큰: {response.usage.total_tokens}")
print(f"생성 시간: {response.response_ms}ms")  # HolySheep AI는 ms 단위 응답 시간 제공
print(f"콘텐츠: {response.choices[0].message.content}")

2. 토큰(Tokens)과 비용 관련 용어

토큰(Token)이란?

토큰(Token)은 텍스트를 모델이 처리할 수 있는最小 단위로 분할한 것입니다. 영어에서는 약 4글자가 1토큰, 한국어에서는 글자당 1-2토큰으로 계산됩니다. HolySheep AI의 실제 가격을 기준으로 비용을 계산해 보겠습니다:

# 토큰 비용 계산기 구현
def calculate_cost(model: str, input_tokens: int, output_tokens: int) -> float:
    """HolySheep AI 모델별 비용 계산"""
    pricing = {
        "gpt-4.1": {"input": 8.00, "output": 8.00},      # $/1M tokens
        "claude-3-5-sonnet": {"input": 15.00, "output": 15.00},
        "gemini-2.5-flash": {"input": 2.50, "output": 10.00},
        "deepseek-chat": {"input": 0.42, "output": 1.68}
    }
    
    if model not in pricing:
        raise ValueError(f"지원하지 않는 모델: {model}")
    
    rates = pricing[model]
    input_cost = (input_tokens / 1_000_000) * rates["input"]
    output_cost = (output_tokens / 1_000_000) * rates["output"]
    
    return {
        "input_cost": round(input_cost, 4),
        "output_cost": round(output_cost, 4),
        "total_cost": round(input_cost + output_cost, 4),
        "total_cost_cents": round((input_cost + output_cost) * 100, 2)  # 센트 단위
    }


사용 예시

cost_info = calculate_cost("deepseek-chat", 5000, 1000)
print(f"DeepSeek V3 비용: {cost_info['total_cost']}달러 ({cost_info['total_cost_cents']}센트)")

Context Window (컨텍스트 윈도우)

컨텍스트 윈도우(Context Window)는 모델이 한 번의 요청에서 처리할 수 있는 최대 토큰 수입니다. 이 범위를 초과하면 오류가 발생합니다:

# 컨텍스트 윈도우 초과 방지 유틸리티
def truncate_to_context(messages: list, model: str, max_reserve: int = 1000) -> list:
    """메시지를 컨텍스트 윈도우에 맞게 자르기"""
    context_limits = {
        "gpt-4.1": 128000,
        "claude-3-5-sonnet": 200000,
        "gemini-2.5-flash": 1000000,
        "deepseek-chat": 64000
    }
    
    limit = context_limits.get(model, 32000)
    effective_limit = limit - max_reserve
    
    # 토큰估算 (간단한估算: 한국어 2토큰/글자)
    def estimate_tokens(text: str) -> int:
        return len(text) * 2
    
    total_tokens = sum(estimate_tokens(m.get("content", "")) for m in messages)
    
    if total_tokens <= effective_limit:
        return messages
    
    # 오래된 메시지부터 제거
    truncated = []
    current_tokens = 0
    
    for msg in messages:
        msg_tokens = estimate_tokens(msg.get("content", ""))
        if current_tokens + msg_tokens <= effective_limit:
            truncated.append(msg)
            current_tokens += msg_tokens
        else:
            break
    
    return truncated


RAG 시스템에서 긴 문서를 처리할 때 유용

sample_messages = [
    {"role": "system", "content": "당신은 도움이 되는 어시스턴트입니다."},
    {"role": "user", "content": "긴 문서 내용..." * 5000},
    {"role": "assistant", "content": "이것은 긴 응답입니다..." * 2000}
]

safe_messages = truncate_to_context(sample_messages, "deepseek-chat")

3. 텍스트 생성 파라미터

Temperature

Temperature는 생성된 텍스트의 무작위성을 조절하는 파라미터입니다. 값이 낮을수록 결정적이고 일관된 응답을, 높을수록 창의적이고 다양한 응답을 생성합니다:

# Temperature 적용 시나리오별 예시
import openai

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)


시나리오 1: 정확한 코드 생성 (낮은 temperature)

code_response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Python으로 피보나치 함수 작성"}],
    temperature=0.1  # 결정적 결과
)


시나리오 2: 창작 콘텐츠 (높은 temperature)

creative_response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "판타지 소설开头문장 작성"}],
    temperature=0.9  # 다양한 결과
)


시나리오 3: 균형 잡힌 대화

chat_response = client.chat.completions.create(
    model="claude-3-5-sonnet",
    messages=[{"role": "user", "content": "점심 메뉴 추천"}],
    temperature=0.5  # 적절한 다양성
)

Top-P와 Top-K

Top-P(nucleus sampling)와 Top-K는 모델이 다음 토큰을 선택할 때 고려하는 후보 범위를 제한합니다:

# Top-P와 Top-K 설정 예시
import openai

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)


Top-P 설정: 누적 확률 90%范围内的 토큰만 고려

response = client.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[{"role": "user", "content": "기술 트렌드 설명"}],
    top_p=0.9,    # 기본값 1.0
    temperature=0.7
)


RAG 시스템에서는 낮은 Top-P로 일관성 확보

rag_response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "제공된 문서 기반으로만 답변"},
        {"role": "user", "content": "문서의 주요 내용 요약"}
    ],
    top_p=0.5,   # 낮추면 더 일관된 응답
    temperature=0.3
)

Max Tokens (최대 토큰 수)

Max Tokens는 생성될 수 있는 최대 토큰 수를 제한합니다. 응답이 잘리면 이 값을 늘려야 합니다:

# 긴 컨텐츠 생성을 위한 Max Tokens 설정
import openai

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)


짧은 응답

short_response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "한국의 수도는?"}],
    max_tokens=50  # 간결한 답변
)


긴 보고서 생성

report_response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "system", "content": "당신은 전문 분석가입니다."},
        {"role": "user", "content": "2024년 AI 산업 동향 보고서 작성 (2000자 이상)"}
    ],
    max_tokens=4000  # 충분한 공간 확보
)

print(f"생성된 토큰: {report_response.usage.completion_tokens}")

4. RAG 시스템 관련 용어

Embedding과 Vector Search

RAG(Retrieval-Augmented Generation) 시스템의 핵심은 임베딩(Embedding)입니다. 텍스트를 숫자 벡터로 변환하여 의미적 유사도를 계산합니다:

# HolySheep AI를 이용한 RAG 시스템 구현
import openai
import numpy as np

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)

def create_embedding(text: str, model: str = "text-embedding-3-small") -> list:
    """텍스트를 벡터로 변환"""
    response = client.embeddings.create(
        model=model,
        input=text
    )
    return response.data[0].embedding

def cosine_similarity(a: list, b: list) -> float:
    """코사인 유사도 계산"""
    a = np.array(a)
    b = np.array(b)
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))


문서 임베딩 생성

documents = [
    "한국의 인공지능 산업은 빠르게 성장하고 있습니다.",
    "자연어 처리는 AI의 핵심 기술 분야입니다.",
    " HolySheep AI는 글로벌 AI API 게이트웨이 서비스입니다."
]

doc_embeddings = [create_embedding(doc) for doc in documents]


사용자 질문 임베딩

query = "AI API 서비스에 대해 알려주세요"
query_embedding = create_embedding(query)


유사도 검색

similarities = [
    (doc, cosine_similarity(query_embedding, emb))
    for doc, emb in zip(documents, doc_embeddings)
]


정렬하여 상위 결과 반환

ranked = sorted(similarities, key=lambda x: x[1], reverse=True)
print("관련 문서 순위:")
for doc, score in ranked:
    print(f"  [{score:.4f}] {doc}")

Chunk와 Splitting

Chunk는 임베딩하기 위해 분할된 텍스트 단위입니다. 적절한 chunk 크기와 오버랩 설정이 검색 품질을 결정합니다:

# 스마트 텍스트 분할 유틸리티
import re

def smart_chunk(text: str, chunk_size: int = 500, overlap: int = 50) -> list:
    """지능형 텍스트 분할 (문장 경계 유지)"""
    sentences = re.split(r'[.!?]\s+', text)
    chunks = []
    current_chunk = ""
    
    for sentence in sentences:
        # 한국어 토큰估算 (약 2토큰/글자)
        estimated_tokens = len(sentence) * 2
        
        if estimated_tokens > chunk_size:
            # 너무 긴 문장은 강제 분할
            if current_chunk:
                chunks.append(current_chunk.strip())
            chunks.append(sentence[:chunk_size//2])
            current_chunk = sentence[chunk_size//2:]
        elif len(current_chunk) + len(sentence) <= chunk_size:
            current_chunk += " " + sentence
        else:
            chunks.append(current_chunk.strip())
            # 오버랩 적용
            current_chunk = current_chunk[-overlap:] + " " + sentence
    
    if current_chunk.strip():
        chunks.append(current_chunk.strip())
    
    return chunks


사용 예시

long_document = """
한국의 이커머스 시장은 연평균 두 자릿수 성장률을 기록하고 있습니다.
특히 모바일 Commerce 비율이 전체 거래의 70%를 차지하며,
AI 기반 추천 시스템의 중요성이 날로 증가하고 있습니다.
"""

chunks = smart_chunk(long_document, chunk_size=200, overlap=30)
print(f"분할 결과: {len(chunks)}개 chunk")
for i, chunk in enumerate(chunks):
    print(f"  Chunk {i+1}: {chunk}")

5. 스트리밍(Streaming)과 배치(Batch) 처리

Streaming Response

Streaming은 응답을 실시간으로chunk 단위로 전송합니다. 사용자에게 즉각적인 피드백을 제공할 수 있습니다:

# HolySheep AI 스트리밍 응답 처리
import openai
from typing import Iterator

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)

def stream_chat(user_message: str) -> Iterator[str]:
    """스트리밍 채팅 응답 생성"""
    stream = client.chat.completions.create(
        model="gpt-4.1",
        messages=[
            {"role": "system", "content": "당신은 유용한 AI 어시스턴트입니다."},
            {"role": "user", "content": user_message}
        ],
        stream=True,  # 스트리밍 활성화
        temperature=0.7
    )
    
    for chunk in stream:
        if chunk.choices[0].delta.content:
            yield chunk.choices[0].delta.content


스트리밍 응답 수신 및 표시

print("AI 응답: ", end="", flush=True)
full_response = ""
for token in stream_chat("AI의 미래에 대해 이야기해 주세요"):
    print(token, end="", flush=True)
    full_response += token

print(f"\n\n총 응답 시간: {len(full_response)}자 생성")

Batch Processing

Batch Processing은 여러 요청을 묶어 한번에 처리하여 비용과 시간을 절약합니다:

# HolySheep AI 배치 처리 예시
import openai
import time

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)


배칭할 작업 목록

tasks = [
    "제품 A의 장점을 3가지 설명해 주세요",
    "제품 B의 배송 policies를 알려주세요",
    "제품 C와 D를 비교해 주세요",
    "할인 promo code 적용 방법을 설명해 주세요",
    "반품/환불 절차를 안내해 주세요"
]

def batch_process(tasks: list, model: str = "gemini-2.5-flash") -> list:
    """배치 처리로 여러 작업 동시 실행"""
    # HolySheep AI는 표준 API를 통해 배치 처리 지원
    results = []
    
    start_time = time.time()
    
    # 동시 요청 시뮬레이션 (실제 배치 API 사용 권장)
    for task in tasks:
        response = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": task}],
            max_tokens=300
        )
        results.append({
            "task": task,
            "response": response.choices[0].message.content,
            "tokens": response.usage.total_tokens
        })
    
    elapsed = time.time() - start_time
    
    print(f"배치 처리 완료: {len(tasks)}개 작업, {elapsed:.2f}초 소요")
    return results


배치 처리 실행

batch_results = batch_process(tasks)


결과 출력

for i, result in enumerate(batch_results, 1):
    print(f"\n[{i}] 질문: {result['task']}")
    print(f"    응답: {result['response'][:100]}...")

6. 모델별 특성과 선택 가이드

HolySheep AI는 다양한 AI 제공자의 모델을 단일 API 키로 통합 제공합니다. 각 모델의 특성을 이해하면 비용 대비 성능을 최적화할 수 있습니다:

모델 가격 ($/1M 토큰) 적합한 용도 평균 지연시간
DeepSeek V3 입력 $0.42 / 출력 $1.68 비용 최적화, 대량 처리 ~150ms
Gemini 2.5 Flash 입력 $2.50 / 출력 $10 빠른 응답, 실시간 채팅 ~80ms
Claude Sonnet 4 $15 / $15 고품질 분석, 장문 작성 ~200ms
GPT-4.1 $8 / $8 범용 최고 성능 ~250ms 
# 모델 선택 로직 구현
def select_model(use_case: str, priority: str = "balanced") -> str:
    """사용 사례에 따른 최적 모델 선택"""
    
    models = {
        "deepseek-chat": {"cost": 0.42, "speed": 0.8, "quality": 0.75},
        "gemini-2.5-flash": {"cost": 2.50, "speed": 0.95, "quality": 0.85},
        "claude-3-5-sonnet": {"cost": 15.0, "speed": 0.6, "quality": 0.92},
        "gpt-4.1": {"cost": 8.0, "speed": 0.5, "quality": 0.90}
    }
    
    if priority == "cost":
        # 비용 최적화
        return min(models.items(), key=lambda x: x[1]["cost"])[0]
    elif priority == "speed":
        # 속도 우선
        return max(models.items(), key=lambda x: x[1]["speed"])[0]
    elif priority == "quality":
        # 품질 우선
        return max(models.items(), key=lambda x: x[1]["quality"])[0]
    else:
        # 균형 (비용 대비 성능)
        scores = {}
        for name, stats in models.items():
            score = (stats["quality"] * 0.5 + stats["speed"] * 0.3) / (stats["cost"] / 15)
            scores[name] = score
        return max(scores.items(), key=lambda x: x[1])[0]


사용 사례별 모델 추천

use_cases = ["대량 데이터 처리", "실시간 고객 채팅", "고품질 보고서 작성", "범용 대화"]
for case in use_cases:
    if "비용" in case or "대량" in case:
        model = select_model(case, "cost")
    elif "실시간" in case or "채팅" in case:
        model = select_model(case, "speed")
    elif "품질" in case or "보고서" in case:
        model = select_model(case, "quality")
    else:
        model = select_model(case, "balanced")
    print(f"{case}: {model}")

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

오류 1: Context Length Exceeded (컨텍스트 길이 초과)

요청한 메시지의 토큰 수가 모델의 컨텍스트 윈도우를 초과할 때 발생합니다.

# ❌ 오류 발생 코드
response = client.chat.completions.create(
    model="deepseek-chat",  # 64K 토큰 제한
    messages=[
        {"role": "user", "content": very_long_text}  # 80K 토큰 입력 시 오류!
    ]
)


✅ 해결 방법 1: 긴 텍스트 자르기

def truncate_long_text(text: str, max_chars: int = 30000) -> str:
    """최대 문자 수로 텍스트 자르기"""
    if len(text) <= max_chars:
        return text
    return text[:max_chars]

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": truncate_long_text(very_long_text)}]
)


✅ 해결 방법 2: 더 큰 컨텍스트 모델 사용

response = client.chat.completions.create(
    model="claude-3-5-sonnet",  # 200K 토큰 컨텍스트
    messages=[{"role": "user", "content": very_long_text}]
)

오류 2: Rate Limit Exceeded (비율 제한 초과)

너무 많은 요청을 짧은 시간에 보내면 발생하는 오류입니다.

# ❌ 오류 발생: 동시 다량 요청
for item in many_items:
    response = client.chat.completions.create(...)  # Rate Limit 발생 가능


✅ 해결 방법 1: Retry 로직 구현

import time
from openai import RateLimitError

def call_with_retry(client, max_retries=3, delay=1.0):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="gemini-2.5-flash",
                messages=[{"role": "user", "content": "요청"}]
            )
        except RateLimitError:
            if attempt < max_retries - 1:
                wait_time = delay * (2 ** attempt)  # 지수 백오프
                print(f"Rate Limit 도달. {wait_time}초 후 재시도...")
                time.sleep(wait_time)
            else:
                raise Exception("최대 재시도 횟수 초과")


✅ 해결 방법 2: 요청 간 딜레이

import asyncio

async def async_call_with_delay(client, message, delay=0.5):
    await asyncio.sleep(delay)  # 요청 간 딜레이
    return client.chat.completions.create(
        model="gemini-2.5-flash",
        messages=[{"role": "user", "content": message}]
    )

오류 3: Invalid API Key (잘못된 API 키)

API 키가 없거나 잘못된 경우 인증 오류가 발생합니다.

# ❌ 오류 발생: 잘못된 base_url 또는 키
client = openai.OpenAI(
    api_key="invalid_key_here",
    base_url="https://api.openai.com/v1"  # 직접 호출 방지
)


✅ 해결 방법: HolySheep AI 올바른 설정

import os

def create_client():
    """HolySheep AI 클라이언트 생성 (환경 변수 사용 권장)"""
    api_key = os.environ.get("HOLYSHEEP_API_KEY")
    
    if not api_key:
        raise ValueError(
            "HOLYSHEEP_API_KEY 환경 변수가 설정되지 않았습니다.\n"
            "https://www.holysheep.ai/register 에서 API 키를 발급받으세요."
        )
    
    return openai.OpenAI(
        api_key=api_key,
        base_url="https://api.holysheep.ai/v1"
    )


환경 변수로 안전하게 관리


export HOLYSHEEP_API_KEY="YOUR_HOLYSHEEP_API_KEY"


client = create_client()
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "테스트"}]
)
print("API 연결 성공!")

오류 4: Response Truncation (응답 잘림)

생성된 텍스트가 max_tokens 한도로 인해 잘리는 현상입니다.

# ❌ 오류 발생: max_tokens 부족
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "5000자에 걸쳐 설명해 주세요"}],
    max_tokens=100  # 너무 작음!
)


✅ 해결 방법: 응답 길이에 따른 동적 max_tokens

def estimate_required_tokens(text: str, words_per_token: float = 0.75) -> int:
    """필요한 토큰 수 추정"""
    estimated_words = len(text.split())
    return int(estimated_words / words_per_token) + 100  # 여유분 추가

user_request = "AI의 역사와 미래 발전 가능성에 대해 상세히 설명해 주세요"
estimated = estimate_required_tokens(user_request)

response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": user_request}],
    max_tokens=estimated  # 동적 설정
)


사용량 확인

print(f"생성 토큰: {response.usage.completion_tokens}")
print(f"max_tokens 설정: {estimated}")
if response.choices[0].finish_reason == "length":
    print("⚠️ 응답이 잘렸을 수 있습니다. max_tokens를 늘려주세요.")

8. 실전 최적화 팁

제 경험상 AI API 비용을 70% 이상 절감하면서 품질을 유지한 방법들을 공유합니다:

# 실전 최적화 예시: 스마트 라우팅
import openai
import hashlib

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)

class SmartRouter:
    """작업 유형에 따른 최적 모델 라우팅"""
    
    def __init__(self):
        self.cache = {}  # 단순 캐시
        self.cache_hits = 0
        
    def route(self, query: str) -> str:
        """쿼리 분석하여 최적 모델 선택"""
        query_lower = query.lower()
        
        # 간단한 작업: 빠른 모델
        if any(kw in query_lower for kw in ["맞다/아니다", "예/아니오", "계산", "조회"]):
            return "deepseek-chat"
        
        # 코드 관련: 품질 우선
        if any(kw in query_lower for kw in ["코드", "함수", "프로그래밍", "debug"]):
            return "gpt-4.1"
        
        # 창의적 작업: 균형
        if any(kw in query_lower for kw in ["이야기", "시", "소설", "창작"]):
            return "claude-3-5-sonnet"
        
        # 기본: 속도와 비용 균형
        return "gemini-2.5-flash"
    
    def ask(self, query: str) -> dict:
        """캐시支持的 스마트 질의"""
        # 캐시 키 생성
        cache_key = hashlib.md5(f"{query}".encode()).hexdigest()
        
        if cache_key in self.cache:
            self.cache_hits += 1
            return {"response": self.cache[cache_key], "cached": True}
        
        # 모델 선택
        model = self.route(query)
        
        # API 호출
        response = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": query}]
        )
        
        result = response.choices[0].message.content
        self.cache[cache_key] = result
        
        return {
            "response": result,
            "model": model,
            "tokens": response.usage.total_tokens,
            "cached": False
        }


사용 예시

router = SmartRouter()
queries = ["배송비 알려줘", "피보나치 코드 작성해줘", "판타지 소설 써줘"]

for q in queries:
    result = router.ask(q)
    print(f"질문: {q}")
    print(f"  모델: {result['model']}, 캐시: {result['cached']}")
    print()

결론

관련 리소스

관련 문서