API Rate Limiting, Retry và Degradation: Hướng Dẫn Toàn Diện Cho Production

Kết luận trước: Nếu bạn đang xây dựng ứng dụng cần gọi LLM API với chi phí thấp, độ trễ dưới 50ms và không giới hạn rate limit khắc nghiệt — đăng ký HolySheep AI ngay. Tiết kiệm 85%+ chi phí so với API chính thức, hỗ trợ WeChat/Alipay, và tín dụng miễn phí khi bắt đầu.

So Sánh Chi Phí: HolySheep vs API Chính Thức

Nhà cung cấp	Model	Giá/1M Tokens	Độ trễ	Rate Limit	Thanh toán
HolySheep AI	GPT-4.1	$8.00	<50ms	Lin hoạt	WeChat/Alipay/USD
HolySheep AI	Claude Sonnet 4.5	$15.00	<50ms	Lin hoạt	WeChat/Alipay/USD
HolySheep AI	Gemini 2.5 Flash	$2.50	<50ms	Lin hoạt	WeChat/Alipay/USD
HolySheep AI	DeepSeek V3.2	$0.42	<50ms	Lin hoạt	WeChat/Alipay/USD
OpenAI (tham khảo)	GPT-4o	$15.00	200-500ms	Nghiêm ngặt	Thẻ quốc tế
Anthropic (tham khảo)	Claude 3.5	$18.00	300-800ms	Nghiêm ngặt	Thẻ quốc tế

Phù Hợp / Không Phù Hợp Với Ai

✅ Nên dùng HolySheep AI khi:

• Startup hoặc dự án cá nhân cần tiết kiệm chi phí API
• Cần thanh toán qua WeChat/Alipay (không có thẻ quốc tế)
• Ứng dụng cần độ trễ thấp (<50ms) cho trải nghiệm real-time
• Hệ thống cần rate limit linh hoạt, không bị giới hạn khắc nghiệt
• Đội ngũ phát triển tại Trung Quốc hoặc Đông Nam Á

❌ Cân nhắc giải pháp khác khi:

• Dự án enterprise cần SLA 99.99% và hỗ trợ chuyên nghiệp 24/7
• Bắt buộc dùng region cụ thể (EU, US) vì compliance
• Cần integration sâu với ecosystem của OpenAI/Anthropic

1. Rate Limiting: Tại Sao Cần Và Cách Triển Khai

Rate limiting là cơ chế kiểm soát số lượng request mà client được phép gửi trong một khoảng thời gian. Không có rate limit, hệ thống của bạn sẽ:

• Bị block IP khi gửi quá nhiều request
• Tốn chi phí phát sinh không kiểm soát được
• Gặp lỗi 429 Too Many Requests liên tục

Từ kinh nghiệm thực chiến với hàng triệu API call mỗi ngày, tôi khuyến nghị triển khai token bucket algorithm — đơn giản nhưng hiệu quả cao.

1.1 Token Bucket Implementation

/**
 * Token Bucket Rate Limiter - HolySheep AI Compatible
 * Triển khai: HolySheep AI với base_url: https://api.holysheep.ai/v1
 * 
 * Specification:
 * - Bucket capacity: 100 tokens
 * - Refill rate: 10 tokens/giây
 * - Mỗi request tiêu tốn 1 token
 */

class TokenBucket {
    constructor(capacity, refillRate) {
        this.capacity = capacity;
        this.tokens = capacity;
        this.refillRate = refillRate;
        this.lastRefill = Date.now();
    }

    async acquire(tokens = 1) {
        // Refill tokens dựa trên thời gian đã trôi qua
        const now = Date.now();
        const elapsed = (now - this.lastRefill) / 1000;
        const tokensToAdd = elapsed * this.refillRate;
        
        this.tokens = Math.min(this.capacity, this.tokens + tokensToAdd);
        this.lastRefill = now;

        // Kiểm tra nếu đủ tokens
        if (this.tokens >= tokens) {
            this.tokens -= tokens;
            return true;
        }

        // Đợi cho đến khi có đủ tokens
        const waitTime = (tokens - this.tokens) / this.refillRate * 1000;
        await new Promise(resolve => setTimeout(resolve, waitTime));
        
        this.tokens -= tokens;
        return true;
    }

    getAvailableTokens() {
        const now = Date.now();
        const elapsed = (now - this.lastRefill) / 1000;
        return Math.min(this.capacity, this.tokens + elapsed * this.refillRate);
    }
}

// Sử dụng với HolySheep API
class HolySheepAIClient {
    constructor(apiKey, rateLimiter) {
        this.baseUrl = 'https://api.holysheep.ai/v1';
        this.apiKey = apiKey;
        this.rateLimiter = rateLimiter || new TokenBucket(100, 10);
    }

    async chat completions(messages, options = {}) {
        // Đợi có token trước khi gọi API
        await this.rateLimiter.acquire();
        
        const response = await fetch(${this.baseUrl}/chat/completions, {
            method: 'POST',
            headers: {
                'Authorization': Bearer ${this.apiKey},
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                model: options.model || 'gpt-4.1',
                messages: messages,
                max_tokens: options.maxTokens || 2048,
                temperature: options.temperature || 0.7
            })
        });

        if (response.status === 429) {
            // HolySheep trả về Retry-After header
            const retryAfter = response.headers.get('Retry-After') || 5;
            console.log(Rate limited. Retrying after ${retryAfter}s...);
            await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
            return this.chat completions(messages, options); // Retry
        }

        return response.json();
    }
}

// Khởi tạo client - Thay YOUR_HOLYSHEEP_API_KEY bằng API key thực tế
const client = new HolySheepAIClient('YOUR_HOLYSHEEP_API_KEY');

1.2 Sliding Window Counter (Alternative)

/**
 * Sliding Window Counter - Độ chính xác cao hơn Token Bucket
 * Phù hợp với HolySheep API có rate limit theo window cố định
 */

class SlidingWindowCounter {
    constructor(maxRequests, windowMs) {
        this.maxRequests = maxRequests;
        this.windowMs = windowMs;
        this.requests = [];
    }

    async acquire() {
        const now = Date.now();
        const windowStart = now - this.windowMs;

        // Loại bỏ các request cũ khỏi window
        this.requests = this.requests.filter(time => time > windowStart);

        if (this.requests.length >= this.maxRequests) {
            // Tính thời gian chờ đến request oldest trong window
            const oldestRequest = Math.min(...this.requests);
            const waitTime = oldestRequest + this.windowMs - now;
            
            console.log(Sliding window full. Waiting ${waitTime}ms...);
            await new Promise(resolve => setTimeout(resolve, waitTime));
            
            // Thử lại sau khi đợi
            return this.acquire();
        }

        // Thêm request hiện tại vào window
        this.requests.push(now);
        return true;
    }

    getRequestCount() {
        const now = Date.now();
        const windowStart = now - this.windowMs;
        return this.requests.filter(time => time > windowStart).length;
    }
}

// Sử dụng: Cho phép 60 request/phút (1 request/giây)
const limiter = new SlidingWindowCounter(60, 60000);

// Wrapper function cho HolySheep API
async function callHolySheepAPI(messages) {
    await limiter.acquire();
    
    const response = await fetch('https://api.holysheep.ai/v1/chat/completions', {
        method: 'POST',
        headers: {
            'Authorization': 'Bearer YOUR_HOLYSHEEP_API_KEY',
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            model: 'deepseek-v3.2',
            messages: messages
        })
    });

    return response.json();
}

2. Retry Strategy: Exponential Backoff Và Jitter

Khi gặp lỗi tạm thời (5xx, network timeout), retry là cần thiết. Tuy nhiên, retry không đúng cách sẽ gây:

• Cascade failure — nhiều client retry cùng lúc
• Overload backend
• Tốn token/quota không cần thiết

Giải pháp: Exponential backoff với jitter (độ trễ ngẫu nhiên).

/**
 * Retry Engine với Exponential Backoff + Jitter
 * Compatible với HolySheep AI API
 * 
 * Specs:
 * - Base delay: 1 giây
 * - Max delay: 32 giây  
 * - Max retries: 5 lần
 * - Jitter: ±20% của delay
 */

class RetryEngine {
    constructor(options = {}) {
        this.maxRetries = options.maxRetries || 5;
        this.baseDelay = options.baseDelay || 1000; // 1 giây
        this.maxDelay = options.maxDelay || 32000; // 32 giây
        this.jitterFactor = options.jitterFactor || 0.2; // ±20%
    }

    // Tính delay với exponential backoff
    calculateDelay(attempt) {
        // Exponential: 1s, 2s, 4s, 8s, 16s, 32s...
        const exponentialDelay = this.baseDelay * Math.pow(2, attempt);
        
        // Giới hạn max delay
        const cappedDelay = Math.min(exponentialDelay, this.maxDelay);
        
        // Thêm jitter (độ ngẫu nhiên)
        const jitter = cappedDelay * this.jitterFactor * (Math.random() * 2 - 1);
        const finalDelay = cappedDelay + jitter;
        
        return Math.max(0, Math.round(finalDelay));
    }

    // Kiểm tra có nên retry không
    shouldRetry(error, attempt) {
        // Không retry quá số lần cho phép
        if (attempt >= this.maxRetries) {
            return false;
        }

        // Retry các lỗi tạm thời
        const retryableStatusCodes = [408, 429, 500, 502, 503, 504];
        const retryableErrors = ['ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND', 'ENETUNREACH'];

        if (error.status && retryableStatusCodes.includes(error.status)) {
            return true;
        }

        if (error.code && retryableErrors.includes(error.code)) {
            return true;
        }

        // Không retry lỗi client (4xx) trừ 429
        if (error.status && error.status >= 400 && error.status < 500 && error.status !== 429) {
            return false;
        }

        return true;
    }

    // Retry wrapper
    async withRetry(fn, context = '') {
        let lastError;

        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
            try {
                return await fn();
            } catch (error) {
                lastError = error;

                console.log([Retry] Attempt ${attempt + 1}/${this.maxRetries + 1} failed for ${context});
                console.log([Retry] Error: ${error.message || error.code || error.status});

                if (!this.shouldRetry(error, attempt)) {
                    console.log([Retry] Not retryable. Giving up.);
                    throw error;
                }

                const delay = this.calculateDelay(attempt);
                console.log([Retry] Waiting ${delay}ms before next attempt...);
                await new Promise(resolve => setTimeout(resolve, delay));
            }
        }

        throw lastError;
    }
}

// Sử dụng với HolySheep API
const retryEngine = new RetryEngine({
    maxRetries: 5,
    baseDelay: 1000,
    maxDelay: 32000
});

async function callLLM(messages, model = 'gpt-4.1') {
    return retryEngine.withRetry(async () => {
        const response = await fetch('https://api.holysheep.ai/v1/chat/completions', {
            method: 'POST',
            headers: {
                'Authorization': 'Bearer YOUR_HOLYSHEEP_API_KEY',
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                model: model,
                messages: messages
            })
        });

        if (!response.ok) {
            const error = new Error(HTTP ${response.status});
            error.status = response.status;
            error.headers = response.headers;
            throw error;
        }

        return response.json();
    }, LLM call (model: ${model}));
}

// Ví dụ sử dụng
async function example() {
    try {
        const result = await callLLM([
            { role: 'system', content: 'Bạn là trợ lý AI hữu ích.' },
            { role: 'user', content: 'Xin chào, hãy giới thiệu về bản thân.' }
        ], 'deepseek-v3.2');
        
        console.log('Response:', result.choices[0].message.content);
    } catch (error) {
        console.error('Final error after all retries:', error);
    }
}

3. Circuit Breaker Pattern: Ngăn Chặn Cascade Failure

Khi backend bị down hoặc quá tải, việc tiếp tục gọi API sẽ gây lãng phí resource và có thể kéo sập toàn bộ hệ thống. Circuit Breaker pattern giải quyết vấn đề này bằng cách "ngắt mạch" khi tỷ lệ lỗi vượt ngưỡng.

/**
 * Circuit Breaker Implementation
 * States: CLOSED (bình thường) → OPEN (ngắt) → HALF_OPEN (thử lại)
 * 
 * HolySheep AI với độ trễ <50ms giúp giảm trigger rate
 */

class CircuitBreaker {
    constructor(options = {}) {
        this.failureThreshold = options.failureThreshold || 5; // Mở circuit sau 5 lỗi
        this.successThreshold = options.successThreshold || 2; // Đóng circuit sau 2 thành công
        this.timeout = options.timeout || 30000; // Thử lại sau 30s
        
        this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
        this.failureCount = 0;
        this.successCount = 0;
        this.lastFailureTime = null;
    }

    async execute(fn) {
        if (this.state === 'OPEN') {
            // Kiểm tra timeout để chuyển sang HALF_OPEN
            if (Date.now() - this.lastFailureTime >= this.timeout) {
                console.log('[CircuitBreaker] Timeout passed. Moving to HALF_OPEN.');
                this.state = 'HALF_OPEN';
            } else {
                throw new Error('Circuit is OPEN. Request blocked.');
            }
        }

        try {
            const result = await fn();
            this.onSuccess();
            return result;
        } catch (error) {
            this.onFailure();
            throw error;
        }
    }

    onSuccess() {
        if (this.state === 'HALF_OPEN') {
            this.successCount++;
            if (this.successCount >= this.successThreshold) {
                console.log('[CircuitBreaker] Recovery successful. Closing circuit.');
                this.state = 'CLOSED';
                this.failureCount = 0;
                this.successCount = 0;
            }
        } else {
            // Reset failure count khi có success liên tiếp
            this.failureCount = Math.max(0, this.failureCount - 1);
        }
    }

    onFailure() {
        this.failureCount++;
        this.lastFailureTime = Date.now();

        if (this.state === 'HALF_OPEN') {
            // Thất bại trong HALF_OPEN → quay về OPEN
            console.log('[CircuitBreaker] Failed in HALF_OPEN. Reopening circuit.');
            this.state = 'OPEN';
            this.successCount = 0;
        } else if (this.failureCount >= this.failureThreshold) {
            // Vượt ngưỡng lỗi → mở circuit
            console.log([CircuitBreaker] Failure threshold reached (${this.failureCount}). Opening circuit.);
            this.state = 'OPEN';
        }
    }

    getState() {
        return this.state;
    }

    // Reset circuit breaker
    reset() {
        this.state = 'CLOSED';
        this.failureCount = 0;
        this.successCount = 0;
        console.log('[CircuitBreaker] Circuit manually reset.');
    }
}

// Integration với HolySheep API
const holySheepBreaker = new CircuitBreaker({
    failureThreshold: 5,
    successThreshold: 2,
    timeout: 30000
});

async function callWithCircuitBreaker(messages, fallbackFn) {
    try {
        return await holySheepBreaker.execute(async () => {
            const response = await fetch('https://api.holysheep.ai/v1/chat/completions', {
                method: 'POST',
                headers: {
                    'Authorization': 'Bearer YOUR_HOLYSHEEP_API_KEY',
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    model: 'gpt-4.1',
                    messages: messages
                })
            });

            if (!response.ok) {
                throw new Error(API Error: ${response.status});
            }

            return response.json();
        });
    } catch (error) {
        console.log('[CircuitBreaker] Circuit open. Using fallback...');
        if (fallbackFn) {
            return fallbackFn(messages);
        }
        throw error;
    }
}

4. Degradation Strategy: Fallback Khi API Fail

Degradation (t阶梯式降级) là chiến lược giảm chất lượng service thay vì complete failure. Nguyên tắc: "Gracefully degrade" — vẫn phục vụ được user với chất lượng thấp hơn.

4.1 Multi-Model Fallback Chain

/**
 * Multi-Model Fallback với HolySheep AI
 * Chiến lược: Thử model đắt tiền trước → fallback sang model rẻ hơn
 * 
 * Priority Chain:
 * 1. gpt-4.1 ($8/1M tokens) - Chất lượng cao nhất
 * 2. gemini-2.5-flash ($2.50/1M tokens) - Cân bằng giá/chất lượng  
 * 3. deepseek-v3.2 ($0.42/1M tokens) - Tiết kiệm nhất
 */

class ModelFallbackChain {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.baseUrl = 'https://api.holysheep.ai/v1';
        
        // Priority chain - thử theo thứ tự
        this.models = [
            { name: 'gpt-4.1', cost: 8.00, priority: 1 },
            { name: 'gemini-2.5-flash', cost: 2.50, priority: 2 },
            { name: 'deepseek-v3.2', cost: 0.42, priority: 3 }
        ];
        
        // Cache cho simple queries
        this.responseCache = new Map();
        this.cacheTTL = 5 * 60 * 1000; // 5 phút
    }

    async callAPI(model, messages) {
        const controller = new AbortController();
        const timeout = setTimeout(() => controller.abort(), 10000); // 10s timeout

        try {
            const response = await fetch(${this.baseUrl}/chat/completions, {
                method: 'POST',
                headers: {
                    'Authorization': Bearer ${this.apiKey},
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    model: model.name,
                    messages: messages,
                    max_tokens: 2048
                }),
                signal: controller.signal
            });

            clearTimeout(timeout);

            if (!response.ok) {
                const error = new Error(HTTP ${response.status});
                error.status = response.status;
                throw error;
            }

            return await response.json();
        } catch (error) {
            clearTimeout(timeout);
            throw error;
        }
    }

    // Kiểm tra cache trước
    getCachedResponse(messages) {
        const cacheKey = JSON.stringify(messages);
        const cached = this.responseCache.get(cacheKey);
        
        if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
            return cached.response;
        }
        
        return null;
    }

    setCachedResponse(messages, response) {
        const cacheKey = JSON.stringify(messages);
        this.responseCache.set(cacheKey, {
            response: response,
            timestamp: Date.now()
        });
    }

    async complete(messages, options = {}) {
        // 1. Thử cache trước cho queries đơn giản
        if (!options.noCache) {
            const cached = this.getCachedResponse(messages);
            if (cached) {
                console.log('[FallbackChain] Using cached response');
                return { ...cached, fromCache: true };
            }
        }

        // 2. Thử lần lượt các model
        let lastError;
        
        for (const model of this.models) {
            console.log([FallbackChain] Trying model: ${model.name} ($${model.cost}/1M tokens));
            
            try {
                const response = await this.callAPI(model, messages);
                
                // Cache response thành công
                if (!options.noCache) {
                    this.setCachedResponse(messages, response);
                }
                
                return {
                    ...response,
                    model: model.name,
                    costPerMillion: model.cost,
                    fromCache: false
                };
            } catch (error) {
                console.log([FallbackChain] ${model.name} failed: ${error.message});
                lastError = error;
                continue; // Thử model tiếp theo
            }
        }

        // 3. Tất cả đều fail → return error response
        console.error('[FallbackChain] All models failed');
        return {
            error: true,
            message: 'All LLM services unavailable',
            originalError: lastError.message,
            fallbackResponse: this.getSimpleFallback(messages)
        };
    }

    // Simple rule-based fallback khi LLM hoàn toàn fail
    getSimpleFallback(messages) {
        const lastMessage = messages[messages.length - 1]?.content?.toLowerCase() || '';
        
        if (lastMessage.includes('chào') || lastMessage.includes('hello')) {
            return { content: 'Xin chào! Tôi đang gặp sự cố kỹ thuật. Vui lòng thử lại sau.' };
        }
        
        if (lastMessage.includes('giá')) {
            return { content: 'Xin lỗi, tôi không thể trả lời lúc này. Vui lòng liên hệ hỗ trợ.' };
        }
        
        return { content: 'Tôi đang gặp trục trặc. Vui lòng thử lại trong giây lát.' };
    }
}

// Sử dụng
const chain = new ModelFallbackChain('YOUR_HOLYSHEEP_API_KEY');

async function intelligentCompletion(messages) {
    const startTime = Date.now();
    const result = await chain.complete(messages);
    const latency = Date.now() - startTime;
    
    console.log(Total latency: ${latency}ms);
    console.log(Model used: ${result.model});
    console.log(Cost: $${(result.costPerMillion || 0).toFixed(4)}/1M tokens);
    
    return result;
}

5. Monitoring Và Observability

Không có monitoring, bạn không biết system có healthy hay không. Triển khai metrics collection cho tất cả các thành phần:

/**
 * API Metrics Collector cho HolySheep AI
 * Theo dõi: Latency, Error Rate, Token Usage, Cost
 */

class APIMetrics {
    constructor() {
        this.metrics = {
            requests: [],
            errors: [],
            tokens: { prompt: 0, completion: 0 },
            cost: { total: 0, byModel: {} }
        };
        
        this.modelPrices = {
            'gpt-4.1': 8.00,
            'claude-sonnet-4.5': 15.00,
            'gemini-2.5-flash': 2.50,
            'deepseek-v3.2': 0.42
        };
    }

    recordRequest(request) {
        this.metrics.requests.push({
            timestamp: Date.now(),
            model: request.model,
            latency: request.latency,
            success: request.success,
            tokens: request.tokens
        });

        // Tính cost
        if (request.success && request.tokens) {
            const promptCost = (request.tokens.prompt / 1_000_000) * this.modelPrices[request.model];
            const completionCost = (request.tokens.completion / 1_000_000) * this.modelPrices[request.model];
            const totalCost = promptCost + completionCost;

            this.metrics.cost.total += totalCost;
            this.metrics.cost.byModel[request.model] = (this.metrics.cost.byModel[request.model] || 0) + totalCost;
            this.metrics.tokens.prompt += request.tokens.prompt;
            this.metrics.tokens.completion += request.tokens.completion;
        }

        if (!request.success) {
            this.metrics.errors.push({
                timestamp: Date.now(),
                model: request.model,
                error: request.error
            });
        }
    }

    getStats() {
        const now = Date.now();
        const last24h = this.metrics.requests.filter(r => now - r.timestamp < 24 * 60 * 60 * 1000);
        const last1h = last24h.filter(r => now - r.timestamp < 60 * 60 * 1000);

        const avgLatency = arr => arr.length ? arr.reduce((sum, r) => sum + r.latency, 0) / arr.length : 0;
        const errorRate = arr => arr.length ? (arr.filter(r => !r.success).length / arr.length * 100) : 0;

        return {
            totalRequests: this.metrics.requests.length,
            last24h: {
                requests: last24h.length,
                avgLatency: Math.round(avgLatency(last24h)),
                errorRate: errorRate(last24h).toFixed(2) + '%'
            },
            last1h: {
                requests: last1h.length,
                avgLatency: Math.round(avgLatency(last1h)),
                errorRate: errorRate(last1h).toFixed(2) + '%'
            },
            tokens: {
                prompt: this.metrics.tokens.prompt.toLocaleString(),
                completion: this.metrics.tokens.completion.toLocaleString(),
                total: (this.metrics.tokens.prompt + this.metrics.tokens.completion).toLocaleString()
            },
            cost: {
                total: '$' + this.metrics.cost.total.toFixed(2),
                byModel: this.metrics.cost.byModel
            }
        };
    }

    // Alert khi error rate vượt ngưỡng
    checkAlerts() {
        const stats = this.getStats();
        const alerts = [];

        if (parseFloat(stats.last1h.errorRate) > 5) {
            alerts.push({ severity: 'HIGH', message: Error rate cao: ${stats.last1h.errorRate} });
        }

        if (stats.last1h.avgLatency > 5000) {
            alerts.push({ severity: 'MEDIUM', message: Latency cao: ${stats.last1h.avgLatency}ms });
        }

        if (this.metrics.cost.total > 100) {
            alerts.push({ severity: 'INFO', message: Cost usage: ${stats.cost.total} });
        }

        return alerts;
    }
}

// Integration với production system
const metrics = new APIMetrics();

// Wrapper để tự động collect metrics
async function trackedLLMCall(messages, model) {
    const start = Date.now();
    let success = false;
    let tokens = null;
    let error = null;

    try {
        const response = await fetch('https://api.holysheep.ai/v1/chat/completions', {
            method: 'POST',
            headers: {
                'Authorization': 'Bearer YOUR_HOLYSHEEP_API_KEY',
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({ model, messages })
        });

        if (!response.ok) throw new Error(HTTP ${response.status});
        
        const data = await response.json();
        tokens = {
            prompt: data.usage?.prompt_tokens || 0,
            completion: data.usage?.completion_tokens || 0
        };
        success = true;
        return data;
    } catch (e) {
        error = e.message;
        throw e;
    } finally {
        metrics.recordRequest({
            model,
            latency: Date.now() - start,
            success,
            tokens,
            error
        });
    }
}

Giá và ROI

Tài nguyên liên quan

• 📚 Hướng dẫn AI API
• 💰 Xem giá
• 📖 Tài liệu nhà phát triển
• 🚀 Đăng ký miễn phí

Bài viết liên quan

• Phân tích quy luật phân bố thời gian của các sự kiện thanh l
• Llama 3.1 Local Deployment Toàn Tập: 8B/70B/405B — Khi Nào N
• Binance 新上币种历史数据获取：Tardis 数据覆盖延迟与首日数据完整性