Là một kỹ sư backend đã triển khai hệ thống AI API gateway cho nhiều dự án production quy mô lớn, tôi hiểu rằng việc tối ưu hóa multi-region CDN không chỉ là vấn đề kỹ thuật thuần túy mà còn là bài toán cân bằng giữa độ trễ, chi phí và độ tin cậy. Trong bài viết này, tôi sẽ chia sẻ kinh nghiệm thực chiến khi triển khai HolySheep AI với kiến trúc CDN đa vùng, từ thiết kế ban đầu đến tối ưu hóa hiệu suất và kiểm soát chi phí.
Tại Sao Multi-region CDN Quan Trọng Với AI API
Khi làm việc với các mô hình AI như GPT-4.1, Claude Sonnet 4.5 hay DeepSeek V3.2, độ trễ network trở thành yếu tố quyết định trải nghiệm người dùng. Một request từ Việt Nam đến server ở Mỹ có thể tốn 200-300ms chỉ riêng cho latency, chưa kể thời gian xử lý của model. Với HolySheep AI, chúng ta có lợi thế tỷ giá ¥1=$1 giúp tiết kiệm 85%+ chi phí, kết hợp WeChat/Alipay thanh toán linh hoạt, nhưng điều quan trọng nhất là đạt được độ trễ dưới 50ms nhờ hạ tầng CDN phân tán.
Kiến Trúc Tổng Quan Multi-region CDN
Kiến trúc tối ưu cho HolySheep AI bao gồm 4 tầng chính:
- Tầng Edge Cache: Đặt tại các PoP (Point of Presence) gần người dùng nhất - Singapore, Tokyo, Frankfurt, Virginia
- Tầng Load Balancer: Điều phối request dựa trên geolocation và health check
- Tầng API Gateway: Xử lý authentication, rate limiting, và request routing
- Tầng Backend: Kết nối trực tiếp đến HolySheep AI API với base_url chuẩn
Triển Khai Chi Tiết Với Code Production
1. Python SDK Wrapper Với Automatic Region Selection
# holy_sheep_cdn.py
import asyncio
import httpx
import hashlib
from typing import Optional, Dict, Any, List
from dataclasses import dataclass
from enum import Enum
import time
class Region(Enum):
"""Các vùng CDN của HolySheep AI"""
SINGAPORE = "sgp1"
TOKYO = "tyo1"
FRANKFURT = "fra1"
VIRGINIA = "vir1"
SHANGHAI = "sha1"
@dataclass
class CDNEndpoint:
"""Cấu hình endpoint cho mỗi region"""
region: Region
base_url: str
priority: int
avg_latency_ms: float
weight: float # Weight cho weighted round-robin
class HolySheepCDNClient:
"""
HolySheep AI CDN Client với tự động chọn region tối ưu.
Đặc điểm:
- Tự động ping các endpoint để chọn region nhanh nhất
- Retry thông minh với exponential backoff
- Connection pooling cho hiệu suất cao
- Token caching để giảm chi phí
"""
BASE_URL = "https://api.holysheep.ai/v1" # LUÔN dùng endpoint chuẩn
def __init__(
self,
api_key: str,
timeout: float = 30.0,
max_retries: int = 3,
enable_caching: bool = True,
cache_ttl: int = 3600
):
self.api_key = api_key
self.timeout = timeout
self.max_retries = max_retries
self.enable_caching = enable_caching
self.cache_ttl = cache_ttl
# Khởi tạo các CDN endpoint
self.endpoints = [
CDNEndpoint(Region.SINGAPORE, self.BASE_URL, 1, 12.5, 0.35),
CDNEndpoint(Region.TOKYO, self.BASE_URL, 2, 18.3, 0.30),
CDNEndpoint(Region.FRANKFURT, self.BASE_URL, 3, 45.2, 0.20),
CDNEndpoint(Region.VIRGINIA, self.BASE_URL, 4, 120.5, 0.10),
CDNEndpoint(Region.SHANGHAI, self.BASE_URL, 5, 8.7, 0.05),
]
# Latency tracking
self.latency_map: Dict[Region, List[float]] = {
ep.region: [] for ep in self.endpoints
}
# HTTP client với connection pooling
self._client = httpx.AsyncClient(
timeout=httpx.Timeout(timeout),
limits=httpx.Limits(max_keepalive_connections=100, max_connections=200),
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json",
"X-CDN-Client": "HolySheepCDN/1.0"
}
)
# Cache cho responses
self._cache: Dict[str, tuple[Any, float]] = {}
async def _measure_latency(self, region: Region) -> float:
"""Đo độ trễ thực tế đến từng region"""
start = time.perf_counter()
try:
# Health check endpoint
response = await self._client.get(
f"{self.BASE_URL}/health",
headers={
"X-Region": region.value,
"Authorization": f"Bearer {self.api_key}"
}
)
latency = (time.perf_counter() - start) * 1000 # Convert to ms
if response.status_code == 200:
self.latency_map[region].append(latency)
# Giữ only 10 measurements gần nhất
if len(self.latency_map[region]) > 10:
self.latency_map[region].pop(0)
return latency
except Exception as e:
print(f"Health check failed for {region.value}: {e}")
return float('inf')
async def _get_optimal_region(self) -> Region:
"""Chọn region tối ưu dựa trên latency thực tế"""
# Đo latency song song cho tất cả regions
tasks = [self._measure_latency(ep.region) for ep in self.endpoints]
await asyncio.gather(*tasks, return_exceptions=True)
# Tính average latency và chọn region tốt nhất
best_region = Region.SINGAPORE
best_latency = float('inf')
for region, latencies in self.latency_map.items():
if latencies:
avg = sum(latencies) / len(latencies)
if avg < best_latency:
best_latency = avg
best_region = region
return best_region
def _get_cache_key(self, prompt: str, model: str, **kwargs) -> str:
"""Tạo cache key cho request"""
params = f"{model}:{prompt}:{str(kwargs)}"
return hashlib.sha256(params.encode()).hexdigest()
async def chat_completion(
self,
model: str,
messages: List[Dict[str, str]],
region: Optional[Region] = None,
temperature: float = 0.7,
max_tokens: int = 2048,
**kwargs
) -> Dict[str, Any]:
"""
Gửi chat completion request với tự động chọn region.
Args:
model: Model name (gpt-4.1, claude-sonnet-4.5, deepseek-v3.2, etc.)
messages: List of message objects
region: Chỉ định region cụ thể (None = auto select)
temperature: Sampling temperature
max_tokens: Maximum tokens to generate
"""
# Auto-select region nếu không chỉ định
if region is None:
region = await self._get_optimal_region()
# Check cache
if self.enable_caching:
prompt = messages[-1]["content"]
cache_key = self._get_cache_key(prompt, model, temperature=temperature, **kwargs)
if cache_key in self._cache:
cached_response, cached_time = self._cache[cache_key]
if time.time() - cached_time < self.cache_ttl:
return {"data": cached_response, "cached": True, "region": region.value}
# Prepare request
payload = {
"model": model,
"messages": messages,
"temperature": temperature,
"max_tokens": max_tokens,
**kwargs
}
headers = {
"X-Region": region.value,
"X-Request-ID": hashlib.uuid4().hex
}
# Retry logic với exponential backoff
for attempt in range(self.max_retries):
try:
start_time = time.perf_counter()
response = await self._client.post(
f"{self.BASE_URL}/chat/completions",
json=payload,
headers=headers
)
latency_ms = (time.perf_counter() - start_time) * 1000
if response.status_code == 200:
result = response.json()
# Cache successful response
if self.enable_caching and "choices" in result:
self._cache[cache_key] = (result, time.time())
return {
"data": result,
"latency_ms": round(latency_ms, 2),
"region": region.value,
"cached": False
}
elif response.status_code == 429:
# Rate limited - chờ và thử region khác
await asyncio.sleep(2 ** attempt)
region = await self._get_optimal_region()
headers["X-Region"] = region.value
continue
else:
response.raise_for_status()
except httpx.HTTPStatusError as e:
if attempt == self.max_retries - 1:
raise Exception(f"Request failed after {self.max_retries} attempts: {e}")
await asyncio.sleep(2 ** attempt)
async def stream_chat_completion(
self,
model: str,
messages: List[Dict[str, str]],
region: Optional[Region] = None,
**kwargs
):
"""Streaming response với tự động chọn region"""
if region is None:
region = await self._get_optimal_region()
payload = {
"model": model,
"messages": messages,
"stream": True,
**kwargs
}
async with self._client.stream(
"POST",
f"{self.BASE_URL}/chat/completions",
json=payload,
headers={"X-Region": region.value}
) as response:
async for line in response.aiter_lines():
if line.startswith("data: "):
yield line[6:] # Remove "data: " prefix
async def close(self):
"""Cleanup connections"""
await self._client.aclose()
def get_stats(self) -> Dict[str, Any]:
"""Lấy thống kê hiệu suất"""
stats = {}
for region, latencies in self.latency_map.items():
if latencies:
stats[region.value] = {
"avg_ms": round(sum(latencies) / len(latencies), 2),
"min_ms": round(min(latencies), 2),
"max_ms": round(max(latencies), 2),
"samples": len(latencies)
}
return stats
============== USAGE EXAMPLE ==============
async def main():
# Khởi tạo client với API key của bạn
client = HolySheepCDNClient(
api_key="YOUR_HOLYSHEEP_API_KEY", # Thay bằng key thực tế
enable_caching=True,
cache_ttl=3600
)
try:
# Chat completion đơn giản - tự động chọn region tối ưu
result = await client.chat_completion(
model="deepseek-v3.2",
messages=[
{"role": "system", "content": "Bạn là trợ lý AI chuyên về lập trình."},
{"role": "user", "content": "Giải thích về multi-region CDN optimization"}
],
temperature=0.7,
max_tokens=1000
)
print(f"Response từ region {result['region']}:")
print(f"Latency: {result['latency_ms']}ms")
print(f"Data: {result['data']}")
# In thống kê
print("\n=== CDN Stats ===")
print(client.get_stats())
finally:
await client.close()
if __name__ == "__main__":
asyncio.run(main())
2. Node.js/TypeScript Implementation Với Connection Pooling
// holy-sheep-cdn.ts
import axios, { AxiosInstance, AxiosError } from 'axios';
import { EventEmitter } from 'events';
interface CDNRegion {
id: string;
name: string;
priority: number;
latencyMs: number;
isHealthy: boolean;
lastCheck: number;
}
interface RequestMetrics {
totalRequests: number;
successfulRequests: number;
failedRequests: number;
avgLatencyMs: number;
cacheHitRate: number;
}
class HolySheepCDNManager extends EventEmitter {
// LUÔN dùng base_url chuẩn của HolySheep
private readonly BASE_URL = 'https://api.holysheep.ai/v1';
private readonly API_KEY: string;
private regions: Map = new Map();
private client: AxiosInstance;
private metrics: RequestMetrics = {
totalRequests: 0,
successfulRequests: 0,
failedRequests: 0,
avgLatencyMs: 0,
cacheHitRate: 0
};
private cache: Map = new Map();
private readonly CACHE_TTL = 3600000; // 1 hour in ms
constructor(apiKey: string) {
super();
this.API_KEY = apiKey;
// Initialize regions với cấu hình tối ưu
this.initializeRegions();
// Setup axios với connection pooling
this.client = axios.create({
baseURL: this.BASE_URL,
timeout: 30000,
maxConnectionsPerHost: 100,
maxRedirects: 0,
headers: {
'Authorization': Bearer ${this.API_KEY},
'Content-Type': 'application/json',
'X-CDN-Client': 'HolySheepCDN/1.0.0',
'Keep-Alive': 'timeout=120, max=100'
}
});
// Setup interceptors
this.setupInterceptors();
// Bắt đầu health check định kỳ
this.startHealthCheck();
}
private initializeRegions(): void {
const regionConfigs: Omit[] = [
{ id: 'sgp', name: 'Singapore', priority: 1 },
{ id: 'tyo', name: 'Tokyo', priority: 2 },
{ id: 'fra', name: 'Frankfurt', priority: 3 },
{ id: 'vir', name: 'Virginia', priority: 4 },
{ id: 'sha', name: 'Shanghai', priority: 5 }
];
regionConfigs.forEach(config => {
this.regions.set(config.id, {
...config,
latencyMs: 0,
isHealthy: true,
lastCheck: Date.now()
});
});
}
private setupInterceptors(): void {
// Response interceptor để track latency
this.client.interceptors.response.use(
response => {
const latency = response.headers['x-response-time']
? parseInt(response.headers['x-response-time'])
: 0;
// Update region latency
const regionId = response.config.headers['X-Region'] as string;
if (regionId && this.regions.has(regionId)) {
const region = this.regions.get(regionId)!;
region.latencyMs = latency || this.calculateLatency(response.config);
region.lastCheck = Date.now();
}
this.metrics.successfulRequests++;
return response;
},
(error: AxiosError) => {
this.metrics.failedRequests++;
// Mark region as unhealthy
if (error.config && error.config.headers) {
const regionId = error.config.headers['X-Region'] as string;
if (regionId && this.regions.has(regionId)) {
const region = this.regions.get(regionId)!;
region.isHealthy = false;
region.latencyMs = 999999;
}
}
return Promise.reject(error);
}
);
}
private calculateLatency(config: any): number {
const start = config.metadata?.startTime;
return start ? Date.now() - start : 0;
}
private async startHealthCheck(): Promise {
setInterval(async () => {
const healthPromises: Promise[] = [];
this.regions.forEach((region, id) => {
healthPromises.push(this.checkRegionHealth(id));
});
await Promise.allSettled(healthPromises);
this.emit('healthCheck', this.getRegionStatus());
}, 30000); // Check every 30 seconds
}
private async checkRegionHealth(regionId: string): Promise {
const region = this.regions.get(regionId);
if (!region) return;
try {
const startTime = Date.now();
await this.client.get('/health', {
headers: { 'X-Region': regionId },
timeout: 5000
});
region.latencyMs = Date.now() - startTime;
region.isHealthy = true;
region.lastCheck = Date.now();
} catch (error) {
region.isHealthy = false;
region.latencyMs = 999999;
}
}
private selectOptimalRegion(): string {
// Weighted random selection dựa trên latency và priority
const healthyRegions = Array.from(this.regions.values())
.filter(r => r.isHealthy)
.sort((a, b) => {
// Ưu tiên latency thấp, nhưng cũng consider priority
const latencyScoreA = a.latencyMs / Math.pow(2, a.priority);
const latencyScoreB = b.latencyMs / Math.pow(2, b.priority);
return latencyScoreA - latencyScoreB;
});
if (healthyRegions.length === 0) {
// Fallback to highest priority region
return 'sgp';
}
return healthyRegions[0].id;
}
private getCacheKey(prompt: string, model: string, options: object): string {
return Buffer.from(${model}:${prompt}:${JSON.stringify(options)}).toString('base64');
}
private getCachedResponse(key: string): any | null {
const cached = this.cache.get(key);
if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
return cached.data;
}
this.cache.delete(key);
return null;
}
async chatCompletion(params: {
model: string;
messages: Array<{ role: string; content: string }>;
temperature?: number;
max_tokens?: number;
top_p?: number;
region?: string;
}): Promise {
const {
model,
messages,
temperature = 0.7,
max_tokens = 2048,
top_p = 1,
region
} = params;
this.metrics.totalRequests++;
// Select region
const selectedRegion = region || this.selectOptimalRegion();
const cacheKey = this.getCacheKey(messages[messages.length - 1].content, model, params);
// Check cache
const cachedData = this.getCachedResponse(cacheKey);
if (cachedData) {
this.metrics.cacheHitRate = (this.metrics.cacheHitRate * 0.9) + 10; // Moving average
return { ...cachedData, cached: true, region: selectedRegion };
}
const startTime = Date.now();
try {
const response = await this.client.post('/chat/completions', {
model,
messages,
temperature,
max_tokens,
top_p
}, {
headers: { 'X-Region': selectedRegion }
});
const latencyMs = Date.now() - startTime;
this.metrics.avgLatencyMs = (this.metrics.avgLatencyMs * 0.9) + (latencyMs * 0.1);
const result = {
data: response.data,
latency_ms: latencyMs,
region: selectedRegion,
cached: false
};
// Store in cache
this.cache.set(cacheKey, {
data: result,
timestamp: Date.now()
});
return result;
} catch (error) {
// Retry với region khác
if ((error as AxiosError).code === 'ECONNRESET' ||
(error as AxiosError).response?.status === 429) {
const fallbackRegion = this.selectOptimalRegion();
if (fallbackRegion !== selectedRegion) {
return this.chatCompletion({ ...params, region: fallbackRegion });
}
}
throw error;
}
}
async *streamChatCompletion(params: {
model: string;
messages: Array<{ role: string; content: string }>;
region?: string;
}): AsyncGenerator {
const selectedRegion = params.region || this.selectOptimalRegion();
const response = await this.client.post('/chat/completions', {
model: params.model,
messages: params.messages,
stream: true
}, {
headers: { 'X-Region': selectedRegion },
responseType: 'stream'
});
let buffer = '';
for await (const chunk of response.data) {
buffer += chunk.toString();
const lines = buffer.split('\n');
buffer = lines.pop() || '';
for (const line of lines) {
if (line.startsWith('data: ')) {
const data = line.slice(6);
if (data === '[DONE]') {
return;
}
yield data;
}
}
}
}
getRegionStatus(): CDNRegion[] {
return Array.from(this.regions.values()).sort((a, b) => a.priority - b.priority);
}
getMetrics(): RequestMetrics {
return { ...this.metrics };
}
// Benchmark method
async benchmarkRegions(): Promise> {
const results = new Map();
for (const [id] of this.regions) {
const times: number[] = [];
// Run 5 requests để lấy average
for (let i = 0; i < 5; i++) {
const start = Date.now();
await this.client.get('/health', {
headers: { 'X-Region': id },
timeout: 5000
});
times.push(Date.now() - start);
}
const avg = times.reduce((a, b) => a + b, 0) / times.length;
results.set(id, Math.round(avg * 100) / 100);
}
return results;
}
}
// ============== USAGE EXAMPLE ==============
async function main() {
const cdn = new HolySheepCDNManager('YOUR_HOLYSHEEP_API_KEY');
try {
// Simple chat completion
const result = await cdn.chatCompletion({
model: 'deepseek-v3.2',
messages: [
{ role: 'system', content: 'Bạn là chuyên gia tối ưu hóa CDN.' },
{ role: 'user', content: 'So sánh latency giữa các region CDN' }
],
temperature: 0.7,
max_tokens: 500
});
console.log(Response from ${result.region}:, result.data);
console.log(Latency: ${result.latency_ms}ms);
// Benchmark tất cả regions
console.log('\n=== Region Benchmark ===');
const benchmark = await cdn.benchmarkRegions();
benchmark.forEach((latency, region) => {
console.log(${region}: ${latency}ms);
});
// Xem metrics
console.log('\n=== Client Metrics ===');
console.log(cdn.getMetrics());
} catch (error) {
console.error('Error:', error);
}
}
main();
3. Go Implementation Cho High-Performance Systems
package main
import (
"bytes"
"context"
"encoding/json"
"fmt"
"log"
"net/http"
"sync"
"sync/atomic"
"time"
)
// HolySheepCDN Client viết bằng Go cho hiệu suất tối đa
// base_url: https://api.holysheep.ai/v1 (KHÔNG ĐƯỢC THAY ĐỔI)
const BaseURL = "https://api.holysheep.ai/v1"
type Region string
const (
RegionSingapore Region = "sgp"
RegionTokyo Region = "tyo"
RegionFrankfurt Region = "fra"
RegionVirginia Region = "vir"
RegionShanghai Region = "sha"
)
type CDNEndpoint struct {
Region Region
Latency atomic.Int64
Healthy atomic.Bool
Weight float64
RequestCount atomic.Int64
}
type HolySheepCDN struct {
apiKey string
client *http.Client
endpoints map[Region]*CDNEndpoint
mu sync.RWMutex
httpClient *http.Client
}
type ChatRequest struct {
Model string json:"model"
Messages []map[string]string json:"messages"
Temperature float64 json:"temperature,omitempty"
MaxTokens int json:"max_tokens,omitempty"
TopP float64 json:"top_p,omitempty"
Stream bool json:"stream,omitempty"
}
type ChatResponse struct {
ID string json:"id"
Object string json:"object"
Created int64 json:"created"
Model string json:"model"
Choices []Choice json:"choices"
Usage Usage json:"usage"
}
type Choice struct {
Index int json:"index"
Message Message json:"message"
FinishReason string json:"finish_reason"
}
type Message struct {
Role string json:"role"
Content string json:"content"
}
type Usage struct {
PromptTokens int json:"prompt_tokens"
CompletionTokens int json:"completion_tokens"
TotalTokens int json:"total_tokens"
}
type CDNMetrics struct {
TotalRequests int64
SuccessfulReqs int64
FailedReqs int64
AvgLatencyMs float64
CacheHits int64
RegionStats map[Region]RegionStats
}
type RegionStats struct {
LatencyMs float64
Healthy bool
RequestsCount int64
}
func NewHolySheepCDN(apiKey string) *HolySheepCDN {
client := &http.Client{
Timeout: 30 * time.Second,
Transport: &http.Transport{
MaxIdleConns: 100,
MaxIdleConnsPerHost: 100,
IdleConnTimeout: 120 * time.Second,
},
}
h := &HolySheepCDN{
apiKey: apiKey,
client: client,
endpoints: map[Region]*CDNEndpoint{
RegionSingapore: {Region: RegionSingapore, Weight: 0.35, Healthy: atomic.Bool{}},
RegionTokyo: {Region: RegionTokyo, Weight: 0.30, Healthy: atomic.Bool{}},
RegionFrankfurt: {Region: RegionFrankfurt, Weight: 0.20, Healthy: atomic.Bool{}},
RegionVirginia: {Region: RegionVirginia, Weight: 0.10, Healthy: atomic.Bool{}},
RegionShanghai: {Region: RegionShanghai, Weight: 0.05, Healthy: atomic.Bool{}},
},
}
// Mark all as healthy initially
for _, ep := range h.endpoints {
ep.Healthy.Store(true)
}
// Start health checker
go h.healthChecker()
return h
}
func (h *HolySheepCDN) healthChecker() {
ticker := time.NewTicker(30 * time.Second)
defer ticker.Stop()
for range ticker.C {
var wg sync.WaitGroup
for region := range h.endpoints {
wg.Add(1)
go func(r Region) {
defer wg.Done()
h.checkHealth(r)
}(region)
}
wg.Wait()
}
}
func (h *HolySheepCDN) checkHealth(region Region) {
endpoint := h.endpoints[region]
req, err := http.NewRequest("GET", fmt.Sprintf("%s/health", BaseURL), nil)
if err != nil {
endpoint.Healthy.Store(false)
return
}
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", h.apiKey))
req.Header.Set("X-Region", string(region))
start := time.Now()
resp, err := h.client.Do(req)
latency := time.Since(start).Milliseconds()
if err != nil || resp.StatusCode != http.StatusOK {
endpoint.Healthy.Store(false)
return
}
defer resp.Body.Close()
endpoint.Latency.Store(latency)
endpoint.Healthy.Store(true)
}
func (h *HolySheepCDN) selectOptimalRegion() Region {
h.mu.RLock()
defer h.mu.RUnlock()
var bestRegion Region
var bestLatency int64 = 1<<63 - 1
for region, endpoint := range h.endpoints {
if !endpoint.Healthy.Load() {
continue
}
latency := endpoint.Latency.Load()
if latency > 0 && latency < bestLatency {
bestLatency = latency
bestRegion = region
}
}
if bestRegion == "" {
// Fallback to Singapore
return RegionSingapore
}
return bestRegion
}
func (h *HolySheepCDN) ChatCompletion(ctx context.Context, req ChatRequest) (*ChatResponse, error) {
region := h.selectOptimalRegion()
endpoint := h.endpoints[region]
body, err := json.Marshal(req)
if err != nil {
return nil, fmt.Errorf("failed to marshal request: %w", err)
}
httpReq, err := http.NewRequestWithContext(ctx, "POST", fmt.Sprintf("%s/chat/completions", BaseURL), bytes.NewBuffer(body))
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
httpReq.Header.Set("Authorization", fmt.Sprintf("Bearer %s", h.apiKey))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("X-Region", string(region))
start := time.Now()
resp, err := h.client.Do(httpReq)
latency := time.Since(start).Milliseconds()
if err != nil {
return nil, fmt.Errorf("request failed: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
}
var result ChatResponse
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
return nil, fmt.Errorf("failed to decode response: %w", err)