LiteLLM AI गेटवे

Clore.ai GPUs पर 100+ LLMs के लिए AI गेटवे प्रॉक्सी के रूप में LiteLLM को तैनात करें

LiteLLM एक ओपन-सोर्स AI गेटवे है जो 100+ भाषा मॉडल प्रदाताओं के लिए एक एकीकृत OpenAI-संगत API प्रदान करता है — जिनमें OpenAI, Anthropic, Azure, Bedrock, HuggingFace और लोकल-होस्टेड मॉडल शामिल हैं। इसे CLORE.AI पर तैनात करें ताकि आप सभी LLM API कॉल्स को एकल एンドपॉइंट के माध्यम से रूट, लोड-बैलेंस और प्रबंधित कर सकें, जिसमें इन-बिल्ट लागत ट्रैकिंग, रेट लिमिटिंग और फॉलबैक लॉजिक शामिल है।

LiteLLM की असली शक्ति स्केल पर दिखती है: मिश्रित लोकल+क्लाउड स्टैक्स चलाने वाली टीमें बिना एप्लिकेशन कोड छुए मॉडल्स को हॉट-स्वैप कर सकती हैं। बदलें gpt-4o के साथ mistral-7b-local config में, पुनरारंभ — हो गया।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है CLORE.AI मार्केटप्लेस.

सर्वर आवश्यकताएँ

पैरामीटर	न्यूनतम	अनुशंसित
RAM	4 GB	8 GB+
VRAM	लागू नहीं (केवल प्रॉक्सी)	लागू नहीं
डिस्क	10 GB	20 GB+
GPU	आवश्यक नहीं	वैकल्पिक (लोकल मॉडलों के लिए)

LiteLLM स्वयं एक CPU-आधारित प्रॉक्सी है और GPU की आवश्यकता नहीं होती। हालांकि, जब आप लोकल मॉडल (Ollama, TGI, vLLM के माध्यम से) उसी मशीन पर LiteLLM के साथ एकीकृत गेटवे के रूप में चलाना चाहते हैं तो इसे CLORE.AI GPU सर्वर पर तैनात करना समझदारी है।

CLORE.AI पर त्वरित तैनाती

Docker इमेज: ghcr.io/berriai/litellm:main-latest

पोर्ट्स: 22/tcp, 4000/http

पर्यावरण चर:

चर	उदाहरण	विवरण
OPENAI_API_KEY	sk-xxx...	OpenAI API कुंजी
ANTHROPIC_API_KEY	sk-ant-xxx...	Anthropic API कुंजी
AZURE_API_KEY	xxx...	Azure OpenAI कुंजी
LITELLM_MASTER_KEY	sk-my-master-key	प्रॉक्सी के लिए मास्टर प्रामाणिकता कुंजी
DATABASE_URL	postgresql://...	लागत ट्रैकिंग के लिए PostgreSQL
STORE_MODEL_IN_DB	True	मॉडल कॉन्फ़िग को DB में स्थायी रूप से सहेजें

चरण-दर-चरण सेटअप

1. CLORE.AI पर एक सर्वर किराये पर लें

LiteLLM CPU-ओनली सर्वरों पर भी शानदार काम करता है। जाएँ CLORE.AI मार्केटप्लेस और फ़िल्टर करें:

• एक शुद्ध प्रॉक्सी सेटअप के लिए सबसे सस्ते CPU सर्वर

• यदि आप लोकल मॉडल भी चलाना चाहते हैं तो GPU सर्वर (RTX 3090+)

2. अपने सर्वर में SSH करें

ssh -p <PORT> root@<SERVER_IP>

3. एक कॉन्फ़िग फाइल बनाएं

LiteLLM मॉडल परिभाषित करने के लिए YAML कॉन्फ़िग फाइल का उपयोग करता है:

mkdir -p /root/litellm
cat > /root/litellm/config.yaml << 'EOF'
model_list:
  # OpenAI मॉडल
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

  - model_name: gpt-4o-mini
    litellm_params:
      model: openai/gpt-4o-mini
      api_key: "os.environ/OPENAI_API_KEY"

  # Anthropic मॉडल
  - model_name: claude-3-5-sonnet
    litellm_params:
      model: anthropic/claude-3-5-sonnet-20241022
      api_key: "os.environ/ANTHROPIC_API_KEY"

  # लोकल मॉडल TGI के माध्यम से (उसी सर्वर पर, पोर्ट 8080)
  - model_name: mistral-7b-local
    litellm_params:
      model: openai/mistralai/Mistral-7B-Instruct-v0.3
      api_base: "http://localhost:8080/v1"
      api_key: "none"

  # लोड बैलेंसर: कई एंडपॉइंट्स को रूट करें
  - model_name: fast-model
    litellm_params:
      model: openai/gpt-4o-mini
      api_key: "os.environ/OPENAI_API_KEY"
    model_info:
      mode: chat

litellm_settings:
  drop_params: True
  set_verbose: False
  num_retries: 3
  request_timeout: 60

general_settings:
  master_key: "sk-my-secret-master-key"  # इसे बदलें!
  alerting: []
EOF

4. LiteLLM लॉन्च करें

बुनियादी लॉन्च:

docker run -d \
  --name litellm \
  --network host \
  -v /root/litellm/config.yaml:/app/config.yaml \
  -e OPENAI_API_KEY=sk-your-openai-key \
  -e ANTHROPIC_API_KEY=sk-ant-your-anthropic-key \
  -e LITELLM_MASTER_KEY=sk-my-secret-master-key \
  ghcr.io/berriai/litellm:main-latest \
  --config /app/config.yaml \
  --port 4000 \
  --host 0.0.0.0

लागत ट्रैकिंग के लिए PostgreSQL के साथ:

सबसे पहले, एक PostgreSQL कंटेनर शुरू करें:

docker run -d \
  --name postgres \
  -e POSTGRES_PASSWORD=litellm_pass \
  -e POSTGRES_DB=litellm \
  -p 5432:5432 \
  postgres:15

# फिर DB के साथ LiteLLM लॉन्च करें
docker run -d \
  --name litellm \
  -p 4000:4000 \
  -v /root/litellm/config.yaml:/app/config.yaml \
  -e OPENAI_API_KEY=sk-your-openai-key \
  -e ANTHROPIC_API_KEY=sk-ant-your-anthropic-key \
  -e LITELLM_MASTER_KEY=sk-my-secret-master-key \
  -e DATABASE_URL="postgresql://postgres:litellm_pass@localhost:5432/litellm" \
  --network host \
  ghcr.io/berriai/litellm:main-latest \
  --config /app/config.yaml \
  --port 4000 \
  --host 0.0.0.0

Docker Compose का उपयोग (अनुशंसित):

cat > /root/litellm/docker-compose.yml << 'EOF'
version: "3.8"
services:
  litellm:
    image: ghcr.io/berriai/litellm:main-latest
    ports:
      - "4000:4000"
    volumes:
      - ./config.yaml:/app/config.yaml
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - LITELLM_MASTER_KEY=sk-my-secret-master-key
      - DATABASE_URL=postgresql://postgres:litellm_pass@db:5432/litellm
    command: --config /app/config.yaml --port 4000 --host 0.0.0.0
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: litellm_pass
      POSTGRES_DB: litellm
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:
EOF

cd /root/litellm && docker compose up -d

5. सर्वर सत्यापित करें

# स्वास्थ्य जाँच करें
curl http://localhost:4000/health

# उपलब्ध मॉडलों की सूची बनाएं
curl http://localhost:4000/v1/models \
  -H "Authorization: Bearer sk-my-secret-master-key"

6. CLORE.AI HTTP प्रॉक्सी के माध्यम से पहुंच

पोर्ट 4000 के लिए आपका CLORE.AI http_pub URL:

https://<order-id>-4000.clore.ai/v1

इसे अपने के रूप में उपयोग करें api_base किसी भी OpenAI-संगत क्लाइंट में।

---

उपयोग के उदाहरण

उदाहरण 1: प्रॉक्सी के माध्यम से डायरेक्ट API कॉल

curl http://localhost:4000/v1/chat/completions \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-my-secret-master-key" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [
      {"role": "user", "content": "जर्मनी की राजधानी क्या है?"}
    ]
  }'

उदाहरण 2: LiteLLM प्रॉक्सी के साथ OpenAI Python SDK

from openai import OpenAI

# केवल base_url और api_key बदलें — बाकी सब समान है
client = OpenAI(
    base_url="http://localhost:4000/v1",
    api_key="sk-my-secret-master-key",
)

# अपने कॉन्फ़िग से कोई भी मॉडल इस्तेमाल करें
response = client.chat.completions.create(
    model="gpt-4o-mini",  # या "claude-3-5-sonnet", "mistral-7b-local"
    messages=[{"role": "user", "content": "GPU कंप्यूटिंग के लाभों का सारांश बताइए."}],
)
print(response.choices[0].message.content)

# शून्य कोड परिवर्तन के साथ मॉडल स्विच करें
response2 = client.chat.completions.create(
    model="claude-3-5-sonnet",
    messages=[{"role": "user", "content": "वही प्रश्न, अलग मॉडल."}],
)
print(response2.choices[0].message.content)

उदाहरण 3: LiteLLM Python SDK (प्रत्यक्ष)

import litellm

# प्रॉक्सी के बिना सीधे उपयोग करें
response = litellm.completion(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "नमस्ते!"}],
    api_key="your-openai-key",
)

# या अपने प्रॉक्सी के माध्यम से रूट करें
response = litellm.completion(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "नमस्ते!"}],
    api_base="http://localhost:4000",
    api_key="sk-my-secret-master-key",
)

उदाहरण 4: फॉलबैक कॉन्फ़िगरेशन

मॉडल्स के बीच स्वचालित फॉलबैक कॉन्फ़िगर करें:

# config.yaml में
model_list:
  - model_name: smart-fallback
    litellm_params:
      model: gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

router_settings:
  routing_strategy: least-busy
  model_group_alias:
    "gpt-4-fallback":
      - "gpt-4o"
      - "claude-3-5-sonnet"
      - "mistral-7b-local"
  num_retries: 3
  fallbacks:
    - gpt-4o:
        - claude-3-5-sonnet
        - mistral-7b-local

उदाहरण 5: लागत ट्रैकिंग डैशबोर्ड

PostgreSQL सक्षम करने के बाद, खर्च विश्लेषण तक पहुँचें:

# उपयोगकर्ता द्वारा खर्च प्राप्त करें
curl http://localhost:4000/global/spend/users \
  -H "Authorization: Bearer sk-my-secret-master-key"

# मॉडल द्वारा खर्च प्राप्त करें
curl http://localhost:4000/global/spend/models \
  -H "Authorization: Bearer sk-my-secret-master-key"

# खर्च रिपोर्ट जनरेट करें
curl "http://localhost:4000/global/spend?start_date=2024-01-01&end_date=2024-12-31" \
  -H "Authorization: Bearer sk-my-secret-master-key"

---

कॉन्फ़िगरेशन

वर्चुअल कुंजियाँ (प्रति-उपयोगकर्ता API कुंजियाँ)

रेट लिमिट्स और बजट के साथ अलग कुंजियाँ बनाएं:

# बजट के साथ एक कुंजी बनाएं
curl http://localhost:4000/key/generate \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-my-secret-master-key" \
  -d '{
    "models": ["gpt-4o-mini", "claude-3-5-sonnet"],
    "duration": "30d",
    "max_budget": 10.0,
    "metadata": {"user_id": "user_123"}
  }'

लोड बैलेंसिंग

model_list:
  # कई OpenAI API कुंजियों के बीच राउंड-रॉबिन
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: sk-key-1
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: sk-key-2

router_settings:
  routing_strategy: least-busy  # या: simple-shuffle, latency-based-routing

कैशिंग

litellm_settings:
  cache: True
  cache_params:
    type: redis
    host: localhost
    port: 6379
    ttl: 3600  # 1 घंटा

रेट लिमिटिंग

general_settings:
  default_team_settings:
    tpm_limit: 100000   # टोकन प्रति मिनट
    rpm_limit: 1000     # रिक्वेस्ट प्रति मिनट

---

प्रदर्शन सुझाव

1. रिपीटेड प्रॉम्प्ट्स के लिए कैशिंग सक्षम करें

RAG या चैटबोट एप्लिकेशंस में सामान्य प्रश्नों के लिए, Redis कैशिंग लागत को 30–70% तक कम कर देती है और कैश हिट्स पर P50 लेटेंसी को <5ms तक घटा देती है:

litellm_settings:
  cache: True
  cache_params:
    type: redis
    host: localhost
    port: 6379

2. Async रिक्वेस्ट का उपयोग करें

import asyncio
import litellm

async def batch_complete(prompts):
    tasks = [
        litellm.acompletion(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": p}],
        )
        for p in prompts
    ]
    return await asyncio.gather(*tasks)

results = asyncio.run(batch_complete(["Hello", "World", "Test"]))

3. लोकल मॉडल रूटिंग

सस्ते/सरल अनुरोधों को Clore.ai GPU पर लोकल मॉडलों को रूट करें, जटिल अनुरोधों को GPT-4 पर भेजें:

model_list:
  - model_name: smart-router
    litellm_params:
      model: openai/gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

एक सामान्य सेटअप: Mistral 7B या Llama 3 8B को Clore.ai RTX 3090 पर लोकली चलाएँ ($0.10–0.15/घं), वहाँ 80% ट्रैफ़िक को संभालें, जटिल कार्यों को GPT-4o पर बढ़ाएँ। केवल क्लाउड के मुकाबले 3–5× लागत बचत सामान्य है।

4. टाइमआउट्स और रिट्राइ सेट करें

litellm_settings:
  request_timeout: 30
  num_retries: 3
  retry_after: 5

---

Clore.ai GPU सिफारिशें

LiteLLM को स्वयं GPU की आवश्यकता नहीं है — यह एक प्रॉक्सी है। GPU का चयन केवल तब मायने रखता है जब आप स्थानीय इन्फरेंस को इसके साथ सह-तैनात कर रहे हों।

लोकल मॉडल	GPU	क्यों
Mistral 7B / Llama 3 8B (bf16)	RTX 3090 24 GB	आराम से फिट होता है, ~200 tok/s थ्रूपुट
Mixtral 8×7B या Llama 3 70B (AWQ)	RTX 4090 24 GB	3090 से तेज़ मेमोरी बैंडविड्थ; 70B AWQ 4-bit फिट होता है
Llama 3 70B (bf16) या मल्टी-मॉडल सर्विंग	A100 80 GB	एक साथ कई 7–13B मॉडल चलाएँ; कम विलंबता के लिए HBM2e

एक सिंगल डेवलपर के लिए अनुशंसित स्टैक: RTX 3090 + Mistral 7B + LiteLLM गेटवे। Clore.ai पर कुल लागत: ~$0.12/घं। सरलता से ~50 रिक्वेस्ट/मिनट संभालता है, जटिल कार्यों के लिए GPT-4o फॉलबैक के साथ।

टीम / प्रोडक्शन स्टैक: A100 80GB, Llama 3 70B + LiteLLM + PostgreSQL चलाएँ। 20+ समवर्ती उपयोगकर्ताओं को सर्व करता है, पूर्ण लागत ट्रैकिंग, अधिकांश रिक्वेस्ट्स के लिए क्लाउड LLM खर्च शून्य।

---

समस्या निवारण

समस्या: "model not found"

सुनिश्चित करें कि आपके अनुरोध में मॉडल नाम बिल्कुल उस चीज़ से मेल खाता है जो config.yaml:

curl http://localhost:4000/v1/models -H "Authorization: Bearer sk-my-secret-master-key"

समस्या: "authentication failed"

अपना जाँचें LITELLM_MASTER_KEY पर्यावरण चर और इसे Bearer टोकन के रूप में उपयोग करें।

समस्या: कॉन्फ़िग परिवर्तन पर प्रतिबिंबित नहीं हो रहा

कॉन्फ़िग परिवर्तन के बाद कंटेनर को पुनरारंभ करें:

docker restart litellm

समस्या: पहले अनुरोध पर उच्च लेटेंसी

LiteLLM स्टार्टअप पर मॉडल कॉन्फ़िग्स लोड करता है। पहले कुछ अनुरोध धीमे हो सकते हैं क्योंकि कनेक्शनों की स्थापना हो रही होती है।

समस्या: डेटाबेस कनेक्शन त्रुटियाँ

# जाँचें कि PostgreSQL चल रहा है
docker logs postgres

# कनेक्शन स्ट्रिंग फ़ॉर्मैट सत्यापित करें
DATABASE_URL="postgresql://user:password@host:5432/dbname"

समस्या: प्रदाताओं से 429 रेट लिमिट त्रुटियाँ

फॉलबैक कॉन्फ़िगर करें:

litellm_settings:
  num_retries: 5
  fallbacks:
    - gpt-4o: [claude-3-5-sonnet]

---

Clore.ai GPU सिफारिशें

LiteLLM एक API गेटवे/प्रॉक्सी है — यह स्वयं इन्फरेंस नहीं करता। GPU चयन इस बात पर निर्भर करता है कि आप क्लाउड APIs को रूट कर रहे हैं या लोकल मॉडलों को।

सेटअप	GPU	Clore.ai कीमत	उपयोग केस
केवल क्लाउड API प्रॉक्सी	केवल CPU	~$0.02/घं	OpenAI, Anthropic, Gemini को रूट करें — GPU की आवश्यकता नहीं
लोकल vLLM बैकएंड	RTX 3090 (24GB)	~$0.12/घंटा	LiteLLM को फ्रंटएंड के रूप में लेकर सेल्फ-हॉस्टेड 7B–13B मॉडल्स
लोकल vLLM बैकएंड	RTX 4090 (24GB)	~$0.70/घंटा	उच्च थ्रूपुट 7B–34B लोकल मॉडल
लोकल vLLM बैकएंड	A100 40GB	~$1.20/घंटा	70B मॉडल्स, प्रोडक्शन लोकल सर्विंग

सबसे सामान्य सेटअप: LiteLLM को आपके Clore.ai-होस्टेड vLLM/Ollama इंस्टेंस के सामने एक एकीकृत प्रॉक्सी के रूप में चलाएँ। इससे आपको प्रदाता फॉलबैक, रेट लिमिटिंग, लागत ट्रैकिंग और OpenAI-संगत रूटिंग मिलती है — जबकि सभी इन्फरेंस लोकल और सस्ता रहता है।

उदाहरण लागत: LiteLLM प्रॉक्सी को CPU-ओनली इंस्टेंस पर चलाएँ ($0.02/घं) और इसे RTX 3090 पर vLLM सर्वर की तरफ़ पॉइंट करें ($0.12/घं)। फॉलबैक, लॉगिंग और रेट लिमिटिंग के साथ प्रोडक्शन-रेडी, सेल्फ-हॉस्टेड LLM API की कुल लागत ~ $0.14/घं है।

---

लिंक

• GitHub

• दस्तावेज़ीकरण

• Docker Hub / GHCR

• समर्थित प्रदाता

• CLORE.AI मार्केटप्लेस