Vercel AI SDK के साथ एक लचीली मल्टी-प्रोवाइडर AI राउटिंग लेयर बनाना

प्रोडक्शन में लार्ज लैंग्वेज मॉडल (LLM) को तैनात करते समय, विश्वसनीयता (reliability) अक्सर सबसे बड़ी बाधा होती है। किसी एक मॉडल प्रदाता पर निर्भर रहने से सिंगल-पॉइंट-ऑफ-फेलियर का जोखिम बढ़ जाता है: जैसे API रेट लिमिट्स (HTTP 429), अस्थाई सर्विस डाउनटाइम (HTTP 500/503), या अचानक लेटेंसी का बढ़ जाना।

अपटाइम और लागत दक्षता सुनिश्चित करने के लिए, टीमों को एक डायनेमिक राउटिंग लेयर की आवश्यकता होती है जो इनपुट मापदंडों के आधार पर बैकअप मॉडल पर स्विच कर सके या प्रदाता बदल सके।

इस गाइड में, हम Vercel AI SDK और Zod का उपयोग करके एक लचीली, टाइप-सेफ मल्टी-प्रदाता राउटिंग लेयर का निर्माण करेंगे।

---

LLM लचीलेपन का आर्किटेक्चर

एक लचीली राउटिंग लेयर तीन मुख्य सिद्धांतों पर काम करती है:

1. क्रमिक विफलता संरक्षण (Sequential Failovers): यदि प्राथमिक प्रदाता विफल हो जाता है, तो सिस्टम स्वचालित रूप से द्वितीयक प्रदाता का उपयोग करके अनुरोध का पुन: प्रयास करता है।
2. डायनेमिक चयन: छोटे संकेतों (prompts) को तेज़ और कम लागत वाले मॉडल पर भेजा जाता है, जबकि बड़े इनपुट को अधिक संदर्भ वाले मॉडलों पर निर्देशित किया जाता है।
3. टाइप-सेफ सत्यापन: अनुरोध को संभालने वाले मॉडल के बावजूद, आउटपुट स्कीमा हमेशा समान और सत्यापित रहता है।

               +-------------------+
               |  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 स्वचालित रूप से सरणी (array) में अगले मॉडलों का उपयोग करके पुन: प्रयास करता है।

फॉलबैक प्रदाताओं के साथ एक लचीला मॉडल कैसे प्रारंभ करें:

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')
]);

जब आप resilientModel के साथ generateText या generateObject कॉल करते हैं, तो 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')
]);

---

टाइप-सेफ संरचित डेटा निष्कर्षण

मल्टी-प्रदाता राउटिंग की चुनौतियों में से एक यह सुनिश्चित करना है कि विभिन्न मॉडल बिल्कुल समान आउटपुट संरचना का पालन करें। generateObject API के साथ Zod का उपयोग इसे हल करता है।

आइए डेवलपर्स के प्रोफाइल से संरचित मेटाडेटा निकालने के लिए एक स्कीमा को परिभाषित करें:

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 द्वारा पार्स और सत्यापित किया जाता है, आपका एप्लिकेशन कोड बिना किसी झिझक के प्राप्त संरचना पर भरोसा कर सकता है, चाहे फॉलबैक श्रृंखला का कोई भी मॉडल सफल रहा हो।

---

संदर्भ आकार के आधार पर डायनेमिक राउटिंग

यद्यपि क्रमिक फ़ॉलबैक डाउनटाइम से सुरक्षा प्रदान करते हैं, लेकिन वे लागत या टोकन सीमाओं को अनुकूलित नहीं करते हैं। उदाहरण के लिए, 128,000-टोकन सीमा वाले मॉडल पर 100,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
  });
}

यह पैटर्न सामान्य कार्यों को सस्ते और तेज़ मॉडलों पर भेजकर लागत को कम रखता है, जबकि भारी इनपुट के लिए बड़े संदर्भ वाले प्रीमियम मॉडलों को सुरक्षित रखता है।

---

टेलीमेट्री और ऑब्जर्वेबिलिटी

आपकी राउटिंग लेयर फॉलबैक मॉडल को कितनी बार ट्रिगर करती है, इसकी निगरानी के लिए आप 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 कुंजियों, दर सीमा स्तरों और बिलिंग खातों को प्रबंधित करना होगा।

Vercel AI SDK के एकीकृत API का उपयोग करके, आप एक अत्यधिक लचीला राउटिंग आर्किटेक्चर बना सकते हैं जो आपके प्रोडक्शन ऐप्स को प्रदाता के डाउनटाइम से बचाता है।