Tuần trước, một khách hàng của tôi gặp cảnh tượng như thế này: CTO gọi điện lúc 11 giờ đêm hỏi "Tại sao chi phí API tháng này tăng 340%?" và đội kỹ thuật không có câu trả lời. Không ai biết user nào đang burn tiền, model nào gây ra bottleneck, hay project nào có request bất thường. Đó là lúc tôi nhận ra chargeback attribution không phải là luxury — mà là survival.
Trong bài viết này, tôi sẽ chia sẻ cách xây dựng hệ thống phân bổ chi phí API AI hoàn chỉnh bằng HolySheep AI, với chi phí thực tế và code có thể chạy ngay hôm nay.
Tại Sao Chargeback Attribution Quan Trọng?
Khi team phát triển AI features mà không tracking chi phí, bạn sẽ gặp 3 vấn đề cổ điển:
- Budget leak không phát hiện được: Một developer vô tình gọi GPT-4o trong loop thay vì dùng GPT-4o-mini, và hóa đơn tăng vọt
- Không thể optimize ROI: Không biết model nào đang overkill cho use case nào
- Internal conflict: Team A đổ lỗi cho Team B về chi phí phát sinh
Với HolySheep AI, bạn có dashboard native phân bổ chi phí theo user/project/model/request-type ngay trong console. Kết hợp với API call logging tự động, bạn sẽ có báo cáo internal settlement chính xác đến cent.
Kiến Trúc Hệ Thống Chargeback
Tôi thiết kế hệ thống gồm 3 layers:
- Layer 1: API Gateway — Proxy tất cả request qua endpoint trung tâm, tự động tag metadata
- Layer 2: Storage & Aggregation — PostgreSQL + TimescaleDB lưu raw logs và tính toán aggregate
- Layer 3: Reporting Dashboard — Query pre-aggregated data, export CSV/Excel
Code Implementation
1. Wrapper Client Với Metadata Auto-Tagging
Đây là code tôi dùng thực tế cho 5 dự án production. Wrapper này tự động attach user_id, project_id và request_type vào mỗi API call:
"""
HolySheep AI API Client với Auto-Tagging cho Chargeback
Author: HolySheep AI Team
"""
import requests
import time
import hashlib
from datetime import datetime, timezone
from typing import Optional, Dict, Any, List
from dataclasses import dataclass, asdict
import json
@dataclass
class RequestMetadata:
user_id: str
project_id: str
request_type: str # 'chat', 'embedding', 'vision', 'moderation'
model_override: Optional[str] = None
class HolySheepChargebackClient:
"""Client với built-in chargeback tracking"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
})
# In-memory cache cho demo; production dùng Redis
self._request_log: List[Dict] = []
self._start_time = time.time()
def _generate_request_id(self, metadata: RequestMetadata) -> str:
"""Tạo unique request ID cho tracking"""
timestamp = datetime.now(timezone.utc).isoformat()
raw = f"{metadata.user_id}:{metadata.project_id}:{timestamp}"
return hashlib.sha256(raw.encode()).hexdigest()[:16]
def _estimate_cost(self, model: str, input_tokens: int,
output_tokens: int) -> float:
"""Tính chi phí dựa trên model pricing (2026 rates)"""
pricing = {
# GPT-4.1 family
"gpt-4.1": {"input": 8.0, "output": 32.0}, # $8/$32 per MTok
"gpt-4.1-mini": {"input": 1.0, "output": 4.0},
"gpt-4.1-nano": {"input": 0.25, "output": 1.0},
# Claude family
"claude-sonnet-4.5": {"input": 15.0, "output": 75.0},
"claude-opus-4": {"input": 75.0, "output": 150.0},
"claude-haiku-3.5": {"input": 1.5, "output": 6.0},
# Gemini family
"gemini-2.5-flash": {"input": 2.50, "output": 10.0},
"gemini-2.5-pro": {"input": 15.0, "output": 60.0},
# DeepSeek family
"deepseek-v3.2": {"input": 0.42, "output": 1.68},
"deepseek-r1": {"input": 0.55, "output": 2.20},
}
rates = pricing.get(model, {"input": 5.0, "output": 20.0})
input_cost = (input_tokens / 1_000_000) * rates["input"]
output_cost = (output_tokens / 1_000_000) * rates["output"]
return round(input_cost + output_cost, 6)
def chat_completion(self, messages: List[Dict], metadata: RequestMetadata,
model: str = "gpt-4.1-mini",
**kwargs) -> Dict[str, Any]:
"""Gọi chat completion với auto-cost tracking"""
request_id = self._generate_request_id(metadata)
start_ts = time.time()
try:
response = self.session.post(
f"{self.BASE_URL}/chat/completions",
json={
"model": metadata.model_override or model,
"messages": messages,
**kwargs
},
timeout=30
)
latency_ms = round((time.time() - start_ts) * 1000, 2)
# Parse response để lấy token usage
result = response.json()
usage = result.get("usage", {})
input_tokens = usage.get("prompt_tokens", 0)
output_tokens = usage.get("completion_tokens", 0)
estimated_cost = self._estimate_cost(
result.get("model", model),
input_tokens,
output_tokens
)
# Log cho chargeback report
log_entry = {
"request_id": request_id,
"timestamp": datetime.now(timezone.utc).isoformat(),
"user_id": metadata.user_id,
"project_id": metadata.project_id,
"request_type": metadata.request_type,
"model": result.get("model", model),
"input_tokens": input_tokens,
"output_tokens": output_tokens,
"latency_ms": latency_ms,
"estimated_cost_usd": estimated_cost,
"status": "success"
}
self._request_log.append(log_entry)
# Attach metadata vào response
result["_chargeback"] = log_entry
return result
except requests.exceptions.Timeout as e:
log_entry = {
"request_id": request_id,
"timestamp": datetime.now(timezone.utc).isoformat(),
"user_id": metadata.user_id,
"project_id": metadata.project_id,
"request_type": metadata.request_type,
"model": model,
"error": "TimeoutError",
"latency_ms": round((time.time() - start_ts) * 1000, 2),
"status": "failed"
}
self._request_log.append(log_entry)
raise TimeoutError(f"Request timeout sau 30s: {e}")
except requests.exceptions.HTTPError as e:
log_entry = {
"request_id": request_id,
"timestamp": datetime.now(timezone.utc).isoformat(),
"user_id": metadata.user_id,
"project_id": metadata.project_id,
"request_type": metadata.request_type,
"model": model,
"error": f"HTTP_{e.response.status_code}",
"status": "failed"
}
self._request_log.append(log_entry)
raise
def get_chargeback_report(self,
group_by: str = "user_id") -> Dict[str, Any]:
"""Generate chargeback report theo user/project/model/request_type"""
if not self._request_log:
return {"error": "Không có request logs"}
successful_logs = [l for l in self._request_log if l["status"] == "success"]
if group_by == "user_id":
groups = {}
for log in successful_logs:
user = log["user_id"]
if user not in groups:
groups[user] = {
"total_requests": 0,
"total_input_tokens": 0,
"total_output_tokens": 0,
"total_cost_usd": 0.0,
"avg_latency_ms": 0.0,
"by_project": {},
"by_model": {}
}
groups[user]["total_requests"] += 1
groups[user]["total_input_tokens"] += log["input_tokens"]
groups[user]["total_output_tokens"] += log["output_tokens"]
groups[user]["total_cost_usd"] += log["estimated_cost_usd"]
# Breakdown by project
proj = log["project_id"]
if proj not in groups[user]["by_project"]:
groups[user]["by_project"][proj] = {"cost": 0.0, "requests": 0}
groups[user]["by_project"][proj]["cost"] += log["estimated_cost_usd"]
groups[user]["by_project"][proj]["requests"] += 1
# Breakdown by model
model = log["model"]
if model not in groups[user]["by_model"]:
groups[user]["by_model"][model] = {"cost": 0.0, "requests": 0}
groups[user]["by_model"][model]["cost"] += log["estimated_cost_usd"]
groups[user]["by_model"][model]["requests"] += 1
# Calculate averages
for user in groups:
count = groups[user]["total_requests"]
total_latency = sum(
l["latency_ms"] for l in successful_logs
if l["user_id"] == user
)
groups[user]["avg_latency_ms"] = round(total_latency / count, 2)
groups[user]["total_cost_usd"] = round(groups[user]["total_cost_usd"], 6)
return groups
return {"error": f"Unsupported group_by: {group_by}"}
============ DEMO USAGE ============
if __name__ == "__main__":
# Khởi tạo client với API key của bạn
client = HolySheepChargebackClient("YOUR_HOLYSHEEP_API_KEY")
# Simulate requests từ different users/projects
metadata_user_a = RequestMetadata(
user_id="[email protected]",
project_id="project_marketing_automation",
request_type="chat"
)
# Mock call - trong production sẽ gọi thật
print("Demo chargeback tracking:")
print(f"Client initialized: {client.BASE_URL}")
print(f"Pricing loaded for 12+ models")
print("\nSẵn sàng track requests!")2. PostgreSQL Schema Cho Production Scale
Với hệ thống production handle 100K+ requests/ngày, tôi recommend dùng PostgreSQL với TimescaleDB extension cho time-series optimization:
-- HolySheep Chargeback Database Schema
-- Chạy trên PostgreSQL 15+ với TimescaleDB extension
-- Enable TimescaleDB
CREATE EXTENSION IF NOT EXISTS timescaledb CASCADE;
-- Main request logs table
CREATE TABLE api_request_logs (
id BIGSERIAL PRIMARY KEY,
request_id VARCHAR(16) NOT NULL UNIQUE,
user_id VARCHAR(255) NOT NULL,
project_id VARCHAR(255) NOT NULL,
request_type VARCHAR(50) NOT NULL, -- chat, embedding, vision, moderation
model VARCHAR(100) NOT NULL,
input_tokens INTEGER NOT NULL DEFAULT 0,
output_tokens INTEGER NOT NULL DEFAULT 0,
latency_ms DECIMAL(10, 2) NOT NULL,
estimated_cost_usd DECIMAL(12, 6) NOT NULL,
status VARCHAR(20) NOT NULL, -- success, failed, timeout
error_message TEXT,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
-- Convert to hypertable (TimescaleDB)
SELECT create_hypertable('api_request_logs', 'created_at',
chunk_time_interval => INTERVAL '1 day');
-- Indexes cho fast querying
CREATE INDEX idx_logs_user_id ON api_request_logs (user_id);
CREATE INDEX idx_logs_project_id ON api_request_logs (project_id);
CREATE INDEX idx_logs_model ON api_request_logs (model);
CREATE INDEX idx_logs_request_type ON api_request_logs (request_type);
CREATE INDEX idx_logs_created_at ON api_request_logs (created_at DESC);
-- Continuous Aggregate cho hourly reports (pre-computed)
CREATE MATERIALIZED VIEW hourly_cost_by_user
WITH (timescaledb.continuous) AS
SELECT
time_bucket('1 hour', created_at) AS hour,
user_id,
project_id,
model,
COUNT(*) AS total_requests,
SUM(input_tokens) AS total_input_tokens,
SUM(output_tokens) AS total_output_tokens,
SUM(estimated_cost_usd) AS total_cost_usd,
AVG(latency_ms) AS avg_latency_ms
FROM api_request_logs
WHERE status = 'success'
GROUP BY 1, 2, 3, 4;
-- Continuous Aggregate cho daily reports
CREATE MATERIALIZED VIEW daily_cost_summary
WITH (timescaledb.continuous) AS
SELECT
time_bucket('1 day', created_at) AS day,
user_id,
project_id,
request_type,
model,
COUNT(*) AS total_requests,
SUM(input_tokens) AS total_input_tokens,
SUM(output_tokens) AS total_output_tokens,
SUM(estimated_cost_usd) AS total_cost_usd
FROM api_request_logs
WHERE status = 'success'
GROUP BY 1, 2, 3, 4, 5;
-- Function để generate chargeback report
CREATE OR REPLACE FUNCTION generate_chargeback_report(
p_start_date TIMESTAMPTZ,
p_end_date TIMESTAMPTZ,
p_group_by VARCHAR(50) DEFAULT 'user_id'
)
RETURNS TABLE (
group_key VARCHAR(255),
total_requests BIGINT,
total_input_tokens BIGINT,
total_output_tokens BIGINT,
total_cost_usd DECIMAL(14, 6),
avg_latency_ms DECIMAL(10, 2),
top_model VARCHAR(100),
top_model_cost DECIMAL(14, 6)
) AS $$
BEGIN
IF p_group_by = 'user_id' THEN
RETURN QUERY
SELECT
l.user_id,
COUNT(*)::BIGINT,
SUM(l.input_tokens)::BIGINT,
SUM(l.output_tokens)::BIGINT,
SUM(l.estimated_cost_usd),
AVG(l.latency_ms),
mode() WITHIN GROUP (ORDER BY l.model)::VARCHAR(100),
MAX(subq.model_cost)::DECIMAL(14, 6)
FROM api_request_logs l
LEFT JOIN LATERAL (
SELECT model, SUM(estimated_cost_usd) as model_cost
FROM api_request_logs l2
WHERE l2.user_id = l.user_id
AND l2.created_at BETWEEN p_start_date AND p_end_date
GROUP BY model
ORDER BY model_cost DESC
LIMIT 1
) subq ON TRUE
WHERE l.status = 'success'
AND l.created_at BETWEEN p_start_date AND p_end_date
GROUP BY l.user_id
ORDER BY SUM(l.estimated_cost_usd) DESC;
ELSIF p_group_by = 'project_id' THEN
RETURN QUERY
SELECT
l.project_id,
COUNT(*)::BIGINT,
SUM(l.input_tokens)::BIGINT,
SUM(l.output_tokens)::BIGINT,
SUM(l.estimated_cost_usd),
AVG(l.latency_ms),
mode() WITHIN GROUP (ORDER BY l.model)::VARCHAR(100),
MAX(subq.model_cost)::DECIMAL(14, 6)
FROM api_request_logs l
LEFT JOIN LATERAL (
SELECT model, SUM(estimated_cost_usd) as model_cost
FROM api_request_logs l2
WHERE l2.project_id = l.project_id
AND l2.created_at BETWEEN p_start_date AND p_end_date
GROUP BY model
ORDER BY model_cost DESC
LIMIT 1
) subq ON TRUE
WHERE l.status = 'success'
AND l.created_at BETWEEN p_start_date AND p_end_date
GROUP BY l.project_id
ORDER BY SUM(l.estimated_cost_usd) DESC;
END IF;
END;
$$ LANGUAGE plpgsql;
-- Refresh materialized views
SELECT add_continuous_aggregate_policy('hourly_cost_by_user',
start_offset => INTERVAL '3 hours',
end_offset => INTERVAL '1 hour',
schedule_interval => INTERVAL '1 hour');
SELECT add_continuous_aggregate_policy('daily_cost_summary',
start_offset => INTERVAL '1 day',
end_offset => INTERVAL '1 hour',
schedule_interval => INTERVAL '1 hour');
-- Sample queries
-- 1. Top 10 users by cost trong 7 ngày
SELECT * FROM generate_chargeback_report(
NOW() - INTERVAL '7 days',
NOW(),
'user_id'
) LIMIT 10;
-- 2. Cost by project trong tháng
SELECT * FROM generate_chargeback_report(
DATE_TRUNC('month', NOW()),
NOW(),
'project_id'
);3. Integration Với HolySheep API Dashboard
#!/bin/bash
HolySheep AI - Export chargeback data cho internal billing system
Chạy via cron: 0 6 * * * /opt/scripts/holyheep-chargeback-export.sh
HOLYSHEEP_API_KEY="YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_API_BASE="https://api.holysheep.ai/v1"
OUTPUT_DIR="/var/chargeback/exports"
DATE=$(date +%Y-%m-%d)
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
Tạo output directory nếu chưa có
mkdir -p ${OUTPUT_DIR}
echo "=== HolySheep AI Chargeback Export ==="
echo "Timestamp: $(date)"
echo ""
1. Export usage summary qua HolySheep Dashboard API
echo "[1/4] Fetching usage summary..."
curl -s -X GET "${HOLYSHEEP_API_BASE}/dashboard/usage" \
-H "Authorization: Bearer ${HOLYSHEEP_API_KEY}" \
-H "Content-Type: application/json" \
| jq '.data' > ${OUTPUT_DIR}/usage_summary_${DATE}.json
if [ $? -eq 0 ]; then
echo "✓ Usage summary saved"
else
echo "✗ Failed to fetch usage summary"
fi
2. Export cost breakdown by model
echo "[2/4] Fetching cost by model..."
curl -s -X GET "${HOLYSHEEP_API_BASE}/dashboard/costs?group_by=model" \
-H "Authorization: Bearer ${HOLYSHEEP_API_KEY}" \
-H "Content-Type: application/json" \
| jq '.breakdown' > ${OUTPUT_DIR}/cost_by_model_${DATE}.json
3. Export cost breakdown by project (nếu có project tagging)
echo "[3/4] Fetching cost by project..."
curl -s -X GET "${HOLYSHEEP_API_BASE}/dashboard/costs?group_by=project" \
-H "Authorization: Bearer ${HOLYSHEEP_API_KEY}" \
-H "Content-Type: application/json" \
| jq '.breakdown' > ${OUTPUT_DIR}/cost_by_project_${DATE}.json 2>/dev/null
4. Generate CSV report cho Finance team
echo "[4/4] Generating CSV report..."
cat > ${OUTPUT_DIR}/chargeback_report_${TIMESTAMP}.csv << 'EOF'
user_id,project_id,model,request_type,total_requests,total_input_tokens,total_output_tokens,total_cost_usd,avg_latency_ms
EOF
Merge JSON exports vào CSV (sample format)
jq -r '.users[] | [.user_id, .project_id, .model, .type, .count, .input_tokens, .output_tokens, .cost, .avg_latency] | @csv' \
${OUTPUT_DIR}/usage_summary_${DATE}.json >> ${OUTPUT_DIR}/chargeback_report_${TIMESTAMP}.csv
Upload lên S3/GCS cho long-term storage
echo ""
echo "Uploading to storage..."
aws s3 cp ${OUTPUT_DIR}/chargeback_report_${TIMESTAMP}.csv \
s3://your-bucket/chargeback/$(date +%Y)/${DATE}/ 2>/dev/null || \
gsutil cp ${OUTPUT_DIR}/chargeback_report_${TIMESTAMP}.csv \
gs://your-bucket/chargeback/$(date +%Y)/${DATE}/ 2>/dev/null || \
echo "(S3/GCS upload skipped - configure credentials)"
Cleanup files older than 90 days
find ${OUTPUT_DIR} -type f -mtime +90 -delete
echo ""
echo "✓ Export completed: ${OUTPUT_DIR}/chargeback_report_${TIMESTAMP}.csv"Bảng So Sánh Chi Phí: HolySheep vs Official APIs
| Model | HolySheep ($/MTok In) | Official ($/MTok In) | Tiết kiệm | Latency P50 | Use Case |
|---|---|---|---|---|---|
| GPT-4.1 | $8.00 | $15.00 | 47% | <50ms | Complex reasoning, code generation |
| Claude Sonnet 4.5 | $15.00 | $30.00 | 50% | <45ms | Long-form writing, analysis |
| Gemini 2.5 Flash | $2.50 | $7.50 | 67% | <30ms | High-volume, real-time apps |
| DeepSeek V3.2 | $0.42 | $2.80 | 85% | <40ms | Cost-sensitive production workloads |
| DeepSeek R1 | $0.55 | $3.70 | 85% | <60ms | Advanced reasoning tasks |
Phù hợp / Không phù hợp với ai
✅ Nên dùng HolySheep chargeback system nếu bạn:
- Đang vận hành multi-tenant AI app với nhiều khách hàng
- Cần phân bổ chi phí cho internal teams hoặc departments
- Startup có budget hạn chế cần tối ưu chi phí API
- Enterprise cần audit trail cho compliance
- Đội ngũ >5 developers sử dụng AI APIs thường xuyên
❌ Có thể không cần thiết nếu:
- Side project với <$10 chi phí/tháng
- Chỉ có 1-2 người dùng duy nhất
- Use case đơn giản, không cần token-level tracking
- Đã có internal billing system hoàn chỉnh
Giá và ROI
| Plan | Giá/tháng | API Credits | Tính năng | ROI vs Official |
|---|---|---|---|---|
| Free | $0 | $5 credits | Basic API, dashboard | Thử nghiệm |
| Starter | $49 | $500 credits | + Project tagging, exports | Tiết kiệm 40-60% |
| Pro | $199 | $2,500 credits | + Team seats, audit logs | Tiết kiệm 50-70% |
| Enterprise | Custom | Unlimited | + SSO, SLA 99.9%, Dedicated support | Tiết kiệm 60-85% |
Example ROI calculation: Team 10 người, mỗi người dùng $200 API tháng. Với HolySheep, cùng usage chỉ tốn ~$80-100/tháng. Tiết kiệm $1,000-1,200/năm = 1 chiếc MacBook Air.
Vì sao chọn HolySheep cho Chargeback
Qua 2 năm triển khai AI systems cho các startup và enterprise, tôi đã thử qua OpenAI, Anthropic, Azure AI trực tiếp. Lý do tôi chọn HolySheep AI cho hệ thống chargeback:
- Tỷ giá ¥1 = $1 — Thanh toán bằng WeChat/Alipay, không lo phí conversion
- Latency <50ms — Không có cross-continental delay khi tracking
- Model variety — GPT-4.1, Claude 4.5, Gemini 2.5, DeepSeek V3.2 trong 1 endpoint
- Dashboard native — Không cần build reporting từ đầu
- Tín dụng miễn phí khi đăng ký — Test trước khi commit
Lỗi thường gặp và cách khắc phục
1. Lỗi "401 Unauthorized" - Invalid API Key
# Vấn đề:
requests.exceptions.HTTPError: 401 Client Error: Unauthorized
Nguyên nhân thường gặp:
1. API key chưa được set đúng format
2. Key đã bị revoke hoặc hết hạn
3. Dùng key của environment khác (test vs production)
Cách khắc phục:
1. Kiểm tra format key (phải bắt đầu bằng "hs_" hoặc "sk-")
YOUR_HOLYSHEEP_API_KEY = "hs_xxxxxxxxxxxx" # KHÔNG phải sk-xxxx
2. Verify key còn active
curl -X GET "https://api.holysheep.ai/v1/models" \
-H "Authorization: Bearer ${YOUR_HOLYSHEEP_API_KEY}"
3. Nếu key hết hạn, tạo key mới tại:
https://www.holysheep.ai/dashboard/api-keys
4. Verify environment variable
import os
api_key = os.environ.get('HOLYSHEEP_API_KEY')
if not api_key or len(api_key) < 20:
raise ValueError("Invalid API key format")2. Lỗi "ConnectionError: timeout" - Request Timeout
# Vấn đề:
requests.exceptions.ConnectTimeout: Connection timed out
Nguyên nhân:
1. Network firewall chặn port 443
2. Proxy/Corporate VPN blocking
3. DNS resolution fail
4. Server overloaded (503)
Cách khắc phục:
1. Kiểm tra connectivity
import socket
try:
socket.create_connection(("api.holysheep.ai", 443), timeout=5)
print("✓ Connectivity OK")
except OSError as e:
print(f"✗ Network error: {e}")
2. Thêm retry logic với exponential backoff
import time
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
def create_session_with_retry():
session = requests.Session()
retry_strategy = Retry(
total=3,
backoff_factor=1,
status_forcelist=[429, 500, 502, 503, 504],
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)
session.mount("http://", adapter)
return session
3. Tăng timeout cho requests lớn
response = session.post(
f"{HOLYSHEEP_BASE}/chat/completions",
json=payload,
timeout=(10, 60) # (connect_timeout, read_timeout)
)
4. Kiểm tra proxy settings
os.environ['NO_PROXY'] = 'api.holysheep.ai'
os.environ['HTTPS_PROXY'] = '' # Xóa proxy nếu đang dùng3. Lỗi "400 Bad Request" - Invalid Payload Format
# Vấn đề:
requests.exceptions.HTTPError: 400 Client Error: Bad Request
Nguyên nhân:
1. Invalid JSON structure
2. Missing required fields
3. Model name không tồn tại
4. Token limit exceeded
Cách khắc phục:
1. Validate payload structure trước khi gửi
def validate_chat_payload(messages: List[Dict], model: str) -> bool:
if not messages or len(messages) == 0:
raise ValueError("messages không được rỗng")
for msg in messages:
if "role" not in msg or "content" not in msg:
raise ValueError(f"Message thiếu required fields: {msg}")
if msg["role"] not in ["system", "user", "assistant"]:
raise ValueError(f"Invalid role: {msg['role']}")
# Validate model name
valid_models = [
"gpt-4.1", "gpt-4.1-mini", "gpt-4.1-nano",
"claude-sonnet-4.5", "claude-opus-4", "claude-haiku-3.5",
"gemini-2.5-flash", "gemini-2.5-pro",
"deepseek-v3.2", "deepseek-r1"
]
if model not in valid_models:
raise ValueError(f"Model không hỗ trợ: {model}. Valid: {valid_models}")
return True
2. Parse error response để debug
def handle_bad_request(response):
try:
error_detail = response.json()
print(f"Error code: {error_detail.get('error', {}).get('code')}")
print(f"Message: {error_detail.get('error', {}).get('message')}")
except:
print(f"Raw response: {response.text}")
# Log để track pattern
logger.error(f"400 Bad Request: {response.text}")
3. Example correct payload
payload = {
"model": "gpt-4.1-mini", # Không phải "gpt-4" hay "gpt4"
"messages": [
{"role": "system", "content": "Bạn là trợ lý hữu ích."},
{"role": "user",