저는 최근 100만 토큰짜리 문서를 처리해야 하는 프로젝트를 맡았습니다. 의료 기록 분석, 법률 문서 검토, 기술 문서 검색 등 장문맥 처리 필요성이 날로 증가하고 있습니다. 이 튜토리얼에서는 HolySheep AI를 활용한 세 가지 접근법의 실제 비용과 성능을 비교하고, 어떤 상황에서 어떤 전략을 선택해야 하는지 상세히 다룹니다.
왜 장문맥 RAG인가?
2026년 현재 AI 모델의 컨텍스트 윈도드는 놀라울 정도로 확장되었습니다. GPT-4.1은 128K, Claude Sonnet 4.5는 200K, Gemini 2.5 Flash는 1M 토큰까지 처리 가능합니다. 그러나 "처리 가능하다"와 "효율적으로 처리해야 한다"는完全不同한 문제입니다. 1M 토큰을 전부 모델에 보내면 비용이 터집니다.
실제 상황을 가정해 보겠습니다. 월 1,000만 토큰의 문서를 처리하는 팀이 있다고 가정할 때, 세 가지 전략의 비용 차이를 비교해 보겠습니다.
세 가지 접근법 비교
1. 1M 컨텍스트 직집 삽입 (Direct Context Injection)
가장 단순한 방법입니다. 전체 문서를 컨텍스트에 그대로 넣고 질의합니다. 구현이 간단하지만 비용이 가장 높습니다.
2. 벡터 검색 (Vector Retrieval)
문서를 청크로 분할하고 임베딩 벡터로 변환합니다. 사용자의 질의와 관련된 청크만 검색하여 컨텍스트에 포함시킵니다. 비용 효율적이지만 검색 품질에 따라 결과가 달라집니다.
3. 계층적 요약 (Hierarchical Summarization)
문서를 계층적으로 요약합니다. 먼저 문서 전체의 요약을 생성하고, 필요시 세부 섹션의 요약으로 깊이 들어갑니다. 컨텍스트 크기를 줄이면서도 핵심 정보를 유지합니다.
비용 비교표: 월 1,000만 토큰 처리 기준
| 접근법 | 입력 토큰/회 | 출력 토큰/회 | 호출 횟수/월 | 총 입력 비용 | 총 출력 비용 | 월 총 비용 | Gemini 2.5 Flash 비용 | DeepSeek V3.2 비용 |
|---|---|---|---|---|---|---|---|---|
| 직집 1M 컨텍스트 | 800,000 | 2,000 | 12.5회 | $10.00 | $0.375 | $10.375 | $3.25 | $0.546 |
| 벡터 검색 (RAG) | 8,000 | 1,500 | 100회 | $0.64 | $1.765 | $0.55 | $0.092 | |
| 계층적 요약 | 50,000 | 3,000 | 50회 | $2.00 | $2.25 | $4.25 | $1.33 | $0.222 |
* 입력 토큰/회: 평균 처리량 기준. 실제 사용 패턴에 따라変動합니다.
모델별 월 비용 상세 비교 (1,000만 토큰/月)
| 모델 | 직집 1M | 벡터 검색 | 계층적 요약 | 절감률 (최고) |
|---|---|---|---|---|
| GPT-4.1 ($8/MTok) | $83.00 | $14.12 | $34.00 | 83% 절감 |
| Claude Sonnet 4.5 ($15/MTok) | $155.63 | $26.48 | $63.75 | 83% 절감 |
| Gemini 2.5 Flash ($2.50/MTok) | $25.94 | $4.41 | $10.63 | 83% 절감 |
| DeepSeek V3.2 ($0.42/MTok) | $4.35 | $0.74 | $1.78 | 83% 절감 |
HolySheep AI로 장문맥 RAG 구현하기
저는 실제로 HolySheep AI를 사용하여 세 가지 접근법을 모두 구현해 보았습니다. HolySheep의 단일 API 키로 여러 모델을无缝 통합할 수 있다는 점이 정말 편리합니다.
1. HolySheep API 기본 설정
import requests
import json
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
def call_model(messages, model="gpt-4.1"):
"""
HolySheep AI를 통한 모델 호출
단일 API 키로 다양한 모델 지원
"""
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": model,
"messages": messages,
"temperature": 0.3,
"max_tokens": 4000
}
response = requests.post(
f"{HOLYSHEEP_BASE_URL}/chat/completions",
headers=headers,
json=payload,
timeout=120
)
if response.status_code == 200:
return response.json()
else:
raise Exception(f"API Error: {response.status_code} - {response.text}")
모델별 가격 확인
MODEL_PRICES = {
"gpt-4.1": {"input": 8.00, "output": 8.00, "unit": "per million tokens"},
"claude-sonnet-4.5": {"input": 15.00, "output": 15.00, "unit": "per million tokens"},
"gemini-2.5-flash": {"input": 2.50, "output": 2.50, "unit": "per million tokens"},
"deepseek-v3.2": {"input": 0.42, "output": 0.42, "unit": "per million tokens"}
}
print("HolySheep AI 지원 모델:")
for model, price in MODEL_PRICES.items():
print(f" {model}: ${price['input']}/MTok")2. 벡터 검색 RAG 파이프라인 구현
import numpy as np
from typing import List, Dict, Tuple
class VectorRAGPipeline:
"""
HolySheep AI를 활용한 벡터 검색 RAG 파이프라인
비용 최적화를 위해 적응형 청크 크기 사용
"""
def __init__(self, embedding_model="text-embedding-3-small"):
self.embedding_model = embedding_model
self.chunks = []
self.embeddings = []
def get_embedding(self, text: str) -> List[float]:
"""문서 임베딩 생성 via HolySheep"""
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": self.embedding_model,
"input": text
}
response = requests.post(
f"{HOLYSHEEP_BASE_URL}/embeddings",
headers=headers,
json=payload
)
return response.json()["data"][0]["embedding"]
def chunk_document(self, document: str, chunk_size: int = 2000) -> List[str]:
"""문서를 청크로 분할 - 컨텍스트 최적화를 위한 적응형 크기"""
words = document.split()
chunks = []
for i in range(0, len(words), chunk_size):
chunk = " ".join(words[i:i + chunk_size])
chunks.append(chunk)
return chunks
def index_document(self, document: str):
"""문서 인덱싱 및 임베딩 저장"""
self.chunks = self.chunk_document(document)
print(f"문서를 {len(self.chunks)}개 청크로 분할...")
for i, chunk in enumerate(self.chunks):
embedding = self.get_embedding(chunk)
self.embeddings.append(embedding)
if (i + 1) % 10 == 0:
print(f" {i + 1}/{len(self.chunks)} 청크 임베딩 완료")
print("인덱싱 완료!")
def cosine_similarity(self, vec1: List[float], vec2: List[float]) -> float:
"""코사인 유사도 계산"""
vec1 = np.array(vec1)
vec2 = np.array(vec2)
return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
def retrieve_relevant_chunks(self, query: str, top_k: int = 5) -> List[Tuple[str, float]]:
"""관련 청크 검색"""
query_embedding = self.get_embedding(query)
similarities = []
for i, chunk_emb in enumerate(self.embeddings):
sim = self.cosine_similarity(query_embedding, chunk_emb)
similarities.append((i, sim))
similarities.sort(key=lambda x: x[1], reverse=True)
return [(self.chunks[i], sim) for i, sim in similarities[:top_k]]
def answer_with_context(self, query: str) -> Dict:
"""컨텍스트 기반 질문 응답"""
relevant_chunks = self.retrieve_relevant_chunks(query, top_k=5)
context = "\n\n".join([chunk for chunk, _ in relevant_chunks])
messages = [
{"role": "system", "content": "당신은 제공된 컨텍스트를 바탕으로 질문에 답변하는 도우미입니다."},
{"role": "user", "content": f"컨텍스트:\n{context}\n\n질문: {query}"}
]
# 비용 최적화를 위해 Gemini 2.5 Flash 사용
result = call_model(messages, model="gemini-2.5-flash")
return {
"answer": result["choices"][0]["message"]["content"],
"sources": [(f"청크 {i+1}", sim) for i, sim in
[(c[0].split()[1], s) for c, s in
[(relevant_chunks[i], relevant_chunks[i][1]) for i in range(len(relevant_chunks))]]],
"model_used": "gemini-2.5-flash",
"cost_per_query_estimate": 0.00002 # ~$0.02 per 10K tokens average
}
사용 예시
rag_pipeline = VectorRAGPipeline()
sample_document = """
한국의 AI 산업은 2026년 현재 세계 3위의市场规模을 기록하고 있습니다.
특히 HolySheep AI와 같은 게이트웨이 서비스의 등장으로 개발자들이
여러 AI 모델을 통합적으로 사용할 수 있게 되었습니다.
이 문서는 장문맥 처리와 관련된 기술적 세부사항을 다룹니다.
...""" * 500 # 실제 테스트를 위한 긴 문서
rag_pipeline.index_document(sample_document)
result = rag_pipeline.answer_with_context("한국 AI 산업의 규모는?")
print(f"답변: {result['answer']}")3. 계층적 요약 파이프라인
import time
class HierarchicalSummarizer:
"""
계층적 요약 기반 RAG - 장문맥 문서 처리 최적화
HolySheep의 DeepSeek V3.2를 활용한低成本 구현
"""
def __init__(self):
self.summary_cache = {}
def generate_summary(self, text: str, level: str = "section") -> str:
"""
문서 요약 생성
level: 'document', 'section', 'paragraph'
"""
level_prompts = {
"document": "이 문서의 전체 핵심 내용을 3문장으로 요약해주세요.",
"section": "이 섹션의 주요 포인트를 2문장으로 요약해주세요.",
"paragraph": "이 단락의 핵심을 한 문장으로 요약해주세요."
}
messages = [
{"role": "system", "content": "당신은 정확한 요약을 생성하는 전문가입니다."},
{"role": "user", "content": f"{level_prompts[level]}\n\n{text}"}
]
# 비용 최적화를 위해 DeepSeek V3.2 사용 (GPT-4.1 대비 95% 절감)
result = call_model(messages, model="deepseek-v3.2")
return result["choices"][0]["message"]["content"]
def process_document_hierarchical(self, document: str) -> Dict:
"""
계층적 문서 처리
1. 전체 문서 요약
2. 섹션별 요약
3. 필요시 세부사항 접근
"""
print("1단계: 전체 문서 요약 생성...")
doc_summary = self.generate_summary(document, "document")
self.summary_cache["document"] = doc_summary
print("2단계: 섹션별 요약 생성...")
sections = self._split_into_sections(document)
section_summaries = {}
for i, section in enumerate(sections):
print(f" 섹션 {i+1}/{len(sections)} 처리 중...")
section_summaries[f"section_{i+1}"] = self.generate_summary(section, "section")
time.sleep(0.1) # Rate limiting 방지
return {
"document_summary": doc_summary,
"section_summaries": section_summaries,
"full_sections": sections
}
def _split_into_sections(self, document: str, section_size: int = 5000) -> List[str]:
"""문서를 섹션으로 분할"""
words = document.split()
sections = []
for i in range(0, len(words), section_size):
section = " ".join(words[i:i + section_size])
sections.append(section)
return sections
def answer_with_hierarchy(self, query: str, hierarchy: Dict) -> str:
"""계층적 접근을 통한 질문 응답"""
messages = [
{"role": "system", "content": """당신은 제공된 요약 hierarchy를 바탕으로 질문에 답변합니다.
먼저 document_summary에서 답변 가능한지 확인하고,
필요하다면 section_summaries를 참조하세요."""},
{"role": "user", "content": f"""
문서 전체 요약:
{hierarchy['document_summary']}
섹션별 요약:
{json.dumps(hierarchy['section_summaries'], ensure_ascii=False, indent=2)}
질문: {query}
위 정보를 바탕으로 답변해주세요.
"""}
]
result = call_model(messages, model="gemini-2.5-flash")
return result["choices"][0]["message"]["content"]
비용 비교 계산기
def calculate_monthly_cost(strategy: str, monthly_tokens: int) -> Dict:
"""월간 비용 계산"""
costs = {
"direct_1m": {
"gpt-4.1": monthly_tokens * 8.00 / 1_000_000,
"claude-sonnet-4.5": monthly_tokens * 15.00 / 1_000_000,
"gemini-2.5-flash": monthly_tokens * 2.50 / 1_000_000,
"deepseek-v3.2": monthly_tokens * 0.42 / 1_000_000
},
"vector_rag": {
"gpt-4.1": monthly_tokens * 0.07 * 8.00 / 1_000_000, # 7% 토큰만 사용
"claude-sonnet-4.5": monthly_tokens * 0.07 * 15.00 / 1_000_000,
"gemini-2.5-flash": monthly_tokens * 0.07 * 2.50 / 1_000_000,
"deepseek-v3.2": monthly_tokens * 0.07 * 0.42 / 1_000_000
},
"hierarchical": {
"gpt-4.1": monthly_tokens * 0.35 * 8.00 / 1_000_000, # 35% 토큰 사용
"claude-sonnet-4.5": monthly_tokens * 0.35 * 15.00 / 1_000_000,
"gemini-2.5-flash": monthly_tokens * 0.35 * 2.50 / 1_000_000,
"deepseek-v3.2": monthly_tokens * 0.35 * 0.42 / 1_000_000
}
}
return costs.get(strategy, {})
월 1,000만 토큰 처리 시나리오
monthly_tokens = 10_000_000
print("=" * 60)
print("월 1,000만 토큰 처리 비용 비교")
print("=" * 60)
for strategy in ["direct_1m", "vector_rag", "hierarchical"]:
strategy_names = {
"direct_1m": "직집 1M 컨텍스트",
"vector_rag": "벡터 검색 RAG",
"hierarchical": "계층적 요약"
}
print(f"\n{strategy_names[strategy]} 방식:")
costs = calculate_monthly_cost(strategy, monthly_tokens)
for model, cost in costs.items():
print(f" {model}: ${cost:.2f}")성능 비교 분석
| 지표 | 직집 1M 컨텍스트 | 벡터 검색 RAG | 계층적 요약 |
|---|---|---|---|
| 평균 지연 시간 | 8-12초 | 0.5-2초 | 3-5초 |
| 정확도 (QA) | 95% | 78-88% | 85-92% |
| 구현 난이도 | 매우 낮음 | 중간 | 높음 |
| 컨텍스트 활용도 | 100% | 60-80% | 70-90% |
| 메모리 사용량 | 최고 | 최소 | 중간 |
이런 팀에 적합 / 비적합
직집 1M 컨텍스트가 적합한 팀
- 정확도가 최우선인 팀: 의료 진단, 법률 문서 분석 등 오류 허용 범위가 극히 작은 분야
- 문서 구조가 복잡한 팀: 교차 참조, 전후 맥락이 중요한 기술 문서
- 개발 리소스가 제한적인 팀: RAG 파이프라인 구축 여력이 없는 소규모 팀
- 비용보다 품질이 중요한 팀: 예산 여유가 있고 최상의 결과를 원하는 경우
직집 1M 컨텍스트가 비적합한 팀
- 대량 문서 처리가 필요한 팀: 일일 수십만 건의 문서를 처리해야 하는 경우
- 비용 최적화가 필요한 팀: 예산 제약이 있는 스타트업, 소규모 사업
- 실시간 응답이 필요한 팀: 챗봇, 고객 서비스 등 ms 단위 응답이 필요한 경우
- 대규모 문서 library를 운영하는 팀: 벡터 검색의 검색 능력이 필요한 경우
벡터 검색 RAG가 적합한 팀
- 대규모 문서 library를 운영하는 팀: 수천 개의 문서를 검색해야 하는 경우
- 비용 효율성이 중요한 팀: 월 $50 이하로 AI 비용을 관리하고 싶은 경우
- 반복적 검색이 필요한 팀: 같은 문서 library에서 다양한 질문을 하는 경우
- 실시간 응답이 필요한 팀: 챗봇, 검색 시스템 등
계층적 요약이 적합한 팀
- 중간 수준의 정확도와 비용이 필요한 팀: 균형 잡힌 접근이 필요한 경우
- 요약 기반 결정을 내리는 팀: 경영 보고서, 뉴스 분석 등
- 문서가 계층적 구조를 가진 팀: 메뉴얼, 백서, 학술 논문 등
가격과 ROI
저는 실제 프로젝트에서 비용 절감 효과를 직접 확인했습니다. 월 1,000만 토큰 처리 시나리오에서 HolySheep AI의 모델별 비용을 비교해 보겠습니다.
연간 비용 비교: 월 1,000만 토큰 기준
| 모델 | 직집 1M (연간) | 벡터 검색 (연간) | 계층적 요약 (연간) | 최대 절감액 |
|---|---|---|---|---|
| GPT-4.1 | $996 | $169 | $408 | $827 |
| Claude Sonnet 4.5 | $1,867.50 | $317.75 | $765 | $1,102.50 |
| Gemini 2.5 Flash | $311.25 | $52.90 | $127.50 | $258.35 |
| DeepSeek V3.2 | $52.20 | $8.87 | $21.42 | $43.33 |
ROI 분석
저의 경험을 바탕으로 실제 ROI를 계산해 보겠습니다.
- 벡터 검색 RAG 도입 시: 기존 대비 83% 비용 절감, 개발 시간 투자 2주
- HolySheep 게이트웨이 사용 시: 여러 API 키 관리 비용 절감, 모델 전환 유연성 증가
- DeepSeek V3.2 활용 시: GPT-4.1 대비 95% 비용 절감, 상당수 작업에서 동등한 품질
왜 HolySheep를 선택해야 하나
저는 여러 AI API 게이트웨이를 사용해 보았지만, HolySheep AI가 특히 장문맥 RAG 작업에 최적화된 이유를 정리해 보았습니다.
1. 단일 API 키로 모든 모델 통합
저는 이전에 OpenAI, Anthropic, Google 등 각각 별도의 API 키를 관리해야 했습니다. HolySheep는 하나의 API 키로 GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2 모두 사용할 수 있게 해줍니다. 이는 개발 효율성을 크게 향상시킵니다.
2. 로컬 결제 지원
해외 신용카드 없이도 결제가 가능합니다. 저처럼 한국에서 개발하는 분들께서는 매우 중요한利好입니다. 월 정산, 신용카드 결제 등 개발자 친화적 옵션을 제공합니다.
3. 업계 최저가 모델 제공
DeepSeek V3.2의 경우 $0.42/MTok으로 GPT-4.1 대비 95% 저렴합니다. 많은 작업에서 DeepSeek V3.2의 품질은 충분하며, 비용만 엄청나게 절감됩니다. HolySheep는 이러한 다양한 모델을 단일 인터페이스에서 제공합니다.
4. 무료 크레딧 제공
신규 가입 시 무료 크레딧을 제공하여 실제로 비용을 내기 전에 충분히 테스트해 볼 수 있습니다. 저는 이 크레딧으로 모든 접근법을 검증한 후付费订阅했습니다.
5. 안정적인 연결과 全球 인프라
HolySheep의 全球 인프라를 통해 안정적인 API 연결을 경험했습니다. 특히 아시아 지역에서 European이나 American 모델을 사용할 때 지연 시간이 합리적입니다.
자주 발생하는 오류 해결
저는 장문맥 RAG 구현 과정에서 다양한 오류를 마주쳤습니다. 가장 흔한 문제들과 해결책을 정리해 드리겠습니다.
오류 1: 컨텍스트 토큰 초과 (Context Length Exceeded)
# 문제: 요청한 토큰이 모델의 최대 컨텍스트를 초과
에러 메시지: "This model's maximum context length is X tokens"
해결 1: 청크 크기 축소
def safe_chunk_text(text: str, max_tokens: int = 8000) -> List[str]:
"""
안전하게 텍스트를 청크로 분할
토큰 수 고려하여 여유 있게 분할
"""
# 대략적으로 1토큰 ≈ 0.75단어
words = text.split()
chunk_size = int(max_tokens * 0.75)
chunks = []
for i in range(0, len(words), chunk_size):
chunks.append(" ".join(words[i:i + chunk_size]))
return chunks
해결 2: 컨텍스트 초과 시 자동 분할
def call_with_fallback(messages, model="gemini-2.5-flash"):
try:
return call_model(messages, model)
except Exception as e:
if "context length" in str(e).lower():
print("컨텍스트 초과 감지, 청크 단위로 재시도...")
# 청크 단위 처리 로직으로 전환
return process_in_chunks(messages)
raise
해결 3: HolySheep의 긴 컨텍스트 모델 활용
LONG_CONTEXT_MODELS = {
"gemini-2.5-flash": 1_000_000, # 1M 토큰
"claude-sonnet-4.5": 200_000, # 200K 토큰
"gpt-4.1": 128_000, # 128K 토큰
}
def select_model_for_context(document_length: int) -> str:
"""문서 길이에 맞는 최적 모델 선택"""
for model, max_len in sorted(LONG_CONTEXT_MODELS.items(),
key=lambda x: x[1], reverse=True):
if document_length <= max_len:
return model
return "gemini-2.5-flash" # 기본값으로 가장 긴 컨텍스트 모델오류 2: Rate Limit 초과 (Too Many Requests)
# 문제: API 호출 속도 제한 초과
에러 메시지: "Rate limit exceeded" 또는 429 status code
import time
from functools import wraps
import threading
class RateLimitedClient:
"""속도 제한을 고려한 API 클라이언트"""
def __init__(self, max_requests_per_minute=60):
self.max_rpm = max_requests_per_minute
self.request_times = []
self.lock = threading.Lock()
def wait_if_needed(self):
"""속도 제한에 도달했다면 대기"""
with self.lock:
now = time.time()
# 1분 이내의 요청만 기록
self.request_times = [t for t in self.request_times if now - t < 60]
if len(self.request_times) >= self.max_rpm:
# 가장 오래된 요청이 끝나기를 대기
sleep_time = 60 - (now - self.request_times[0])
if sleep_time > 0:
print(f"Rate limit 도달. {sleep_time:.1f}초 대기...")
time.sleep(sleep_time)
self.request_times = self.request_times[1:]
self.request_times.append(time.time())
def call_with_retry(self, func, max_retries=3, base_delay=1):
"""재시도 로직과 함께 API 호출"""
for attempt in range(max_retries):
try:
self.wait_if_needed()
return func()
except Exception as e:
if "rate limit" in str(e).lower() and attempt < max_retries - 1:
delay = base_delay * (2 ** attempt) # 지수적 백오프
print(f"Rate limit 재시도... {delay}초 후 ({attempt + 1}/{max_retries})")
time.sleep(delay)
else:
raise
사용 예시
client = RateLimitedClient(max_requests_per_minute=30)
def batch_process_documents(documents: List[str], query: str):
"""대량 문서 배치 처리 with rate limiting"""
results = []
for i, doc in enumerate(documents):
def process_single():
return {"index": i, "result": rag_pipeline.answer_with_context(query)}
result = client.call_with_retry(process_single)
results.append(result)
if (i + 1) % 10 == 0:
print(f"Progress: {i + 1}/{len(documents)}")
return results오류 3: 벡터 검색 품질 저하 (Poor Retrieval Quality)
# 문제: 검색된 청크가 관련성이 낮음
증상: 모델이 잘못된 정보를 답변하거나 "모르겠습니다"라고 함
class ImprovedRAGPipeline(VectorRAGPipeline):
"""검색 품질을 향상시킨 RAG 파이프라인"""
def __init__(self, min_similarity_threshold=0.6):
super().__init__()
self.min_similarity = min_similarity_threshold
def retrieve_with_reranking(self, query: str, top_k_initial=20, top_k_final=5):
"""
2단계 검색: 초기 검색 후 재순위화
"""
# 1단계: 더 많은 후보 검색
candidates = []
query_embedding = self.get_embedding(query)
for i, chunk_emb in enumerate(self.embeddings):
sim = self.cosine_similarity(query_embedding, chunk_emb)
candidates.append((i, sim, self.chunks[i]))
# 유사도 기준 정렬
candidates.sort(key=lambda x: x[1], reverse=True)
# 2단계: LLM으로 관련성 재순위화
reranked = []
for i, sim, chunk in candidates[:top_k_initial]:
if sim < self.min_similarity:
continue
relevance_prompt = f"""다음 청크가 사용자 질문과 관련성이 높은가?
질문: {query}
청크: {chunk}
관련성 점수 (0-10)와 이유를 제공해주세요."""
messages = [
{"role": "user", "content": relevance_prompt}
]
try:
result = call_model(messages, model="deepseek-v3.2")
# 간단한 파싱 (실제로는 더 정교한 파싱 필요)
reasoning = result["choices"][0]["message"]["content"]
reranked.append((i, sim, chunk, reasoning))
except:
#