HolySheep 智能客服多模型路由架构: Kinh Nghiệm Triển Khai Kimi, MiniMax, Claude Cho SLA Thực Chiến

Để xây dựng hệ thống chatbot chăm sóc khách hàng đa ngôn ngữ với chi phí tối ưu, tôi đã thử nghiệm nhiều giải pháp và kết luận: HolySheep AI là lựa chọn tốt nhất cho doanh nghiệp Việt Nam cần routing thông minh giữa Kimi (dài), MiniMax (voice), Claude (cảm xúc) với SLA failover tự động. Bài viết này là báo cáo thực chiến từ dự án triển khai cho 3 doanh nghiệp TMĐT với tổng 50,000+ ticket/tháng.

Tóm Lượt Kết Quả

Triển khai multi-model routing trên HolySheep giúp tôi tiết kiệm 73% chi phí API so với dùng Claude duy nhất, giảm độ trễ trung bình từ 2.3s xuống <180ms với cache thông minh, và đạt uptime 99.94% nhờ failover tự động khi model saturate.

HolySheep vs Đối Thủ: Bảng So Sánh Chi Tiết

HolySheep Là Gì?

HolySheep AI là nền tảng API aggregation từ Trung Quốc với tỷ giá đặc biệt ¥1 = $1, cho phép truy cập hàng trăm model AI (OpenAI, Anthropic, Google, Moonshot/Kimi, MiniMax, DeepSeek...) qua một endpoint duy nhất. Với độ trễ <50ms và tính năng intelligent routing, đây là giải pháp tối ưu cho hệ thống chatbot enterprise cần cân bằng chi phí và chất lượng. Đăng ký tại đây để nhận tín dụng miễn phí.

Kiến Trúc Multi-Model Routing Cho智能客服

Hệ thống chatbot chăm sóc khách hàng thông minh của tôi sử dụng 3 tầng routing:

• Tầng 1 - Kimi (Moonshot): Xử lý yêu cầu dài, FAQ phức tạp, tổng hợp đơn hàng
• Tầng 2 - MiniMax: Voice/Speech-to-text, xử lý tin nhắn thoại từ khách hàng
• Tầng 3 - Claude: Phân tích cảm xúc, trả lời nhạy cảm, escalation handling
• Tầng 4 - Failover: DeepSeek V3.2 làm fallback khi primary model saturate

Code Triển Khai Chi Tiết

1. Routing Engine Cơ Bản Với HolySheep

#!/usr/bin/env python3
"""
HolySheep Multi-Model Router cho Customer Service
File: holysheep_router.py
Author: HolySheep AI Technical Team
"""

import asyncio
import hashlib
import time
from typing import Optional, Dict, Any
from dataclasses import dataclass
from enum import Enum

=== CẤU HÌNH HOLYSHEEP - KHÔNG DÙNG API CHÍNH THỨC ===
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # Thay thế bằng key thật

class ModelType(Enum):
    KIMI = "moonshot/kimi-v1.5-128k"      # Dài, phức tạp
    MINIMAX = "minimax/t2a-01"            # Voice/speech
    CLAUDE = "anthropic/claude-sonnet-4.5" # Cảm xúc
    DEEPSEEK = "deepseek/deepseek-v3.2"   # Fallback
    GPT = "openai/gpt-4.1"                # Tổng quát

@dataclass
class RoutingConfig:
    """Cấu hình routing thông minh"""
    # Ngưỡng độ dài để chuyển sang Kimi
    long_content_threshold: int = 500
    
    # Ngưỡng cảm xúc để chuyển sang Claude
    emotion_threshold: float = 0.7
    
    # Timeout per request (ms)
    request_timeout: int = 5000
    
    # Retry count khi fail
    max_retries: int = 3

class HolySheepRouter:
    """
    Router thông minh cho multi-model customer service
    - Kimi: Yêu cầu dài, FAQ phức tạp
    - MiniMax: Voice/speech input
    - Claude: Phân tích cảm xúc, escalation
    - DeepSeek: Fallback khi primary fail
    """
    
    def __init__(self, api_key: str, config: Optional[RoutingConfig] = None):
        self.base_url = HOLYSHEEP_BASE_URL
        self.api_key = api_key
        self.config = config or RoutingConfig()
        self.request_count = {"kimi": 0, "minimax": 0, "claude": 0, "deepseek": 0}
        
    def classify_intent(self, message: str, metadata: Dict[str, Any]) -> ModelType:
        """
        Phân loại intent để chọn model phù hợp
        """
        message_lower = message.lower()
        message_length = len(message)
        
        # === Kiểm tra Voice/Speech Input ===
        if metadata.get("has_audio") or metadata.get("input_type") == "voice":
            return ModelType.MINIMAX
            
        # === Kiểm tra độ dài - yêu cầu dài dùng Kimi ===
        if message_length > self.config.long_content_threshold:
            return ModelType.KIMI
            
        # === Kiểm tra từ khóa cảm xúc - escalation dùng Claude ===
        emotion_keywords = [
            "tệ", "không hài lòng", "phẫn nộ", "quá tệ", "hoàn tiền", 
            "kiện", "tố cáo", "rất thất vọng", "khó chịu", "bực mình",
            " прекрасно", "terrible", "angry", "frustrated", "refund"
        ]
        
        emotion_score = sum(1 for kw in emotion_keywords if kw in message_lower)
        emotion_ratio = emotion_score / max(len(message.split()), 1)
        
        if emotion_ratio > self.config.emotion_threshold or emotion_score >= 2:
            return ModelType.CLAUDE
            
        # === Kiểm tra yêu cầu tổng hợp/summary ===
        summary_keywords = ["tổng hợp", "liệt kê", "danh sách", "summary", "list all"]
        if any(kw in message_lower for kw in summary_keywords):
            return ModelType.KIMI
            
        # === Default: GPT cho general queries ===
        return ModelType.GPT
        
    async def route_and_call(
        self, 
        message: str, 
        metadata: Dict[str, Any] = None,
        conversation_history: list = None
    ) -> Dict[str, Any]:
        """
        Routing thông minh + gọi API với failover
        """
        metadata = metadata or {}
        conversation_history = conversation_history or []
        
        # === Bước 1: Phân loại intent ===
        model = self.classify_intent(message, metadata)
        model_name = model.value
        self.request_count[model.name.lower()] += 1
        
        # === Bước 2: Build request ===
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        system_prompt = self._get_system_prompt(model, metadata)
        
        payload = {
            "model": model_name,
            "messages": [
                {"role": "system", "content": system_prompt},
                *[{"role": msg["role"], "content": msg["content"]} 
                  for msg in conversation_history[-10:]],
                {"role": "user", "content": message}
            ],
            "temperature": 0.7,
            "max_tokens": 2000
        }
        
        # === Bước 3: Gọi API với retry và failover ===
        for attempt in range(self.config.max_retries):
            try:
                start_time = time.time()
                response = await self._call_holysheep(headers, payload)
                latency_ms = (time.time() - start_time) * 1000
                
                return {
                    "success": True,
                    "model_used": model_name,
                    "response": response,
                    "latency_ms": round(latency_ms, 2),
                    "attempt": attempt + 1
                }
                
            except Exception as e:
                if attempt < self.config.max_retries - 1:
                    # === Failover sang DeepSeek ===
                    if model != ModelType.DEEPSEEK:
                        print(f"[HolySheep] {model_name} fail, failover sang DeepSeek...")
                        payload["model"] = ModelType.DEEPSEEK.value
                        model = ModelType.DEEPSEEK
                        await asyncio.sleep(0.5 * (attempt + 1))
                    else:
                        await asyncio.sleep(1)
                else:
                    return {
                        "success": False,
                        "error": str(e),
                        "model_failed": model_name
                    }
        
        return {"success": False, "error": "Max retries exceeded"}
    
    def _get_system_prompt(self, model: ModelType, metadata: Dict) -> str:
        """
        System prompt theo từng model
        """
        base_prompt = """Bạn là agent chăm sóc khách hàng của cửa hàng TMĐT Việt Nam.
Trả lời ngắn gọn, thân thiện, chuyên nghiệp. Luôn hỏi thêm nếu cần làm rõ."""
        
        prompts = {
            ModelType.KIMI: base_prompt + """
Bạn xử lý các yêu cầu phức tạp, dài. 
- Tổng hợp đơn hàng từ nhiều ngày
- So sánh sản phẩm chi tiết
- Trả lời FAQ dài với nhiều điều kiện""",
            
            ModelType.MINIMAX: base_prompt + """
Bạn xử lý input thoại/voice.
- Chuyển đổi speech thành text
- Hiểu intent từ ngữ cảnh hội thoại
- Trả lời tự nhiên như đang nói chuyện""",
            
            ModelType.CLAUDE: base_prompt + """
Bạn xử lý các tình huống nhạy cảm về cảm xúc khách hàng.
- Nhận diện và đồng cảm với cảm xúc tiêu cực
- Escalate khi cần human agent
- Đưa ra giải pháp bồi thường phù hợp""",
            
            ModelType.GPT: base_prompt,
            
            ModelType.DEEPSEEK: base_prompt
        }
        
        return prompts.get(model, base_prompt)
    
    async def _call_holysheep(
        self, 
        headers: Dict, 
        payload: Dict
    ) -> str:
        """Gọi HolySheep API"""
        import aiohttp
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=aiohttp.ClientTimeout(
                    total=self.config.request_timeout / 1000
                )
            ) as resp:
                if resp.status != 200:
                    error_text = await resp.text()
                    raise Exception(f"HTTP {resp.status}: {error_text}")
                    
                data = await resp.json()
                return data["choices"][0]["message"]["content"]

=== SỬ DỤNG ===
async def main():
    router = HolySheepRouter(
        api_key="YOUR_HOLYSHEEP_API_KEY",
        config=RoutingConfig()
    )
    
    # Test các loại query
    test_cases = [
        {
            "msg": "Tôi muốn tổng hợp tất cả đơn hàng từ 01/01/2025 đến 15/01/2025",
            "meta": {"input_type": "text"}
        },
        {
            "msg": "Tôi rất không hài lòng với sản phẩm này, tôi muốn hoàn tiền ngay",
            "meta": {"input_type": "text"}
        },
        {
            "msg": "Xin chào",
            "meta": {"input_type": "voice", "has_audio": True}
        }
    ]
    
    for i, case in enumerate(test_cases):
        result = await router.route_and_call(case["msg"], case["meta"])
        print(f"\n=== Test {i+1} ===")
        print(f"Model: {result.get('model_used', 'N/A')}")
        print(f"Latency: {result.get('latency_ms', 'N/A')}ms")
        print(f"Response: {result.get('response', result.get('error'))[:100]}...")

if __name__ == "__main__":
    asyncio.run(main())

2. SLA Failover Và Health Check System

#!/usr/bin/env python3
"""
HolySheep SLA Monitor & Automatic Failover
File: holysheep_sla_monitor.py
"""

import asyncio
import time
from typing import Dict, List, Optional
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from collections import deque
import aiohttp

=== CẤU HÌNH HOLYSHEEP ===
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"

@dataclass
class ModelHealth:
    """Sức khỏe của từng model"""
    name: str
    endpoint: str
    is_available: bool = True
    consecutive_failures: int = 0
    last_success: datetime = field(default_factory=datetime.now)
    last_failure: Optional[datetime] = None
    avg_latency_ms: float = 0
    latency_history: deque = field(default_factory=lambda: deque(maxlen=100))
    
    # SLA thresholds
    failure_threshold: int = 3
    latency_threshold_ms: float = 3000
    recovery_cooldown_seconds: int = 60

class SLAMonitor:
    """
    Monitor SLA cho multi-model routing
    - Health check tự động mỗi 30 giây
    - Failover khi model fail liên tục
    - Recovery tự động khi model khỏe lại
    - Alert khi SLA drop dưới 99%
    """
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.models: Dict[str, ModelHealth] = {}
        self.sla_history: deque = deque(maxlen=1000)
        self.current_sla: float = 100.0
        self.alert_callbacks: List = []
        
        self._initialize_models()
        
    def _initialize_models(self):
        """Khởi tạo các model được monitor"""
        model_configs = [
            {"name": "kimi", "endpoint": "moonshot/kimi-v1.5-128k"},
            {"name": "minimax", "endpoint": "minimax/t2a-01"},
            {"name": "claude", "endpoint": "anthropic/claude-sonnet-4.5"},
            {"name": "deepseek", "endpoint": "deepseek/deepseek-v3.2"},
            {"name": "gpt", "endpoint": "openai/gpt-4.1"},
        ]
        
        for config in model_configs:
            self.models[config["name"]] = ModelHealth(
                name=config["name"],
                endpoint=config["endpoint"]
            )
    
    async def health_check(self, model: ModelHealth) -> bool:
        """
        Health check định kỳ cho từng model
        Trả về True nếu model healthy
        """
        test_payload = {
            "model": model.endpoint,
            "messages": [{"role": "user", "content": "ping"}],
            "max_tokens": 5
        }
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        try:
            start = time.time()
            async with aiohttp.ClientSession() as session:
                async with session.post(
                    f"{HOLYSHEEP_BASE_URL}/chat/completions",
                    headers=headers,
                    json=test_payload,
                    timeout=aiohttp.ClientTimeout(total=10)
                ) as resp:
                    latency = (time.time() - start) * 1000
                    
                    if resp.status == 200:
                        model.last_success = datetime.now()
                        model.latency_history.append(latency)
                        model.avg_latency_ms = sum(model.latency_history) / len(model.latency_history)
                        
                        # Reset failure count on success
                        if model.consecutive_failures >= model.failure_threshold:
                            print(f"[SLA] ✅ {model.name} recovered!")
                            await self._trigger_recovery(model)
                        
                        model.consecutive_failures = 0
                        model.is_available = True
                        return True
                    else:
                        raise Exception(f"HTTP {resp.status}")
                        
        except Exception as e:
            model.consecutive_failures += 1
            model.last_failure = datetime.now()
            
            print(f"[SLA] ❌ {model.name} failed ({model.consecutive_failures}/{model.failure_threshold}): {e}")
            
            # Check if should mark unavailable
            if model.consecutive_failures >= model.failure_threshold:
                model.is_available = False
                await self._trigger_failover_alert(model)
            
            return False
    
    async def _trigger_failover_alert(self, model: ModelHealth):
        """Alert khi model failover"""
        for callback in self.alert_callbacks:
            await callback({
                "type": "failover",
                "model": model.name,
                "timestamp": datetime.now().isoformat(),
                "action": f"Traffic chuyển sang model fallback"
            })
    
    async def _trigger_recovery(self, model: ModelHealth):
        """Alert khi model recovered"""
        for callback in self.alert_callbacks:
            await callback({
                "type": "recovery",
                "model": model.name,
                "timestamp": datetime.now().isoformat(),
                "avg_latency_ms": round(model.avg_latency_ms, 2)
            })
    
    def get_available_models(self, required_type: Optional[str] = None) -> List[str]:
        """
        Lấy danh sách model khả dụng
        Loại bỏ model có failure count cao
        """
        available = []
        for name, model in self.models.items():
            if model.is_available and model.consecutive_failures < model.failure_threshold:
                if required_type and name != required_type:
                    continue
                available.append(name)
        
        # Sort theo latency (ưu tiên model nhanh nhất)
        available.sort(key=lambda n: self.models[n].avg_latency_ms)
        return available
    
    def get_fallback_model(self, primary_model: str) -> Optional[str]:
        """
        Lấy fallback model phù hợp
        Priority: DeepSeek > GPT > Claude
        """
        fallbacks = {
            "kimi": ["deepseek", "gpt"],
            "minimax": ["gpt", "claude"],
            "claude": ["gpt", "deepseek"],
            "gpt": ["deepseek", "claude"],
            "deepseek": ["gpt"]
        }
        
        available = self.get_available_models()
        for fallback in fallbacks.get(primary_model, ["gpt"]):
            if fallback in available and fallback != primary_model:
                return fallback
        
        return None
    
    async def calculate_sla(self) -> float:
        """
        Tính SLA % dựa trên history
        SLA = (Total Requests - Failed Requests) / Total Requests * 100
        """
        if not self.sla_history:
            return 100.0
        
        total = len(self.sla_history)
        successful = sum(1 for record in self.sla_history if record.get("success"))
        
        self.current_sla = (successful / total) * 100
        return self.current_sla
    
    async def run_monitoring_loop(self, interval_seconds: int = 30):
        """
        Main monitoring loop
        Chạy health check định kỳ cho tất cả model
        """
        print(f"[SLA Monitor] Bắt đầu monitoring (interval: {interval_seconds}s)")
        
        while True:
            for name, model in self.models.items():
                health = await self.health_check(model)
                
                # Log latency
                if health:
                    print(f"[SLA] {name}: ✅ {model.avg_latency_ms:.0f}ms")
                else:
                    print(f"[SLA] {name}: ❌ {model.consecutive_failures} failures")
            
            # Calculate overall SLA
            sla = await self.calculate_sla()
            print(f"[SLA] Current: {sla:.2f}% | Available: {len(self.get_available_models())}/{len(self.models)}")
            
            # Check SLA alert
            if sla < 99.0:
                await self._sla_alert(sla)
            
            await asyncio.sleep(interval_seconds)
    
    async def _sla_alert(self, sla: float):
        """Alert khi SLA drop dưới ngưỡng"""
        print(f"[⚠️ ALERT] SLA dropped to {sla:.2f}%!")
        for callback in self.alert_callbacks:
            await callback({
                "type": "sla_alert",
                "sla": sla,
                "timestamp": datetime.now().isoformat()
            })
    
    def record_request(self, model: str, success: bool, latency_ms: float):
        """Ghi nhận request để tính SLA"""
        self.sla_history.append({
            "model": model,
            "success": success,
            "latency_ms": latency_ms,
            "timestamp": datetime.now()
        })

=== DEMO SỬ DỤNG ===
async def demo():
    monitor = SLAMonitor(api_key="YOUR_HOLYSHEEP_API_KEY")
    
    # Thêm alert callback
    async def my_alert(data):
        print(f"[ALERT] {data}")
    
    monitor.alert_callbacks.append(my_alert)
    
    # Run 3 health checks
    for i in range(3):
        print(f"\n--- Health Check {i+1} ---")
        await monitor.health_check(monitor.models["kimi"])
        await monitor.health_check(monitor.models["claude"])
        await asyncio.sleep(2)
    
    print(f"\nAvailable models: {monitor.get_available_models()}")
    print(f"Fallback for kimi: {monitor.get_fallback_model('kimi')}")

if __name__ == "__main__":
    asyncio.run(demo())

3. Cache Layer Giảm Chi Phí 60%

#!/usr/bin/env python3
"""
HolySheep Intelligent Cache - Giảm chi phí 60%+
File: holysheep_cache.py
"""

import hashlib
import json
import time
from typing import Optional, Any
from dataclasses import dataclass
from collections import OrderedDict
import asyncio

@dataclass
class CacheEntry:
    """Entry trong cache"""
    key: str
    value: Any
    created_at: float
    accessed_at: float
    hit_count: int = 0
    ttl_seconds: int = 3600

class IntelligentCache:
    """
    LRU Cache với TTL và semantic matching
    - Cache response theo semantic hash (không chỉ exact match)
    - Tự động evict theo LRU
    - Metrics để tối ưu hit rate
    """
    
    def __init__(
        self, 
        max_size: int = 10000,
        default_ttl: int = 3600,
        semantic_threshold: float = 0.85
    ):
        self.max_size = max_size
        self.default_ttl = default_ttl
        self.semantic_threshold = semantic_threshold
        
        self._cache: OrderedDict[str, CacheEntry] = OrderedDict()
        self._stats = {
            "hits": 0,
            "misses": 0,
            "evictions": 0,
            "ttl_evictions": 0
        }
    
    def _normalize_text(self, text: str) -> str:
        """Chuẩn hóa text để tạo cache key"""
        text = text.lower().strip()
        text = " ".join(text.split())  # Remove extra whitespace
        return text
    
    def _create_key(self, message: str, model: str, context: dict = None) -> str:
        """
        Tạo cache key từ message và context
        """
        normalized = self._normalize_text(message)
        
        # Include relevant context in key
        context_hash = ""
        if context:
            relevant_keys = ["customer_id", "product_id", "intent_type"]
            relevant_context = {
                k: v for k, v in context.items() 
                if k in relevant_keys
            }
            if relevant_context:
                context_hash = hashlib.md5(
                    json.dumps(relevant_context, sort_keys=True).encode()
                ).hexdigest()[:8]
        
        # Create composite key
        composite = f"{model}:{normalized[:200]}:{context_hash}"
        return hashlib.sha256(composite.encode()).hexdigest()
    
    async def get(
        self, 
        message: str, 
        model: str, 
        context: dict = None
    ) -> Optional[Any]:
        """Lấy response từ cache"""
        key = self._create_key(message, model, context)
        
        if key not in self._cache:
            self._stats["misses"] += 1
            return None
        
        entry = self._cache[key]
        
        # Check TTL
        if time.time() - entry.created_at > entry.ttl_seconds:
            del self._cache[key]
            self._stats["ttl_evictions"] += 1
            self._stats["misses"] += 1
            return None
        
        # Update access time và move to end (LRU)
        entry.accessed_at = time.time()
        entry.hit_count += 1
        self._cache.move_to_end(key)
        
        self._stats["hits"] += 1
        return entry.value
    
    async def set(
        self,
        message: str,
        model: str,
        response: Any,
        context: dict = None,
        ttl: int = None
    ):
        """Lưu response vào cache"""
        key = self._create_key(message, model, context)
        
        # Evict if full (LRU)
        if len(self._cache) >= self.max_size and key not in self._cache:
            evicted_key = next(iter(self._cache))
            del self._cache[evicted_key]
            self._stats["evictions"] += 1
        
        self._cache[key] = CacheEntry(
            key=key,
            value=response,
            created_at=time.time(),
            accessed_at=time.time(),
            ttl_seconds=ttl or self.default_ttl
        )
        self._cache.move_to_end(key)
    
    def get_stats(self) -> dict:
        """Lấy cache statistics"""
        total = self._stats["hits"] + self._stats["misses"]
        hit_rate = (
            self._stats["hits"] / total * 100 
            if total > 0 else 0
        )
        
        return {
            **self._stats,
            "total_requests": total,
            "hit_rate": round(hit_rate, 2),
            "cache_size": len(self._cache),
            "memory_estimate_mb": (
                len(self._cache) * 0.5 / 1024  # ~0.5KB per entry estimate
            )
        }
    
    def clear(self):
        """Clear toàn bộ cache"""
        self._cache.clear()
        self._stats = {
            "hits": 0,
            "misses": 0,
            "evictions": 0,
            "ttl_evictions": 0
        }

=== INTEGRATION VỚI ROUTER ===
class CachedHolySheepRouter:
    """HolySheep Router với cache thông minh"""
    
    def __init__(self, router, cache: IntelligentCache = None):
        self.router = router
        self.cache = cache or IntelligentCache()
        self.cost_savings = 0
    
    async def query(
        self,
        message: str,
        metadata: dict = None,
        context: dict = None,
        use_cache: bool = True
    ):
        """
        Query với cache thông minh
        """
        metadata = metadata or {}
        context = context or {}
        
        # === Check cache first ===
        if use_cache:
            cached_response = await self.cache.get(
                message, 
                metadata.get("model", "default"),
                context
            )
            
            if cached_response:
                self.cost_savings += self._estimate_cost(metadata.get("model"))
                return {
                    **cached_response,
                    "cached": True
                }
        
        # === Call HolySheep ===
        result = await self.router.route_and_call(message, metadata)
        
        # === Store in cache ===
        if use_cache and result.get("success"):
            await self.cache.set(
                message,
                result.get("model_used
Tài nguyên liên quan
📚 Hướng dẫn AI API
💰 Xem giá
📖 Tài liệu nhà phát triển
🚀 Đăng ký miễn phí
Bài viết liên quan
HolySheep Cursor / Cline 双端 MCP 工作流落地教程：统一 API key、模型自动 fall
Triển Khai API Gateway AI Riêng Tư Cho Doanh Nghiệp: So Sánh