Từ kinh nghiệm triển khai hệ thống AI cho 50+ doanh nghiệp, tôi nhận ra một thực tế: 80% các sự cố nghiêm trọng đều bắt nguồn từ việc không phân tách rõ ràng giữa môi trường thử nghiệm và sản xuất. Bài viết này sẽ hướng dẫn chi tiết cách xây dựng hệ thống cách ly hoàn chỉnh, đồng thời tiết kiệm đến 85% chi phí API nhờ tỷ giá ưu đãi từ HolySheep AI.
Tại Sao Cần Cách Ly Sandbox và Production?
Khi làm việc với các mô hình AI như GPT-4.1 ($8/MTok), Claude Sonnet 4.5 ($15/MTok), Gemini 2.5 Flash ($2.50/MTok), hay DeepSeek V3.2 ($0.42/MTok), việc phân tách môi trường không chỉ là best practice — đó là chiến lược tài chính.
So Sánh Chi Phí Thực Tế Cho 10 Triệu Token/Tháng
| Mô Hình | Giá Gốc | HolySheep (85% tiết kiệm) | Tiết Kiệm |
|---|---|---|---|
| GPT-4.1 | $80 | $12 | $68 |
| Claude Sonnet 4.5 | $150 | $22.50 | $127.50 |
| Gemini 2.5 Flash | $25 | $3.75 | $21.25 |
| DeepSeek V3.2 | $4.20 | $0.63 | $3.57 |
Với mô hình hybrid sử dụng 5M token Gemini + 3M DeepSeek + 2M GPT-4, chi phí hàng tháng chỉ còn $16.38 thay vì $109.20 — tiết kiệm $92.82 mỗi tháng.
Kiến Trúc Cách Ly 3 Lớp
Tôi đã áp dụng kiến trúc sau cho các dự án production và đạt độ uptime 99.95% trong 18 tháng qua:
Lớp 1: API Gateway Đa Môi Trường
# config/environments.py
from enum import Enum
from dataclasses import dataclass
from typing import Optional
import os
class Environment(Enum):
SANDBOX = "sandbox"
STAGING = "staging"
PRODUCTION = "production"
@dataclass
class APIConfig:
base_url: str
api_key: str
timeout: int
max_retries: int
rate_limit_per_minute: int
@classmethod
def get_config(cls, env: Environment) -> 'APIConfig':
"""Lấy cấu hình theo môi trường"""
configs = {
Environment.SANDBOX: cls(
base_url="https://api.holysheep.ai/v1",
api_key=os.getenv("HOLYSHEEP_SANDBOX_KEY"),
timeout=30,
max_retries=3,
rate_limit_per_minute=60
),
Environment.PRODUCTION: cls(
base_url="https://api.holysheep.ai/v1",
api_key=os.getenv("HOLYSHEEP_PRODUCTION_KEY"),
timeout=60,
max_retries=5,
rate_limit_per_minute=600
)
}
return configs.get(env, configs[Environment.SANDBOX])
class AIBaseClient:
"""Client cơ sở với cách ly môi trường"""
def __init__(self, env: Environment):
self.config = APIConfig.get_config(env)
self.env = env
self._validate_config()
def _validate_config(self):
if not self.config.api_key:
raise ValueError(
f"API key missing for {self.env.value} environment. "
"Check HOLYSHEEP_SANDBOX_KEY or HOLYSHEEP_PRODUCTION_KEY"
)
if self.env == Environment.PRODUCTION:
assert self.config.rate_limit_per_minute >= 100, \
"Production requires rate_limit >= 100 req/min"
Lớp 2: Service Factory Với Isolation
# services/ai_factory.py
from abc import ABC, abstractmethod
from enum import Enum
from typing import Dict, Type, Any
from .ai_client import AIBaseClient, Environment
from .cost_tracker import CostTracker
class ModelType(Enum):
GPT_4_1 = "gpt-4.1"
CLAUDE_SONNET = "claude-sonnet-4.5"
GEMINI_FLASH = "gemini-2.5-flash"
DEEPSEEK_V3 = "deepseek-v3.2"
class AIResponse:
def __init__(self, content: str, model: str,
tokens_used: int, latency_ms: float, cost: float):
self.content = content
self.model = model
self.tokens_used = tokens_used
self.latency_ms = latency_ms
self.cost = cost
class AIService(ABC):
"""Abstract base cho tất cả AI services"""
PRICING = {
ModelType.GPT_4_1: 8.0, # $/MTok
ModelType.CLAUDE_SONNET: 15.0,
ModelType.GEMINI_FLASH: 2.50,
ModelType.DEEPSEEK_V3: 0.42,
}
def __init__(self, client: AIBaseClient,
cost_tracker: CostTracker):
self.client = client
self.cost_tracker = cost_tracker
@abstractmethod
async def generate(self, prompt: str, **kwargs) -> AIResponse:
pass
def calculate_cost(self, tokens: int, model: ModelType) -> float:
"""Tính chi phí với độ chính xác cent"""
return round(tokens / 1_000_000 * self.PRICING[model], 4)
class ChatService(AIService):
"""Service cho các mô hình chat"""
MODEL_MAPPING = {
ModelType.GPT_4_1: "gpt-4-1",
ModelType.CLAUDE_SONNET: "claude-sonnet-4-5",
ModelType.DEEPSEEK_V3: "deepseek-v3.2",
}
async def generate(self, prompt: str,
model: ModelType = ModelType.GPT_4_1,
temperature: float = 0.7,
max_tokens: int = 2048) -> AIResponse:
import time
start = time.perf_counter()
# Build request
request_body = {
"model": self.MODEL_MAPPING[model],
"messages": [{"role": "user", "content": prompt}],
"temperature": temperature,
"max_tokens": max_tokens
}
# Call API thông qua client đã cách ly
response = await self.client.post(
"/chat/completions",
json=request_body
)
latency_ms = (time.perf_counter() - start) * 1000
# Parse response
usage = response["usage"]
total_tokens = usage["prompt_tokens"] + usage["completion_tokens"]
cost = self.calculate_cost(total_tokens, model)
# Track chi phí
await self.cost_tracker.record(
environment=self.client.env.value,
model=model.value,
tokens=total_tokens,
cost=cost
)
return AIResponse(
content=response["choices"][0]["message"]["content"],
model=model.value,
tokens_used=total_tokens,
latency_ms=round(latency_ms, 2),
cost=cost
)
class AIServiceFactory:
"""Factory pattern để tạo services với cách ly"""
_services: Dict[Environment, Dict[str, AIService]] = {}
@classmethod
def get_service(cls, env: Environment,
service_type: str = "chat") -> AIService:
"""Lấy service đã được cách ly theo môi trường"""
if env not in cls._services:
client = AIBaseClient(env)
tracker = CostTracker(env)
cls._services[env] = {
"chat": ChatService(client, tracker)
}
return cls._services[env][service_type]
Lớp 3: Middleware Quản Lý Chi Phí Real-time
# middleware/cost_guard.py
from fastapi import Request, HTTPException
from starlette.middleware.base import BaseHTTPMiddleware
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import Dict
import asyncio
@dataclass
class BudgetLimit:
monthly_limit: float
daily_limit: float
alert_threshold: float = 0.8
@property
def alert_at(self) -> float:
return self.monthly_limit * self.alert_threshold
@dataclass
class UsageTracker:
"""Theo dõi chi phí theo thời gian thực"""
monthly_spend: float = 0.0
daily_spend: float = 0.0
last_reset: datetime = field(default_factory=datetime.now)
request_count: int = 0
def reset_if_new_day(self):
if (datetime.now() - self.last_reset).days >= 1:
self.daily_spend = 0.0
self.last_reset = datetime.now()
class CostGuardMiddleware(BaseHTTPMiddleware):
"""
Middleware bảo vệ ngân sách - tự động block
khi vượt ngưỡng cho phép
"""
def __init__(self, app, budget: BudgetLimit,
environment: str):
super().__init__(app)
self.budget = budget
self.environment = environment
self.tracker = UsageTracker()
self._lock = asyncio.Lock()
async def dispatch(self, request: Request, call_next):
# Reset daily nếu cần
self.tracker.reset_if_new_day()
# Extract cost từ request body (nếu có)
estimated_cost = self._estimate_cost(request)
async with self._lock:
# Check ngưỡng
if self.tracker.daily_spend + estimated_cost > self.budget.daily_limit:
raise HTTPException(
status_code=429,
detail=f"Daily budget exceeded. "
f"Limit: ${self.budget.daily_limit:.2f}, "
f"Current: ${self.tracker.daily_spend:.2f}"
)
if self.tracker.monthly_spend + estimated_cost > self.budget.monthly_limit:
raise HTTPException(
status_code=402,
detail=f"Monthly budget exceeded. "
f"Limit: ${self.budget.monthly_limit:.2f}"
)
# Alert nếu gần đạt ngưỡng
if self.tracker.monthly_spend >= self.budget.alert_at:
await self._send_alert()
response = await call_next(request)
return response
def _estimate_cost(self, request: Request) -> float:
"""Ước tính chi phí từ request"""
# Implement logic estimate dựa trên model và token count
return 0.01 # Default estimate
Sử dụng trong FastAPI app
from config.environments import Environment
#
sandbox_budget = BudgetLimit(monthly_limit=50, daily_limit=5)
production_budget = BudgetLimit(monthly_limit=500, daily_limit=50)
#
if env == Environment.PRODUCTION:
app.add_middleware(CostGuardMiddleware,
budget=production_budget,
environment="production")
Cấu Hình Docker Compose Đa Môi Trường
# docker-compose.yml
version: '3.8'
x-api-base: &api_base
BASE_URL: https://api.holysheep.ai/v1
# KHÔNG BAO GIỜ hardcode api.openai.com ở đây
services:
# =====================
# MÔI TRƯỜNG SANDBOX
# =====================
api-sandbox:
build:
context: .
dockerfile: Dockerfile
environment:
<<: *api_base
API_KEY: ${HOLYSHEEP_SANDBOX_KEY}
ENVIRONMENT: sandbox
LOG_LEVEL: DEBUG
RATE_LIMIT: 60
CORS_ORIGINS: "http://localhost:3000"
ports:
- "8001:8000"
volumes:
- ./logs/sandbox:/app/logs
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
interval: 30s
timeout: 10s
retries: 3
networks:
- ai-sandbox-net
deploy:
resources:
limits:
cpus: '0.5'
memory: 512M
# =====================
# MÔI TRƯỜNG PRODUCTION
# =====================
api-production:
build:
context: .
dockerfile: Dockerfile
environment:
<<: *api_base
API_KEY: ${HOLYSHEEP_PRODUCTION_KEY}
ENVIRONMENT: production
LOG_LEVEL: INFO
RATE_LIMIT: 600
CORS_ORIGINS: "https://yourdomain.com"
ports:
- "8000:8000"
volumes:
- ./logs/production:/app/logs
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
interval: 15s
timeout: 5s
retries: 5
networks:
- ai-production-net
deploy:
replicas: 2
resources:
limits:
cpus: '2'
memory: 2G
networks:
ai-sandbox-net:
driver: bridge
ai-production-net:
driver: bridge
ipam:
config:
- subnet: 172.28.0.0/16
Tích Hợp HolySheep AI — Tiết Kiệm 85%+ Chi Phí
Trong quá trình triển khai, tôi đã thử nghiệm nhiều nhà cung cấp API. HolySheep AI nổi bật với:
- Tỷ giá ưu đãi: ¥1 = $1 (thay vì tỷ giá thị trường), tiết kiệm đến 85%+
- Độ trễ thấp: Trung bình <50ms với hạ tầng được tối ưu
- Thanh toán linh hoạt: Hỗ trợ WeChat Pay, Alipay, Visa/Mastercard
- Tín dụng miễn phí: Nhận $5 credit khi đăng ký tài khoản mới
- API tương thích: Sử dụng endpoint https://api.holysheep.ai/v1 hoàn toàn tương thích OpenAI SDK
# Ví dụ tích hợp hoàn chỉnh với HolySheep AI
import os
from openai import AsyncOpenAI
from cost_tracker import CostTracker
class HolySheepClient:
"""
Client tối ưu chi phí sử dụng HolySheep AI
Base URL: https://api.holysheep.ai/v1 (KHÔNG phải api.openai.com)
"""
def __init__(self, api_key: str = None,
environment: str = "production"):
self.client = AsyncOpenAI(
api_key=api_key or os.getenv("HOLYSHEEP_API_KEY"),
base_url="https://api.holysheep.ai/v1", # Endpoint chính thức
timeout=60.0,
max_retries=3
)
self.cost_tracker = CostTracker(environment)
async def chat(self, prompt: str,
model: str = "gpt-4-1",
**kwargs) -> dict:
"""Gọi API với tracking chi phí"""
import time
start = time.perf_counter()
response = await self.client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": prompt}],
**kwargs
)
latency_ms = (time.perf_counter() - start) * 1000
usage = response.usage
# Tính chi phí thực tế với bảng giá HolySheep 2026
cost = self._calculate_cost(usage.total_tokens, model)
await self.cost_tracker.record(
model=model,
tokens=usage.total_tokens,
cost=cost,
latency_ms=latency_ms
)
return {
"content": response.choices[0].message.content,
"model": model,
"tokens": usage.total_tokens,
"cost_usd": cost,
"latency_ms": round(latency_ms, 2)
}
def _calculate_cost(self, tokens: int, model: str) -> float:
"""Tính chi phí theo bảng giá HolySheep 2026"""
pricing = {
"gpt-4-1": 8.0, # $8/MTok
"claude-sonnet-4-5": 15.0, # $15/MTok
"gemini-2.5-flash": 2.50, # $2.50/MTok
"deepseek-v3.2": 0.42, # $0.42/MTok
}
rate = pricing.get(model, 8.0)
return round(tokens / 1_000_000 * rate, 4)
Sử dụng
client = HolySheepClient(
api_key="YOUR_HOLYSHEEP_API_KEY",
environment="production"
)
#
result = await client.chat(
prompt="Phân tích dữ liệu bán hàng tháng này",
model="deepseek-v3.2" # Chi phí thấp nhất
)
print(f"Chi phí: ${result['cost_usd']:.4f}")
Monitoring và Alerting Chi Phí
Để kiểm soát chi phí hiệu quả, tôi sử dụng dashboard real-time với Prometheus và Grafana:
# monitoring/cost_dashboard.py
from prometheus_client import Counter, Histogram, Gauge
from datetime import datetime, timedelta
import asyncio
Metrics cho Prometheus
REQUEST_COUNT = Counter(
'ai_api_requests_total',
'Total AI API requests',
['environment', 'model', 'status']
)
TOKEN_USAGE = Counter(
'ai_tokens_used_total',
'Total tokens used',
['environment', 'model']
)
COST_USD = Counter(
'ai_cost_usd_total',
'Total cost in USD',
['environment', 'model']
)
LATENCY_MS = Histogram(
'ai_request_latency_ms',
'Request latency in milliseconds',
['environment', 'model'],
buckets=[10, 25, 50, 100, 200, 500, 1000]
)
MONTHLY_BUDGET = Gauge(
'ai_monthly_budget_remaining',
'Remaining monthly budget in USD',
['environment']
)
class CostMonitor:
"""Monitor chi phí real-time với alerting"""
def __init__(self, environment: str):
self.environment = environment
self.daily_costs = {}
self.monthly_total = 0.0
self.budget_alerts = []
async def record_request(self, model: str, tokens: int,
cost: float, latency_ms: float,
success: bool = True):
"""Ghi nhận request với metrics"""
status = "success" if success else "error"
# Update Prometheus counters
REQUEST_COUNT.labels(
environment=self.environment,
model=model,
status=status
).inc()
TOKEN_USAGE.labels(
environment=self.environment,
model=model
).inc(tokens)
COST_USD.labels(
environment=self.environment,
model=model
).inc(cost)
LATENCY_MS.labels(
environment=self.environment,
model=model
).observe(latency_ms)
# Update internal tracking
today = datetime.now().date()
self.daily_costs[today] = self.daily_costs.get(today, 0) + cost
self.monthly_total += cost
# Check alerts
await self._check_alerts(cost)
async def _check_alerts(self, current_cost: float):
"""Kiểm tra và gửi alerts"""
# Alert khi chi phí vượt ngưỡng
if self.monthly_total >= 100 and len(self.budget_alerts) == 0:
await self._send_alert(
level="warning",
message=f"Monthly spending reached ${self.monthly_total:.2f}"
)
self.budget_alerts.append("monthly_warning")
if self.monthly_total >= 200:
await self._send_alert(
level="critical",
message=f"Monthly budget nearly exhausted: ${self.monthly_total:.2f}"
)
async def _send_alert(self, level: str, message: str):
"""Gửi alert qua webhook/Slack/Email"""
# Implement notification logic
print(f"[{level.upper()}] {message}")
Cron job chạy hàng ngày để reset daily tracking
async def reset_daily_costs():
while True:
await asyncio.sleep(86400) # 24 giờ
# Reset daily counters
pass
Lỗi Thường Gặp và Cách Khắc Phục
Qua 3 năm triển khai hệ thống AI production, tôi đã gặp và xử lý hàng trăm lỗi. Dưới đây là 5 lỗi phổ biến nhất kèm giải pháp:
1. Lỗi "Invalid API Key" - Sai Endpoint
Mô tả: Nhận được lỗi 401 dù API key hoàn toàn chính xác.
Nguyên nhân: SDK mặc định trỏ đến api.openai.com thay vì HolySheep.
# ❌ SAI - Sử dụng endpoint mặc định
client = AsyncOpenAI(api_key="YOUR_KEY")
✅ ĐÚNG - Chỉ định rõ base_url
client = AsyncOpenAI(
api_key="YOUR_HOLYSHEEP_API_KEY",
base_url="https://api.holysheep.ai/v1" # Endpoint chính xác
)
Verify bằng cách gọi test
models = await client.models.list()
print(models)
2. Lỗi "Rate Limit Exceeded" Trong Production
Mô tả: API trả về 429 khi lưu lượng tăng đột ngột.
Giải pháp: Implement exponential backoff và rate limiter phía client.
import asyncio
from ratelimit import limits, sleep_and_retry
class RateLimitedClient:
"""Client với rate limiting thông minh"""
def __init__(self, calls: int, period: float):
self.calls = calls
self.period = period
self.semaphore = asyncio.Semaphore(calls // 10)
async def call_with_retry(self, func, *args, max_retries=5, **kwargs):
"""Gọi API với exponential backoff"""
for attempt in range(max_retries):
try:
async with self.semaphore:
return await func(*args, **kwargs)
except Exception as e:
if "429" in str(e) or "rate limit" in str(e).lower():
wait_time = min(2 ** attempt * 0.5, 30) # Max 30s
print(f"Rate limited. Waiting {wait_time}s...")
await asyncio.sleep(wait_time)
else:
raise
raise Exception(f"Max retries ({max_retries}) exceeded")
Sử dụng
rate_limiter = RateLimitedClient(calls=600, period=60) # 600 req/min
result = await rate_limiter.call_with_retry(
client.chat.completions.create,
model="gpt-4-1",
messages=[{"role": "user", "content": "Hello"}]
)
3. Lỗi Cost Explosion - Không Kiểm Soát Được Chi Phí
Mô tả: Chi phí API tăng vượt kiểm soát trong tháng.
Giải pháp: Implement budget guard với automatic circuit breaker.
class BudgetCircuitBreaker:
"""
Circuit breaker tự động ngắt khi vượt ngân sách
"""
def __init__(self, monthly_budget: float):
self.monthly_budget = monthly_budget
self.current_spend = 0.0
self.is_open = False
self.reset_date = self._get_next_month()
def _get_next_month(self) -> datetime:
today = datetime.now()
if today.month == 12:
return datetime(today.year + 1, 1, 1)
return datetime(today.year, today.month + 1, 1)
async def execute(self, cost_estimate: float, func, *args, **kwargs):
"""Thực thi với kiểm tra ngân sách"""
# Reset nếu sang tháng mới
if datetime.now() >= self.reset_date:
self.current_spend = 0.0
self.is_open = False
self.reset_date = self._get_next_month()
# Check circuit breaker
if self.is_open:
raise Exception("Circuit breaker OPEN - Budget exceeded")
# Check ngân sách trước khi thực thi
if self.current_spend + cost_estimate > self.monthly_budget:
self.is_open = True
await self._notify_budget_exceeded()
raise Exception(
f"Budget exceeded! Current: ${self.current_spend:.2f}, "
f"Attempted: ${cost_estimate:.2f}, Budget: ${self.monthly_budget:.2f}"
)
# Execute
result = await func(*args, **kwargs)
self.current_spend += cost_estimate
return result
async def _notify_budget_exceeded(self):
"""Gửi notification khi ngân sách bị vượt"""
# Implement notification (Slack, Email, etc.)
print(f"⚠️ BUDGET EXCEEDED: ${self.current_spend:.2f}/{self.monthly_budget:.2f}")
Sử dụng
breaker = BudgetCircuitBreaker(monthly_budget=200) # $200/month
Estimate cost trước khi gọi
estimated_cost = tokens / 1_000_000 * 8.0 # GPT-4.1 pricing
result = await breaker.execute(
cost_estimate=estimated_cost,
func=client.chat.completions.create,
model="gpt-4-1",
messages=[{"role": "user", "content": prompt}]
)
4. Lỗi Context Overflow - Token Limit Exceeded
Mô tả: Lỗi 400 với message "maximum context length exceeded".
class ContextManager:
"""Quản lý context window thông minh"""
CONTEXT_LIMITS = {
"gpt-4-1": 128000,
"claude-sonnet-4-5": 200000,
"gemini-2.5-flash": 1000000,
"deepseek-v3.2": 64000,
}
def __init__(self, model: str):
self.model = model
self.limit = self.CONTEXT_LIMITS.get(model, 8000)
# Reserve 20% cho response
self.max_input = int(self.limit * 0.8)
def truncate_to_fit(self, messages: list) -> list:
"""Truncate messages để fit vào context window"""
total_tokens = self._count_tokens(messages)
if total_tokens <= self.max_input:
return messages
# Keep system prompt + latest messages
system_msg = messages[0] if messages[0]["role"] == "system" else None
result = []
if system_msg:
result.append(system_msg)
# Add messages từ cuối đến đầu cho đến khi đủ
remaining = self.max_input
if system_msg:
remaining -= self._count_tokens([system_msg])
for msg in reversed(messages[1 if system_msg else 0:]):
msg_tokens = self._count_tokens([msg])
if remaining >= msg_tokens:
result.insert(len(result) if not system_msg else 1, msg)
remaining -= msg_tokens
else:
break
return result
def _count_tokens(self, messages: list) -> int:
"""Đếm tokens ước tính (có thể dùng tiktoken)"""
# Rough estimation: 1 token ≈ 4 characters
total = 0
for msg in messages:
total += len(str(msg)) // 4
return total
Sử dụng
manager = ContextManager("gpt-4-1")
safe_messages = manager.truncate_to_fit(long_conversation)
response = await client.chat.completions.create(
model="gpt-4-1",
messages=safe_messages
)
5. Lỗi Sandbox/Production Cross-Contamination
Mô tả: Request từ sandbox vô tình chạy trên production key và ngược lại.
import os
from enum import Enum
class EnvKey(Enum):
"""Enum an toàn cho việc quản lý keys"""
SANDBOX = "HOLYSHEEP_SANDBOX_KEY"
PRODUCTION = "HOLYSHEEP_PRODUCTION_KEY"
def get_api_key(env: EnvKey) -> str:
"""Lấy API key với validation nghiêm ngặt"""
key = os.getenv(env.value)
if not key:
raise ValueError(
f"Missing {env.value}. "
f"Please set it in environment variables."
)
# Validation pattern
if env == EnvKey.SANDBOX:
if not key.startswith("sandbox_"):
raise ValueError(
f"Sandbox key must start with 'sandbox_'. "
f"Found: {key[:20]}..."
)
elif env == EnvKey.PRODUCTION:
if key.startswith("sandbox_"):
raise ValueError(
"⚠️ WARNING: Production key starts with 'sandbox_'! "
"Check your environment configuration."
)
if "_test" in key.lower():
raise ValueError(
"⚠️ DANGER: Production key contains '_test'! "
"This should NOT be used in production."
)
return key
Sử dụng
SANDBOX_KEY = get_api_key(EnvKey.SANDBOX)
PRODUCTION_KEY = get_api_key(EnvKey.PRODUCTION)
Kiểm tra để đảm bảo không cross-contaminate
assert "sandbox" not in PRODUCTION_KEY.lower()
assert "test" not in PRODUCTION_KEY.lower()
Kết Luận
Việc cách ly môi trường Sandbox và Production cho