अपने मॉडल से शादी न करो

LLM राउटिंग, अभी बहुत हॉट

ज़्यादातर इंजीनियरिंग टीमें एक लैंग्वेज मॉडल चुनती हैं और उसी से चिपकी रहती हैं। एक प्रोवाइडर, एक मॉडल, सब काम। ऐसा करना बिल्कुल वैसा है जैसे किसी एक इंसान को अपना कोडिंग, कॉपीराइटिंग और टैक्स फ़ाइलिंग सब दे दो, सिर्फ़ क्योंकि वो पहले इंटरव्यू में अच्छा लगा।

किसी भी समय, एक मॉडल कोड में बेहतर होता है, दूसरा लंबे उलझे कॉन्टेक्स्ट में मज़बूत होता है, और तीसरा क्लासिफ़िकेशन के लिए सबसे सस्ता भरोसेमंद कामचलाऊ होता है। नाम बदलते रहते हैं। समस्या का स्वरूप नहीं। एक मॉडल को सब कुछ में बेहतरीन मानना मतलब है कि आप आसान कामों पर ज़्यादा पैसे दे रहे हैं या विशेष कामों पर मामूली नतीजे पा रहे हैं।

मैंने एक टीम को हज़ारों डॉलर ज़लाते देखा — सेंटिमेंट एनालिसिस चला रही थी $30-per-million-token मॉडल से, जबकि $0.50 वाला मॉडल वैसा ही काम बिल्कुल सही करता। सिर्फ़ JSON फ़ॉर्मेटिंग, बेसिक क्लासिफ़िकेशन — सब उनके प्रीमियम प्रोवाइडर से गुज़रता। गरम हो रहा था सिर्फ़ उनका AWS बिल।

एक बेहतर तरीका है, और वो ज़्यादा मुश्किल नहीं है।

भक्ति से बेहतर है प्रतिनिधित्व

क्या होगा अगर आप रिक्वेस्ट्स को उस मॉडल के पास भेज सकें जो उस खास काम के लिए सबसे उपयुक्त हो? मुश्किल कामों के लिए अपने महंगे पावरहाउस को इस्तेमाल करो, लेकिन आसान पार्सिंग और फ़ॉर्मेटिंग को सस्ते वाले के पास भेजो। कई प्रोवाइडर्स के फ़ायदे पाओ बिना अपने कोडबेस में उन्हें मैन्युअली जगह-जगह जुगाड़ करने के।

Mastra ऐसी सिस्टम बनने देता है। आप अलग-अलग काम के लिए स्पेशलिस्ट एजेंट्स सेट करो, फिर एक राउटर एजेंट बनाओ जो तय करे कि हर रिक्वेस्ट कौन सा स्पेशलिस्ट हैंडल करेगा। नीचे दिए मॉडल ID उदाहरण हैं, लीडरबोर्ड नहीं। उन्हें अपने वर्तमान मॉडल्स से बदलो जो आपके evals जीतते हैं और आपके बजट में बैठते हैं।

ऐसा सोचो: आपकी टीम में तीन स्पेशलिस्ट्स हैं।

import { Mastra } from '@mastra/core';
import { Agent } from '@mastra/core/agent';
import { openai } from '@ai-sdk/openai';
import { anthropic } from '@ai-sdk/anthropic';
import { google } from '@ai-sdk/google';

export const claudeAgent = new Agent({
  id: 'claude-agent',
  instructions: 'You are an expert engineer. Write bugs? You are fired.',
  model: anthropic(process.env.CODE_MODEL ?? 'claude-sonnet-4-5'),
});

export const geminiAgent = new Agent({
  id: 'gemini-agent',
  instructions: 'You are a creative writer. Be weird.',
  model: google(process.env.LONG_CONTEXT_MODEL ?? 'gemini-3-pro-preview'),
});

export const gptAgent = new Agent({
  id: 'gpt-agent',
  instructions: 'You are a helpful assistant. Be boring.',
  model: openai(process.env.GENERAL_MODEL ?? 'gpt-5.2'),
});

हर एक का अपना काम है। आपका कोड एजेंट वो मॉडल होना चाहिए जो आपके repo-specific कोडिंग evals पास करे। आपका लंबे-कॉन्टेक्स्ट एजेंट वो हो जो आपके असली डॉक्यूमेंट्स को बिना गड़बड़ी के संभाल सके। आपका जनरल एजेंट सस्ता, भरोसेमंद, और सबसे अच्छे अंदाज़ में बोरिंग हो।

अब यहाँ काम दिलचस्प हो जाता है। आप एक राउटर जोड़ो जो एक intelligent proxy की तरह काम करे:

export const routerAgent = new Agent({
  id: 'router-agent',
  name: 'The Boss',
  instructions: `You are an intelligent router.
  - Coding -> Claude
  - Poetry -> Gemini
  - Facts -> GPT

  Do not do the work yourself. Delegate.`,
  model: openai(process.env.ROUTER_MODEL ?? 'gpt-5-mini'), // Use a cheap model for routing!
  agents: {
    claudeAgent,
    geminiAgent,
    gptAgent,
  },
});

export const mastra = new Mastra({
  agents: { routerAgent, claudeAgent, geminiAgent, gptAgent },
});

राउटर खुद एक लाइटवेट मॉडल पर चलता है क्योंकि वो सिर्फ़ तय करता है कि ट्रैफ़िक कहाँ भेजना है। आप प्रीमियम रेट्स पर पैसे खर्च नहीं कर रहे कि ये तय हो कि कौन सा दूसरा प्रीमियम मॉडल इस्तेमाल करना है। इसको भी मेज़र करो; एक बुरा राउटर बचत को चुपचाप मिसरूट्स में बदल देता है।

जब कोई bubble sort implementation मांगता है, राउटर पहचानता है कि ये कोड का काम है और उसे आपके कोड स्पेशलिस्ट के पास भेजता है। क्रिएटिव राइटिंग प्रॉम्प्ट? वो उस मॉडल के पास जाता है जो आपने वॉइस और रेंज के लिए चुना। ऐतिहासिक इवेंट्स का कोई तथ्य-आधारित सवाल? जनरल एजेंट के पास रूट करो, ideally retrieval के साथ जब फ़्रेशनेस या citation महत्वपूर्ण हो।

व्यावहारिक फ़ायदे

कॉस्ट एफ़िशिएंसी आपकी सोच से ज़्यादा महत्वपूर्ण है। एक छोटा रूटिंग मॉडल delegation के फ़ैसले करता है, जो हर रिक्वेस्ट को सबसे महंगे प्रोवाइडर से चलाने के मुकाबले एक छोटा सा हिस्सा खर्च करता है। समय के साथ, खासकर बड़े पैमाने पर, ये सच्चे पैसे जमा करता है। आप सिर्फ़ हैवी-डूटी इंटेलिजेंस के लिए पैसे देते हैं जब आप सच में उसकी ज़रूरत हो।

क्वालिटी सुधरती है जब आप मॉडल्स को कामों से मैच करो। कौन जीतता है — ये महीने, काम, और प्रॉम्प्ट स्वरूप से बदलता है। इसीलिए रूटिंग लेयर आपके evals पर निर्भर होनी चाहिए, ना कि उस मॉडल पर जो उस हफ़्ते Twitter जीत रहा था जब आपने integration लिखा।

रेज़िलिएंस एक साइड बेनिफ़िट बन जाता है। जब OpenAI को उसकी periodic outage में गिरता है (और वो गिरता है), आपका राउटर ट्रैफ़िक दूसरे प्रोवाइडर्स के पास रीडायरेक्ट कर सकता है। आप एक खास API के ऑनलाइन आने का इंतज़ार करके पूरी तरह बेकार नहीं होते।

ये बनावटी चतुराई के लिए नहीं है। ये ऐसी सिस्टम बनाने के लिए है जो वित्तीय और तकनीकी दोनों तरह से समझदारी रखे। आप हर कॉन्स्ट्रक्शन काम के लिए वैसा ही हैमर इस्तेमाल नहीं करते, और संभवतः हर AI काम के लिए वैसा ही लैंग्वेज मॉडल भी इस्तेमाल नहीं करना चाहिए।

इस तरीके की ख़ूबसूरती ये है कि आपका एप्लिकेशन कोड नहीं बदलता। आप बस अपने राउटर एजेंट को कॉल करते हैं। कौन सा मॉडल कौन से काम के लिए — इसका फ़ैसला एक जगह रहता है, एक बार कॉन्फ़िगर किया, बजट आपके कोडबेस में बिखरे conditional logic के ढेर में नहीं।

संसाधन

• Mastra.ai डॉक्यूमेंटेशन
• Mastra GitHub रिपॉज़िटरी

सीरीज़ पढ़ो

1. LLM राउटिंग (यह पोस्ट)
2. सुरक्षा & गार्डरेल्स
3. MCP & टूल इंटीग्रेशन्स
4. वर्कफ़्लोज़ & मेमोरी