Vercel AI Gateway API - 统一 AI 模型访问接口

npm install ai @ai-sdk/openai @vercel/ai-gateway

from openai import OpenAI

# 初始化客户端
# 注意：实际的 base_url 请以 Vercel Dashboard 中 AI Gateway 显示的端点为准
client = OpenAI(
    base_url="https://gateway.vercel.ai/v1",  # 示例端点，请替换为实际端点
    api_key="YOUR_VERCEL_API_KEY"  # ⬅️ 替换为您的 Vercel API 密钥
)

# 发送请求
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "介绍一下 Vercel AI Gateway 的优势"}
    ],
    max_tokens=1000
)

# 打印响应
print(response.choices[0].message.content)

# 查看 Token 使用情况
print(f"\n使用 Tokens: {response.usage.total_tokens}")

# 流式输出
stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "写一首关于云计算的诗"}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

import { createAI } from '@ai-sdk/openai';
import { generateText } from 'ai';

// 配置 AI Gateway
const ai = createAI({
  apiKey: process.env.VERCEL_API_KEY,
  // 启用 Gateway
  gateway: {
    enabled: true
  }
});

async function main() {
  // 使用 OpenAI 模型
  const { text } = await generateText({
    model: ai('gpt-4o'),
    prompt: '介绍一下 Vercel AI Gateway 的优势',
  });

  console.log(text);
}

main();

import { createAI } from '@ai-sdk/openai';
import { createAnthropic } from '@ai-sdk/anthropic';
import { generateText } from 'ai';

// 配置主提供商
const openai = createAI({
  apiKey: process.env.OPENAI_API_KEY,
  gateway: { enabled: true }
});

// 配置备用提供商
const anthropic = createAnthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  gateway: { enabled: true }
});

async function generateWithFallback() {
  try {
    // 首先尝试 OpenAI
    const { text } = await generateText({
      model: openai('gpt-4o'),
      prompt: 'Hello, world!',
    });
    return text;
  } catch (error) {
    console.log('OpenAI 失败，切换到 Anthropic');
    // 失败时自动切换到 Anthropic
    const { text } = await generateText({
      model: anthropic('claude-3-5-sonnet-20241022'),
      prompt: 'Hello, world!',
    });
    return text;
  }
}

generateWithFallback();

import { createAI } from '@ai-sdk/openai';
import { generateText } from 'ai';

// 使用自己的 OpenAI API 密钥
const openai = createAI({
  apiKey: process.env.OPENAI_API_KEY,  // 您自己的密钥
  gateway: {
    enabled: true,
    byok: true  // 启用 BYOK 模式
  }
});

async function main() {
  const { text } = await generateText({
    model: openai('gpt-4o'),
    prompt: '使用 BYOK 模式调用',
  });

  console.log(text);
}

main();

curl https://api.vercel.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_VERCEL_API_KEY" \
  -d '{
    "model": "openai:gpt-4o",
    "messages": [
      {
        "role": "user",
        "content": "Hello, Vercel AI Gateway!"
      }
    ]
  }'

import { generateText } from 'ai';

async function robustGenerate(model, prompt, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const { text } = await generateText({
        model,
        prompt,
      });
      return text;
    } catch (error) {
      console.error(`尝试 ${i + 1} 失败:`, error.message);
      
      if (i === maxRetries - 1) {
        throw new Error('所有重试均失败');
      }
      
      // 指数退避
      await new Promise(resolve => 
        setTimeout(resolve, Math.pow(2, i) * 1000)
      );
    }
  }
}

import { createAI } from '@ai-sdk/openai';
import { createAnthropic } from '@ai-sdk/anthropic';
import { generateText } from 'ai';

const openai = createAI({
  apiKey: process.env.OPENAI_API_KEY,
  gateway: { enabled: true }
});

const anthropic = createAnthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  gateway: { enabled: true }
});

async function compareModels(prompt) {
  const models = [
    { name: 'GPT-4o', provider: openai('gpt-4o') },
    { name: 'Claude 3.5 Sonnet', provider: anthropic('claude-3-5-sonnet-20241022') }
  ];

  const results = await Promise.all(
    models.map(async ({ name, provider }) => {
      const startTime = Date.now();
      const { text } = await generateText({
        model: provider,
        prompt,
      });
      const duration = Date.now() - startTime;

      return { name, text, duration };
    })
  );

  return results;
}

// 使用示例
const results = await compareModels('解释量子计算的基本原理');
results.forEach(({ name, text, duration }) => {
  console.log(`\n=== ${name} (${duration}ms) ===`);
  console.log(text);
});

import { generateText } from 'ai';

const providers = [
  { name: 'OpenAI', model: openai('gpt-4o'), priority: 1 },
  { name: 'Anthropic', model: anthropic('claude-3-5-sonnet-20241022'), priority: 2 },
  { name: 'Google', model: google('gemini-pro'), priority: 3 }
];

async function chatWithFallback(message) {
  // 按优先级排序
  const sortedProviders = providers.sort((a, b) => a.priority - b.priority);

  for (const provider of sortedProviders) {
    try {
      console.log(`尝试使用 ${provider.name}...`);
      
      const { text } = await generateText({
        model: provider.model,
        prompt: message,
      });

      console.log(`✅ ${provider.name} 成功`);
      return {
        text,
        provider: provider.name
      };
    } catch (error) {
      console.error(`❌ ${provider.name} 失败: ${error.message}`);
      continue;
    }
  }

  throw new Error('所有提供商均不可用');
}

// 使用示例
const response = await chatWithFallback('你好，介绍一下自己');
console.log(`回复来自 ${response.provider}:`, response.text);