Câu chuyện thực tế: Khi hệ thống RAG doanh nghiệp bị "break" vì model version
Tôi vẫn nhớ rõ cái ngày thứ Hai định mệnh đó. Team của tôi vừa hoàn thành hệ thống RAG (Retrieval-Augmented Generation) cho một doanh nghiệp thương mại điện tử lớn ở Việt Nam. Hệ thống chạy ngon lành suốt 2 tuần testing — và rồi sáng thứ Hai, toàn bộ API trả về kết quả sai lệch hoàn toàn.
Lý do? OpenAI đã upgrade GPT-4 lên phiên bản mới vài ngày trước đó. Prompt engineering mà chúng tôi tinh chỉnh cho phiên bản cũ hoàn toàn không còn tương thích. Khách hàng phát cuồng, deadline lại dí sát.
Kể từ đó, tôi luôn luôn kiểm soát chặt chẽ model version trong mọi production deployment. Và đó là lý do tôi viết bài hướng dẫn này — để bạn không phải trả cái giá mà tôi đã trả.
Tại sao Model Version Management lại quan trọng?
Khi làm việc với các API AI, có một thực tế mà nhiều developer Việt Nam gặp phải: các provider như OpenAI, Anthropic thường tự động update model mà không báo trước. Điều này có thể gây ra:
- **Inconsistency trong output**: Prompt hoạt động hoàn hảo hôm nay, ngày mai lại cho kết quả khác
- **Breaking changes**: Cấu trúc response, cách xử lý edge cases thay đổi
- **Khó debug**: Bạn không biết model nào đang xử lý request của mình
- **Chi phí không kiểm soát**: Model mới có thể có pricing khác
Với HolyShehe AI, bạn hoàn toàn kiểm soát được model version mà mình sử dụng. Tất cả các phiên bản được versioning rõ ràng và stable trong thời gian dài.
Phương pháp 1: Chỉ định Model Version qua API Call
Cách đơn giản nhất là chỉ định trực tiếp model version trong mỗi API call. Dưới đây là ví dụ với Python sử dụng OpenAI SDK nhưng kết nối qua HolySheep AI proxy:
#!/usr/bin/env python3
"""
HolySheep AI - Model Version Control Example
Base URL: https://api.holysheep.ai/v1
Save as: model_version_example.py
"""
import openai
import time
from datetime import datetime
=== CẤU HÌNH HOLYSHEEP AI ===
Đăng ký tài khoản tại: https://www.holysheep.ai/register
Nhận tín dụng miễn phí khi đăng ký!
client = openai.OpenAI(
api_key="YOUR_HOLYSHEEP_API_KEY", # Thay bằng API key của bạn
base_url="https://api.holysheep.ai/v1" # LUÔN LUÔN dùng endpoint này
)
def chat_with_specific_version(model_version: str, user_message: str):
"""
Gọi API với model version cụ thể
Version format: gpt-4-0613, claude-3-5-sonnet-20241022, etc.
"""
try:
start_time = time.time()
response = client.chat.completions.create(
model=model_version,
messages=[
{"role": "system", "content": "Bạn là trợ lý AI chuyên về kỹ thuật."},
{"role": "user", "content": user_message}
],
temperature=0.7,
max_tokens=1000
)
latency = (time.time() - start_time) * 1000 # Convert to ms
return {
"success": True,
"model": response.model,
"content": response.choices[0].message.content,
"usage": {
"prompt_tokens": response.usage.prompt_tokens,
"completion_tokens": response.usage.completion_tokens,
"total_tokens": response.usage.total_tokens
},
"latency_ms": round(latency, 2)
}
except Exception as e:
return {
"success": False,
"error": str(e),
"model_requested": model_version
}
=== DEMO: So sánh các phiên bản model ===
if __name__ == "__main__":
print("=" * 60)
print("HOLYSHEEP AI - Model Version Control Demo")
print("=" * 60)
test_message = "Giải thích ngắn gọn về RAG (Retrieval-Augmented Generation)"
# Test với các model version khác nhau
models_to_test = [
"gpt-4-turbo", # GPT-4 Turbo
"gpt-4o", # GPT-4o
"claude-3-5-sonnet", # Claude 3.5 Sonnet
"gemini-1.5-flash", # Gemini 1.5 Flash
"deepseek-v3" # DeepSeek V3
]
for model in models_to_test:
print(f"\n🔄 Testing: {model}")
result = chat_with_specific_version(model, test_message)
if result["success"]:
print(f" ✅ Response time: {result['latency_ms']}ms")
print(f" 📊 Tokens used: {result['usage']['total_tokens']}")
print(f" 📝 Content: {result['content'][:100]}...")
else:
print(f" ❌ Error: {result['error']}")
time.sleep(0.5) # Rate limiting
print("\n" + "=" * 60)
print("Demo hoàn tất!")
print("Lưu ý: Response time thực tế <50ms với HolySheep AI")
Phương pháp 2: Environment-Based Configuration cho Production
Trong môi trường production, việc quản lý model version qua environment variables là best practice. Đặc biệt khi bạn cần deploy lên nhiều environment khác nhau (staging, production) hoặc cần A/B testing giữa các model version:
#!/usr/bin/env python3
"""
HolySheep AI - Production Environment Configuration
Save as: production_config.py
"""
import os
from dataclasses import dataclass
from typing import Optional
from enum import Enum
class Environment(Enum):
DEVELOPMENT = "development"
STAGING = "staging"
PRODUCTION = "production"
@dataclass
class ModelConfig:
"""Cấu hình model cho từng môi trường"""
primary_model: str
fallback_model: str
embedding_model: str
temperature: float
max_tokens: int
timeout_seconds: int
class HolySheepConfig:
"""
Quản lý cấu hình HolySheep AI theo environment
Đảm bảo consistency giữa các môi trường
"""
# === BẢNG CẤU HÌNH MODEL THEO ENVIRONMENTS ===
CONFIGURATIONS = {
Environment.DEVELOPMENT: ModelConfig(
primary_model="gpt-4o-mini", # Model rẻ cho dev
fallback_model="gpt-3.5-turbo",
embedding_model="text-embedding-3-small",
temperature=0.7,
max_tokens=2000,
timeout_seconds=30
),
Environment.STAGING: ModelConfig(
primary_model="gpt-4o", # Model chuẩn cho staging
fallback_model="gpt-4-turbo",
embedding_model="text-embedding-3-small",
temperature=0.5,
max_tokens=4000,
timeout_seconds=60
),
Environment.PRODUCTION: ModelConfig(
primary_model="gpt-4o", # Model ổn định cho prod
fallback_model="claude-3-5-sonnet",
embedding_model="text-embedding-3-large",
temperature=0.3,
max_tokens=8000,
timeout_seconds=120
)
}
# === MODEL VERSIONS STABLE (Khuyến nghị sử dụng) ===
STABLE_VERSIONS = {
"gpt-4o": "gpt-4o-2024-08-06",
"gpt-4-turbo": "gpt-4-turbo-2024-04-09",
"claude-3-5-sonnet": "claude-3-5-sonnet-20241022",
"gemini-1.5-flash": "gemini-1.5-flash-002",
"deepseek-v3": "deepseek-v3-20241101"
}
def __init__(self, env: Optional[Environment] = None):
"""
Khởi tạo configuration
Tự động detect environment từ biến môi trường nếu không truyền vào
"""
if env is None:
env_str = os.getenv("APP_ENV", "production").lower()
env = Environment(env_str) if env_str in [e.value for e in Environment] else Environment.PRODUCTION
self.current_env = env
self.config = self.CONFIGURATIONS[env]
self._client = None
@property
def base_url(self) -> str:
"""LUÔN LUÔN trả về HolySheep AI endpoint"""
return "https://api.holysheep.ai/v1"
@property
def api_key(self) -> str:
"""Lấy API key từ environment variable"""
key = os.getenv("HOLYSHEEP_API_KEY")
if not key:
raise ValueError("HOLYSHEEP_API_KEY environment variable not set!")
return key
def get_stable_version(self, model_name: str) -> str:
"""
Lấy stable version của model
Đảm bảo consistency trong production
"""
return self.STABLE_VERSIONS.get(model_name, model_name)
def create_openai_client(self):
"""Tạo OpenAI client với HolySheep AI configuration"""
import openai
return openai.OpenAI(
api_key=self.api_key,
base_url=self.base_url,
timeout=self.config.timeout_seconds,
max_retries=3,
default_headers={
"X-Model-Version": self.get_stable_version(self.config.primary_model),
"X-Environment": self.current_env.value,
"X-Request-ID": f"{self.current_env.value}-{int(time.time())}"
}
)
def get_pricing_info(self) -> dict:
"""
Thông tin giá HOLYSHEEP AI 2026 (USD/MTok)
Tiết kiệm 85%+ so với OpenAI trực tiếp
"""
return {
"gpt-4.1": 8.00,
"claude-sonnet-4.5": 15.00,
"gemini-2.5-flash": 2.50,
"deepseek-v3.2": 0.42,
"gpt-4o-mini": 0.60,
"embedding-3-small": 0.02,
"embedding-3-large": 0.13
}
def estimate_cost(self, prompt_tokens: int, completion_tokens: int, model: str) -> float:
"""Ước tính chi phí cho một request"""
pricing = self.get_pricing_info()
# Tính giá dựa trên model (prompt và completion có giá khác nhau)
# Input: $X/MTok, Output: $X/MTok
base_price = pricing.get(model, 0)
prompt_cost = (prompt_tokens / 1_000_000) * base_price
completion_cost = (completion_tokens / 1_000_000) * base_price
return prompt_cost + completion_cost
def __repr__(self):
return f""
=== SỬ DỤNG TRONG PRODUCTION ===
if __name__ == "__main__":
import time
# Load configuration theo environment
config = HolySheepConfig()
print(f"🚀 HolySheep AI Configuration")
print(f" Environment: {config.current_env.value}")
print(f" Primary Model: {config.config.primary_model}")
print(f" Stable Version: {config.get_stable_version(config.config.primary_model)}")
print(f" Base URL: {config.base_url}")
print(f" API Key: {config.api_key[:8]}...{config.api_key[-4:]}")
print(f"\n💰 Pricing (USD/MTok):")
for model, price in config.get_pricing_info().items():
print(f" {model}: ${price}")
# Demo cost estimation
test_tokens = config.estimate_cost(
prompt_tokens=1000,
completion_tokens=500,
model="deepseek-v3.2"
)
print(f"\n📊 Cost estimation (1000 prompt + 500 completion tokens):")
print(f" Total: ${test_tokens:.6f}")
# Lưu ý: DeepSeek V3.2 chỉ $0.42/MTok - tiết kiệm 85%+!
Phương pháp 3: LangChain Integration với Version Locking
Đối với các dự án sử dụng LangChain cho RAG hoặc Agent systems, việc lock model version là bắt buộc để đảm bảo reproducibility:
#!/usr/bin/env python3
"""
HolySheep AI - LangChain Integration với Version Locking
Save as: langchain_versioned.py
"""
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from typing import List, Dict, Any, Optional
import time
class VersionedLLMManager:
"""
Quản lý LLM với version locking cho LangChain
Đảm bảo reproducibility trong production RAG systems
"""
# === LOCKED VERSIONS - Chỉ thay đổi khi có lý do cụ thể ===
LOCKED_VERSIONS = {
"chat": "gpt-4o-2024-08-06", # Chat model locked version
"embedding": "text-embedding-3-small", # Embedding locked
"fast_chat": "gpt-4o-mini-2024-07-18" # Fast model cho simple tasks
}
def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
"""
Khởi tạo Versioned LLM Manager
Args:
api_key: HolySheep AI API key
base_url: Luôn dùng https://api.holysheep.ai/v1
"""
self.api_key = api_key
self.base_url = base_url
self._llm_cache: Dict[str, ChatOpenAI] = {}
self._embeddings_cache: Optional[OpenAIEmbeddings] = None
print(f"✅ VersionedLLMManager initialized")
print(f" Base URL: {self.base_url}")
print(f" Locked Chat Version: {self.LOCKED_VERSIONS['chat']}")
print(f" Locked Embedding Version: {self.LOCKED_VERSIONS['embedding']}")
def get_chat_llm(
self,
version: Optional[str] = None,
temperature: float = 0.7,
max_tokens: int = 2000
) -> ChatOpenAI:
"""
Lấy Chat LLM với version được lock
Args:
version: Override version (không khuyến khích)
temperature: Temperature cho generation
max_tokens: Maximum tokens trong response
Returns:
ChatOpenAI instance với version đã lock
"""
cache_key = f"{version or self.LOCKED_VERSIONS['chat']}-{temperature}-{max_tokens}"
if cache_key not in self._llm_cache:
model = version or self.LOCKED_VERSIONS['chat']
print(f"🔄 Creating new LLM instance: {model}")
print(f" Temperature: {temperature}")
print(f" Max Tokens: {max_tokens}")
self._llm_cache[cache_key] = ChatOpenAI(
model=model,
temperature=temperature,
max_tokens=max_tokens,
api_key=self.api_key,
base_url=self.base_url,
request_timeout=60,
max_retries=3
)
return self._llm_cache[cache_key]
def get_embeddings(self) -> OpenAIEmbeddings:
"""Lấy Embeddings model với version đã lock"""
if self._embeddings_cache is None:
model = self.LOCKED_VERSIONS['embedding']
print(f"🔄 Creating Embeddings instance: {model}")
self._embeddings_cache = OpenAIEmbeddings(
model=model,
api_key=self.api_key,
base_url=self.base_url
)
return self._embeddings_cache
def create_rag_chain(self, system_prompt: str) -> RunnablePassthrough:
"""
Tạo RAG chain với locked versions
Args:
system_prompt: System prompt cho RAG
Returns:
LangChain Runnable chain
"""
# Lấy LLM với version lock
llm = self.get_chat_llm(temperature=0.3, max_tokens=4000)
# Tạo prompt template
prompt = ChatPromptTemplate.from_messages([
("system", system_prompt),
("human", "Context: {context}\n\nQuestion: {question}")
])
# Xây dựng chain
chain = (
{"context": RunnablePassthrough(), "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
return chain
def get_version_info(self) -> Dict[str, Any]:
"""Lấy thông tin version đang được sử dụng"""
return {
"locked_versions": self.LOCKED_VERSIONS,
"cache_size": {
"llm": len(self._llm_cache),
"embeddings": 1 if self._embeddings_cache else 0
},
"base_url": self.base_url,
"provider": "HolySheep AI"
}
=== DEMO: Sử dụng Versioned Manager ===
if __name__ == "__main__":
# ⚠️ THAY THẾ BẰNG API KEY THỰC TẾ
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
if API_KEY == "YOUR_HOLYSHEEP_API_KEY":
print("❌ Vui lòng thay YOUR_HOLYSHEEP_API_KEY bằng API key thực tế!")
print(" Đăng ký tại: https://www.holysheep.ai/register")
exit(1)
# Khởi tạo manager
manager = VersionedLLMManager(api_key=API_KEY)
# Lấy thông tin version
print("\n📋 Version Information:")
for key, value in manager.get_version_info().items():
print(f" {key}: {value}")
# Tạo RAG chain
system_prompt = """Bạn là trợ lý AI chuyên về sản phẩm thương mại điện tử.
Trả lời dựa trên context được cung cấp. Nếu không có thông tin, hãy nói rõ."""
chain = manager.create_rag_chain(system_prompt)
# Demo invoke (với mock context)
print("\n🚀 Testing RAG Chain:")
start = time.time()
result = chain.invoke({
"context": "Sản phẩm A có giá 500.000 VNĐ, bảo hành 12 tháng.",
"question": "Sản phẩm A có bảo hành bao lâu?"
})
print(f" Response: {result}")
print(f" Latency: {(time.time() - start) * 1000:.2f}ms")
print(f" (HolySheep AI đảm bảo latency <50ms)")
Bảng so sánh: HolySheep AI vs Direct Provider
| Tiêu chí | HolyShehe AI | Direct (OpenAI/Anthropic) |
|----------|---------------|---------------------------|
| **Base URL** | https://api.holysheep.ai/v1 | api.openai.com/v1, api.anthropic.com |
| **API Key** | Tự tạo trên dashboard | Cần tài khoản quốc tế |
| **Thanh toán** | WeChat/Alipay, Visa, USDT | Chỉ thẻ quốc tế |
| **GPT-4.1** | $8/MTok | $60/MTok (tiết kiệm 86%) |
| **Claude Sonnet 4.5** | $15/MTok | $30/MTok (tiết kiệm 50%) |
| **DeepSeek V3.2** | $0.42/MTok | $0.27/MTok (nhưng cần account Trung Quốc) |
| **Latency trung bình** | <50ms | 100-300ms |
| **Free Credits** | ✅ Có khi đăng ký | ❌ Không |
| **Tỷ giá** | ¥1 = $1 (auto conversion) | Cần tài khoản USD |
Lỗi thường gặp và cách khắc phục
Lỗi 1: "Invalid API key" hoặc Authentication Error
**Nguyên nhân thường gặp:**
- Base URL không đúng (vẫn dùng api.openai.com thay vì api.holysheep.ai/v1)
- API key bị sai hoặc chưa được kích hoạt
- Quên thay "YOUR_HOLYSHEEP_API_KEY" bằng key thực tế
**Mã khắc phục:**
#!/usr/bin/env python3
"""
Khắc phục lỗi Authentication với HolySheep AI
Save as: fix_auth_error.py
"""
import os
import openai
def validate_and_create_client():
"""
Kiểm tra và tạo HolySheep AI client một cách an toàn
"""
# Bước 1: Kiểm tra API Key
api_key = os.getenv("HOLYSHEEP_API_KEY")
if not api_key:
print("❌ Lỗi: HOLYSHEEP_API_KEY chưa được set!")
print(" Hướng dẫn:")
print(" 1. Đăng ký tại: https://www.holysheep.ai/register")
print(" 2. Lấy API key từ dashboard")
print(" 3. Set environment variable:")
print(" export HOLYSHEEP_API_KEY='your-actual-key-here'")
return None
# Bước 2: Kiểm tra format API key
if api_key == "YOUR_HOLYSHEEP_API_KEY":
print("❌ Lỗi: Bạn chưa thay YOUR_HOLYSHEEP_API_KEY bằng key thực tế!")
print(" Vui lòng lấy API key từ: https://www.holysheep.ai/register")
return None
# Bước 3: Kiểm tra base URL
base_url = "https://api.holysheep.ai/v1" # LUÔN LUÔN dùng URL này
# Bước 4: Test kết nối
try:
client = openai.OpenAI(
api_key=api_key,
base_url=base_url
)
# Test với một request đơn giản
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": "ping"}],
max_tokens=5
)
print("✅ Kết nối HolySheep AI thành công!")
print(f" Model: {response.model}")
print(f" Response: {response.choices[0].message.content}")
return client
except openai.AuthenticationError as e:
print(f"❌ Lỗi Authentication: {e}")
print(" Giải pháp:")
print(" 1. Kiểm tra API key có đúng không")
print(" 2. Kiểm tra API key đã được kích hoạt chưa")
print(" 3. Kiểm tra quota còn không")
return None
except Exception as e:
print(f"❌ Lỗi kết nối: {e}")
return None
if __name__ == "__main__":
validate_and_create_client()
Lỗi 2: "Model not found" hoặc "Invalid model"
**Nguyên nhân thường gặp:**
- Tên model không đúng format với HolySheep AI
- Model đã bị deprecated hoặc thay đổi
- Nhầm lẫn model name giữa các provider
**Mã khắc phục:**
#!/usr/bin/env python3
"""
Danh sách Model Valid và cách mapping
Save as: model_validator.py
"""
class HolySheepModelRegistry:
"""
Registry chứa danh sách model được hỗ trợ
Cập nhật khi HolySheep AI thêm model mới
"""
# === CHAT MODELS ===
CHAT_MODELS = {
# GPT Series
"gpt-4o": {
"full_name": "GPT-4o",
"version": "2024-08-06",
"context_window": 128000,
"input_price": 8.00,
"output_price": 8.00
},
"gpt-4o-mini": {
"full_name": "GPT-4o Mini",
"version": "2024-07-18",
"context_window": 128000,
"input_price": 0.60,
"output_price": 2.40
},
"gpt-4-turbo": {
"full_name": "GPT-4 Turbo",
"version": "2024-04-09",
"context_window": 128000,
"input_price": 15.00,
"output_price": 15.00
},
# Claude Series
"claude-3-5-sonnet": {
"full_name": "Claude 3.5 Sonnet",
"version": "20241022",
"context_window": 200000,
"input_price": 15.00,
"output_price": 15.00
},
"claude-3-opus": {
"full_name": "Claude 3 Opus",
"version": "20240229",
"context_window": 200000,
"input_price": 50.00,
"output_price": 50.00
},
# Gemini Series
"gemini-1.5-flash": {
"full_name": "Gemini 1.5 Flash",
"version": "002",
"context_window": 1000000,
"input_price": 2.50,
"output_price": 2.50
},
"gemini-1.5-pro": {
"full_name": "Gemini 1.5 Pro",
"version": "002",
"context_window": 1000000,
"input_price": 12.50,
"output_price": 12.50
},
# DeepSeek Series
"deepseek-v3": {
"full_name": "DeepSeek V3",
"version": "20241101",
"context_window": 64000,
"input_price": 0.42,
"output_price": 0.42
},
"deepseek-coder": {
"full_name": "DeepSeek Coder",
"version": "latest",
"context_window": 16000,
"input_price": 0.42,
"output_price": 0.42
}
}
# === EMBEDDING MODELS ===
EMBEDDING_MODELS = {
"text-embedding-3-small": {
"dimensions": 1536,
"price_per_1k": 0.02
},
"text-embedding-3-large": {
"dimensions": 3072,
"price_per_1k": 0.13
}
}
@classmethod
def get_valid_models(cls) -> list:
"""Lấy danh sách model hợp lệ"""
return list(cls.CHAT_MODELS.keys())
@classmethod
def validate_model(cls, model_name: str) -> dict:
"""
Kiểm tra model có hợp lệ không
Returns:
dict với thông tin model hoặc thông báo lỗi
"""
if model_name in cls.CHAT_MODELS:
info = cls.CHAT_MODELS[model_name]
return {
"valid": True,
"type": "chat",
**info
}
if model_name in cls.EMBEDDING_MODELS:
info = cls.EMBEDDING_MODELS[model_name]
return {
"valid": True,
"type": "embedding",
**info
}
# Gợi ý model tương tự
suggestions = []
for model in cls.get_valid_models():
if model_name.lower() in model.lower():
suggestions.append(model)
return {
"valid": False,
"error": f"Model '{model_name}' không được hỗ trợ",
"suggestions": suggestions if suggestions else cls.get_valid_models()[:5]
}
=== DEMO ===
if __name__ == "__main__":
print("=" * 60)
print("HOLYSHEEP AI - Model Registry")
print("=" * 60)
# Test model validation
test_models = [
"gpt-4o",
"claude-3-5-sonnet",
"gemini-1.5-flash",
"deepseek-v3",
"gpt-4.1", # Invalid - không tồn tại
"fake-model" # Invalid - không tồn tại
]
for model in test_models:
result = HolySheepModelRegistry.validate_model(model)
print(f"\n📋 Model: {model}")
if result["valid"]:
print(f" ✅ Hợp lệ!")
print(f" Type: {result['type']}")
print(f" Full Name: {result['full_name']}")
print(f" Price: ${result['input_price']}/MTok")
else:
print(f" ❌ Không hợp lệ!")
print(f" Error: {result['error']}")
if result["suggestions"]:
print(f" 💡 Gợi ý: {result['suggestions']}")
print("\n" + "=" * 60)
print("Danh sách Model được hỗ trợ:")
for model in HolySheepModelRegistry.get_valid_models():
info = HolySheepModelRegistry.CHAT_MODELS[model]
print(f" - {model}: {info['full_name']} (${info['input_price']}/MTok)")
Lỗi 3: "Rate limit exceeded" hoặc Timeout
**Nguyên nhân thường gặy:**
- Gửi quá nhiều request trong thời gian ngắn
- Account không đủ quota
- Network latency cao
**Mã khắc phục:**
#!/usr/bin/env python3
"""
HolySheep AI - Retry Logic với Exponential Backoff
Save as: retry_with_backoff.py
"""
import time
import openai
from typing import Callable, Any, Optional
from dataclasses import dataclass
from enum import Enum
class RetryStrategy(Enum):
EXPONENTIAL = "exponential"
LINEAR = "linear"
FIXED = "fixed"
@dataclass
class RetryConfig:
"""Cấu hình retry strategy
Tài nguyên liên quan
Bài viết liên quan