Tích hợp OpenAI, Claude, Gemini API vào web app: so sánh chi phí, tốc độ và chất lượng

import OpenAI from 'openai';

// Khởi tạo client - key lấy từ biến môi trường
const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

async function chatWithOpenAI(userMessage) {
  const response = await openai.chat.completions.create({
    model: 'gpt-4o-mini', // Dùng mini cho use case phổ thông, rẻ hơn nhiều
    messages: [
      { role: 'system', content: 'Bạn là trợ lý hữu ích.' },
      { role: 'user', content: userMessage },
    ],
    max_tokens: 1000,
  });

  return response.choices[0].message.content;
}

import Anthropic from '@anthropic-ai/sdk';

// Khởi tạo Anthropic client
const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

async function chatWithClaude(userMessage) {
  const response = await anthropic.messages.create({
    model: 'claude-haiku-4-5', // Haiku: nhanh và rẻ nhất trong dòng Claude
    max_tokens: 1000,
    system: 'Bạn là trợ lý hữu ích.',
    messages: [
      { role: 'user', content: userMessage },
    ],
  });

  return response.content[0].text;
}

import { GoogleGenerativeAI } from '@google/generative-ai';

// Khởi tạo Gemini client
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

async function chatWithGemini(userMessage) {
  // Chọn model: flash cho tốc độ, pro cho chất lượng
  const model = genAI.getGenerativeModel({ model: 'gemini-2.5-flash' });

  const result = await model.generateContent(userMessage);
  return result.response.text();
}

// Express route xử lý streaming
app.post('/api/chat/stream', async (req, res) => {
  const { message, provider } = req.body;

  // Thiết lập header cho SSE
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');

  try {
    if (provider === 'openai') {
      const stream = await openai.chat.completions.create({
        model: 'gpt-4o-mini',
        messages: [{ role: 'user', content: message }],
        stream: true, // Bật streaming
      });

      for await (const chunk of stream) {
        const text = chunk.choices[0]?.delta?.content || '';
        if (text) {
          // Gửi từng chunk về client theo format SSE
          res.write(`data: ${JSON.stringify({ text })}\n\n`);
        }
      }
    } else if (provider === 'claude') {
      const stream = anthropic.messages.stream({
        model: 'claude-haiku-4-5',
        max_tokens: 1000,
        messages: [{ role: 'user', content: message }],
      });

      for await (const event of stream) {
        if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
          res.write(`data: ${JSON.stringify({ text: event.delta.text })}\n\n`);
        }
      }
    } else if (provider === 'gemini') {
      const model = genAI.getGenerativeModel({ model: 'gemini-2.5-flash' });
      const result = await model.generateContentStream(message);

      for await (const chunk of result.stream) {
        const text = chunk.text();
        if (text) {
          res.write(`data: ${JSON.stringify({ text })}\n\n`);
        }
      }
    }

    // Báo client biết stream đã xong
    res.write('data: [DONE]\n\n');
    res.end();
  } catch (error) {
    res.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
    res.end();
  }
});

// Utility: retry với exponential backoff
async function callWithRetry(fn, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      const isRetryable = error.status === 429 || error.status >= 500;

      // Lỗi không retry được (sai key, hết tiền...)
      if (!isRetryable || attempt === maxRetries - 1) {
        throw error;
      }

      // Exponential backoff + jitter để tránh thundering herd
      const delay = Math.pow(2, attempt) * 1000 + Math.random() * 500;
      console.log(`Thử lại lần ${attempt + 1} sau ${delay}ms...`);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

// Wrapper cho rate limiting per user (dùng in-memory đơn giản)
const userRequestCounts = new Map();

function checkRateLimit(userId, limitPerMinute = 20) {
  const now = Date.now();
  const userRequests = userRequestCounts.get(userId) || [];

  // Lọc request trong 1 phút gần nhất
  const recentRequests = userRequests.filter(t => now - t < 60000);

  if (recentRequests.length >= limitPerMinute) {
    throw new Error('Bạn đang gửi quá nhiều yêu cầu. Vui lòng thử lại sau.');
  }

  recentRequests.push(now);
  userRequestCounts.set(userId, recentRequests);
}

// Dùng trong route handler
app.post('/api/chat', async (req, res) => {
  const { userId, message } = req.body;

  try {
    checkRateLimit(userId);

    const result = await callWithRetry(() =>
      chatWithOpenAI(message)
    );

    res.json({ reply: result });
  } catch (error) {
    const statusCode = error.status || 500;
    res.status(statusCode).json({ error: error.message });
  }
});