HolySheep API 中转RAG系统：Embedding模型选型与优化

Đêm hôm đó, hệ thống RAG của tôi sụp đổ lúc 2 giờ sáng. Người dùng than phiền chatbot không trả lời được câu hỏi đơn giản như "Tài liệu bảo hành của sản phẩm XYZ ở đâu?". Kiểm tra log thì thấy hàng loạt lỗi: ConnectionError: HTTPSConnectionPool(host='api.openai.com', port=443): Max retries exceeded. Đó là lúc tôi nhận ra mình đã phụ thuộc hoàn toàn vào một provider duy nhất. Bài viết này là tổng kết 6 tháng tối ưu hóa RAG với HolySheep API — giải pháp trung gian giúp tôi giảm 85% chi phí và loại bỏ hoàn toàn downtime.

RAG là gì và tại sao Embedding Model quan trọng

Retrieval-Augmented Generation (RAG) là kiến trúc kết hợp truy xuất tài liệu với sinh text. Thay vì dựa hoàn toàn vào kiến thức nội bộ của LLM, RAG tìm đoạn văn bản liên quan trong cơ sở dữ liệu vector trước, rồi mới đưa vào prompt. Điều này đặc biệt quan trọng khi:

• Tài liệu doanh nghiệp cần cập nhật liên tục
• Cần độ chính xác thực tế cao (không hallucinate)
• Muốn kiểm soát nguồn thông tin trả lời

Embedding model là trái tim của RAG — nó chuyển đổi văn bản thành vector số học. Một embedding tốt giúp hệ thống truy xuất đúng tài liệu, ngược lại thì sinh ra "bốc phốt" hoàn toàn. Tốc độ embedding ảnh hưởng trực tiếp đến latency của toàn bộ pipeline.

Tích hợp HolySheep API cho RAG Pipeline

Kiến trúc hệ thống

# holysheep_rag_pipeline.py
import openai
import numpy as np
from typing import List, Tuple, Optional
from dataclasses import dataclass

Cấu hình HolySheep API - KHÔNG dùng api.openai.com
openai.api_base = "https://api.holysheep.ai/v1"
openai.api_key = "YOUR_HOLYSHEEP_API_KEY"  # Thay bằng API key của bạn

@dataclass
class Document:
    """Cấu trúc tài liệu đầu vào"""
    content: str
    metadata: dict
    chunk_id: Optional[str] = None

class HolySheepRAGPipeline:
    """Pipeline RAG sử dụng HolySheep API"""
    
    def __init__(self, embedding_model: str = "text-embedding-3-small"):
        self.embedding_model = embedding_model
        self.vector_store = {}  # Đơn giản hóa: dùng dict thay vì DB thực tế
        
    def create_embeddings(self, texts: List[str]) -> List[np.ndarray]:
        """
        Tạo embeddings qua HolySheep API
        Đo lường độ trễ thực tế
        """
        import time
        start = time.time()
        
        response = openai.Embedding.create(
            model=self.embedding_model,
            input=texts
        )
        
        elapsed_ms = (time.time() - start) * 1000
        print(f"Embedding latency: {elapsed_ms:.2f}ms cho {len(texts)} texts")
        
        embeddings = [np.array(item['embedding']) for item in response['data']]
        return embeddings
    
    def index_documents(self, documents: List[Document]) -> int:
        """Đánh chỉ mục tài liệu vào vector store"""
        texts = [doc.content for doc in documents]
        embeddings = self.create_embeddings(texts)
        
        for doc, embedding in zip(documents, embeddings):
            chunk_id = doc.chunk_id or f"chunk_{len(self.vector_store)}"
            self.vector_store[chunk_id] = {
                'embedding': embedding,
                'content': doc.content,
                'metadata': doc.metadata
            }
        
        print(f"Đã index {len(documents)} documents. Tổng chunks: {len(self.vector_store)}")
        return len(documents)
    
    def retrieve(self, query: str, top_k: int = 5) -> List[Tuple[Document, float]]:
        """Truy xuất tài liệu liên quan nhất"""
        query_embedding = self.create_embeddings([query])[0]
        
        similarities = []
        for chunk_id, data in self.vector_store.items():
            similarity = np.dot(query_embedding, data['embedding']) / (
                np.linalg.norm(query_embedding) * np.linalg.norm(data['embedding'])
            )
            similarities.append((chunk_id, similarity, data))
        
        # Sắp xếp theo độ tương đồng giảm dần
        similarities.sort(key=lambda x: x[1], reverse=True)
        
        results = []
        for chunk_id, score, data in similarities[:top_k]:
            doc = Document(
                content=data['content'],
                metadata=data['metadata'],
                chunk_id=chunk_id
            )
            results.append((doc, score))
        
        return results
    
    def generate_answer(self, query: str, retrieved_docs: List[Document]) -> str:
        """Sinh câu trả lời với context từ tài liệu"""
        context = "\n\n".join([f"[Document {i+1}]\n{doc.content}" 
                               for i, doc in enumerate(retrieved_docs)])
        
        prompt = f"""Dựa trên các tài liệu được cung cấp, trả lời câu hỏi một cách chính xác.

Tài liệu:
{context}

Câu hỏi: {query}

Trả lời (chỉ dựa vào thông tin trong tài liệu):"""
        
        response = openai.ChatCompletion.create(
            model="gpt-4.1",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3,
            max_tokens=500
        )
        
        return response['choices'][0]['message']['content']


Demo sử dụng
if __name__ == "__main__":
    pipeline = HolySheepRAGPipeline(embedding_model="text-embedding-3-small")
    
    # Index sample documents
    docs = [
        Document(
            content="Chính sách bảo hành: Sản phẩm được bảo hành 12 tháng từ ngày mua.",
            metadata={"source": "policy.pdf", "category": "warranty"}
        ),
        Document(
            content="Điều kiện đổi trả: Có thể đổi trả trong 7 ngày nếu sản phẩm còn nguyên seal.",
            metadata={"source": "policy.pdf", "category": "return"}
        ),
    ]
    
    pipeline.index_documents(docs)
    
    # Query
    query = "Tôi muốn biết về chính sách bảo hành"
    results = pipeline.retrieve(query, top_k=2)
    
    print(f"\nTruy xuất được {len(results)} kết quả:")
    for doc, score in results:
        print(f"  - Score: {score:.4f} | {doc.content[:50]}...")
    
    answer = pipeline.generate_answer(query, [r[0] for r in results])
    print(f"\nCâu trả lời: {answer}")

Đo lường hiệu suất thực tế

# benchmark_embedding.py
import openai
import time
import statistics

openai.api_base = "https://api.holysheep.ai/v1"
openai.api_key = "YOUR_HOLYSHEEP_API_KEY"

def benchmark_embedding(model: str, texts: list, runs: int = 10) -> dict:
    """Benchmark latency và chi phí embedding model"""
    
    latencies = []
    total_tokens = 0
    
    for _ in range(runs):
        start = time.time()
        response = openai.Embedding.create(model=model, input=texts)
        elapsed = (time.time() - start) * 1000  # ms
        latencies.append(elapsed)
        total_tokens += response['usage']['total_tokens']
    
    avg_latency = statistics.mean(latencies)
    p95_latency = sorted(latencies)[int(len(latencies) * 0.95)]
    
    # Ước tính chi phí ( HolySheep pricing 2026)
    # text-embedding-3-small: $0.02/1M tokens
    cost_per_1k = 0.02 / 1000  # $ cho 1K tokens
    estimated_cost = total_tokens * cost_per_1k
    
    return {
        'model': model,
        'avg_latency_ms': round(avg_latency, 2),
        'p95_latency_ms': round(p95_latency, 2),
        'total_tokens': total_tokens,
        'estimated_cost_usd': round(estimated_cost, 4),
        'runs': runs
    }

if __name__ == "__main__":
    test_texts = [
        "Chính sách bảo hành sản phẩm công nghệ",
        "Điều kiện đổi trả và hoàn tiền",
        "Hướng dẫn sử dụng thiết bị điện tử",
    ] * 10  # 30 texts
    
    models = ["text-embedding-3-small", "text-embedding-3-large"]
    
    print("=" * 60)
    print("BENCHMARK EMBEDDING MODELS - HOLYSHEEP API")
    print("=" * 60)
    
    for model in models:
        result = benchmark_embedding(model, test_texts, runs=10)
        print(f"\n📊 {result['model']}")
        print(f"   Latency trung bình: {result['avg_latency_ms']}ms")
        print(f"   Latency P95: {result['p95_latency_ms']}ms")
        print(f"   Tổng tokens: {result['total_tokens']}")
        print(f"   Chi phí ước tính: ${result['estimated_cost_usd']}")

So sánh Embedding Models cho RAG

Model	Chi phí/1M tokens	Dimensions	Latency trung bình	Độ chính xác	Phù hợp cho
text-embedding-3-small	$0.02	1536	<50ms	Tốt	General RAG, chatbot
text-embedding-3-large	$0.13	3072	<80ms	Rất tốt	Legal, medical, technical
text-embedding-ada-002	$0.10	1536	<60ms	Trung bình	Legacy systems

Tối ưu hóa Embedding cho RAG

1. Chunking Strategy

Kích thước chunk ảnh hưởng lớn đến chất lượng truy xuất. Quá ngắn → mất ngữ cảnh. Quá dài → nhiễu thông tin.

# advanced_chunking.py
import re
from typing import List, Iterator
from dataclasses import dataclass

@dataclass
class Chunk:
    content: str
    start_char: int
    end_char: int
    metadata: dict

def smart_chunking(
    text: str,
    chunk_size: int = 512,
    overlap: int = 50,
    min_chunk_size: int = 100
) -> List[Chunk]:
    """
    Chunking thông minh với overlap và bảo toàn ngữ cảnh
    chunk_size: số tokens ước tính
    overlap: số ký tự overlap giữa các chunks
    """
    chunks = []
    
    # Tách theo câu
    sentences = re.split(r'(?<=[.!?])\s+', text)
    current_chunk = []
    current_size = 0
    
    for sentence in sentences:
        sentence_tokens = len(sentence.split())
        current_size += sentence_tokens
        
        if current_size > chunk_size and current_chunk:
            # Ghép chunk hiện tại
            content = ' '.join(current_chunk)
            
            # Tránh chunk quá nhỏ
            if len(content) >= min_chunk_size:
                chunks.append(Chunk(
                    content=content,
                    start_char=len(' '.join(current_chunk[:1])),
                    end_char=len(content),
                    metadata={'sentence_count': len(current_chunk)}
                ))
            
            # Giữ lại overlap
            overlap_text = ' '.join(current_chunk)[-overlap:] if overlap > 0 else ''
            current_chunk = [overlap_text + sentence] if overlap_text else [sentence]
            current_size = len(overlap_text.split()) + sentence_tokens
        else:
            current_chunk.append(sentence)
    
    # Chunk cuối
    if current_chunk:
        content = ' '.join(current_chunk)
        if len(content) >= min_chunk_size:
            chunks.append(Chunk(
                content=content,
                start_char=0,
                end_char=len(content),
                metadata={'sentence_count': len(current_chunk), 'is_last': True}
            ))
    
    return chunks

def semantic_chunking(
    text: str,
    similarity_threshold: float = 0.7,
    min_chunk_size: int = 200
) -> List[Chunk]:
    """
    Semantic chunking - nhóm sentences có ngữ cảnh liên quan
    Sử dụng HolySheep API để tính similarity
    """
    import openai
    
    sentences = re.split(r'(?<=[.!?])\s+', text)
    
    if len(sentences) <= 2:
        return [Chunk(content=text, start_char=0, end_char=len(text), metadata={})]
    
    chunks = []
    current_group = [sentences[0]]
    
    for i in range(1, len(sentences)):
        # Tính similarity giữa câu hiện tại và previous
        prev_embedding = openai.Embedding.create(
            model="text-embedding-3-small",
            input=[current_group[-1]]
        )['data'][0]['embedding']
        
        curr_embedding = openai.Embedding.create(
            model="text-embedding-3-small",
            input=[sentences[i]]
        )['data'][0]['embedding']
        
        # Cosine similarity
        import numpy as np
        similarity = np.dot(prev_embedding, curr_embedding) / (
            np.linalg.norm(prev_embedding) * np.linalg.norm(curr_embedding)
        )
        
        if similarity >= similarity_threshold:
            current_group.append(sentences[i])
        else:
            # Hoàn thành chunk hiện tại
            content = ' '.join(current_group)
            if len(content) >= min_chunk_size:
                chunks.append(Chunk(
                    content=content,
                    start_char=0,
                    end_char=len(content),
                    metadata={'group_size': len(current_group)}
                ))
            current_group = [sentences[i]]
    
    # Chunk cuối
    if current_group:
        content = ' '.join(current_group)
        if len(content) >= min_chunk_size:
            chunks.append(Chunk(
                content=content,
                start_char=0,
                end_char=len(content),
                metadata={'group_size': len(current_group)}
            ))
    
    return chunks


if __name__ == "__main__":
    sample_text = """
    Chính sách bảo hành của công ty được áp dụng cho tất cả sản phẩm điện tử. 
    Thời gian bảo hành tiêu chuẩn là 12 tháng kể từ ngày mua hàng. 
    Điều kiện bảo hành bao gồm: sản phẩm còn trong thời hạn bảo hành, có phiếu bảo hành hợp lệ, 
    không có tác động vật lý bất thường. Khách hàng có thể liên hệ hotline 1900-xxxx 
    để được hỗ trợ bảo hành. Quy trình bảo hành thường mất 3-5 ngày làm việc.
    """
    
    # Smart chunking
    smart_chunks = smart_chunking(sample_text, chunk_size=30, overlap=10)
    print(f"Smart chunking: {len(smart_chunks)} chunks")
    for chunk in smart_chunks:
        print(f"  [{chunk.start_char}-{chunk.end_char}]: {chunk.content[:50]}...")

2. Hybrid Search

Kết hợp vector search với keyword search giúp tăng độ chính xác đáng kể.

# hybrid_search.py
import openai
import numpy as np
from collections import Counter

class HybridSearch:
    """Kết hợp semantic search và keyword search"""
    
    def __init__(self, vector_weight: float = 0.7, keyword_weight: float = 0.3):
        self.vector_weight = vector_weight
        self.keyword_weight = keyword_weight
        self.documents = {}
    
    def index_document(self, doc_id: str, content: str, metadata: dict = None):
        """Index document với cả embedding và keywords"""
        # Tạo embedding
        response = openai.Embedding.create(
            model="text-embedding-3-small",
            input=content
        )
        embedding = response['data'][0]['embedding']
        
        # Trích xuất keywords
        words = content.lower().split()
        keywords = [w for w in words if len(w) > 3]  # Loại bỏ stopwords đơn giản
        
        self.documents[doc_id] = {
            'content': content,
            'embedding': embedding,
            'keywords': keywords,
            'metadata': metadata or {}
        }
    
    def keyword_search(self, query: str) -> dict:
        """BM25-style keyword matching đơn giản"""
        query_words = query.lower().split()
        scores = {}
        
        for doc_id, doc in self.documents.items():
            matches = sum(1 for word in query_words if word in doc['keywords'])
            scores[doc_id] = matches / len(query_words) if query_words else 0
        
        return scores
    
    def vector_search(self, query: str) -> dict:
        """Semantic search qua vector"""
        response = openai.Embedding.create(
            model="text-embedding-3-small",
            input=query
        )
        query_embedding = np.array(response['data'][0]['embedding'])
        
        scores = {}
        for doc_id, doc in self.documents.items():
            doc_embedding = np.array(doc['embedding'])
            
            similarity = np.dot(query_embedding, doc_embedding) / (
                np.linalg.norm(query_embedding) * np.linalg.norm(doc_embedding)
            )
            scores[doc_id] = float(similarity)
        
        return scores
    
    def hybrid_search(self, query: str, top_k: int = 5) -> list:
        """Kết hợp cả hai phương pháp"""
        vector_scores = self.vector_search(query)
        keyword_scores = self.keyword_search(query)
        
        # Normalize scores
        max_vector = max(vector_scores.values()) if vector_scores else 1
        max_keyword = max(keyword_scores.values()) if keyword_scores else 1
        
        combined_scores = {}
        for doc_id in self.documents:
            v_score = vector_scores.get(doc_id, 0) / max_vector
            k_score = keyword_scores.get(doc_id, 0) / max_keyword
            
            combined_scores[doc_id] = (
                self.vector_weight * v_score + 
                self.keyword_weight * k_score
            )
        
        # Sort và return top-k
        sorted_docs = sorted(combined_scores.items(), key=lambda x: x[1], reverse=True)
        
        results = []
        for doc_id, score in sorted_docs[:top_k]:
            results.append({
                'doc_id': doc_id,
                'score': score,
                'content': self.documents[doc_id]['content'],
                'metadata': self.documents[doc_id]['metadata']
            })
        
        return results


if __name__ == "__main__":
    search = HybridSearch(vector_weight=0.7, keyword_weight=0.3)
    
    # Index sample documents
    search.index_document("doc1", 
        "Chính sách bảo hành 12 tháng cho sản phẩm điện tử",
        {"source": "policy", "type": "warranty"})
    
    search.index_document("doc2",
        "Quy trình đổi trả sản phẩm trong 7 ngày",
        {"source": "policy", "type": "return"})
    
    # Hybrid search
    results = search.hybrid_search("bảo hành điện tử bao lâu", top_k=2)
    
    print("Kết quả Hybrid Search:")
    for r in results:
        print(f"  Score: {r['score']:.3f} | {r['content']}")

Lỗi thường gặp và cách khắc phục

1. Lỗi 401 Unauthorized

# Lỗi: openai.error.AuthenticationError: Incorrect API key provided
Nguyên nhân: API key không đúng hoặc chưa được set

Cách khắc phục:
import openai

Sai - key không đúng format
openai.api_key = "sk-xxxx"  # Đây là key gốc, không phải HolySheep key

Đúng - sử dụng HolySheep API key
openai.api_base = "https://api.holysheep.ai/v1"
openai.api_key = "YOUR_HOLYSHEEP_API_KEY"

Verify bằng cách gọi test
try:
    response = openai.Embedding.create(
        model="text-embedding-3-small",
        input="test"
    )
    print("✓ Kết nối thành công!")
except Exception as e:
    print(f"✗ Lỗi: {e}")
    # Kiểm tra lại key tại: https://www.holysheep.ai/dashboard
    print("Vui lòng kiểm tra API key tại HolySheep Dashboard")

2. Lỗi Rate Limit

# Lỗi: openai.error.RateLimitError: Rate limit exceeded
Nguyên nhân: Gọi API quá nhiều trong thời gian ngắn

import time
import openai
from tenacity import retry, stop_after_attempt, wait_exponential

openai.api_base = "https://api.holysheep.ai/v1"
openai.api_key = "YOUR_HOLYSHEEP_API_KEY"

class RateLimitedClient:
    """Client với retry logic và rate limit handling"""
    
    def __init__(self, max_retries: int = 3):
        self.max_retries = max_retries
    
    def create_embedding_with_retry(self, text: str, model: str = "text-embedding-3-small"):
        """Tạo embedding với automatic retry"""
        
        for attempt in range(self.max_retries):
            try:
                response = openai.Embedding.create(
                    model=model,
                    input=text
                )
                return response['data'][0]['embedding']
            
            except openai.error.RateLimitError:
                wait_time = (2 ** attempt) * 1.5  # Exponential backoff
                print(f"Rate limit hit. Chờ {wait_time}s...")
                time.sleep(wait_time)
            
            except Exception as e:
                print(f"Lỗi không xác định: {e}")
                raise
        
        raise Exception("Max retries exceeded")
    
    def batch_embeddings(self, texts: list, batch_size: int = 100):
        """Embedding batch với rate limit handling"""
        all_embeddings = []
        
        for i in range(0, len(texts), batch_size):
            batch = texts[i:i + batch_size]
            
            for attempt in range(self.max_retries):
                try:
                    response = openai.Embedding.create(
                        model="text-embedding-3-small",
                        input=batch
                    )
                    embeddings = [item['embedding'] for item in response['data']]
                    all_embeddings.extend(embeddings)
                    print(f"✓ Batch {i//batch_size + 1}: {len(batch)} embeddings")
                    break
                
                except openai.error.RateLimitError:
                    wait_time = (2 ** attempt) * 2
                    print(f"Rate limit. Chờ {wait_time}s...")
                    time.sleep(wait_time)
        
        return all_embeddings


if __name__ == "__main__":
    client = RateLimitedClient(max_retries=3)
    
    # Test với dummy data
    test_texts = [f"Tài liệu số {i}" for i in range(250)]
    embeddings = client.batch_embeddings(test_texts, batch_size=100)
    print(f"\nTổng: {len(embeddings)} embeddings")

3. Lỗi Connection Timeout

# Lỗi: ConnectionError, Timeout
Nguyên nhân: Network issues, server overloaded

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
import openai

Cấu hình session với retry strategy
def create_session_with_retry():
    session = requests.Session()
    
    retry_strategy = Retry(
        total=3,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504],
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("https://", adapter)
    session.mount("http://", adapter)
    
    return session

Cấu hình OpenAI client
openai.api_base = "https://api.holysheep.ai/v1"
openai.api_key = "YOUR_HOLYSHEEP_API_KEY"
openai.timeout = 60  # Timeout 60 giây

class RobustRAGClient:
    """RAG client với connection resilience"""
    
    def __init__(self):
        self.session = create_session_with_retry()
    
    def health_check(self) -> bool:
        """Kiểm tra kết nối API"""
        try:
            response = openai.Embedding.create(
                model="text-embedding-3-small",
                input="health check"
            )
            return True
        except Exception as e:
            print(f"Health check failed: {e}")
            return False
    
    def create_embedding(self, text: str) -> list:
        """Tạo embedding với error handling đầy đủ"""
        
        try:
            response = openai.Embedding.create(
                model="text-embedding-3-small",
                input=text,
                timeout=30
            )
            return response['data'][0]['embedding']
        
        except requests.exceptions.Timeout:
            print("Timeout - thử lại với model khác...")
            # Fallback: thử với model nhẹ hơn
            response = openai.Embedding.create(
                model="text-embedding-3-small",
                input=text[:1000]  # Cắt ngắn text
            )
            return response['data'][0]['embedding']
        
        except requests.exceptions.ConnectionError:
            print("Connection error - kiểm tra network...")
            time.sleep(5)
            raise
        
        except Exception as e:
            print(f"Unexpected error: {e}")
            raise


if __name__ == "__main__":
    client = RobustRAGClient()
    
    # Kiểm tra health trước
    if client.health_check():
        print("✓ API hoạt động bình thường")
        embedding = client.create_embedding("Test embedding")
        print(f"✓ Embedding length: {len(embedding)}")
    else:
        print("✗ API không khả dụng - kiểm tra lại cấu hình")

4. Lỗi Context Length

# Lỗi: InvalidRequestError: This model's maximum context length is exceeded
Nguyên nhân: Prompt + context quá dài

import tiktoken

def truncate_context(context: str, max_tokens: int = 3000, model: str = "gpt-4.1") -> str:
    """Truncate context để fit trong token limit"""
    
    encoder = tiktoken.encoding_for_model(model)
    tokens = encoder.encode(context)
    
    if len(tokens) <= max_tokens:
        return context
    
    truncated_tokens = tokens[:max_tokens]
    return encoder.decode(truncated_tokens)

def smart_context_window(query: str, retrieved_docs: list, max_context_tokens: int = 6000) -> str:
    """
    Chọn context tối ưu từ retrieved docs
    Ưu tiên documents có relevance score cao hơn
    """
    
    context_parts = []
    current_tokens = 0
    
    # Ước tính tokens cho query
    encoder = tiktoken.encoding_for_model("gpt-4.1")
    query_tokens = len(encoder.encode(query))
    available_tokens = max_context_tokens - query_tokens - 500  # Buffer cho prompt
    
    for doc, score in retrieved_docs:
        doc_tokens = len(encoder.encode(doc.content))
        
        if current_tokens + doc_tokens <= available_tokens:
            context_parts.append(f"[Relevance: {score:.2f}]\n{doc.content}")
            current_tokens += doc_tokens
        else:
            # Cắt document nếu cần
            remaining = available_tokens - current_tokens
            if remaining > 200:  # Còn đủ chỗ cho ít nhất 200 tokens
                truncated = truncate_context(doc.content, remaining)
                context_parts.append(f"[Relevance: {score:.2f}]\n{truncated}")
            break
    
    return "\n\n---\n\n".join(context_parts)


Sử dụng trong pipeline
if __name__ == "__main__":
    # Demo
    from dataclasses import dataclass
    
    @dataclass
    class SampleDoc:
        content: str
        score: float
    
    docs = [
        SampleDoc(content="Nội dung dài " * 500, score=0.95),
        SampleDoc(content="Nội dung ngắn hơn", score=0.85),
        SampleDoc(content="Nội dung thứ ba cũng khá dài " * 200, score=0.75),
    ]
    
    context = smart_context_window("Câu hỏi test", docs, max_context_tokens=1000)
    print(f"Context length: {len(context)} characters")

Phù hợp / không phù hợp với ai

Phù hợp với	Không phù hợp với
Doanh nghiệp cần chatbot hỗ trợ khách hàng 24/7	Ứng dụng cần real-time speech-to-text
Team cần search tài liệu nội bộ thông minh	Người dùng cá nhân với budget rất hạn chế