如何接入大模型API

# OpenAI
pnpm add openai
 
# Anthropic
pnpm add @anthropic-ai/sdk
 
# Google Gemini
pnpm add @google/genai

# OpenAI
pip install openai
 
# Anthropic
pip install anthropic
 
# Google Gemini
pip install google-genai

import OpenAI from 'openai'
 
const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
})
 
const response = await client.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'user', content: '用一句话解释什么是大模型' },
  ],
})
 
console.log(response.choices[0].message.content)

import Anthropic from '@anthropic-ai/sdk'
 
const client = Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
})
 
const response = await client.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: '用一句话解释什么是大模型' },
  ],
})
 
console.log(response.content[0].text)

import { GoogleGenAI } from '@google/genai'
 
const ai = new GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY })
 
const response = await ai.models.generateContent({
  model: 'gemini-2.5-flash',
  contents: '用一句话解释什么是大模型',
})
 
console.log(response.text)

# .env 文件（加入 .gitignore）
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxx
ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxxxxxx
GOOGLE_API_KEY=AIzaSyxxxxxxxxxxxxxxxx

// 通过环境变量读取
const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
})

const response = await client.messages.create({
  model: 'claude-sonnet-4-20250514',  // 模型标识
  max_tokens: 1024,                     // 最大输出 token 数（必填）
  system: '你是一个专业的翻译助手',       // 系统提示词（顶层字段）
  messages: [                           // 对话消息列表
    { role: 'user', content: '你好' },
    { role: 'assistant', content: '你好！有什么可以帮你的？' },
    { role: 'user', content: '把"Hello World"翻译成中文' },
  ],
  temperature: 0.7,                     // 随机性（0-1）
  top_p: 0.9,                           // 核采样
  top_k: 40,                            // top-k 采样
  stop_sequences: ['\n\n'],             // 停止序列
  stream: false,                        // 是否流式
  metadata: {                           // 自定义元数据
    user_id: 'user_123',
  },
})

// Anthropic 多模态请求
const response = await client.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  messages: [
    {
      role: 'user',
      content: [
        {
          type: 'image',
          source: {
            type: 'base64',
            media_type: 'image/png',
            data: base64String,
          },
        },
        {
          type: 'text',
          text: '描述这张图片的内容',
        },
      ],
    },
  ],
})

const stream = await client.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: '写一首关于春天的诗' }],
  stream: true,
})
 
for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content ?? ''
  process.stdout.write(delta)  // 逐块输出到终端
}

const stream = await client.messages.stream({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  messages: [{ role: 'user', content: '写一首关于春天的诗' }],
})
 
for await (const event of stream) {
  if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
    process.stdout.write(event.delta.text)
  }
}

const response = await ai.models.generateContentStream({
  model: 'gemini-2.5-flash',
  contents: '写一首关于春天的诗',
})
 
for await (const chunk of response) {
  process.stdout.write(chunk.text ?? '')
}

// app/api/chat/route.ts
import Anthropic from '@anthropic-ai/sdk'
 
const client = Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
 
export async function POST(req: Request) {
  const { messages } = await req.json()
 
  const stream = await client.messages.stream({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 2048,
    messages,
  })
 
  return new Response(
    new ReadableStream({
      async start(controller) {
        for await (const event of stream) {
          if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
            const text = event.delta.text
            controller.enqueue(
              new TextEncoder().encode(`data: ${JSON.stringify({ text })}\n\n`)
            )
          }
        }
        controller.enqueue(new TextEncoder().encode('data: [DONE]\n\n'))
        controller.close()
      },
    }),
    {
      headers: {
        'Content-Type': 'text/event-stream',
        'Cache-Control': 'no-cache',
        Connection: 'keep-alive',
      },
    }
  )
}

async function sendMessage(userMessage: string) {
  const response = await fetch('/api/chat', {
    method: 'POST',
    body: JSON.stringify({
      messages: [{ role: 'user', content: userMessage }],
    }),
  })
 
  const reader = response.body?.getReader()
  const decoder = new TextDecoder()
 
  while (reader) {
    const { done, value } = await reader.read()
    if (done) break
 
    const text = decoder.decode(value)
    const lines = text.split('\n').filter(line => line.startsWith('data: '))
 
    for (const line of lines) {
      const data = line.slice(6)
      if (data === '[DONE]') return
 
      const { text: chunk } = JSON.parse(data)
      // 将 chunk 追加到界面显示
      appendToUI(chunk)
    }
  }
}

async function withRetry<T>(
  fn: () => Promise<T>,
  options: { maxRetries?: number; baseDelay?: number } = {}
): Promise<T> {
  const { maxRetries = 3, baseDelay = 1000 } = options
 
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn()
    } catch (error) {
      if (attempt === maxRetries) throw error
 
      // 只对可重试的错误进行重试
      if (isRetryable(error)) {
        const delay = baseDelay * Math.pow(2, attempt)
        // 添加随机抖动，避免多个请求同时重试
        const jitter = Math.random() * 1000
        await new Promise(resolve => setTimeout(resolve, delay + jitter))
      } else {
        throw error
      }
    }
  }
 
  throw new Error('Unreachable')
}
 
function isRetryable(error: unknown): boolean {
  if (error instanceof Error) {
    const status = (error as any).status
    return status === 429 || status === 500 || status === 529
  }
  return false
}
 
// 使用
const response = await withRetry(() =>
  client.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    messages: [{ role: 'user', content: '你好' }],
  })
)

const controller = new AbortController()
const timeoutId = setTimeout(() => controller.abort(), 60_000) // 60 秒超时
 
try {
  const response = await client.messages.create(
    {
      model: 'claude-sonnet-4-20250514',
      max_tokens: 1024,
      messages: [{ role: 'user', content: '你好' }],
    },
    { signal: controller.signal }
  )
} catch (error) {
  if (error instanceof DOMException && error.name === 'AbortError') {
    console.error('请求超时，请稍后重试')
  }
} finally {
  clearTimeout(timeoutId)
}

// 粗略估算 token 数
function estimateTokens(text: string): number {
  const chineseChars = (text.match(/[一-鿿]/g) || []).length
  const otherChars = text.length - chineseChars
  return Math.ceil(chineseChars / 1.5 + otherChars / 4)
}

// 模型提供商抽象
interface LLMProvider {
  name: string
  chat(messages: Message[], options?: ChatOptions): Promise<string>
  chatStream(messages: Message[], options?: ChatOptions): AsyncIterable<string>
}
 
// 降级链实现
class LLMRouter {
  private providers: LLMProvider[]
 
  constructor(providers: LLMProvider[]) {
    this.providers = providers
  }
 
  async chat(messages: Message[], options?: ChatOptions): Promise<string> {
    for (const provider of this.providers) {
      try {
        return await provider.chat(messages, options)
      } catch (error) {
        console.warn(`${provider.name} 调用失败，尝试下一个:`, error)
        continue
      }
    }
    throw new Error('所有模型提供商均不可用')
  }
}
 
// 使用
const router = new LLMRouter([
  new AnthropicProvider(),  // 首选
  new OpenAIProvider(),     // 降级 1
  new GeminiProvider(),     // 降级 2
])
 
const reply = await router.chat(messages)

async function* translateStream(text: string, targetLang: string) {
  const systemPrompt = `你是一个专业翻译。将用户输入翻译为${targetLang}。
要求：
- 保持原文的段落结构
- 专有名词保留原文并附翻译
- 只输出翻译结果，不要解释`
 
  const stream = await client.messages.stream({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 4096,
    system: systemPrompt,
    messages: [{ role: 'user', content: text }],
  })
 
  // 逐块 yield，上层可实时推送到前端
  for await (const event of stream) {
    if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
      yield event.delta.text
    }
  }
}
 
// 在 Route Handler 中使用
export async function POST(req: Request) {
  const { text, targetLang } = await req.json()
 
  return new Response(
    new ReadableStream({
      async start(controller) {
        const encoder = new TextEncoder()
        for await (const chunk of translateStream(text, targetLang)) {
          controller.enqueue(
            encoder.encode(`data: ${JSON.stringify({ text: chunk })}\n\n`)
          )
        }
        controller.enqueue(encoder.encode('data: [DONE]\n\n'))
        controller.close()
      },
    }),
    {
      headers: { 'Content-Type': 'text/event-stream' },
    }
  )
}