HolySheep 智慧地热供暖 Agent: GPT-5 井下温度建模 + Gemini 红外热像分析与 SLA 限流重试配置完整指南 (2026)

Chào mừng bạn đến với bài đánh giá chuyên sâu từ đội ngũ kỹ thuật HolySheep AI. Trong bài viết này, tôi sẽ chia sẻ kinh nghiệm thực chiến khi triển khai hệ thống 智慧地热供暖 Agent — giải pháp AI-driven geothermal heating monitoring sử dụng GPT-5 cho underground temperature modeling, Gemini cho infrared thermal imaging analysis, và chiến lược SLA-backed rate limiting với retry configuration tối ưu. Bài viết bao gồm so sánh giá chi tiết, code mẫu production-ready, và hướng dẫn khắc phục lỗi thường gặp.

TL;DR — Kết Luận Nhanh

Nếu bạn đang tìm kiếm giải pháp AI cho hệ thống địa nhiệt (geothermal heating) với chi phí thấp nhất thị trường, HolySheep AI là lựa chọn tối ưu. Với mức giá từ $0.42/MTok cho DeepSeek V3.2 và độ trễ trung bình dưới 50ms, bạn tiết kiệm được 85%+ chi phí so với API chính thức OpenAI/Anthropic. Đăng ký ngay hôm nay để nhận tín dụng miễn phí khi đăng ký.

Bảng So Sánh Chi Phí: HolySheep vs OpenAI vs Anthropic vs Đối Thủ (2026)

Tiết kiệm khi dùng HolySheep: GPT-4.1 (-86.7%), Gemini 2.5 Flash (-85.7%), DeepSeek V3.2 (-85%)

Giải Pháp 智慧地热供暖 Agent là gì?

Hệ thống Smart Geothermal Heating Agent là ứng dụng AI tiên tiến giúp:

• GPT-5 Underground Temperature Modeling: Dự đoán phân bố nhiệt độ trong các giếng khoan địa nhiệt bằng mô hình GPT-5 với độ chính xác cao
• Gemini Infrared Thermal Imaging Analysis: Phân tích hình ảnh hồng ngoại từ drone/camera nhiệt để phát hiện bất thường nhiệt
• SLA Rate Limiting với Retry Configuration: Đảm bảo uptime 99.9% với chiến lược retry thông minh, exponential backoff
• Real-time Dashboard: Giám sát trạng thái hệ thống địa nhiệt 24/7

Kiến Trúc Hệ Thống

Hệ thống được thiết kế theo mô hình microservice với 3 layer chính:

• Data Collection Layer: Thu thập dữ liệu từ cảm biến IoT, drone thermal camera, SCADA system
• AI Processing Layer: Xử lý bằng GPT-5 (temperature modeling) + Gemini (thermal image analysis)
• Decision & Control Layer: Ra quyết định điều khiển, alert, và reporting

Mã Nguồn Triển Khai Production-Ready

1. Cấu Hình HolySheep API Client với Rate Limiting

"""
HolySheep Geothermal Heating Agent - Core Configuration
Author: HolySheep AI Technical Team
Version: 2.1.0 (2026-05-28)
"""

import os
import time
import asyncio
import httpx
from typing import Optional, Dict, Any, List
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from enum import Enum
import logging

Cấu hình logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

=============================================================================
CẤU HÌNH HOLYSHEEP API - THAY THẾ API KEY CỦA BẠN
=============================================================================
⚠️ LƯU Ý: KHÔNG sử dụng api.openai.com hay api.anthropic.com
Chỉ dùng: https://api.holysheep.ai/v1

@dataclass
class HolySheepConfig:
    """Cấu hình kết nối HolySheep API"""
    # Base URL cho tất cả các endpoint - CHỈ DÙNG HolySheep
    base_url: str = "https://api.holysheep.ai/v1"
    
    # API Key - Đăng ký tại: https://www.holysheep.ai/register
    api_key: str = "YOUR_HOLYSHEEP_API_KEY"
    
    # Timeout configuration (mili giây)
    timeout_ms: int = 30000
    
    # Retry configuration
    max_retries: int = 3
    initial_backoff_ms: int = 100
    max_backoff_ms: int = 10000
    backoff_multiplier: float = 2.0
    
    # Rate limiting
    requests_per_minute: int = 60
    tokens_per_minute: int = 100000
    
    # SLA Configuration
    sla_uptime_target: float = 0.999  # 99.9% uptime
    max_latency_ms: int = 200
    
    def __post_init__(self):
        if self.api_key == "YOUR_HOLYSHEEP_API_KEY":
            logger.warning("⚠️ Vui lòng thay YOUR_HOLYSHEEP_API_KEY bằng key thực tế")
            logger.warning("📝 Đăng ký tại: https://www.holysheep.ai/register")


class RateLimitStrategy(Enum):
    """Chiến lược xử lý rate limit"""
    RETRY_WITH_BACKOFF = "exponential_backoff"
    QUEUE_AND_WAIT = "queue_wait"
    FALLBACK_MODEL = "fallback_model"
    CIRCUIT_BREAKER = "circuit_breaker"


@dataclass
class RateLimitState:
    """Trạng thái rate limiting"""
    remaining_requests: int = 60
    remaining_tokens: int = 100000
    reset_timestamp: datetime = field(default_factory=datetime.now)
    retry_after_seconds: Optional[float] = None
    consecutive_failures: int = 0
    
    def should_wait(self) -> bool:
        if self.retry_after_seconds:
            wait_time = (self.reset_timestamp - datetime.now()).total_seconds()
            return wait_time > 0
        return False


class HolySheepGeothermalClient:
    """
    Client cho HolySheep Geothermal Heating Agent
    Hỗ trợ GPT-5 temperature modeling và Gemini thermal imaging
    """
    
    def __init__(self, config: Optional[HolySheepConfig] = None):
        self.config = config or HolySheepConfig()
        self._client: Optional[httpx.AsyncClient] = None
        self._rate_limit_state = RateLimitState()
        self._circuit_open = False
        self._circuit_open_time: Optional[datetime] = None
        self._request_history: List[Dict] = []
        self._latency_history: List[float] = []
        
    @property
    def client(self) -> httpx.AsyncClient:
        """Lazy initialization của HTTP client"""
        if self._client is None:
            self._client = httpx.AsyncClient(
                base_url=self.config.base_url,
                headers={
                    "Authorization": f"Bearer {self.config.api_key}",
                    "Content-Type": "application/json",
                    "X-Holysheep-Client": "geothermal-agent-v2.1"
                },
                timeout=httpx.Timeout(self.config.timeout_ms / 1000)
            )
        return self._client
    
    async def close(self):
        """Đóng kết nối HTTP"""
        if self._client:
            await self._client.aclose()
            self._client = None
    
    def _calculate_backoff(self, attempt: int) -> float:
        """Tính toán thời gian backoff với exponential backoff"""
        backoff = min(
            self.config.initial_backoff_ms * (self.config.backoff_multiplier ** attempt),
            self.config.max_backoff_ms
        )
        # Thêm jitter để tránh thundering herd
        import random
        jitter = backoff * 0.1 * random.random()
        return (backoff + jitter) / 1000  # Convert sang giây
    
    def _update_rate_limit_state(self, headers: httpx.Headers):
        """Cập nhật trạng thái rate limit từ response headers"""
        if "X-RateLimit-Remaining" in headers:
            self._rate_limit_state.remaining_requests = int(headers["X-RateLimit-Remaining"])
        if "X-RateLimit-Reset" in headers:
            self._rate_limit_state.reset_timestamp = datetime.fromtimestamp(
                int(headers["X-RateLimit-Reset"])
            )
        if "Retry-After" in headers:
            self._rate_limit_state.retry_after_seconds = float(headers["Retry-After"])
    
    async def _execute_with_retry(
        self,
        endpoint: str,
        payload: Dict[str, Any],
        strategy: RateLimitStrategy = RateLimitStrategy.RETRY_WITH_BACKOFF
    ) -> Dict[str, Any]:
        """
        Thực thi request với retry logic theo SLA
        """
        last_error = None
        
        for attempt in range(self.config.max_retries + 1):
            start_time = time.time()
            
            try:
                # Kiểm tra circuit breaker
                if self._circuit_open:
                    if datetime.now() - self._circuit_open_time > timedelta(minutes=5):
                        self._circuit_open = False
                        logger.info("🔄 Circuit breaker reset - thử lại")
                    else:
                        raise Exception("Circuit breaker OPEN - service unavailable")
                
                # Chờ nếu cần thiết
                if self._rate_limit_state.should_wait():
                    wait_time = max(0, (self._rate_limit_state.reset_timestamp - datetime.now()).total_seconds())
                    logger.info(f"⏳ Rate limit - chờ {wait_time:.2f}s")
                    await asyncio.sleep(wait_time)
                
                # Gửi request
                response = await self.client.post(endpoint, json=payload)
                latency_ms = (time.time() - start_time) * 1000
                
                # Ghi nhận latency
                self._latency_history.append(latency_ms)
                if len(self._latency_history) > 1000:
                    self._latency_history = self._latency_history[-500:]
                
                # Xử lý response
                if response.status_code == 200:
                    self._rate_limit_state.consecutive_failures = 0
                    self._update_rate_limit_state(response.headers)
                    result = response.json()
                    logger.info(f"✅ Request thành công - Latency: {latency_ms:.2f}ms")
                    return result
                
                elif response.status_code == 429:
                    # Rate limit exceeded
                    self._update_rate_limit_state(response.headers)
                    logger.warning(f"⚠️ Rate limit (attempt {attempt + 1}/{self.config.max_retries + 1})")
                    
                    if strategy == RateLimitStrategy.CIRCUIT_BREAKER:
                        self._circuit_open = True
                        self._circuit_open_time = datetime.now()
                        raise Exception("Circuit breaker triggered")
                    
                    if attempt < self.config.max_retries:
                        backoff = self._calculate_backoff(attempt)
                        logger.info(f"⏳ Backoff {backoff:.2f}s")
                        await asyncio.sleep(backoff)
                    else:
                        raise Exception(f"Rate limit exceeded after {self.config.max_retries} retries")
                
                elif response.status_code >= 500:
                    # Server error - retry
                    logger.warning(f"⚠️ Server error {response.status_code} (attempt {attempt + 1})")
                    if attempt < self.config.max_retries:
                        backoff = self._calculate_backoff(attempt)
                        await asyncio.sleep(backoff)
                    else:
                        raise Exception(f"Server error after {self.config.max_retries} retries")
                
                else:
                    # Client error - không retry
                    raise Exception(f"Client error: {response.status_code} - {response.text}")
                    
            except httpx.TimeoutException as e:
                latency_ms = (time.time() - start_time) * 1000
                logger.error(f"⏱️ Timeout after {latency_ms:.2f}ms")
                last_error = e
                if attempt < self.config.max_retries:
                    await asyncio.sleep(self._calculate_backoff(attempt))
                    
            except httpx.ConnectError as e:
                logger.error(f"🔌 Connection error: {e}")
                self._circuit_open = True
                self._circuit_open_time = datetime.now()
                raise Exception("Cannot connect to HolySheep API")
                
            except Exception as e:
                last_error = e
                logger.error(f"❌ Error: {e}")
                self._rate_limit_state.consecutive_failures += 1
                
                if self._rate_limit_state.consecutive_failures >= 5:
                    self._circuit_open = True
                    self._circuit_open_time = datetime.now()
                    logger.warning("🚫 Circuit breaker triggered due to consecutive failures")
                
                if attempt < self.config.max_retries:
                    await asyncio.sleep(self._calculate_backoff(attempt))
        
        raise last_error or Exception("Max retries exceeded")
    
    def get_health_metrics(self) -> Dict[str, Any]:
        """Lấy metrics về health của service"""
        avg_latency = sum(self._latency_history) / len(self._latency_history) if self._latency_history else 0
        p95_latency = sorted(self._latency_history)[int(len(self._latency_history) * 0.95)] if self._latency_history else 0
        
        return {
            "uptime_target": f"{self.config.sla_uptime_target * 100}%",
            "avg_latency_ms": round(avg_latency, 2),
            "p95_latency_ms": round(p95_latency, 2),
            "circuit_breaker_status": "OPEN" if self._circuit_open else "CLOSED",
            "consecutive_failures": self._rate_limit_state.consecutive_failures,
            "rate_limit_remaining": self._rate_limit_state.remaining_requests
        }


=============================================================================
KHỞI TẠO CLIENT
=============================================================================
ĐĂNG KÝ API KEY: https://www.holysheep.ai/register

config = HolySheepConfig(
    api_key="YOUR_HOLYSHEEP_API_KEY",  # Thay bằng key thực tế
    max_retries=3,
    requests_per_minute=60
)

geothermal_client = HolySheepGeothermalClient(config)

print("✅ HolySheep Geothermal Client initialized")
print(f"📡 Base URL: {config.base_url}")
print(f"⏱️ Timeout: {config.timeout_ms}ms")
print(f"🔄 Max Retries: {config.max_retries}")
print("\n📝 Đăng ký API key tại: https://www.holysheep.ai/register")

2. GPT-5 Underground Temperature Modeling với HolySheep

"""
GPT-5 Underground Temperature Modeling Module
Sử dụng HolySheep API cho dự đoán nhiệt độ địa nhiệt trong giếng khoan
"""

import json
import asyncio
from typing import List, Dict, Optional, Tuple
from dataclasses import dataclass
from datetime import datetime
import logging

logger = logging.getLogger(__name__)


@dataclass
class WellSensorData:
    """Dữ liệu cảm biến từ một giếng địa nhiệt"""
    well_id: str
    depth_meters: float
    timestamp: datetime
    temperature_celsius: float
    pressure_bar: float
    flow_rate_m3h: float
    geological_layer: str  # e.g., "granite", "sediment", "aquifer"
    water_table_depth: Optional[float] = None


@dataclass
class TemperaturePrediction:
    """Kết quả dự đoán nhiệt độ"""
    well_id: str
    predicted_temps: List[float]
    depth_profile: List[float]
    confidence: float
    anomalies: List[Dict]
    model_version: str
    processing_time_ms: float


class GeothermalTemperatureModel:
    """
    Mô hình dự đoán nhiệt độ ngầm sử dụng GPT-5 qua HolySheep API
    """
    
    def __init__(self, client: HolySheepGeothermalClient):
        self.client = client
        self.model_name = "gpt-5"  # Sử dụng GPT-5 của HolySheep
        self.fallback_model = "deepseek-v3.2"  # Fallback nếu cần
        
    async def predict_temperature_profile(
        self,
        sensor_data: List[WellSensorData],
        target_depth: float = 5000,  # meters
        resolution: int = 50  # Điểm dự đoán
    ) -> TemperaturePrediction:
        """
        Dự đoán profile nhiệt độ theo độ sâu cho toàn bộ mỏ địa nhiệt
        
        Args:
            sensor_data: Dữ liệu từ các giếng cảm biến
            target_depth: Độ sâu mục tiêu (meters)
            resolution: Số điểm dự đoán
            
        Returns:
            TemperaturePrediction với profile nhiệt độ chi tiết
        """
        import time
        start_time = time.time()
        
        # Chuẩn bị context cho GPT-5
        context = self._prepare_model_context(sensor_data, target_depth)
        
        # Gọi HolySheep API với GPT-5
        prompt = f"""
        Bạn là chuyên gia mô hình hóa địa nhiệt (geothermal modeling).
        Dựa trên dữ liệu cảm biến từ {len(sensor_data)} giếng địa nhiệt, hãy:
        
        1. Phân tích gradient nhiệt (geothermal gradient)
        2. Xác định các zone có nhiệt độ bất thường
        3. Dự đoán phân bố nhiệt độ từ 0m đến {target_depth}m
        4. Đề xuất vị trí tối ưu cho drilling
        
        Dữ liệu đầu vào:
        {json.dumps(context, indent=2, default=str)}
        
        Trả về JSON với cấu trúc:
        {{
            "predicted_temps": [danh_sach_nhiet_do_theo_do_sau],
            "depth_profile": [danh_sach_do_sau_tuong_ung],
            "confidence": 0.0-1.0,
            "anomalies": [{{"depth": x, "temp": y, "type": "hot_spot|cold_zone", "severity": "low|medium|high"}}],
            "recommendations": ["cac_de_xuat_drilling"]
        }}
        """
        
        payload = {
            "model": self.model_name,
            "messages": [
                {"role": "system", "content": "Bạn là chuyên gia mô hình hóa địa nhiệt với 20 năm kinh nghiệm."},
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.3,  # Low temperature cho predictions nhất quán
            "max_tokens": 4000,
            "response_format": {"type": "json_object"}
        }
        
        try:
            response = await self.client._execute_with_retry(
                endpoint="/chat/completions",
                payload=payload
            )
            
            result = json.loads(response["choices"][0]["message"]["content"])
            processing_time = (time.time() - start_time) * 1000
            
            return TemperaturePrediction(
                well_id="multi-well-analysis",
                predicted_temps=result.get("predicted_temps", []),
                depth_profile=result.get("depth_profile", []),
                confidence=result.get("confidence", 0.0),
                anomalies=result.get("anomalies", []),
                model_version=response.get("model", "unknown"),
                processing_time_ms=processing_time
            )
            
        except Exception as e:
            logger.error(f"❌ GPT-5 prediction failed: {e}")
            # Fallback to simpler model
            return await self._fallback_prediction(sensor_data, target_depth)
    
    def _prepare_model_context(
        self,
        sensor_data: List[WellSensorData],
        target_depth: float
    ) -> Dict:
        """Chuẩn bị context data cho model"""
        
        # Tính toán statistics
        temps = [s.temperature_celsius for s in sensor_data]
        depths = [s.depth_meters for s in sensor_data]
        
        # Phân nhóm theo geological layer
        layers = {}
        for s in sensor_data:
            if s.geological_layer not in layers:
                layers[s.geological_layer] = []
            layers[s.geological_layer].append({
                "depth": s.depth_meters,
                "temp": s.temperature_celsius,
                "well_id": s.well_id
            })
        
        return {
            "analysis_timestamp": datetime.now().isoformat(),
            "num_wells": len(sensor_data),
            "target_depth_m": target_depth,
            "temperature_stats": {
                "min": min(temps),
                "max": max(temps),
                "avg": sum(temps) / len(temps),
                "gradient_per_m": (max(temps) - min(temps)) / max(depths) if max(depths) > 0 else 0
            },
            "geological_layers": layers,
            "well_data_summary": [
                {
                    "well_id": s.well_id,
                    "depth": s.depth_meters,
                    "temp": s.temperature_celsius,
                    "pressure": s.pressure_bar,
                    "flow_rate": s.flow_rate_m3h,
                    "layer": s.geological_layer
                }
                for s in sensor_data
            ]
        }
    
    async def _fallback_prediction(
        self,
        sensor_data: List[WellSensorData],
        target_depth: float
    ) -> TemperaturePrediction:
        """Fallback sử dụng DeepSeek V3.2 - model rẻ hơn 95%"""
        
        import time
        start_time = time.time()
        
        logger.info("🔄 Falling back to DeepSeek V3.2 for prediction")
        
        # Sử dụng DeepSeek V3.2 với giá chỉ $0.42/MTok
        payload = {
            "model": self.fallback_model,
            "messages": [
                {"role": "user", "content": f"Predict temperature gradient from surface to {target_depth}m based on {len(sensor_data)} sensor readings. Return JSON."}
            ],
            "temperature": 0.3,
            "max_tokens": 2000
        }
        
        try:
            response = await self.client._execute_with_retry(
                endpoint="/chat/completions",
                payload=payload
            )
            
            content = response["choices"][0]["message"]["content"]
            try:
                result = json.loads(content)
            except:
                result = {"predicted_temps": [], "confidence": 0.5}
            
            processing_time = (time.time() - start_time) * 1000
            
            return TemperaturePrediction(
                well_id="fallback-analysis",
                predicted_temps=result.get("predicted_temps", []),
                depth_profile=result.get("depth_profile", []),
                confidence=result.get("confidence", 0.5) * 0.8,  # Giảm confidence cho fallback
                anomalies=[],
                model_version=f"{self.fallback_model}-fallback",
                processing_time_ms=processing_time
            )
            
        except Exception as e:
            logger.error(f"❌ Fallback prediction also failed: {e}")
            raise


class AnomalyDetector:
    """Phát hiện bất thường nhiệt độ real-time"""
    
    def __init__(self, client: HolySheepGeothermalClient):
        self.client = client
        
    async def detect_anomalies(
        self,
        current_readings: List[WellSensorData],
        historical_avg: Dict[str, float],  # well_id -> avg_temp
        threshold_std: float = 2.0  # Standard deviations for anomaly
    ) -> List[Dict]:
        """
        Phát hiện bất thường nhiệt độ sử dụng Gemini qua HolySheep
        """
        
        anomaly_prompt = f"""
        Phân tích dữ liệu cảm biến địa nhiệt để phát hiện bất thường:
        
        Dữ liệu hiện tại:
        {json.dumps([{
            "well_id": s.well_id,
            "temp": s.temperature_celsius,
            "expected_avg": historical_avg.get(s.well_id, s.temperature_celsius),
            "deviation": s.temperature_celsius - historical_avg.get(s.well_id, s.temperature_celsius),
            "depth": s.depth_meters,
            "pressure": s.pressure_bar
        } for s in current_readings], indent=2, default=str)}
        
        Trả về JSON:
        {{
            "anomalies": [
                {{
                    "well_id": "string",
                    "type": "temperature_spike|pressure_drop|flow_anomaly|cooling_trend",
                    "severity": "low|medium|high|critical",
                    "deviation_from_normal": number,
                    "possible_causes": ["string"],
                    "recommended_actions": ["string"]
                }}
            ],
            "overall_system_health": "healthy|warning|critical",
            "confidence": 0.0-1.0
        }}
        """
        
        payload = {
            "model": "gemini-2.5-flash",  # Dùng Gemini cho phân tích nhanh
            "messages": [
                {"role": "user", "content": anomaly_prompt}
            ],
            "temperature": 0.2,
            "max_tokens": 2000
        }
        
        try:
            response = await self.client._execute_with_retry(
                endpoint="/chat/completions",
                payload=payload
            )
            
            result = json.loads(response["choices"][0]["message"]["content"])
            return result.get("anomalies", [])
            
        except Exception as e:
            logger.error(f"❌ Anomaly detection failed: {e}")
            return []


=============================================================================
VÍ DỤ SỬ DỤNG
=============================================================================

async def main():
    """Ví dụ sử dụng Geothermal Temperature Model"""
    
    # Khởi tạo client
    config = HolySheepConfig(api_key="YOUR_HOLYSHEEP_API_KEY")
    client = HolySheepGeothermalClient(config)
    
    # Dữ liệu cảm biến mẫu
    sensor_data = [
        WellSensorData(
            well_id="GTH-001",
            depth_meters=1500,
            timestamp=datetime.now(),
            temperature_celsius=85.5,
            pressure_bar=150,
            flow_rate_m3h=45.2,
            geological_layer="granite",
            water_table_depth=200
        ),
        WellSensorData(
            well_id="GTH-002",
            depth_meters=1800,
            timestamp=datetime.now(),
            temperature_celsius=92.3,
            pressure_bar=165,
            flow_rate_m3h=52.1,
            geological_layer="granite",
            water_table_depth=180
        ),
        WellSensorData(
            well_id="GTH-003",
            depth_meters=2000,
            timestamp=datetime.now(),
            temperature_celsius=105.8,
            pressure_bar=180,
            flow_rate_m3h=48.7,
            geological_layer="basalt",
            water_table_depth=220
        )
    ]
    
    # Khởi tạo model
    temp_model = GeothermalTemperatureModel(client)
    
    # Dự đoán nhiệt độ profile
    prediction = await temp_model.predict_temperature_profile(
        sensor_data=sensor_data,
        target_depth=5000,
        resolution=100
    )
    
    print(f"\n📊 Temperature Prediction Results")
    print(f"   Well ID: {prediction.well_id}")
    print(f"   Model: {prediction.model_version}")
    print(f"   Confidence: {prediction.confidence:.2%}")
    print(f"   Processing Time: {prediction.processing_time_ms:.2f}ms")
    print(f"   Anomalies Found: {len(prediction.anomalies)}")
    
    # Cleanup
    await client.close()


if __name__ == "__main__":
    print("🔥 HolySheep Geothermal Temperature Modeling")
    print("📝 Sử dụng GPT-5 cho predictions, DeepSeek V3.2 làm fallback")
    print("💰 Chi phí: GPT-5 $8/MTok, DeepSeek V3.2 $0.42/MTok (tiết kiệm 95%)")
    print("\n🚀 Chạy ví dụ...")
    asyncio
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í