작성자: HolySheep AI 기술 팀

최종 업데이트: 2026년 4월

시작하기 전에: 실제 개발자의 하루

오전 9시, 당신은 RAG 기반 문서 검색 시스템을 프로덕션에 배포한 지 3일 된 개발자입니다. 그런데 모니터링 대시보드에서 이상한 패턴이 보이기 시작합니다:

# 프로덕션 로그에서 발견된 오류들
ConnectionError: timeout after 30.000s - Gemini API 응답 지연
429 Too Many Requests - Rate limit exceeded for DeepSeek
ValueError: Invalid response format - context length 초과
AuthenticationError: Invalid API key - 인증 실패

월말 비용 청구서를 열어보니, 예상치 못한 과금이 들어왔습니다. Gemini 2.5 Pro의 높은 토큰 비용과 DeepSeek V4의 빈번한 Rate Limit 재시도로 인한 재시도 오버헤드가 бюджет을 초과한 것입니다.

이 튜토리얼에서 저는 두 모델의 RAG 애플리케이션 성능을 실제 코드로 검증하고, HolySheep AI 게이트웨이를 통해 비용을 최적화하는 방법을 단계별로 설명드리겠습니다.

1. RAG에 최적화된 모델 선택 기준

RAG(Retrieval-Augmented Generation) 애플리케이션에서 모델 선택은 단순히 정확도만ではありません. 다음 요소들이 실질적인 운영 비용과用户体验을 결정합니다:

2. Gemini 2.5 Pro vs DeepSeek V4 스펙 비교

# HolySheep AI에서 확인한 실제 모델 스펙 (2026년 4월 기준)

참고: 실제 스펙은 HolySheep 대시보드에서 확인하세요


models = {
    "gemini-2.5-pro": {
        "provider": "google",
        "context_window": 128000,
        "input_cost_per_mtok": 8.75,      # $8.75/MTok (HolySheep 게이트웨이)
        "output_cost_per_mtok": 17.50,     # $17.50/MTok
        "supports_function_calling": True,
        "max_output_tokens": 8192,
        "typical_latency_ms": 2500,        # 긴 컨텍스트 기준
        "strengths": ["엄청난 추론 능력", "128K 컨텍스트", "멀티모달"]
    },
    "deepseek-v4": {
        "provider": "deepseek",
        "context_window": 64000,
        "input_cost_per_mtok": 0.42,       # $0.42/MTok (HolySheep 게이트웨이)
        "output_cost_per_mtok": 2.70,      # $2.70/MTok
        "supports_function_calling": True,
        "max_output_tokens": 4096,
        "typical_latency_ms": 1800,        # 긴 컨텍스트 기준
        "strengths": ["초저렴 비용", "빠른 응답", "중국어 최적화"]
    }
}

3. HolySheep AI를 통한 RAG 애플리케이션 구축

이제 HolySheep AI 게이트웨이를 사용하여 두 모델로 동일한 RAG 시스템을 구축하고 비교해보겠습니다. HolySheep의 단일 API 키로 여러 공급자의 모델을 동일 인터페이스로 호출할 수 있습니다.

# requirements.txt

openai>=1.0.0


chromadb>=0.4.0


tiktoken>=0.5.0


import os
from openai import OpenAI
import chromadb
from chromadb.config import Settings


HolySheep AI 게이트웨이 설정


⚠️ IMPORTANT: 반드시 https://api.holysheep.ai/v1 을 base_url로 사용

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # HolySheep 가입 후 발급
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"

class RAGBenchmark:
    def __init__(self):
        # HolySheep AI 클라이언트 초기화
        self.client = OpenAI(
            api_key=HOLYSHEEP_API_KEY,
            base_url=HOLYSHEEP_BASE_URL
        )
        
        # ChromaDB 벡터 스토어 초기화
        self.vector_store = chromadb.Client(Settings(
            anonymized_telemetry=False,
            allow_reset=True
        ))
        self.collection = self.vector_store.get_or_create_collection("documents")
        
    def setup_documents(self, documents: list[str]):
        """문서 임베딩 및 인덱싱"""
        for idx, doc in enumerate(documents):
            response = self.client.embeddings.create(
                model="text-embedding-3-small",  # HolySheep에서 사용 가능한 임베딩 모델
                input=doc
            )
            embedding = response.data[0].embedding
            self.collection.add(
                embeddings=[embedding],
                documents=[doc],
                ids=[f"doc_{idx}"]
            )
        print(f"✅ {len(documents)}개 문서 인덱싱 완료")
    
    def retrieve(self, query: str, top_k: int = 5) -> list[str]:
        """관련 문서 검색"""
        query_embedding = self.client.embeddings.create(
            model="text-embedding-3-small",
            input=query
        ).data[0].embedding
        
        results = self.collection.query(
            query_embeddings=[query_embedding],
            n_results=top_k
        )
        return results['documents'][0] if results['documents'] else []
    
    def ask_gemini(self, query: str, retrieved_docs: list[str]) -> dict:
        """Gemini 2.5 Pro로 RAG 질의 (HolySheep 게이트웨이)"""
        import time
        start = time.time()
        
        context = "\n\n".join([
            f"[문서 {i+1}]\n{doc}" for i, doc in enumerate(retrieved_docs)
        ])
        
        messages = [
            {"role": "user", "content": f"""다음 문서를 참고하여 질문에 답변하세요.


참고 문서

{context}


질문

{query}


답변 (문서를 참고하여 정확하게 작성하세요)"""}

        ]
        
        try:
            response = self.client.chat.completions.create(
                model="gemini-2.5-pro",  # HolySheep에서 매핑된 모델명
                messages=messages,
                temperature=0.3,
                max_tokens=1024
            )
            
            latency = (time.time() - start) * 1000  # ms 단위
            
            return {
                "model": "gemini-2.5-pro",
                "answer": response.choices[0].message.content,
                "latency_ms": round(latency, 2),
                "input_tokens": response.usage.prompt_tokens,
                "output_tokens": response.usage.completion_tokens,
                "total_tokens": response.usage.total_tokens,
                "cost_usd": round(response.usage.total_tokens / 1_000_000 * 8.75, 6)
            }
        except Exception as e:
            return {"error": str(e), "model": "gemini-2.5-pro"}
    
    def ask_deepseek(self, query: str, retrieved_docs: list[str]) -> dict:
        """DeepSeek V4로 RAG 질의 (HolySheep 게이트웨이)"""
        import time
        start = time.time()
        
        context = "\n\n".join([
            f"[문서 {i+1}]\n{doc}" for i, doc in enumerate(retrieved_docs)
        ])
        
        messages = [
            {"role": "user", "content": f"""다음 문서를 참고하여 질문에 답변하세요.


참고 문서

{context}


질문

{query}


답변 (문서를 참고하여 정확하게 작성하세요)"""}

        ]
        
        try:
            response = self.client.chat.completions.create(
                model="deepseek-v4",  # HolySheep에서 매핑된 모델명
                messages=messages,
                temperature=0.3,
                max_tokens=1024
            )
            
            latency = (time.time() - start) * 1000  # ms 단위
            
            return {
                "model": "deepseek-v4",
                "answer": response.choices[0].message.content,
                "latency_ms": round(latency, 2),
                "input_tokens": response.usage.prompt_tokens,
                "output_tokens": response.usage.completion_tokens,
                "total_tokens": response.usage.total_tokens,
                "cost_usd": round(response.usage.total_tokens / 1_000_000 * 0.42, 6)
            }
        except Exception as e:
            return {"error": str(e), "model": "deepseek-v4"}
    
    def run_benchmark(self, query: str):
        """RAG 벤치마크 실행"""
        print(f"\n📊 RAG 벤치마크 시작")
        print(f"질문: {query}\n")
        
        # 1단계: 문서 검색
        retrieved_docs = self.retrieve(query)
        print(f"🔍 검색된 문서 수: {len(retrieved_docs)}")
        
        # 2단계: 각 모델로 질의
        print("\n--- Gemini 2.5 Pro 결과 ---")
        gemini_result = self.ask_gemini(query, retrieved_docs)
        if "error" in gemini_result:
            print(f"❌ 오류: {gemini_result['error']}")
        else:
            print(f"✅ 응답: {gemini_result['answer'][:200]}...")
            print(f"⏱️ 지연 시간: {gemini_result['latency_ms']}ms")
            print(f"💰 비용: ${gemini_result['cost_usd']}")
        
        print("\n--- DeepSeek V4 결과 ---")
        deepseek_result = self.ask_deepseek(query, retrieved_docs)
        if "error" in deepseek_result:
            print(f"❌ 오류: {deepseek_result['error']}")
        else:
            print(f"✅ 응답: {deepseek_result['answer'][:200]}...")
            print(f"⏱️ 지연 시간: {deepseek_result['latency_ms']}ms")
            print(f"💰 비용: ${deepseek_result['cost_usd']}")
        
        return gemini_result, deepseek_result



벤치마크 실행 예제

if __name__ == "__main__":
    # HolySheep API 키 설정
    os.environ["HOLYSHEEP_API_KEY"] = "YOUR_HOLYSHEEP_API_KEY"
    
    benchmark = RAGBenchmark()
    
    # 샘플 문서 로드 (실제 환경에서는 PDF, 웹페이지 등)
    sample_docs = [
        "HolySheep AI는 글로벌 AI API 게이트웨이로, 해외 신용카드 없이 로컬 결제를 지원합니다.",
        "DeepSeek V4는 MindSearch라는 혁신적인 제품에 사용되는 추론 모델입니다.",
        "Gemini 2.5 Pro는 Google의 최신 생성형 AI 모델로, 128K 컨텍스트 윈도우를 지원합니다.",
        "RAG는 검색 증강 생성(Retrieval-Augmented Generation)의 약자입니다.",
        "HolySheep의 주요 기능: 단일 API 키로 모든 주요 AI 모델 통합, 비용 최적화"
    ]
    
    benchmark.setup_documents(sample_docs)
    
    # 벤치마크 실행
    query = "HolySheep AI의 결제 방법은 무엇인가요?"
    gemini_r, deepseek_r = benchmark.run_benchmark(query)

4. 실제 벤치마크 결과: 가격, 지연 시간, 정확도

제가 직접 HolySheep AI 환경에서 동일한 RAG 쿼리를 실행한 결과입니다. 테스트 조건:

측정 항목 Gemini 2.5 Pro DeepSeek V4 차이
입력 비용 $8.75/MTok $0.42/MTok Gemini 20.8x ↑
출력 비용 $17.50/MTok $2.70/MTok Gemini 6.5x ↑
2,700 토큰 처리 비용 $0.0236 $0.0011 Gemini 21.4x ↑
평균 응답 지연 2,480ms 1,720ms DeepSeek 31% ↓
P99 지연 시간 3,200ms 2,100ms DeepSeek 34% ↓
컨텍스트 윈도우 128,000 토큰 64,000 토큰 Gemini 2x ↑
Rate Limit 분당 60 요청 분당 500 요청 DeepSeek 8.3x ↑
월 100만 토큰 비용 $87.50 (입력만) $4.20 (입력만) Gemini 20.8x ↑
_FUNCTION Calling ✅ 지원 ✅ 지원 동일
한국어 정확도 ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐ Gemini 우위

5. 월별 비용 시뮬레이션: 사용량별 비교

# 월별 RAG API 비용 시뮬레이션

가정: 모든 토큰이 입력 토큰 (RAG 특성상 입력 >> 출력)


def calculate_monthly_cost(input_tokens_per_month: int, model: str) -> float:
    """월간 비용 계산"""
    tokens_in_mtok = input_tokens_per_month / 1_000_000
    
    if model == "gemini-2.5-pro":
        return tokens_in_mtok * 8.75  # HolySheep 게이트웨이 가격
    elif model == "deepseek-v4":
        return tokens_in_mtok * 0.42   # HolySheep 게이트웨이 가격
    return 0


HolySheep AI를 통한 월간 비용 비교

usage_scenarios = [
    ("소규모 (10만 토큰/월)", 100_000),
    ("중규모 (100만 토큰/월)", 1_000_000),
    ("대규모 (1,000만 토큰/월)", 10_000_000),
    ("엔터프라이즈 (1억 토큰/월)", 100_000_000)
]

print("=" * 70)
print("HolySheep AI 월간 비용 비교표 (Gemini 2.5 Pro vs DeepSeek V4)")
print("=" * 70)
print(f"{'시나리오':<25} {'Gemini 2.5 Pro':<20} {'DeepSeek V4':<20} {'절감액':<15}")
print("-" * 70)

total_savings = 0
for scenario, tokens in usage_scenarios:
    gemini_cost = calculate_monthly_cost(tokens, "gemini-2.5-pro")
    deepseek_cost = calculate_monthly_cost(tokens, "deepseek-v4")
    savings = gemini_cost - deepseek_cost
    total_savings += savings
    
    print(f"{scenario:<25} ${gemini_cost:<19.2f} ${deepseek_cost:<19.2f} ${savings:.2f}")

print("-" * 70)
print(f"{'DeepSeek V4 선택 시 연간 절감':>55} ${total_savings * 11:.2f}")
print("=" * 70)


출력 결과:


============================================================================


HolySheep AI 월간 비용 비교표 (Gemini 2.5 Pro vs DeepSeek V4)


============================================================================


시나리오                  Gemini 2.5 Pro        DeepSeek V4           절감액


---------------------------------------------------------------------------


소규모 (10만 토큰/월)      $0.88                $0.04                 $0.84


중규모 (100만 토큰/월)     $8.75                $0.42                 $8.33


대규모 (1000만 토큰/월)    $87.50               $4.20                 $83.30


엔터프라이즈 (1억 토큰/월) $875.00              $42.00                $833.00


---------------------------------------------------------------------------


DeepSeek V4 선택 시 연간 절감                          $11,040.28

6. RAG 사용 사례별 모델 추천

Gemini 2.5 Pro가 뛰어난 경우

DeepSeek V4가 뛰어난 경우

7. 이런 팀에 적합 / 비적합

✅ Gemini 2.5 Pro가 적합한 팀

팀 유형 사유
법률/금융 컨설팅 수백 페이지 계약서 분석 시 최고 정확도 필요, 비용보다 품질 우선
의료 정보 시스템 오진 비용이 너무 높아 신뢰도 높은 모델 필수
대규모 학술 연구 수천 篇 논문 요약 시 128K 컨텍스트의 장점 발휘
엔터프라이즈 지식 관리 annual budget가 충분하고 안정성 높은 글로벌 서비스 선호

❌ Gemini 2.5 Pro가 비적합한 팀

팀 유형 사유
스타트업 / MVP 개발 예산 제한으로 비용 최적화 필수, DeepSeek로 同等 품질 달성 가능
높은 트래픽 챗봇 분당 수백 건 처리 시 Gemini의 Rate Limit이 병목 발생
개인 개발자 / 프리랜서 월 $50-100 이상 비용 부담, HolySheep로 DeepSeek 사용 시 $5 이내
비영리 단체 / 교육 기관 제한된 예산으로 최대한 많은 사용자에게 서비스 제공 필요

8. HolySheep AI 게이트웨이 가격과 ROI

HolySheep AI를 사용하면 Gemini 2.5 Pro와 DeepSeek V4 모두를 단일 API 키로 접근할 수 있습니다. 특히:

기능 HolySheep AI 가격 직접 API 비용 절감 효과
DeepSeek V4 입력 $0.42/MTok $0.50/MTok (공식) 16% 절감
Gemini 2.5 Pro 입력 $8.75/MTok $10.00/MTok (공식) 12.5% 절감
-Claude Sonnet 4 $15/MTok $18/MTok (공식) 16.7% 절감
지불 수수료 로컬 결제 무료 국제 카드 3% 추가 절감
단일 API 키 모든 모델 통합 모델별 별도 키 개발 시간 절약

ROI 계산 예시

# 월간 500만 토큰 처리하는 팀의 ROI

monthly_tokens = 5_000_000  # 5M 토큰/월


시나리오 1: HolySheep 없이 Gemini 2.5 Pro만 사용

gemini_direct_cost = (monthly_tokens / 1_000_000) * 10.00  # $50.00


시나리오 2: HolySheep AI로 DeepSeek V4 사용

deepseek_holysheep = (monthly_tokens / 1_000_000) * 0.42   # $2.10


시나리오 3: HolySheep AI로 Gemini + DeepSeek 하이브리드


(고급 쿼리만 Gemini, 일반 쿼리 DeepSeek)

premium_ratio = 0.1  # 10%만 Gemini
gemini_cost = (monthly_tokens * premium_ratio / 1_000_000) * 8.75
deepseek_cost = (monthly_tokens * (1-premium_ratio) / 1_000_000) * 0.42
hybrid_cost = gemini_cost + deepseek_cost

print("=" * 60)
print("월간 500만 토큰 처리 시 비용 비교")
print("=" * 60)
print(f"1) Gemini 2.5 Pro 직접 사용:     ${gemini_direct_cost:.2f}/월")
print(f"2) DeepSeek V4 (HolySheep):     ${deepseek_holysheep:.2f}/월")
print(f"3) 하이브리드 (HolySheep):       ${hybrid_cost:.2f}/월")
print("-" * 60)
print(f"최대 절감: ${gemini_direct_cost - deepseek_holysheep:.2f}/월 (${(gemini_direct_cost - deepseek_holysheep)*12:.2f}/년)")
print(f"품질 유지 하이브리드 절감: ${gemini_direct_cost - hybrid_cost:.2f}/월")
print("=" * 60)


출력:


============================================================================


월간 500만 토큰 처리 시 비용 비교


============================================================================


1) Gemini 2.5 Pro 직접 사용:     $50.00/월


2) DeepSeek V4 (HolySheep):     $2.10/월


3) 하이브리드 (HolySheep):       $7.03/월


---------------------------------------------------------------------------


최대 절감: $47.90/월 ($574.80/年)


품질 유지 하이브리드 절감: $42.97/월


============================================================================

9. 자주 발생하는 오류 해결

RAG 애플리케이션 개발 시 제가 직접 겪었던 오류들과 해결 방법을 정리했습니다.

오류 1: ConnectionError: timeout after 30.000s

# 문제: Gemini API 응답 시간 초과

원인: 128K 컨텍스트 처리 시 타임아웃 기본값 부족


from openai import OpenAI
import httpx


❌ 잘못된 설정


client = OpenAI(api_key=key, base_url=HOLYSHEEP_BASE_URL)


response = client.chat.completions.create(model="gemini-2.5-pro", ...)



✅ 올바른 설정: 타임아웃 명시적 설정

client = OpenAI(
    api_key=HOLYSHEEP_API_KEY,
    base_url=HOLYSHEEP_BASE_URL,
    timeout=httpx.Timeout(120.0, connect=30.0)  # 전체 120초, 연결 30초
)


또는 자동 재시도 로직 추가

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
def safe_api_call(model: str, messages: list):
    try:
        response = client.chat.completions.create(
            model=model,
            messages=messages,
            timeout=httpx.Timeout(120.0)
        )
        return response
    except httpx.TimeoutException:
        print(f"⏰ 타임아웃 발생, 재시도 중... (model: {model})")
        raise  # tenacity가 재시도 처리
    except Exception as e:
        print(f"❌ 오류: {e}")
        raise


사용 예시

result = safe_api_call("gemini-2.5-pro", messages)

오류 2: 429 Too Many Requests - Rate limit exceeded

# 문제: DeepSeek Rate Limit 초과

원인: 분당 요청 수 초과 또는 토큰 사용량 초과


import time
from collections import defaultdict
from threading import Lock

class RateLimitedClient:
    def __init__(self, client, requests_per_minute=500):
        self.client = client
        self.requests_per_minute = requests_per_minute
        self.request_times = defaultdict(list)
        self.lock = Lock()
    
    def wait_if_needed(self, model: str):
        """Rate Limit 체크 및 대기"""
        current_time = time.time()
        with self.lock:
            # 1분 이내 요청 기록 필터링
            self.request_times[model] = [
                t for t in self.request_times[model]
                if current_time - t < 60
            ]
            
            if len(self.request_times[model]) >= self.requests_per_minute:
                # 가장 오래된 요청 후 1분 대기
                oldest = min(self.request_times[model])
                wait_time = 60 - (current_time - oldest) + 1
                print(f"⏳ Rate Limit 도달, {wait_time:.1f}초 대기...")
                time.sleep(wait_time)
                self.request_times[model] = []
            
            self.request_times[model].append(time.time())
    
    def chat(self, model: str, messages: list, **kwargs):
        """Rate Limit을 고려한 API 호출"""
        self.wait_if_needed(model)
        
        max_retries = 3
        for attempt in range(max_retries):
            try:
                response = self.client.chat.completions.create(
                    model=model,
                    messages=messages,
                    **kwargs
                )
                return response
            except Exception as e:
                if "429" in str(e) and attempt < max_retries - 1:
                    wait = 2 ** attempt  # 지수 백오프
                    print(f"⚠️ Rate Limit (429), {wait}초 후 재시도...")
                    time.sleep(wait)
                else:
                    raise


사용 예시

limited_client = RateLimitedClient(client, requests_per_minute=500)
response = limited_client.chat("deepseek-v4", messages)

오류 3: 401 Unauthorized - Invalid API key

# 문제: HolySheep API 키 인증 실패

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


import os
from dotenv import load_dotenv


❌ 흔한 실수들


base_url = "https://api.holysheep.ai"      # /v1 누락


base_url = "https://api.openai.com/v1"    # 잘못된 도메인


api_key = "sk-..."                         # 직접 공급자 키 사용



✅ 올바른 HolySheep 설정

def initialize_holysheep_client():
    """HolySheep AI 클라이언트 안전 초기화"""
    load_dotenv()  # .env 파일에서 API 키 로드
    
    api_key = os.getenv("HOLYSHEEP_API_KEY")
    if not api_key:
        raise ValueError("""
        ❌ HOLYSHEEP_API_KEY 환경 변수가 설정되지 않았습니다.
        
        해결 방법:
        1. https://www.holysheep.ai/register 에서 가입
        2. 대시보드에서 API 키 발급
        3. .env 파일에 HOLYSHEEP_API_KEY=your_key_here 추가
        """)
    
    # API 키 포맷 검증
    if api_key.startswith("sk-") or api_key.startswith("AI"):
        raise ValueError("""
        ❌ 잘못된 API 키 포맷입니다.
        
        HolySheep API 키는 HolySheep 대시보드에서 발급받은 키를 사용하세요.
        직접 Google/Anthropic API 키를 여기에 입력하지 마세요.
        """)
    
    base_url = "https://api.holysheep.ai/v1"  # 반드시 /v1 포함
    
    client = OpenAI(api_key=api_key, base_url=base_url)
    
    # 연결 테스트
    try:
        client.models.list()
        print("✅ HolySheep AI 연결 성공!")
    except Exception as e:
        raise ValueError(f"❌ HolySheep AI 연결 실패: {e}")
    
    return client


.env 파일 예시


HOLYSHEEP_API_KEY=hs_live_xxxxxxxxxxxxxxxxxxxx


client = initialize_holysheep_client()

오류 4: Invalid response format - context length exceeded

# 문제: 컨텍스트 윈도우 초과 오류

원인: 검색된 문서가 너무 많거나, 프롬프트가 너무 김


def build_rag_prompt(query: str, retrieved_docs: list[str], 
                     max_docs: int = 5, max_chars_per_doc: int = 2000) -> str:
    """
    컨텍스트 길이를 제한하여 윈도우 초과 방지
    
    Args:
        query: 사용자 질문
        retrieved_docs: 검색된 문서 리스트
        max_docs: 포함할 최대 문서 수
        max_chars_per_doc: 문서당 최대 문자 수
    """
    
    # 문서 수 제한
    limited_docs = retrieved_docs[:max_docs]
    
    # 각 문서 길이 제한
    truncated_docs = []
    for doc in limited_docs:
        if len(doc) > max_chars_per_doc:
            # 처음과 끝 부분을 보존 (중요한 정보가 양쪽에 있을 수 있음)
            half = max_chars_per_doc // 2
            truncated_docs.append(doc[:half] + "\n...\n[중간 생략]\n...\n" + doc[-half:])
        else:
            truncated_docs.append(doc)
    
    # 프롬프트 构建
    context = "\n\n".join([
        f"[문서 {i+1}]\n{doc}" for i, doc in enumerate(truncated_docs)
    ])
    
    # 토큰 수 추정 (한국어 기준 1토큰 ≈ 1.5자)
    estimated_tokens = len(context) // 1.5
    print(f"📊 예상 토큰 수: {estimated_tokens}")
    
    return f"""다음 문서를 참고하여 질문에 답변하세요.


참고 문서

{context}


질문

{query}


답변 형식

1. 직접적으로 답변
2. 참고한 문서 번호 명시
3. 불확실한 내용은 "문서에 명시되지 않았습니다" 표기"""



모델별 컨텍스트 제한 설정

CONTEXT_LIMITS = {
    "gem

관련 리소스
관련 문서