Designing Explainable Ranking Systems with LLMs — Build Rankers That Can Justify Orderings

Use Case kỹ thuật: Khi hệ thống cần xếp hạng kết quả tìm kiếm, đề xuất sản phẩm hoặc ưu tiên công việc với hàng triệu request/giây, và phải giải thích được lý do xếp hạng cho người dùng cuối.

---

1. Vấn đề: Tại sao cần ranking system có khả năng giải thích?

Khi xây dựng hệ thống xếp hạng (ranking system), chúng ta thường gặp hai vấn đề lớn:

• Black box problem: Mô hình ML đưa ra kết quả nhưng không thể giải thích tại sao item A xếp trên item B
• Trust issue: Người dùng không tin vào kết quả nếu không hiểu logic đằng sau

⚠️ Cảnh báo: Một hệ thống xếp hạng không có khả năng giải thích sẽ gặp khó khăn khi bị audit hoặc khi cần tuân thủ các quy định như GDPR, AI Act của EU.

---

2. Các phương pháp truyền thống để tạo explainable ranking

2.1 Feature-based ranking

Công thức tính điểm xếp hạng:

score = w1 * feature1 + w2 * feature2 + ... + wn * featureN

Trong đó:
– w1, w2, ..., wn là trọng số của từng feature
– feature1, feature2, ..., featureN là các thuộc tính của item

Ưu điểm:
– Minh bạch hoàn toàn
– Dễ debug
– Tốc độ tính toán nhanh (O(n))

Nhược điểm:
– Cần domain knowledge để chọn feature
– Khó capture non-linear relationships

2.2 Rule-based ranking

def rank_item(item):
    score = 0

    # Rule 1: Freshness
    if item.age < 24:  # hours
        score += 10

    # Rule 2: Popularity
    score += item.views * 0.01

    # Rule 3: Authority
    if item.author.is_verified:
        score += 5

    return score

Ưu điểm:
– Dễ maintain
– Logic rõ ràng
– Có thể giải thích từng rule

Nhược điểm:
– Khó scale với nhiều rule
– Cần expert để maintain

---

3. LLMs cho explainable ranking: Tại sao và khi nào?

3.1 Lợi ích của LLMs trong ranking

LLMs (Large Language Models) mang lại khả năng:
– Contextual understanding: Hiểu ngữ cảnh phức tạp
– Dynamic reasoning: Có thể suy luận logic mới
– Natural language explanation: Giải thích bằng ngôn ngữ tự nhiên

Công thức tính chi phí vận hành LLM:

Trong đó:
– N: Số lượng request
– T: Tokens per request
– C: Cost per token (USD)

Giải thích: Chi phí = (Số request × Tokens/request × Giá/token) / 1000

3.2 Khi nào nên dùng LLMs cho ranking

Tiêu chí	Nên dùng LLMs	Không nên dùng LLMs
Volume	< 10,000 request/giây	> 100,000 request/giây
Complexity	High (cần context)	Low (đơn giản)
Latency tolerance	> 500ms	< 100ms
Need for explanation	Yes	No

---

4. Kiến trúc hệ thống ranking với LLMs

4.1 Overall Architecture

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Request Layer │───▶│  Feature Engine  │───▶│    LLM Layer    │
│ (API Gateway)   │    │ (Vector DB +     │    │ (Reasoning +    │
│                 │    │  Feature Store)  │    │  Explanation)   │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                            │                        │
                            ▼                        ▼
                  ┌──────────────────┐    ┌─────────────────┐
                  │   Cache Layer    │    │   Monitoring    │
                  │ (Redis/Vector    │    │   (Prometheus)  │
                  │  Cache)          │    │                 │
                  └──────────────────┘    └─────────────────┘

4.2 Detailed Flow

1. Request Processing
   • Normalize query
   • Extract intent
   • Identify context
2. Feature Engineering
   • Retrieve item features
   • Calculate dynamic features
   • Generate embeddings
3. LLM Reasoning
   • Prompt engineering
   • Multi-step reasoning
   • Generate explanation
4. Post-processing
   • Apply business rules
   • Cache results
   • Return response

---

5. Implementation Details

5.1 Prompt Engineering for Ranking

def generate_ranking_prompt(query, items, context):
    """
    Tạo prompt cho LLM để thực hiện ranking và giải thích
    """
    prompt = f"""
    You are a ranking expert. Given the following information:

    QUERY: {query}

    ITEMS:
    {format_items(items)}

    CONTEXT:
    {context}

    TASK:
    1. Rank the items from most relevant to least relevant
    2. For each item, provide a brief explanation (1-2 sentences)
       of why it has that ranking position

    FORMAT:
    RANKING:
    1. Item A (Score: X) - Explanation: ...
    2. Item B (Score: Y) - Explanation: ...
    3. Item C (Score: Z) - Explanation: ...

    Please provide your ranking in the exact format above.
    """
    return prompt

5.2 Hybrid Ranking System

class HybridRanker:
    def __init__(self, llm_client, feature_store, cache_client):
        self.llm = llm_client
        self.features = feature_store
        self.cache = cache_client

    def rank(self, query, items, context=None):
        # Check cache first
        cache_key = f"rank:{query}:{len(items)}"
        cached = self.cache.get(cache_key)
        if cached:
            return cached

        # Get features
        item_features = self.features.get_features(items)

        # Generate prompt
        prompt = generate_ranking_prompt(query, items, context)

        # Call LLM
        response = self.llm.generate(prompt)

        # Parse response
        ranking = parse_ranking_response(response)

        # Cache result
        self.cache.set(cache_key, ranking, ttl=3600)

        return ranking

5.3 Performance Optimization

Caching Strategy:

# Cache key structure
# rank:{query_hash}:{item_count}:{context_hash}

# Cache invalidation
# - TTL-based (1 hour for most queries)
# - Event-based (when item features update)
# - Manual (for A/B testing)

Batch Processing:

def batch_rank(queries, items_list, contexts):
    """
    Xử lý batch để tối ưu chi phí và latency
    """
    # Group similar queries
    query_groups = group_by_similarity(queries)

    results = []
    for group in query_groups:
        # Generate single prompt for group
        prompt = generate_batch_prompt(group, items_list, contexts)

        # Call LLM once
        response = self.llm.generate(prompt)

        # Parse and distribute results
        group_results = parse_batch_response(response)
        results.extend(group_results)

    return results

---

6. Evaluation Metrics

6.1 Traditional Ranking Metrics

Metric	Formula	Use Case
DCG (Discounted Cumulative Gain)		Đo quality của ranking
NDCG (Normalized DCG)		So sánh giữa các ranking
MAP (Mean Average Precision)		Đo precision across queries

6.2 Explainability Metrics

Explanation Quality:

def explanation_quality(explanation, item, query):
    """
    Đo chất lượng của explanation
    """
    # Coherence: explanation có logic không?
    coherence = coherence_score(explanation)

    # Relevance: explanation có liên quan đến query không?
    relevance = jaccard_similarity(explanation, query)

    # Accuracy: explanation có đúng không?
    accuracy = fact_check(explanation, item)

    return (coherence + relevance + accuracy) / 3

Trust Score:

def trust_score(ranking, user_feedback):
    """
    Đo độ tin cậy của ranking system
    """
    # User satisfaction
    satisfaction = user_feedback['satisfied'] / user_feedback['total']

    # Explanation understanding
    understanding = user_feedback['understood'] / user_feedback['exposed']

    # Result accuracy
    accuracy = self_evaluation(ranking)

    return (satisfaction + understanding + accuracy) / 3

---

7. Case Studies (Technical Use Cases)

7.1 E-commerce Product Ranking

Problem: Một sàn thương mại điện tử cần xếp hạng sản phẩm theo query của người dùng, nhưng phải giải thích tại sao sản phẩm A xếp trên sản phẩm B.

Solution Architecture:

Query → Intent Recognition → Feature Extraction → LLM Reasoning → Ranking + Explanation → Cache → Response

Implementation Details:

class ProductRanker:
    def __init__(self):
        self.intent_model = IntentRecognizer()
        self.feature_store = ProductFeatureStore()
        self.ranker = HybridRanker()

    def rank_products(self, query, user_context):
        # Step 1: Intent recognition
        intent = self.intent_model.predict(query)

        # Step 2: Feature extraction
        products = self.feature_store.get_relevant_products(query, intent)
        features = self.feature_store.extract_features(products, user_context)

        # Step 3: LLM reasoning
        context = {
            'intent': intent,
            'user_context': user_context,
            'business_rules': self.get_business_rules()
        }

        ranking = self.ranker.rank(query, products, context)

        return ranking

Performance Numbers:
– Latency: 350-450ms (bao gồm LLM call)
– Cache hit rate: 65%
– User satisfaction: 87%

7.2 Job Search Ranking

Problem: Nền tảng tuyển dụng cần xếp hạng job postings theo profile candidate, với giải thích chi tiết.

Technical Challenges:
– Cold start problem: Candidate mới không có history
– Multi-objective optimization: Match cả skills, location, salary, culture fit
– Dynamic updates: Job postings thay đổi liên tục

Solution:

class JobRanker:
    def rank_jobs(self, candidate_profile, jobs):
        # Multi-step reasoning
        prompt = f"""
        You are a career advisor. Given:

        CANDIDATE:
        {candidate_profile}

        JOBS:
        {jobs}

        TASK:
        For each job, evaluate:
        1. Skill match (0-10)
        2. Experience match (0-10)
        3. Location preference (0-10)
        4. Career growth potential (0-10)

        Then rank jobs and provide explanation for each ranking position.
        """

        response = self.llm.generate(prompt)
        return parse_job_ranking(response)

Evaluation Results:
– Skill match accuracy: 82%
– Location preference accuracy: 91%
– Overall satisfaction: 89%

---

8. Best Practices & Common Pitfalls

8.1 Best Practices

Prompt Engineering:

# DO: Use structured output
prompt = """
RANKING:
1. Item (Score: X) - Reason: ...
2. Item (Score: Y) - Reason: ...
"""

# DO: Provide examples
prompt += """
Example:
RANKING:
1. iPhone 15 (Score: 95) - Reason: Latest model, high demand, excellent reviews
2. Samsung S23 (Score: 88) - Reason: Good camera, competitive price, strong brand
"""

# DO: Set constraints
prompt += """
Constraints:
- Keep explanations under 20 words
- Focus on 2-3 key factors per item
- Be specific and factual
"""

Caching Strategy:
– Short TTL (5-15 minutes) cho trending items
– Long TTL (1-4 hours) cho evergreen content
– User-specific cache cho personalized results

8.2 Common Pitfalls

Pitfall 1: Over-reliance on LLMs

# ❌ BAD: Relying entirely on LLM for ranking
def bad_ranker(query, items):
    prompt = f"Rank these items: {items}"
    return llm.generate(prompt)

# ✅ GOOD: Hybrid approach
def good_ranker(query, items):
    # Use LLM for reasoning, not calculation
    features = extract_features(items)
    base_rank = calculate_base_rank(features)

    # Use LLM for explanation and fine-tuning
    explanation = llm.explain_ranking(base_rank, query)
    final_rank = apply_business_rules(base_rank, explanation)

    return final_rank

Pitfall 2: Ignoring Performance

# ❌ BAD: No caching, no batching
for query in incoming_queries:
    result = ranker.rank(query, items)
    return result

# ✅ GOOD: Optimized approach
batch_results = batch_ranker.rank_batch(queries, items_list)
return distribute_results(batch_results)

Pitfall 3: Poor Error Handling

# ❌ BAD: No fallback
try:
    result = llm.generate(prompt)
except:
    return None  # Fail silently

# ✅ GOOD: Graceful degradation
try:
    result = llm.generate(prompt)
    return result
except LLMTimeout:
    # Fallback to simpler model
    return fast_ranker.rank(query, items)
except LLMError:
    # Fallback to rule-based
    return rule_based_ranker.rank(query, items)

---

9. Cost Analysis & Optimization

9.1 Cost Breakdown

Component	Cost per 1000 requests	Notes
LLM Call	$0.50 – $2.00	Depends on model and tokens
Feature Extraction	$0.05	Database queries, API calls
Post-processing	$0.01	Business logic, formatting
Total	$0.56 – $2.06	Varies by use case

9.2 Optimization Strategies

Token Optimization:

def optimize_prompt(prompt, items):
    """
    Giảm tokens bằng cách:
    1. Remove duplicate information
    2. Use abbreviations
    3. Limit context
    """
    # Remove duplicates
    items = remove_duplicates(items)

    # Use abbreviations
    prompt = prompt.replace("explanation", "exp")
    prompt = prompt.replace("ranking", "rank")

    # Limit context
    if len(items) > 10:
        items = items[:10]  # Process top 10, explain why truncated

    return prompt

Model Selection:

class CostOptimizedRanker:
    def __init__(self):
        self.models = {
            'simple': FastLLMModel(),      # $0.10/1000
            'medium': BalancedLLMModel(), # $0.50/1000
            'complex': AdvancedLLMModel() # $2.00/1000
        }

    def rank(self, query, items, complexity):
        model = self.models[complexity]
        return model.generate_ranking(query, items)

---

10. Future Trends & Considerations

10.1 Emerging Technologies

Small Language Models (SLMs):
– Advantage: Rẻ hơn 10x, nhanh hơn 5x
– Use case: Simple ranking tasks
– Example: LLaMA 7B fine-tuned for ranking

Vector Database Integration:

# Using vector similarity for initial ranking
def vector_based_initial_rank(query, items, vector_db):
    query_vector = vector_db.embed(query)
    item_vectors = vector_db.get_vectors(items)

    similarities = cosine_similarity(query_vector, item_vectors)
    ranked_items = [items[i] for i in np.argsort(similarities)[::-1]]

    return ranked_items

10.2 Regulatory Considerations

AI Act Compliance:
– Transparency: Giải thích rõ ràng cách thức xếp hạng
– Bias testing: Đảm bảo không phân biệt đối xử
– Human oversight: Có cơ chế review của người

Data Privacy:
– GDPR: Anonymize personal data in explanations
– Right to explanation: Cung cấp giải thích khi được yêu cầu
– Data retention: Xóa dữ liệu ranking sau khi sử dụng

---

Key Takeaways

1. Hybrid approach is key: Kết hợp LLMs với traditional ranking methods để tối ưu performance và chi phí
2. Caching is critical: Implement multi-layer caching để giảm latency và cost
3. Evaluation matters: Dùng cả traditional metrics (DCG, NDCG) và explainability metrics
4. Cost optimization: Optimize prompts, use model selection, implement batching
5. Error handling: Always có fallback strategies cho production systems

---

Discussion Question: Anh em đã từng xây dựng hệ thống ranking nào chưa? Gặp khó khăn gì về performance hay explainability? Share kinh nghiệm bên dưới nhé!

---

Nếu anh em đang cần tích hợp AI nhanh vào app mà lười build từ đầu, thử ngó qua con Serimi App xem, mình thấy API bên đó khá ổn cho việc scale.