LiteLLM: व्यावहारिक उदाहरणों के साथ एक गाइड

अलग-अलग LLM प्रदाताओं के बीच स्विच करने के लिए आपका पूरा कोडबेस फिर से लिखना नहीं पड़ना चाहिए। लेकिन आज कई AI सेवाओं के साथ काम करते समय अक्सर यही होता है। हर प्रदाता का अपना SDK, प्रमाणीकरण तरीका, और रिस्पॉन्स फ़ॉर्मैट होता है। LiteLLM इसे एकीकृत इंटरफ़ेस के साथ हल करता है।

इस ट्यूटोरियल में, मैं LiteLLM के मुख्य हिस्सों की व्याख्या करूंगा और दिखाऊंगा कि बुनियादी API कॉल्स से कैसे शुरू करें और स्ट्रीमिंग रिस्पॉन्स, संरचित आउटपुट, और लागत ट्रैकिंग तक कैसे पहुँचें।

LiteLLM क्या है?

LiteLLM एक ओपन-सोर्स Python लाइब्रेरी है जो AI मॉडलों के लिए यूनिवर्सल ट्रांसलेटर की तरह काम करती है। हर प्रदाता के लिए अलग API सीखने के बजाय, आप एक ही इंटरफ़ेस उपयोग करते हैं जो 100 से अधिक LLM सेवाओं से जुड़ता है।

इस फ़्रेमवर्क के दो मुख्य भाग हैं। Python SDK आपको एक बार कोड लिखने और किसी भी प्रदाता के साथ चलाने देता है। प्रॉक्सी सर्वर उन टीमों और कंपनियों के लिए केंद्रीय गेटवे की तरह काम करता है जिन्हें बड़े पैमाने पर AI सेवाओं का प्रबंधन करना होता है।

LiteLLM आपको ये अतिरिक्त लाभ देता है:

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

ध्यान दें कि OpenRouter भी कई LLMs तक एकीकृत पहुंच देता है, हालांकि उसकी कीमतें और फीचर सेट अलग हैं।

प्रॉक्सी सर्वर टीम-स्तरीय खर्च सीमाएँ, परियोजनाओं में उपयोग ट्रैकिंग, और केंद्रीकृत API कुंजी प्रबंधन जोड़ता है। सारा कॉन्फ़िगरेशन सरल YAML फ़ाइलों के माध्यम से होता है।

LiteLLM विभिन्न प्रकार के उपयोगकर्ताओं के लिए उपयुक्त है:

• व्यक्तिगत डेवलपर जो हर जगह खाते बनाए बिना कई मॉडलों का परीक्षण करना चाहते हैं
• छोटी टीमें जिन्हें लागत की पारदर्शिता चाहिए और वेंडर लॉक-इन नहीं चाहिए
• बड़ी कंपनियाँ जिन्हें केंद्रीकृत प्रबंधन, बजट कंट्रोल्स, और विस्तृत उपयोग विश्लेषण चाहिए

यह लाइब्रेरी MIT-लाइसेंस प्राप्त और पूरी तरह ओपन-सोर्स है। आप कोड देख सकते हैं, अपनी ज़रूरत के अनुसार संशोधित कर सकते हैं, या प्रोजेक्ट में योगदान दे सकते हैं।

अब जब आप जानते हैं कि LiteLLM क्या कर सकता है, तो यहाँ बताया गया है कि अपना वातावरण कैसे सेट करें।

पूर्वापेक्षाएँ

LiteLLM उपयोग करना शुरू करने से पहले, आपको कुछ चीज़ें सेट करनी होंगी। यदि आप पहले AI मॉडलों के साथ काम कर चुके हैं, तो इनमें से अधिकांश शायद पहले से हो चुका होगा।

Python वातावरण

आपको Python 3.7 या नया चाहिए। आज अधिकांश सिस्टम में यह होता है, लेकिन आप अपना वर्शन इस तरह जाँच सकते हैं:

import sys
print(f"Python version: {sys.version_info.major}.{sys.version_info.minor}")संचालित द्वारा

पैकेज इंस्टॉलेशन

LiteLLM और python-dotenv इंस्टॉल करें ताकि आप environment variables प्रबंधित कर सकें:

uv add litellm python-dotenv
# or with pip: pip install litellm python-dotenvसंचालित द्वारा

API कुंजियाँ

आपको उन प्रदाताओं से API कुंजियाँ चाहिए होंगी जिन्हें आप उपयोग करना चाहते हैं। इस ट्यूटोरियल के लिए, हम दो मॉडलों के साथ काम करेंगे:

• OpenAI API कुंजी: आप कुंजी यहाँ से ले सकते हैं platform.openai.com (GPT-5 के लिए)
• Anthropic API कुंजी: आप कुंजी यहाँ से ले सकते हैं console.anthropic.com (Claude Sonnet 4 के लिए)

इन्हें अपने प्रोजेक्ट डायरेक्टरी में .env फ़ाइल में स्टोर करें:

OPENAI_API_KEY=your_openai_key_here
ANTHROPIC_API_KEY=your_anthropic_key_hereसंचालित द्वारा

एन्वायरनमेंट जाँच

सेटअप जाँचने के लिए यह स्क्रिप्ट चलाएँ:

import os
import sys
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Check Python version
print(f"Python version: {sys.version_info.major}.{sys.version_info.minor}")

# Check LiteLLM
try:
   import litellm
   print("✓ LiteLLM installed")
except ImportError:
   print("✗ LiteLLM not installed")

# Check API keys
openai_key = os.getenv("OPENAI_API_KEY")
anthropic_key = os.getenv("ANTHROPIC_API_KEY")

if openai_key:
   print(f"✓ OpenAI API key found")
else:
   print("✗ OpenAI API key not found")

if anthropic_key:
   print(f"✓ Anthropic API key found")
else:
   print("✗ Anthropic API key not found")संचालित द्वारा

Python version: 3.11
✓ LiteLLM installed
✓ OpenAI API key found
✓ Anthropic API key foundसंचालित द्वारा

यदि आपको सभी जगह हरे चेकमार्क दिखाई दें, तो आप तैयार हैं। यदि कोई जाँच फेल हो, तो सुनिश्चित करें कि आपने पैकेज इंस्टॉल किए हैं और .env फ़ाइल में अपनी API कुंजियाँ जोड़ी हैं।

LiteLLM के साथ अपनी पहली API कॉल करना

LiteLLM वही इंटरफ़ेस उपयोग करता है जिसे आप OpenAI से जानते होंगे, लेकिन यह किसी भी प्रदाता के साथ काम करता है।

बेसिक सेटअप

इन इम्पोर्ट्स से शुरू करें:

import litellm
from dotenv import load_dotenv

# Load your API keys
load_dotenv()संचालित द्वारा

GPT-5 को भेजी जाने वाली एक बुनियादी रिक्वेस्ट इस पैटर्न का पालन करती है: अपने संदेश परिभाषित करें, litellm.completion() कॉल करें, और रिस्पॉन्स प्राप्त करें।

messages = [
   {"role": "user", "content": "Write a simple Python function that adds two numbers"}
]

response = litellm.completion(
   model="gpt-5",
   messages=messages
)

print(response.choices[0].message.content)संचालित द्वारा

def add(a, b):
   """Return the sum of a and b."""
   return a + bसंचालित द्वारा

आपने LiteLLM के माध्यम से GPT-5 को कॉल किया। रिस्पॉन्स ऑब्जेक्ट OpenAI के फ़ॉर्मैट का अनुसरण करता है, तो यदि आपने पहले उनका API उपयोग किया है, तो यह परिचित लगेगा। आप यह भी देखना चाहेंगे कि वास्तव में किस मॉडल ने उत्तर दिया और टोकन उपयोग जाँचें:

print(f"Model used: {response.model}")
print(f"Response ID: {response.id}")
print(f"Total tokens: {response.usage.total_tokens}")संचालित द्वारा

Model used: gpt-5-2025-08-07
Response ID: chatcmpl-CIbZWUDE1amW2vHtHDmieTX6hnZUq
Total tokens: 557संचालित द्वारा

प्रदाताओं के बीच स्विच करना

LiteLLM की असली ताकत प्रदाताओं के बीच स्विच करते समय दिखती है। क्या आप Claude Sonnet 4 आज़माना चाहते हैं? एक पैरामीटर बदलें:

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=messages
)

print(response.choices[0].message.content)संचालित द्वारा

Here's a simple Python function that adds two numbers:

def add_numbers(a, b):
   """
   Adds two numbers and returns the result.
  
   Args:
       a: First number
       b: Second number
  
   Returns:
       The sum of a and b
   """
   return a + b

# Example usage:
result = add_numbers(5, 3)
print(result)  # Output: 8

This function:
- Takes two parameters a and b
- Returns their sum using the + operator
- Works with integers, floats, and even negative numbers
- Includes a docstring to explain what the function doesसंचालित द्वारा

कोड स्ट्रक्चर वही, प्रदाता अलग। Claude डॉक्यूमेंटेशन और उदाहरणों के साथ कहीं अधिक विस्तृत उत्तर देता है, जबकि GPT-5 अधिक संक्षिप्त था।

बेसिक एरर हैंडलिंग

समस्याएँ होने पर कुछ एरर हैंडलिंग जोड़ें:

try:
   response = litellm.completion(
       model="gpt-5",
       messages=messages
   )
   print(response.choices[0].message.content)
except Exception as e:
   print(f"API call failed: {e}")संचालित द्वारा

यह पैटर्न आम समस्याएँ पकड़ता है, जैसे अवैध API कुंजी, नेटवर्क समस्याएँ, या मॉडल अनुपलब्ध होना।

आगे क्या

अब आप किसी भी प्रदाता के साथ LiteLLM उपयोग करने का बेसिक पैटर्न जानते हैं। Getting Started डॉक्यूमेंटेशन समर्थित मॉडलों और पैरामीटर्स पर अधिक विवरण कवर करता है, और Completion फ़ंक्शन संदर्भ सभी उपलब्ध विकल्प दिखाता है।

प्रोडक्शन एप्लिकेशन बनाने के लिए, आप API डिजाइन के सर्वश्रेष्ठ अभ्यास भी अपनाना चाहेंगे ताकि भरोसेमंद, उच्च-प्रदर्शन सिस्टम बन सकें।

प्रदाता स्विचिंग और फॉलबैक

LiteLLM की फॉलबैक प्रणाली अपने आप प्रदाता विफलताओं को संभालती है ताकि आपके उपयोगकर्ताओं को एरर संदेश न दिखें। जब आप वास्तविक एप्लिकेशन बनाते हैं, तो आपको ऐसे बैकअप प्लान चाहिए जो आपके हिस्से किसी अतिरिक्त कोड के बिना काम करें।

बेसिक फॉलबैक सेटअप

फॉलबैक सेट करने के लिए, अपनी completion कॉल में fallbacks सूची जोड़ें:

messages = [
   {"role": "user", "content": "Explain what a Python decorator is in one sentence"}
]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   fallbacks=["anthropic/claude-sonnet-4-20250514"]
)

print(f"Response: {response.choices[0].message.content}")
print(f"Model used: {response.model}")संचालित द्वारा

Response: A Python decorator is a callable that wraps another function or class to augment its behavior and returns it, applied with the @ syntax so you can add reusable functionality without changing the original code.
Model used: gpt-5-2025-08-07संचालित द्वारा

यदि GPT-5 फेल होता है, तो LiteLLM अपने आप Claude Sonnet 4 आज़माता है। किसी भी तरह उपयोगकर्ताओं को उत्तर मिल जाता है।

फॉलबैक चेन बनाना

बेहतर विश्वसनीयता के लिए आप कई प्रदाताओं को चेन कर सकते हैं। पहले वाले ही संदेशों का उपयोग करते हुए:

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   fallbacks=["anthropic/claude-sonnet-4-20250514", "gpt-3.5-turbo"]
)

print(f"Model used: {response.model}")संचालित द्वारा

Model used: gpt-5-2025-08-07संचालित द्वारा

LiteLLM क्रम में मॉडल आज़माता है। यदि प्राथमिक फेल हो, तो पहला फॉलबैक, फिर दूसरा। कई परतों की सुरक्षा।

रीट्राइज़ जोड़ना

और बेहतर विश्वसनीयता के लिए फॉलबैक के साथ रीट्राइज़ मिलाएँ:

response = litellm.completion(
   model="gpt-5",
   messages=messages,  # Same messages as before
   num_retries=2
)संचालित द्वारा

फॉलबैक पर जाने से पहले वही मॉडल दो बार रीट्राइ करेगा। अस्थायी नेटवर्क समस्याओं या रेट लिमिट स्पाइक्स के लिए अच्छा है।

फॉलबैक अधिकांश विफलताओं को अपने आप संभालते हैं, लेकिन फिर भी आपको ऐसे मामलों को पकड़ना चाहिए जहाँ सभी मॉडल फेल हो जाएँ:

try:
   response = litellm.completion(
       model="gpt-5",
       messages=messages,  # Same messages as before
       fallbacks=["anthropic/claude-sonnet-4-20250514"],
       num_retries=2
   )
   return response.choices[0].message.content
except Exception as e:
   # All models failed - handle gracefully
   return "Sorry, I'm having trouble right now. Please try again."संचालित द्वारा

यहाँ तक कि जब प्रदाता पूरी तरह काम कर रहे हों, तब भी उपयोगकर्ता एक और समस्या का सामना करते हैं: खीझ पैदा करने वाला इंतज़ार। कोई आपके ऐप में सबमिट पर क्लिक करता है और कई सेकंड तक कुछ नहीं दिखता। उन्हें लगता है कि कुछ टूट गया।

रीयल-टाइम रिस्पॉन्स के लिए स्ट्रीमिंग

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

स्ट्रीमिंग उपयोगकर्ता अनुभव कैसे बदलती है

पूरे रिस्पॉन्स का इंतज़ार करने के बजाय, स्ट्रीमिंग AI के जनरेट करते ही टेक्स्ट दिखाती है। फर्क देखें:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "What is Python in one sentence?"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   stream=True
)

for chunk in response:
   if chunk.choices[0].delta.content:
       print(chunk.choices[0].delta.content, end="", flush=True)संचालित द्वारा

Python is a high-level, interpreted, dynamically typed, general-purpose programming language known for its readability and vast ecosystem, used across web development, data science, automation, scripting, and more.संचालित द्वारा

टेक्स्ट धीरे-धीरे दिखाई देता है, एक साथ नहीं (जब आप ऊपर का स्निपेट अपनी मशीन पर चलाते हैं)। उपयोगकर्ता तुरंत प्रगति देखते हैं, जो केवल लोडिंग स्पिनर घूरने की तुलना में कहीं अधिक उत्तरदायी लगता है।

स्ट्रीमिंग वास्तव में कैसे काम करती है

यह चंक स्तर पर काम करता है। एक बड़े रिस्पॉन्स के बजाय, आपको कई छोटे हिस्से मिलते हैं, जिन्हें डेल्टा कहा जाता है। कभी-कभी चंक खाली होते हैं, इसलिए सुरक्षा के लिए उन्हें ठीक से हैंडल करना चाहिए:

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=[{"role": "user", "content": "Define JavaScript in exactly two sentences"}],
   stream=True
)

for chunk in response:
   if hasattr(chunk.choices[0].delta, 'content') and chunk.choices[0].delta.content:
       print(f"'{chunk.choices[0].delta.content}'", end=" ")संचालित द्वारा

'JavaScript is a high' '-level, interpreted programming language primarily used for creating' ' interactive and dynamic content on web pages, running' ' in web browsers to manip' 'ulate HTML elements, handle user events' ', and communicate with servers.' ' Originally designed for client-side web development, JavaScript has evolve' 'd into a versatile language that can also' ' be used for server-side development, mobile applications' ', and desktop software through various runtime' ' environments like Node.js.'संचालित द्वारा

स्ट्रीमिंग को पुन: प्रयोज्य बनाना

वास्तविक एप्लिकेशन के लिए, आप स्ट्रीमिंग आउटपुट दिखाते हुए पूरा रिस्पॉन्स कैप्चर करना चाहेंगे। यह करने के लिए एक फ़ंक्शन यहाँ है:

def stream_and_capture(model, messages):
   """Stream response while capturing the complete text"""
   response = litellm.completion(
       model=model,
       messages=messages,
       stream=True
   )
  
   full_response = ""
   for chunk in response:
       if chunk.choices[0].delta.content:
           content = chunk.choices[0].delta.content
           print(content, end="", flush=True)
           full_response += content
  
   print()  # New line after response
   return full_response

# Test it
messages = [{"role": "user", "content": "Define APIs in 2 sentences max"}]
result = stream_and_capture("gpt-5", messages)संचालित द्वारा

APIs (Application Programming Interfaces) are standardized contracts, often exposed as endpoints, that specify how software components or services can communicate, including the allowed operations, inputs, and outputs. They let developers access functionality or data without knowing the underlying implementation, enabling modular, interoperable systems.संचालित द्वारा

end="" पैरामीटर चंक्स के बीच लाइन ब्रेक रोकता है। flush=True बफर करने के बजाय तुरंत डिस्प्ले फोर्स करता है।

फॉलबैक के साथ स्ट्रीमिंग

बेहतर विश्वसनीयता के लिए आप स्ट्रीमिंग को फॉलबैक सिस्टम के साथ भी मिला सकते हैं:

response = litellm.completion(
   model="gpt-5",
   messages=[{"role": "user", "content": "Define machine learning in one sentence"}],
   fallbacks=["anthropic/claude-sonnet-4-20250514"],
   stream=True
)

for chunk in response:
   if chunk.choices[0].delta.content:
       print(chunk.choices[0].delta.content, end="", flush=True)संचालित द्वारा

Machine learning is a branch of artificial intelligence where algorithms learn patterns from data to make predictions or decisions without being explicitly programmed.संचालित द्वारा

तुरंत फीडबैक, साथ ही यदि प्राथमिक मॉडल फेल हो तो स्वचालित प्रदाता स्विचिंग।

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

संरचित आउटपुट का उपयोग

वास्तव में होता यह है: आप ग्राहक फीडबैक का विश्लेषण करने वाला ऐप बनाते हैं। आपका AI ऐसा टेक्स्ट लौटाता है: “The sentiment is positive with confidence 0.85 and top keywords: responsive, helpful, fast.” आप कॉन्फिडेंस स्कोर और कीवर्ड्स निकालने के लिए regex पैटर्न लिखते हैं। टेस्टिंग में सब काम करता है।

फिर AI थोड़ा फ़ॉर्मैट बदलकर यह लौटाता है: “Sentiment: positive (confidence: 0.85). Keywords include responsive, helpful, and fast.” आपका regex टूट जाता है। आपकी डेटा पाइपलाइन काम करना बंद कर देती है। ग्राहक सेंटिमेंट रिपोर्ट स्कोर की जगह खाली वैल्यू दिखाती है। आपका डैशबोर्ड क्रैश हो जाता है। आप कल तक काम कर रहे पार्सिंग कोड को ठीक करने में घंटे लगा देते हैं।

संरचित आउटपुट इस समस्या से बचाते हैं—शुरू से ही पूर्वानुमेय फ़ॉर्मैट में डेटा लौटाकर।

टेक्स्ट की जगह JSON प्राप्त करना

LiteLLM सादा टेक्स्ट की जगह JSON लौटा सकता है। आप प्रॉम्प्ट में बताते हैं कि आपको कैसी संरचना चाहिए, और यह उसी फ़ॉर्मैट में वापस आता है:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "Describe Python as a programming language. Return as JSON with fields: language, difficulty, description"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   response_format={"type": "json_object"}
)

print(response.choices[0].message.content)संचालित द्वारा

{
 "language": "Python",
 "difficulty": "Beginner-friendly (easy to learn, moderate to master)",
 "description": "Python is a high-level, interpreted, dynamically typed, general-purpose programming language focused on readability and developer productivity. It supports multiple paradigms (object-oriented, functional, procedural), uses indentation for block structure, and includes a large standard library with an extensive third-party ecosystem (PyPI). Common uses include web development, data science, machine learning, automation/scripting, scientific computing, and DevOps. While not the fastest for CPU-bound tasks, it integrates well with C/C++ and accelerators, and runs cross-platform."
}संचालित द्वारा

यह संरचित तरीका आम पार्सिंग समस्याएँ खत्म कर देता है। टेक्स्ट में खोजने के बजाय आपको वैध JSON मिलता है, जिसमें ठीक वही फ़ील्ड होते हैं जो आपने माँगे थे। न पार्सिंग की झंझट, न फ़ॉर्मैट के सरप्राइज़।

JSON डेटा के साथ काम करना

कच्चे JSON स्ट्रिंग तब तक उपयोगी नहीं होते जब तक आप उन्हें Python ऑब्जेक्ट्स में न बदल दें जिनके साथ आपका एप्लिकेशन काम कर सके। आपको उस स्ट्रिंग को वास्तविक उपयोग योग्य Python ऑब्जेक्ट्स में बदलना होगा:

import json

messages = [{"role": "user", "content": "Describe JavaScript in 2 sentences. Return as JSON with fields: name, paradigm, use_cases (array of exactly 3 items)"}]

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=messages,
   response_format={"type": "json_object"}
)

# Parse the JSON response
data = json.loads(response.choices[0].message.content)
print(f"Language: {data['name']}")
print(f"Paradigm: {data['paradigm']}")
print(f"Use cases: {', '.join(data['use_cases'])}")संचालित द्वारा

Language: JavaScript
Paradigm: multi-paradigm (object-oriented, functional, event-driven)
Use cases: web development and browser scripting, server-side development with Node.js, mobile app development with frameworks like React Nativeसंचालित द्वारा

अब जब आपके पास संरचित डेटा है, तो आप इसे सीधे अन्य फ़ंक्शनों को पास कर सकते हैं, डेटाबेस में स्टोर कर सकते हैं, या अपने UI में दिखा सकते हैं—बिना किसी टेक्स्ट मैनिपुलेशन के। डेटा विश्लेषण वर्कफ़्लोज़ के लिए, Pandas AI जैसे टूल इस संरचित आउटपुट के साथ सीधे काम कर सकते हैं और इनसाइट्स दे सकते हैं।

Pydantic के साथ टाइप सेफ्टी जोड़ना

JSON पार्सिंग सिंटैक्स एरर पकड़ती है, लेकिन गलत डेटा प्रकार या मिसिंग फ़ील्ड अलग समस्याएँ हैं। Pydantic मॉडल इसे हल करते हैं—आपकी डेटा संरचना को वैलिडेट करके और समस्याएँ आपके एप्लिकेशन को तोड़ने से पहले पकड़कर:

from pydantic import BaseModel
import json

class ProgrammingLanguage(BaseModel):
   name: str
   paradigm: str
   use_cases: list[str]

messages = [{"role": "user", "content": "Describe CSS briefly. Return as JSON with fields: name, paradigm, use_cases (array of 3 items)"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   response_format={"type": "json_object"}
)

# Parse and validate with Pydantic
data = json.loads(response.choices[0].message.content)
language = ProgrammingLanguage(**data)

print(f"Validated data: {language.name} - {language.paradigm}")
print(f"Use cases: {language.use_cases}")संचालित द्वारा

Validated data: CSS (Cascading Style Sheets) - Declarative, rule-based stylesheet language for describing the presentation of structured documents.
Use cases: ['Styling layout, colors, and typography of web pages', 'Responsive design across devices and viewports', 'Animations, transitions, and visual effects']संचालित द्वारा

Pydantic अपने आप वैलिडेट करता है कि name और paradigm स्ट्रिंग हैं, और use_cases स्ट्रिंग्स की सूची है। यदि AI गलत प्रकार लौटाए या कोई आवश्यक फ़ील्ड भूल जाए, तो आपको बाद में रहस्यमयी बग्स के बजाय स्पष्ट त्रुटि मिलती है।

JSON एरर हैंडल करना

यदि AI गलत फ़ॉर्मैट का JSON या गैर-JSON टेक्स्ट लौटाए, तो JSON पार्सिंग फेल हो सकती है। बेसिक एरर हैंडलिंग जोड़ें:

import json

messages = [{"role": "user", "content": "Summarize machine learning in 1 sentence. Return as JSON with topic and summary fields"}]

try:
   response = litellm.completion(
       model="anthropic/claude-sonnet-4-20250514",
       messages=messages,
       response_format={"type": "json_object"}
   )
  
   data = json.loads(response.choices[0].message.content)
   print(f"Topic: {data['topic']}")
   print(f"Summary: {data['summary']}")
  
except json.JSONDecodeError:
   print("Invalid JSON returned")
except Exception as e:
   print(f"Request failed: {e}")संचालित द्वारा

Topic: machine learning
Summary: Machine learning is a subset of artificial intelligence that allows computers to learn and make predictions or decisions from data without being explicitly programmed for each specific task.संचालित द्वारा

संरचित आउटपुट गंदे टेक्स्ट पार्सिंग को साफ डेटा संरचनाओं से बदल देते हैं। आप JSON मोड को फॉलबैक के साथ वैसे ही मिला सकते हैं जैसे सामान्य कंप्लीशंस में।

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

लागत ट्रैकिंग

यह होता है: आपका प्रोटोटाइप टेस्टिंग में रोज़ 50 API कॉल पर बढ़िया काम करता है। आप हफ्ते के लगभग $2 खर्च कर रहे हैं। सब ठीक लगता है। आप प्रोडक्शन में लॉन्च करते हैं और 500 उपयोगकर्ता मिल जाते हैं। अब आप रोज़ 5,000 API कॉल कर रहे हैं। आपका मासिक बिल $8 से बढ़कर $800 हो जाता है।

कास्ट ट्रैकिंग के बिना, आपको कोई चेतावनी नहीं मिली। आप नहीं बता सकते कि कौन-से फीचर सबसे महंगे हैं, कौन-से मॉडल ज्यादा खर्चीले हैं, या ग्रोथ के लिए बजट कैसे बनाना है। आप हफ्तों बाद क्रेडिट कार्ड स्टेटमेंट आने पर बिल स्पाइक का पता लगाते हैं।

LiteLLM सभी प्रदाताओं पर आपका खर्च ठीक-ठीक ट्रैक करता है।

टोकन उपयोग समझना

हर AI रिस्पॉन्स में विस्तृत उपयोग जानकारी होती है जो दिखाती है कि आपसे किस चीज़ के लिए शुल्क लिया जा रहा है:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "Explain what a REST API is in two sentences"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages
)

print(f"Response: {response.choices[0].message.content}")
print(f"Prompt tokens: {response.usage.prompt_tokens}")
print(f"Completion tokens: {response.usage.completion_tokens}")
print(f"Total tokens: {response.usage.total_tokens}")संचालित द्वारा

Response: A REST API is a web service that follows the Representational State Transfer architectural style, exposing resources identified by URLs and manipulated with HTTP methods like GET, POST, PUT, and DELETE. It uses stateless client-server communication, cacheability, and uniform representations (often JSON) to support scalable, decoupled interactions.
Prompt tokens: 15
Completion tokens: 201
Total tokens: 216संचालित द्वारा

इनपुट टोकन आपका प्रॉम्प्ट होते हैं, आउटपुट टोकन AI का उत्तर। अलग-अलग प्रदाता प्रत्येक प्रकार के लिए अलग दरें वसूलते हैं।

स्वचालित लागत गणना

कच्ची टोकन गिनती आपको डॉलर की राशि नहीं बताती। LiteLLM आपके लिए वास्तविक लागत निकाल देता है:

# Get the cost for a completed response
cost = litellm.completion_cost(completion_response=response)
print(f"Total cost: ${cost:.4f}")
Total cost: $0.0020संचालित द्वारा

LiteLLM का प्राइसिंग डेटाबेस आपके मॉडल के आधार पर टोकन को डॉलर में बदल देता है।

मैन्युअल लागत गणना

कभी-कभी आप कॉल करने से पहले लागत का अनुमान लगाना चाहते हैं, या पहले से मौजूद टेक्स्ट के लिए लागत निकालना चाहते हैं:

# Calculate cost without making an API call
prompt_text = "Explain machine learning"
completion_text = "Machine learning is a method of data analysis that automates analytical model building."

estimated_cost = litellm.completion_cost(
   model="anthropic/claude-sonnet-4-20250514",
   prompt=prompt_text,
   completion=completion_text
)

print(f"Estimated cost: ${estimated_cost:.4f}")संचालित द्वारा

Estimated cost: $0.0002संचालित द्वारा

यह बजटिंग और मॉडलों की तुलना के लिए उपयोगी है।

कई API कॉल्स को ट्रैक करना

ऐप्लिकेशन जो कई API कॉल करते हैं, उनके लिए आप संचयी लागत ट्रैक कर सकते हैं:

total_cost = 0.0

conversation = [
   "What is Python?",
   "How do you install Python packages?",
   "What are virtual environments?"
]

for i, question in enumerate(conversation):
   response = litellm.completion(
       model="gpt-5",
       messages=[{"role": "user", "content": question}]
   )
  
   call_cost = litellm.completion_cost(completion_response=response)
   total_cost += call_cost
  
   print(f"Call {i+1}: ${call_cost:.4f}")

print(f"Total cost: ${total_cost:.4f}")संचालित द्वारा

Call 1: $0.0057
Call 2: $0.0134
Call 3: $0.0102
Total cost: $0.0292संचालित द्वारा

लागत ट्रैकिंग आपको यह तय करने में मदद करती है कि कौन-से मॉडल उपयोग करने हैं और अचानक आने वाले बिलों से बचाती है। हर API कॉल की सटीक लागत देखें और प्रदाताओं की तुलना करें।

निष्कर्ष

अब आपके पास ऐसे AI एप्लिकेशन बनाने के टूल हैं जिनमें वेंडर लॉक-इन नहीं है। आपने बेसिक API कॉल्स, स्वचालित फॉलबैक, स्ट्रीमिंग रिस्पॉन्स, संरचित आउटपुट, और लागत ट्रैकिंग सीखी।

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