1. Bối Cảnh Thực Chiến: Khi Hệ Thống RAG Của Tôi Gặp Sự Cố
Năm 2025, tôi triển khai hệ thống RAG (Retrieval-Augmented Generation) cho một doanh nghiệp thương mại điện tử với hơn 50,000 sản phẩm. Hệ thống tích hợp
HolySheep AI để xử lý truy vấn khách hàng tự động. Đỉnh điểm là ngày Black Friday — 10,000 request mỗi phút — và API contract giữa service và LLM provider bị break. Đó là khoảnh khắc tôi nhận ra: contract testing không phải optional, mà là lifeboat.
Bài viết này chia sẻ cách tôi xây dựng hệ thống contract testing hoàn chỉnh, từ schema validation đến response simulation, giúp team của tôi giảm 73% production incident liên quan đến API integration.
2. Contract Testing Là Gì và Tại Sao Cần Thiết?
Contract testing xác minh rằng API consumer và provider đồng ý trên cùng một "hợp đồng" — tức format request, response structure, và behavior. Với AI API, contract phức tạp hơn traditional REST API vì:
- Response không deterministic — cùng prompt có thể cho ra các bài viết khác nhau
- Streaming response cần test latency và chunk size
- Token usage và cost tracking phải được verify
- Model behavior có thể thay đổi giữa các phiên bản
3. Kiến Trúc Contract Testing Hoàn Chỉnh
3.1. Schema Definition với JSON Schema
Đầu tiên, tôi định nghĩa contract dưới dạng JSON Schema để validate cả request và response tự động:
{
"$schema": "http://json-schema.org/draft-07/schema#",
"title": "AI Chat Contract",
"description": "Contract cho HolySheep AI Chat API integration",
"type": "object",
"required": ["model", "messages", "temperature", "max_tokens"],
"properties": {
"model": {
"type": "string",
"enum": ["gpt-4.1", "claude-sonnet-4.5", "deepseek-v3.2", "gemini-2.5-flash"],
"description": "Model identifier phải match với provider"
},
"messages": {
"type": "array",
"minItems": 1,
"items": {
"type": "object",
"required": ["role", "content"],
"properties": {
"role": {
"type": "string",
"enum": ["system", "user", "assistant"]
},
"content": {
"type": "string",
"minLength": 1
}
}
}
},
"temperature": {
"type": "number",
"minimum": 0,
"maximum": 2
},
"max_tokens": {
"type": "integer",
"minimum": 1,
"maximum": 32000
},
"response_format": {
"type": "object",
"properties": {
"type": {
"type": "string",
"enum": ["text", "json_object"]
}
}
}
}
}
3.2. Python Test Framework với pytest và jsonschema
Dưới đây là implementation đầy đủ tôi sử dụng trong production, với HolySheep AI base URL:
import pytest
import requests
import jsonschema
import time
from typing import Dict, Any, List
from dataclasses import dataclass
from datetime import datetime
@dataclass
class ContractTestResult:
test_name: str
passed: bool
latency_ms: float
token_usage: Dict[str, int]
error_message: str = ""
timestamp: str = ""
class HolySheepContractTester:
"""Contract tester cho HolySheep AI API"""
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"
})
def validate_request_schema(self, payload: Dict[str, Any], schema: Dict) -> bool:
"""Validate request payload trước khi gửi"""
try:
jsonschema.validate(instance=payload, schema=schema)
return True
except jsonschema.ValidationError as e:
print(f"Schema validation failed: {e.message}")
return False
def test_chat_completion(self, payload: Dict[str, Any]) -> ContractTestResult:
"""Test chat completion endpoint với full contract validation"""
start_time = time.time()
try:
response = self.session.post(
f"{self.BASE_URL}/chat/completions",
json=payload,
timeout=30
)
latency_ms = (time.time() - start_time) * 1000
# Contract validation: Status code
assert response.status_code == 200, \
f"Expected 200, got {response.status_code}: {response.text}"
data = response.json()
# Contract validation: Response structure
required_fields = ["id", "model", "created", "choices", "usage"]
for field in required_fields:
assert field in data, f"Missing required field: {field}"
# Contract validation: Choices structure
assert len(data["choices"]) > 0, "No choices in response"
choice = data["choices"][0]
assert "message" in choice, "Missing message in choice"
assert "content" in choice["message"] or "function_call" in choice["message"], \
"Missing content or function_call in message"
# Contract validation: Usage tracking
usage = data["usage"]
assert "prompt_tokens" in usage
assert "completion_tokens" in usage
assert "total_tokens" in usage
return ContractTestResult(
test_name="chat_completion",
passed=True,
latency_ms=round(latency_ms, 2),
token_usage={
"prompt": usage["prompt_tokens"],
"completion": usage["completion_tokens"],
"total": usage["total_tokens"]
},
timestamp=datetime.now().isoformat()
)
except Exception as e:
return ContractTestResult(
test_name="chat_completion",
passed=False,
latency_ms=round((time.time() - start_time) * 1000, 2),
token_usage={},
error_message=str(e),
timestamp=datetime.now().isoformat()
)
def test_streaming_completion(self, payload: Dict[str, Any]) -> ContractTestResult:
"""Test streaming response với latency assertion"""
payload["stream"] = True
start_time = time.time()
try:
response = self.session.post(
f"{self.BASE_URL}/chat/completions",
json=payload,
stream=True,
timeout=60
)
chunks_received = 0
total_content = ""
for line in response.iter_lines():
if line:
chunks_received += 1
# Parse SSE format: data: {"..."}
if line.startswith(b"data: "):
import json
chunk_data = json.loads(line[6:])
if "choices" in chunk_data and len(chunk_data["choices"]) > 0:
delta = chunk_data["choices"][0].get("delta", {})
if "content" in delta:
total_content += delta["content"]
latency_ms = (time.time() - start_time) * 1000
# Contract: Stream phải nhận được chunks
assert chunks_received > 0, "No chunks received in streaming mode"
assert len(total_content) > 0, "No content in streaming response"
# Performance contract: Latency phải < 50ms cho streaming chunks
avg_chunk_time = latency_ms / chunks_received if chunks_received > 0 else latency_ms
assert avg_chunk_time < 100, f"Average chunk time {avg_chunk_time}ms exceeds 100ms"
return ContractTestResult(
test_name="streaming_completion",
passed=True,
latency_ms=round(latency_ms, 2),
token_usage={"chunks": chunks_received, "content_length": len(total_content)},
timestamp=datetime.now().isoformat()
)
except Exception as e:
return ContractTestResult(
test_name="streaming_completion",
passed=False,
latency_ms=round((time.time() - start_time) * 1000, 2),
token_usage={},
error_message=str(e),
timestamp=datetime.now().isoformat()
)
Pytest fixtures và test cases
@pytest.fixture
def contract_tester():
api_key = "YOUR_HOLYSHEEP_API_KEY"
return HolySheepContractTester(api_key)
def test_minimal_request(contract_tester):
"""Test contract với request tối thiểu"""
payload = {
"model": "gpt-4.1",
"messages": [{"role": "user", "content": "Xin chào"}]
}
result = contract_tester.test_chat_completion(payload)
assert result.passed, f"Test failed: {result.error_message}"
assert result.latency_ms < 1000, f"Latency {result.latency_ms}ms exceeds 1s"
def test_json_mode_response(contract_tester):
"""Test JSON mode với structured output"""
payload = {
"model": "deepseek-v3.2",
"messages": [
{"role": "system", "content": "Bạn là trợ lý trả lời JSON"},
{"role": "user", "content": "Liệt kê 3 loại trái cây với màu sắc"}
],
"response_format": {"type": "json_object"}
}
result = contract_tester.test_chat_completion(payload)
assert result.passed
# Verify JSON parsing capability
import json
response_text = contract_tester.session.post(
f"{contract_tester.BASE_URL}/chat/completions",
json=payload
).json()
content = response_text["choices"][0]["message"]["content"]
parsed = json.loads(content)
assert isinstance(parsed, dict), "Response is not valid JSON object"
if __name__ == "__main__":
tester = HolySheepContractTester("YOUR_HOLYSHEEP_API_KEY")
# Run test suite
result = tester.test_chat_completion({
"model": "gpt-4.1",
"messages": [{"role": "user", "content": "Test contract"}]
})
print(f"Test Result: {'PASSED' if result.passed else 'FAILED'}")
print(f"Latency: {result.latency_ms}ms")
print(f"Token Usage: {result.token_usage}")
3.3. Mock Server với WireMock để Test Offline
Để chạy tests mà không cần gọi API thực, tôi sử dụng WireMock stub:
import requests
import json
from typing import Optional, Callable
class MockHolySheepAPI:
"""Mock server để test contract không cần API thực"""
def __init__(self, base_url: str = "http://localhost:8080"):
self.base_url = base_url
self.stubs_created = []
def setup_chat_completion_stub(
self,
model: str,
response_content: str,
latency_ms: int = 50,
token_usage: Optional[dict] = None
):
"""Tạo stub cho chat completion endpoint"""
stub_payload = {
"request": {
"method": "POST",
"urlPath": "/v1/chat/completions",
"header": {
"Authorization": {"matches": "Bearer .*"}
},
"jsonBody": {
"model": model,
"messages": {"matches": ".+"}
}
},
"response": {
"status": 200,
"jsonBody": {
"id": f"chatcmpl-mock-{hash(response_content) % 10000}",
"object": "chat.completion",
"created": 1700000000,
"model": model,
"choices": [{
"index": 0,
"message": {
"role": "assistant",
"content": response_content
},
"finish_reason": "stop"
}],
"usage": token_usage or {
"prompt_tokens": 10,
"completion_tokens": 20,
"total_tokens": 30
}
},
"delay": latency_ms
}
}
response = requests.post(
f"{self.base_url}/__admin/mappings",
json=stub_payload
)
if response.status_code == 201:
self.stubs_created.append(response.json()["id"])
return True
return False
def setup_error_stub(self, model: str, status_code: int, error_message: str):
"""Stub cho error scenarios"""
stub_payload = {
"request": {
"method": "POST",
"urlPath": "/v1/chat/completions",
"jsonBody": {
"model": model
}
},
"response": {
"status": status_code,
"jsonBody": {
"error": {
"message": error_message,
"type": "invalid_request_error",
"param": None,
"code": status_code
}
}
}
}
response = requests.post(
f"{self.base_url}/__admin/mappings",
json=stub_payload
)
if response.status_code == 201:
self.stubs_created.append(response.json()["id"])
return True
return False
def setup_streaming_stub(self, model: str, chunks: list):
"""Stub cho streaming response"""
responses = []
for i, chunk_content in enumerate(chunks):
sse_response = {
"request": {
"method": "POST",
"urlPath": "/v1/chat/completions",
"jsonBody": {"stream": True}
},
"response": {
"status": 200,
"body": f'data: {json.dumps({"choices": [{"index": 0, "delta": {"content": chunk_content}, "finish_reason": None}]})}\n\n',
"headers": {
"Content-Type": "text/event-stream"
},
"transformers": []
}
}
# Thiết lập transformer để handle streaming sequence
if i == len(chunks) - 1:
sse_response["response"]["body"] = f'data: {json.dumps({"choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}]})}\n\ndata: [DONE]\n\n'
requests.post(f"{self.base_url}/__admin/mappings", json=sse_response)
return True
def reset_all_stubs(self):
"""Xóa tất cả stubs đã tạo"""
response = requests.post(f"{self.base_url}/__admin/reset")
self.stubs_created.clear()
return response.status_code == 200
def get_all_mappings(self):
"""Lấy danh sách tất cả active stubs"""
response = requests.get(f"{self.base_url}/__admin/mappings")
return response.json().get("mappings", [])
Integration test example với mock
def test_with_mock_server():
"""Chạy contract test với mock server"""
mock_api = MockHolySheepAPI()
# Setup stub cho successful response
mock_api.setup_chat_completion_stub(
model="gpt-4.1",
response_content="Đây là response từ mock server",
latency_ms=30,
token_usage={"prompt_tokens": 5, "completion_tokens": 10, "total_tokens": 15}
)
# Verify stub được tạo
mappings = mock_api.get_all_mappings()
assert len(mappings) > 0, "No stubs created"
# Cleanup
mock_api.reset_all_stubs()
return True
if __name__ == "__main__":
# Khởi động WireMock: java -jar wiremock-standalone.jar --port 8080
print("Starting mock server tests...")
mock = MockHolySheepAPI()
success = test_with_mock_server()
print(f"Mock tests: {'PASSED' if success else 'FAILED'}")
4. CI/CD Integration với GitHub Actions
Tự động hóa contract testing trong CI pipeline giúp catch contract violations trước khi merge:
name: AI API Contract Tests
on:
push:
branches: [main, develop]
pull_request:
branches: [main]
jobs:
contract-tests:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.11'
- name: Install dependencies
run: |
pip install pytest requests jsonschema pytest-cov
pip install wiremock-python 2>/dev/null || true
- name: Start WireMock
run: |
curl -sLO https://repo1.maven.org/maven2/org/wiremock/wiremock-standalone/3.3.1/wiremock-standalone-3.3.1.jar
java -jar wiremock-standalone-3.3.1.jar --port 8080 &
sleep 5
- name: Run Contract Tests
env:
HOLYSHEEP_API_KEY: ${{ secrets.HOLYSHEEP_API_KEY }}
run: |
pytest tests/contract_tests.py \
-v \
--tb=short \
--cov=src \
--cov-report=xml \
--junitxml=contract-results.xml
- name: Upload Test Results
uses: actions/upload-artifact@v4
with:
name: contract-test-results
path: |
contract-results.xml
coverage.xml
- name: Check Contract Coverage
run: |
echo "## Contract Test Summary" >> $GITHUB_STEP_SUMMARY
echo "- Tests Run: $(grep -c 'testcase' contract-results.xml)" >> $GITHUB_STEP_SUMMARY
echo "- Failures: $(grep -c 'failure' contract-results.xml)" >> $GITHUB_STEP_SUMMARY
echo "- Coverage: $(grep -o 'line-rate="[0-9.]*"' coverage.xml | head -1)" >> $GITHUB_STEP_SUMMARY
contract-tests-mock:
runs-on: ubuntu-latest
# Run mock tests in parallel
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.11'
- run: pip install pytest requests jsonschema
- name: Start WireMock
run: |
curl -sLO https://repo1.maven.org/maven2/org/wiremock/wiremock-standalone/3.3.1/wiremock-standalone-3.3.1.jar
java -jar wiremock-standalone-3.3.1.jar --port 8080 &
sleep 5
- run: python -m pytest tests/mock_tests.py -v
5. Chiến Lược Testing Nâng Cao
5.1. Property-Based Testing với Hypothesis
Thay vì test từng case cố định, property-based testing sinh hàng trăm inputs để verify invariants:
from hypothesis import given, strategies as st, settings, assume
import pytest
from contract_tester import HolySheepContractTester
@given(
model=st.sampled_from(["gpt-4.1", "claude-sonnet-4.5", "deepseek-v3.2", "gemini-2.5-flash"]),
temp=st.floats(min_value=0.0, max_value=2.0),
max_tokens=st.integers(min_value=1, max_value=4000),
message_count=st.integers(min_value=1, max_value=10)
)
@settings(max_examples=100, deadline=None)
def test_contract_invariants(model, temp, max_tokens, message_count):
"""
Property: Với bất kỳ valid input nào, response phải:
1. Có status 200
2. Chứa usage object với positive tokens
3. Có choices array không rỗng
"""
tester = HolySheepContractTester("YOUR_HOLYSHEEP_API_KEY")
payload = {
"model": model,
"messages": [
{"role": "user", "content": f"Test message {i}"}
for i in range(message_count)
],
"temperature": round(temp, 2),
"max_tokens": max_tokens
}
result = tester.test_chat_completion(payload)
# Invariants phải luôn đúng
assert result.passed, f"Contract violated: {result.error_message}"
assert result.token_usage["total"] >= 0, "Token usage cannot be negative"
assert result.latency_ms > 0, "Latency must be measurable"
@given(content=st.text(min_size=1, max_size=1000))
@settings(max_examples=50)
def test_special_characters_handling(content):
"""
Property: Content với special characters (emoji, Unicode, special chars)
phải được xử lý đúng
"""
tester = HolySheepContractTester("YOUR_HOLYSHEEP_API_KEY")
payload = {
"model": "gemini-2.5-flash",
"messages": [
{"role": "user", "content": content}
]
}
result = tester.test_chat_completion(payload)
assert result.passed, f"Failed to handle special content: {content[:50]}"
def test_cost_estimation_contract():
"""
Contract test: Verify token usage match với cost estimation
HolySheep pricing (2026):
- GPT-4.1: $8/MTok input, $8/MTok output
- Claude Sonnet 4.5: $15/MTok
- Gemini 2.5 Flash: $2.50/MTok
- DeepSeek V3.2: $0.42/MTok
"""
tester = HolySheepContractTester("YOUR_HOLYSHEEP_API_KEY")
test_cases = [
("gpt-4.1", 1000, 1000, 0.016), # $8/MTok
("deepseek-v3.2", 1000, 1000, 0.00084), # $0.42/MTok
("gemini-2.5-flash", 1000, 1000, 0.005), # $2.50/MTok
]
for model, prompt_tokens, completion_tokens, expected_cost_per_million in test_cases:
payload = {
"model": model,
"messages": [{"role": "user", "content": "x" * 100}]
}
result = tester.test_chat_completion(payload)
if result.passed:
actual_tokens = result.token_usage["total"]
# Token count phải positive
assert actual_tokens > 0, f"Zero tokens for {model}"
# Verify usage reporting
assert result.token_usage["prompt"] >= 0
assert result.token_usage["completion"] >= 0
if __name__ == "__main__":
import subprocess
result = subprocess.run(["pytest", __file__, "-v"], capture_output=True, text=True)
print(result.stdout)
print(result.stderr)
5.2. Performance Contract: Latency SLA
Với HolySheep AI, tôi verify SLA <50ms thông qua systematic testing:
import time
import statistics
from typing import List, Tuple
class LatencyContractVerifier:
"""Verify latency SLA compliance cho HolySheep API"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
def measure_latency(self, payload: dict, iterations: int = 10) -> Tuple[float, List[float]]:
"""Đo latency qua nhiều iterations"""
latencies = []
import requests
for _ in range(iterations):
start = time.time()
response = requests.post(
f"{self.base_url}/chat/completions",
headers={"Authorization": f"Bearer {self.api_key}"},
json=payload
)
elapsed_ms = (time.time() - start) * 1000
latencies.append(elapsed_ms)
if response.status_code != 200:
raise Exception(f"API error: {response.status_code}")
avg_latency = statistics.mean(latencies)
return avg_latency, latencies
def verify_sla_compliance(self, model: str, sla_ms: float = 50) -> dict:
"""Verify model đạt SLA latency"""
payload = {
"model": model,
"messages": [{"role": "user", "content": "Ping"}],
"max_tokens": 10
}
avg, all_latencies = self.measure_latency(payload, iterations=20)
p50 = statistics.median(all_latencies)
p95 = sorted(all_latencies)[int(len(all_latencies) * 0.95)]
p99 = sorted(all_latencies)[int(len(all_latencies) * 0.99)]
return {
"model": model,
"sla_ms": sla_ms,
"avg_latency_ms": round(avg, 2),
"p50_ms": round(p50, 2),
"p95_ms": round(p95, 2),
"p99_ms": round(p99, 2),
"sla_met": avg < sla_ms,
"compliance_rate": sum(1 for l in all_latencies if l < sla_ms) / len(all_latencies)
}
def run_performance_contract_tests():
"""Chạy performance contract tests cho tất cả models"""
verifier = LatencyContractVerifier("YOUR_HOLYSHEEP_API_KEY")
models = ["gpt-4.1", "gemini-2.5-flash", "deepseek-v3.2"]
results = []
print("Running Performance Contract Tests...")
print("=" * 60)
for model in models:
try:
result = verifier.verify_sla_compliance(model, sla_ms=50)
results.append(result)
status = "✓ PASS" if result["sla_met"] else "✗ FAIL"
print(f"{status} | {model}")
print(f" Avg: {result['avg_latency_ms']}ms | P95: {result['p95_ms']}ms | P99: {result['p99_ms']}ms")
print(f" SLA Compliance: {result['compliance_rate']*100:.1f}%")
except Exception as e:
print(f"ERROR | {model}: {e}")
print("=" * 60)
all_passed = all(r["sla_met"] for r in results)
print(f"\nOverall: {'ALL PASSED' if all_passed else 'SOME FAILED'}")
return results
if __name__ == "__main__":
run_performance_contract_tests()
6. Lỗi Thường Gặp và Cách Khắc Phục
6.1. Lỗi 401 Unauthorized - Sai API Key Format
Triệu chứng: Request trả về
{"error": {"message": "Invalid API key", "type": "invalid_request_error", "code": 401}}
Nguyên nhân: HolySheep AI yêu cầu Bearer token với format chính xác. Common mistakes:
- Thiếu prefix "Bearer "
- Key có trailing spaces hoặc newline
- Dùng key từ environment variable chưa được export
Mã khắc phục:
# ❌ SAI - gây lỗi 401
headers = {
"Authorization": api_key # Thiếu "Bearer "
}
✓ ĐÚNG
import os
headers = {
"Authorization": f"Bearer {os.environ.get('HOLYSHEEP_API_KEY', '').strip()}"
}
Verify key format
import re
def validate_api_key(key: str) -> bool:
if not key:
return False
# HolySheep keys thường dạng hsk_... hoặc sk-...
pattern = r'^(hs[kK]_|sk-)[a-zA-Z0-9]{20,}$'
return bool(re.match(pattern, key.strip()))
Test connection
def test_connection(api_key: str) -> bool:
import requests
response = requests.get(
"https://api.holysheep.ai/v1/models",
headers={"Authorization": f"Bearer {api_key}"},
timeout=10
)
return response.status_code == 200
6.2. Lỗi 400 Invalid Request - Schema Validation Fail
Triệu chứng: {"error": {"message": "Invalid request parameters", "type": "invalid_request_error", ...}}
Nguyên nhân thường gặp:
temperature vượt ngoài range [0, 2]max_tokens vượt limit của modelmessages array rỗng hoặc thiếu required fieldsmodel name không đúng format
Mã khắc phục:
import jsonschema
from jsonschema import Draft7Validator
Define model constraints
MODEL_CONSTRAINTS = {
"gpt-4.1": {"max_tokens": 32000, "supports_functions": True},
"claude-sonnet-4.5": {"max_tokens": 64000, "supports_functions": True},
"deepseek-v3.2": {"max_tokens": 64000, "supports_functions": False},
"gemini-2.5-flash": {"max_tokens": 32000, "supports_functions": True}
}
def validate_request(payload: dict) -> list:
"""Validate request trước khi gửi, return list of errors"""
errors = []
# Check model
model = payload.get("model")
if model not in MODEL_CONSTRAINTS:
errors.append(f"Unknown model: {model}. Available: {list(MODEL_CONSTRAINTS.keys())}")
return errors
# Check temperature
temp = payload.get("temperature", 1.0)
if not isinstance(temp, (int, float)) or temp < 0 or temp > 2:
errors.append(f"temperature must be between 0 and 2, got: {temp}")
# Check max_tokens
max_tokens = payload.get("max_tokens", 4096)
model_max = MODEL_CONSTRAINTS[model]["max_tokens"]
if max_tokens > model_max:
errors.append(f"max_tokens {max_tokens} exceeds model limit {model_max}")
# Check messages
messages = payload.get("messages", [])
if not messages:
errors.append("messages cannot be empty")
else:
for i, msg in enumerate(messages):
if "role" not in msg:
errors.append(f"Message {i} missing 'role' field")
if "content" not in msg or not msg["content"]:
errors.append(f"Message {i} has empty content")
if msg.get("role") not in ["system", "user", "assistant"]:
errors.append(f"Message {i} has invalid role: {msg['role']}")
# Check response_format
if "response_format" in payload:
rf = payload["response_format"]
if rf.get("type") == "json_object" and not MODEL_CONSTRAINTS[model]["supports_functions"]:
errors.append(f"Model {model} does not support JSON mode")
return errors
Usage
def safe_api_call(payload: dict, api_key: str):
errors = validate_request(payload)
if errors:
raise ValueError(f"Validation errors: {'; '.join(errors)}")
import requests
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={"Authorization": f"Bearer {api_key}"},
json=payload
)
return response
6.3. Lỗi Timeout - Streaming và Large Response
Triệu chứng: Request hanging >
Tài nguyên liên quan
Bài viết liên quan