# LiteLLM AI Gateway

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

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

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

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

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

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

## 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 मार्केटप्लेस](https://clore.ai/marketplace) और फ़िल्टर करें:

* एक शुद्ध प्रॉक्सी सेटअप के लिए सबसे सस्ते CPU सर्वर
* यदि आप लोकल मॉडल भी चलाना चाहते हैं तो GPU सर्वर (RTX 3090+)

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

```bash
ssh -p <PORT> root@<SERVER_IP>
```

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

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

```bash
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 लॉन्च करें

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

```bash
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 कंटेनर शुरू करें:

```bash
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 का उपयोग (अनुशंसित):**

```bash
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. सर्वर सत्यापित करें

```bash
# स्वास्थ्य जाँच करें
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 कॉल

```bash
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

```python
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 (प्रत्यक्ष)

```python
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: फॉलबैक कॉन्फ़िगरेशन

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

```yaml
# 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 सक्षम करने के बाद, खर्च विश्लेषण तक पहुँचें:

```bash
# उपयोगकर्ता द्वारा खर्च प्राप्त करें
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 कुंजियाँ)

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

```bash
# बजट के साथ एक कुंजी बनाएं
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"}
  }'
```

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

```yaml
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
```

### कैशिंग

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

### रेट लिमिटिंग

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

***

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

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

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

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

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

```python
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 पर भेजें:

```yaml
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. टाइमआउट्स और रिट्राइ सेट करें

```yaml
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`:

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

### समस्या: "authentication failed"

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

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

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

```bash
docker restart litellm
```

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

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

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

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

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

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

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

```yaml
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 मॉडल्स, प्रोडक्शन लोकल सर्विंग                              |

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

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

***

## लिंक

* [GitHub](https://github.com/BerriAI/litellm)
* [दस्तावेज़ीकरण](https://docs.litellm.ai)
* [Docker Hub / GHCR](https://github.com/BerriAI/litellm/pkgs/container/litellm)
* [समर्थित प्रदाता](https://docs.litellm.ai/docs/providers)
* [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace)