Создание устойчивого уровня маршрутизации ИИ между несколькими провайдерами с помощью Vercel AI SDK

При развертывании больших языковых моделей (LLM) в продакшене надежность часто становится главным узким местом. Опора на одного провайдера моделей создает риски появления единой точки отказа: ограничения на количество запросов к API (HTTP 429), временные сбои в работе сервиса (HTTP 500/503) или внезапные скачки задержки.

Чтобы гарантировать бесперебойную работу и экономическую эффективность, командам необходим уровень динамической маршрутизации, который может автоматически переключаться на резервные модели или менять провайдеров в зависимости от входных параметров.

В этом руководстве мы реализуем отказоустойчивый и типизированный уровень маршрутизации между несколькими провайдерами с помощью Vercel AI SDK и Zod.

Архитектура отказоустойчивости LLM

Отказоустойчивый уровень маршрутизации работает на основе трех ключевых принципов:

Последовательное переключение при отказе (Failover): если основной провайдер недоступен, система автоматически повторяет запрос, используя резервного провайдера.
Динамический выбор: короткие промпты направляются в быстрые и недорогие модели, в то время как объемные входные данные отправляются в модели с большим контекстным окном.
Безопасная валидация типов: независимо от того, какая модель обрабатывает запрос, схема вывода остается идентичной и проверенной.

               +-------------------+
               |  Incoming Request |
               +-------------------+
                         |
                         v
             +-----------------------+
             | Dynamic Route Selector|
             +-----------------------+
               /                   \
        (Short Input)          (Long Input)
             /                       \
            v                         v
   +-----------------+       +-----------------+
   |  Primary Model  |       |  Primary Model  |
   | (OpenAI Luna)   |       | (Gemini-3.1-Pro)|
   +-----------------+       +-----------------+
            |                         |
       (On Failure)              (On Failure)
            v                         v
   +-----------------+       +-----------------+
   | Fallback Model  |       | Fallback Model  |
   | (Gemini-3.5-Fl) |       | (Claude-Sonnet5)|
   +-----------------+       +-----------------+
            \                         /
             \                       /
              v                     v
            +-------------------------+
            |  Zod Schema Validation  |
            +-------------------------+
                        |
                        v
               +-------------------+
               | Validated Output  |
               +-------------------+

Реализация резервных моделей с помощью Vercel AI SDK

Vercel AI SDK предоставляет встроенную обертку fallback, которая позволяет указать приоритетный список моделей. Если вызов первой модели завершается ошибкой, SDK автоматически повторяет попытку, используя последующие модели из массива.

Вот как можно инициализировать отказоустойчивую модель с резервными провайдерами:

import { fallback } from 'ai';
import { openai } from '@ai-sdk/openai';
import { google } from '@ai-sdk/google';
import { anthropic } from '@ai-sdk/anthropic';

// Initialize a resilient model that crosses three distinct providers
export const resilientModel = fallback([
  openai('terra'),
  anthropic('claude-sonnet-5'),
  google('gemini-3.1-pro')
]);

При вызове функций generateText или generateObject с использованием resilientModel SDK автоматически обрабатывает ошибки, таймауты и повторные попытки.

Локальное резервирование с помощью Ollama

Для автономной работы, гибридных сред или бесплатного выполнения запросов во время локального тестирования вы можете интегрировать локально развернутые модели через Ollama. Vercel AI SDK работает с моделями Ollama как с первоклассными провайдерами, позволяя напрямую переключаться с облачных API на локальное оборудование (локальный кремний).

Вот как настраивается гибридное облачно-локальное резервирование:

import { fallback } from 'ai';
import { openai } from '@ai-sdk/openai';
import { ollama } from '@ai-sdk/ollama';

// Fallback to a locally hosted Llama 4 Scout model if the OpenAI API is unreachable
export const hybridModel = fallback([
  openai('luna'),
  ollama('llama4-scout')
]);

Безопасное извлечение структурированных данных с контролем типов

Одной из проблем маршрутизации между несколькими провайдерами является обеспечение того, чтобы разные модели строго следовали одной и той же структуре вывода. Использование библиотеки Zod совместно с API generateObject решает эту задачу.

Определим схему для извлечения структурированных метаданных из необработанных профилей разработчиков:

import { generateObject } from 'ai';
import { z } from 'zod';
import { resilientModel } from './models';

const ProfileSchema = z.object({
  fullName: z.string(),
  skills: z.array(z.string()),
  yearsOfExperience: z.number(),
  certifications: z.array(
    z.object({
      name: z.string(),
      issuer: z.string()
    })
  )
});

export async function extractProfile(text: string) {
  try {
    const { object } = await generateObject({
      model: resilientModel,
      schema: ProfileSchema,
      prompt: `Extract structured profile details from the following resume text:\n\n${text}`
    });

    return object;
  } catch (error) {
    console.error('Failed to extract profile after exhausting all fallbacks:', error);
    throw new Error('Profile extraction failed');
  }
}

Поскольку выходные данные анализируются и валидируются с помощью Zod во время выполнения приложения, ваш код может быть полностью уверен в полученной структуре, независимо от того, какая модель из цепочки резервирования выполнила запрос успешно.

Динамическая маршрутизация на основе размера контекста

Хотя последовательные резервные вызовы защищают от полного простоя, они не оптимизируют затраты или лимиты токенов. Например, отправка документа объемом 100 000 токенов в модель с лимитом 128 000 токенов допустима, но отправка его в модель с лимитом 16 000 токенов приведет к мгновенной ошибке.

Мы можем построить динамический маршрутизатор, который проверяет размер входных данных перед выбором цепочки моделей:

import { LanguageModel, generateText } from 'ai';
import { openai } from '@ai-sdk/openai';
import { google } from '@ai-sdk/google';
import { anthropic } from '@ai-sdk/anthropic';

// Define specialized model chains
const standardChain = fallback([
  openai('luna'),
  google('gemini-3.5-flash')
]);

const highContextChain = fallback([
  google('gemini-3.1-pro'),
  anthropic('claude-sonnet-5')
]);

// Estimate token count (simple word-count approximation for demo)
function estimateTokens(text: string): number {
  return text.trim().split(/\s+/).length * 1.3;
}

export async function smartRouteRequest(promptText: string) {
  const tokenEstimate = estimateTokens(promptText);
  
  // Route to the appropriate chain based on input size
  const model = tokenEstimate > 50000 ? highContextChain : standardChain;

  return generateText({
    model,
    prompt: promptText
  });
}

Такой паттерн позволяет минимизировать затраты, направляя стандартные задачи на недорогие и быстрые модели, сохраняя премиум-модели с большими контекстными окнами для тяжелых нагрузок.

Телеметрия и наблюдаемость (Observability)

Чтобы отслеживать, насколько часто ваш уровень маршрутизации обращается к резервным моделям, вы можете подключить экспериментальные функции телеметрии Vercel AI SDK. Это позволит собирать метрики использования токенов, задержки и показатели успешности провайдеров:

import { generateText } from 'ai';
import { resilientModel } from './models';

const response = await generateText({
  model: resilientModel,
  prompt: 'Analyze this log output...',
  experimental_telemetry: {
    isEnabled: true,
    functionId: 'analyze-logs',
    metadata: {
      environment: 'production'
    }
  }
});

Эти трассировки передаются в стандартные коллекторы OpenTelemetry, предоставляя вашей команде полную видимость процессов переключения и состояния провайдеров.

Заключение и компромиссы

Маршрутизация между несколькими провайдерами значительно повышает надежность. Тем не менее, важно учитывать следующие компромиссы:

Различия в стиле вывода: резервные модели могут отличаться по стилю изложения, нюансам форматирования или уровню соответствия правилам.
Холодный старт: повторная попытка невыполненного запроса на резервной модели увеличивает время ожидания для пользователя.
Ключи API провайдеров: вашей инфраструктуре потребуется настраивать и поддерживать ключи API, уровни лимитов запросов и биллинговые аккаунты для нескольких вендоров.

Используя унифицированные интерфейсы API Vercel AI SDK, вы можете построить высоконадежную архитектуру маршрутизации, которая защитит ваши промышленные приложения от сбоев отдельных провайдеров.