# MLC-LLM

**एमएल कम्पाइलेशन के माध्यम से सार्वभौमिक LLM परिनियोजन** — मशीन लर्निंग कम्पाइलेशन का उपयोग करके किसी भी हार्डवेयर पर किसी भी बड़े लैंग्वेज मॉडल को अधिकतम प्रदर्शन के साथ चलाएँ।

> 🌟 **20,000+ GitHub स्टार्स** | MLC AI टीम द्वारा मेंटained | Apache-2.0 लाइसेंस

***

## MLC-LLM क्या है?

MLC-LLM (Machine Learning Compilation for Large Language Models) एक सार्वभौमिक फ्रेमवर्क है जो विविध हार्डवेयर बैकएंड्स पर बड़े लैंग्वेज मॉडलों के कुशल परिनियोजन को सक्षम बनाता है। का लाभ उठाकर **TVM (Tensor Virtual Machine)** अपनी कम्पाइलेशन बैकएंड के रूप में, MLC-LLM LLM मॉडलों को सीधे नेटिव हार्डवेयर कोड में कम्पाइल करता है — बिना हार्डवेयर-विशेष इंजीनियरिंग के लगभग अनुकूल प्रदर्शन प्राप्त करता है।

### मुख्य क्षमताएँ

* **सर्वव्यापी हार्डवेयर समर्थन** — NVIDIA CUDA, AMD ROCm, Apple Metal, Vulkan, WebGPU
* **OpenAI-अनुकूल REST API** — मौजूदा वर्कफ़्लो के लिए ड्रॉप-इन रिप्लेसमेंट
* **कई मॉडल फ़ॉर्मैट** — Llama, Mistral, Gemma, Phi, Qwen, Falcon, और अधिक
* **4-बिट / 8-बिट क्वांटाइजेशन** — उपभोक्ता GPUs पर बड़े मॉडल चलाएँ
* **चैट इंटरफ़ेस** — त्वरित परीक्षण के लिए बिल्ट-इन वेब UI
* **Python और CLI टूल्स** — लचीले एकीकरण विकल्प

### Clore.ai पर MLC-LLM क्यों उपयोग करें?

Clore.ai GPU मार्केटप्लेस आपको प्रतियोगी किराये की दरों पर उच्च-प्रदर्शन NVIDIA GPUs तक पहुँच देता है। MLC-LLM की कम्पाइलेशन अप्रोच प्रत्येक GPU से अधिकतम थ्रुपुट निकालती है — जिससे यह आदर्श है:

* स्केल पर प्रोडक्शन API इनफेरेंस
* मॉडल आकारों के पार रिसर्च और बेंचमार्किंग
* क्वांटाइज़्ड मॉडलों के साथ लागत-कुशल सर्विंग
* एक ही GPU इंस्टेंस पर मल्टी-मॉडल परिनियोजन

***

## Clore.ai पर शीघ्र आरम्भ

### चरण 1: एक GPU सर्वर खोजें

1. जाएँ [clore.ai](https://clore.ai) मार्केटप्लेस
2. सर्वरों को फ़िल्टर करें: **NVIDIA GPU**，न्यूनतम **8GB VRAM** (7B+ मॉडलों के लिए 16GB+ अनुशंसित)
3. इष्टतम प्रदर्शन के लिए: RTX 3090, RTX 4090, A100, या H100

### चरण 2: MLC-LLM परिनियोजित करें

{% hint style="info" %}
**नोट:** MLC-LLM Docker Hub पर आधिकारिक प्री-बिल्ट Docker इमेज प्रकाशित नहीं करता। अनुशंसित परिनियोजन दृष्टिकोण यह है कि NVIDIA CUDA बेस इमेज का उपयोग करें और pip के माध्यम से MLC-LLM इंस्टॉल करें। उपयोग करें `nvidia/cuda:12.1.0-devel-ubuntu22.04` को अपने Clore.ai बेस इमेज के रूप में।
{% endhint %}

Clore.ai ऑर्डर कॉन्फ़िगरेशन में NVIDIA CUDA बेस इमेज का उपयोग करें:

```
Docker Image: nvidia/cuda:12.1.0-devel-ubuntu22.04
```

**पोर्ट मैपिंग्स:**

| कंटेनर पोर्ट | उद्देश्य       |
| ------------ | -------------- |
| `22`         | SSH पहुंच      |
| `8000`       | REST API सर्वर |

**अनुशंसित पर्यावरण चर:**

```
MLC_MODEL=HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC
MLC_HOST=0.0.0.0
MLC_PORT=8000
```

**स्टार्टअप स्क्रिप्ट** (SSH के बाद चलाएँ):

```bash
pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121
```

### चरण 3: SSH के जरिए कनेक्ट करें

```bash
ssh root@<clore-node-ip> -p <assigned-ssh-port>
```

***

## स्थापन और सेटअप

### विकल्प A: प्री-कम्पाइल्ड मॉडल का उपयोग करें (सबसे तेज)

MLC-AI Hugging Face पर प्री-कम्पाइल्ड मॉडलों का पुस्तकालय रखता है। किसी कम्पाइलेशन की आवश्यकता नहीं:

```bash
# एक प्री-कम्पाइल्ड Llama 3 8B (4-बिट क्वांटाइज़्ड) खींचें और चलाएँ
python -m mlc_llm serve HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \
  --port 8000
```

### विकल्प B: अपना स्वयं का मॉडल कम्पाइल करें

कस्टम मॉडलों या विशिष्ट क्वांटाइज़ेशन आवश्यकताओं के लिए:

```bash
# चरण 1: मॉडल वेट्स को कन्वर्ट करें
python -m mlc_llm convert_weight \
  ./path/to/model \
  --quantization q4f16_1 \
  --output ./compiled/model-q4f16_1

# चरण 2: मॉडल कॉन्फ़िगरेशन जनरेट करें
python -m mlc_llm gen_config \
  ./path/to/model \
  --quantization q4f16_1 \
  --conv-template llama-3 \
  --output ./compiled/model-q4f16_1

# चरण 3: मॉडल कम्पाइल करें
python -m mlc_llm compile \
  ./compiled/model-q4f16_1/mlc-chat-config.json \
  --device cuda \
  --output ./compiled/model-q4f16_1/lib.so
```

{% hint style="info" %}
**कम्पाइलेशन समय:** एक 7B मॉडल को पहली बार चलाते समय आम तौर पर कम्पाइल करने में 10–30 मिनट लगते हैं। कम्पाइल किए गए आर्टिफैक्ट्स कैश किए जाते हैं और बाद के लॉन्च पर पुन: प्रयुक्त होते हैं।
{% endhint %}

***

## API सर्वर चलाना

### OpenAI-अनुकूल सर्वर प्रारम्भ करें

```bash
python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \
  --port 8000 \
  --max-batch-size 4 \
  --max-total-sequence-length 8192
```

### सर्वर स्टार्टअप आउटपुट

```
[2024-01-01 12:00:00] INFO: HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC से मॉडल लोड किया जा रहा है
[2024-01-01 12:00:15] INFO: मॉडल सफलतापूर्वक लोड हो गया
[2024-01-01 12:00:15] INFO: सर्वर 0.0.0.0:8000 पर शुरू हो रहा है
[2024-01-01 12:00:15] INFO: OpenAI-अनुकूल API http://0.0.0.0:8000/v1 पर उपलब्ध है
```

### उपलब्ध API एंडपॉइंट्स

| एंडपॉइंट                     | विधि | विवरण                           |
| ---------------------------- | ---- | ------------------------------- |
| `/v1/chat/completions`       | POST | चैट कंप्लीशंस (OpenAI फ़ॉर्मैट) |
| `/v1/completions`            | POST | टेक्स्ट कंप्लीशंस               |
| `/v1/models`                 | GET  | उपलब्ध मॉडलों की सूची बनाएँ     |
| `/v1/debug/dump_event_trace` | GET  | प्रदर्शन डिबगिंग                |

***

## API उपयोग उदाहरण

### चैट कंप्लीशंस (Python)

```python
from openai import OpenAI

# अपने Clore.ai सर्वर की ओर पॉइंट करें
client = OpenAI(
    base_url="http://<clore-node-ip>:<api-port>/v1",
    api_key="none"  # डिफ़ॉल्ट रूप से MLC-LLM को ऑथ की आवश्यकता नहीं है
)

response = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "साधारण शब्दों में क्वांटम कंप्यूटिंग समझाइए."}
    ],
    temperature=0.7,
    max_tokens=512
)

print(response.choices[0].message.content)
```

### स्ट्रीमिंग प्रतिक्रिया

```python
stream = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[{"role": "user", "content": "AI के बारे में एक छोटी कहानी लिखें."}],
    stream=True,
    max_tokens=1024
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

### cURL उदाहरण

```bash
curl http://<clore-node-ip>:<api-port>/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Llama-3-8B-Instruct-q4f16_1-MLC",
    "messages": [
      {"role": "user", "content": "2+2 क्या है?"}
    ],
    "temperature": 0.7,
    "max_tokens": 100
  }'
```

***

## उपलब्ध प्री-कम्पाइल्ड मॉडल

MLC-AI Hugging Face पर रेडी-टू-यूज़ कम्पाइल्ड मॉडल प्रदान करता है:

### Llama 3 सीरीज़

```bash
# 8B Instruct (अधिकांश उपयोग मामलों के लिए अनुशंसित)
HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC

# 70B Instruct (40GB+ VRAM या मल्टी-GPU की आवश्यकता)
HF://mlc-ai/Llama-3-70B-Instruct-q4f16_1-MLC
```

### Mistral / Mixtral

```bash
HF://mlc-ai/Mistral-7B-Instruct-v0.3-q4f16_1-MLC
HF://mlc-ai/Mixtral-8x7B-Instruct-v0.1-q4f16_1-MLC
```

### Gemma

```bash
HF://mlc-ai/gemma-2b-it-q4f16_1-MLC
HF://mlc-ai/gemma-7b-it-q4f16_1-MLC
```

### Phi

```bash
HF://mlc-ai/phi-2-q4f16_1-MLC
HF://mlc-ai/Phi-3-mini-4k-instruct-q4f16_1-MLC
```

{% hint style="success" %}
**पूर्ण मॉडल सूची:** सभी प्री-कम्पाइल्ड मॉडलों को ब्राउज़ करें: [huggingface.co/mlc-ai](https://huggingface.co/mlc-ai)
{% endhint %}

***

## क्वांटाइज़ेशन विकल्प

MLC-LLM कई क्वांटाइज़ेशन स्कीम्स का समर्थन करता है। अपने VRAM बजट के आधार पर चुनें:

| क्वांटाइजेशन | बिट्स                    | गुणवत्ता | VRAM (7B) | VRAM (13B) |
| ------------ | ------------------------ | -------- | --------- | ---------- |
| `q4f16_1`    | 4-बिट                    | ★★★★☆    | \~4GB     | \~7GB      |
| `q4f32_1`    | 4-बिट (f32 एक्यूम)       | ★★★★☆    | \~4GB     | \~7GB      |
| `q8f16_1`    | 8-बिट                    | ★★★★★    | \~8GB     | \~14GB     |
| `q0f16`      | 16-बिट (कोई क्वांट नहीं) | ★★★★★    | \~14GB    | \~26GB     |
| `q0f32`      | 32-बिट (कोई क्वांट नहीं) | ★★★★★    | \~28GB    | \~52GB     |

{% hint style="warning" %}
**VRAM अनुशंसा:** CUDA ओवरहेड और KV कैश के लिए हमेशा 2–3GB हेडरूम छोड़ें। एक 7B मॉडल के साथ `q4f16_1` आम वर्कलोड पर कुल लगभग 6–7GB की आवश्यकता होती है।
{% endhint %}

***

## मल्टी-GPU परिनियोजन

बड़े मॉडलों (70B+) के लिए जो मल्टी-GPU की आवश्यकता रखते हैं:

```bash
# 2 GPUs पर टेन्सर पैरेललिज़्म सक्षम करें
python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-70B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \
  --port 8000 \
  --tensor-parallel-shards 2
```

परिनियोजन से पहले GPU टोपोलॉजी जांचें:

```bash
nvidia-smi topo -m  # NVLink/PCIe कनेक्टिविटी जांचें
```

{% hint style="info" %}
**सबसे अच्छा प्रदर्शन:** मल्टी-GPU NVLink से जुड़े कार्ड्स (जैसे A100 80GB SXM जोड़े) के साथ सबसे अच्छा काम करता है। PCIe-से जुड़े GPUs बड़े मॉडलों पर बॉटलनेक्स दिखाएँगे।
{% endhint %}

***

## वेब चैट इंटरफ़ेस

MLC-LLM में एक बिल्ट-इन वेब UI शामिल है जो सर्वर चलने पर पहुँचा जा सकता है:

```bash
# वेब UI सक्षम करके सर्वर शुरू करें
python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \
  --port 8000 \
  --enable-debug  # वैकल्पिक: डिबग एंडपॉइंट सक्षम करता है
```

UI पर पहुँचें: `http://<clore-node-ip>:<api-port>`

***

## प्रदर्शन ट्यूनिंग

### बैच साइज का अनुकूलन करें

```bash
# उच्च थ्रुपुट के लिए बैच साइज बढ़ाएँ (अधिक VRAM की आवश्यकता होती है)
python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \
  --port 8000 \
  --max-batch-size 8 \
  --max-total-sequence-length 16384 \
  --prefill-chunk-size 2048
```

### GPU उपयोग की निगरानी करें

```bash
# एक अलग टर्मिनल में
watch -n 1 nvidia-smi

# और अधिक विस्तृत मॉनिटरिंग
nvidia-smi dmon -s u  # उपयोगिता मेट्रिक्स का स्ट्रीमिंग
```

### थ्रुपुट का बेंचमार्क करें

```python
import time
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="none")

start = time.time()
response = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[{"role": "user", "content": "1 से 100 तक गिनती करें"}],
    max_tokens=512
)
elapsed = time.time() - start

tokens = response.usage.completion_tokens
print(f"Throughput: {tokens/elapsed:.1f} tokens/sec")
```

***

## Docker Compose सेटअप

Clore.ai पर उत्पादन-तैयार परिनियोजन के लिए NVIDIA CUDA बेस इमेज के साथ और pip के माध्यम से MLC-LLM इंस्टॉल करके:

```yaml
version: '3.8'
services:
  mlc-llm:
    image: nvidia/cuda:12.1.0-devel-ubuntu22.04
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    ports:
      - "8000:8000"
    volumes:
      - ./models:/root/models
      - mlc-cache:/root/.cache/mlc_llm
    command: >
      bash -c "pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121 &&
      python -m mlc_llm serve
      HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC
      --host 0.0.0.0
      --port 8000
      --max-batch-size 4"
    restart: unless-stopped

volumes:
  mlc-cache:
```

***

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

### मॉडल डाउनलोड विफल

```bash
# इंटरनेट कनेक्टिविटी जांचें
curl -I https://huggingface.co

# huggingface-cli के साथ मैन्युअली डाउनलोड करें
pip install huggingface_hub
huggingface-cli download mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC
```

### मेमोरी खत्म (OOM)

```bash
# संदर्भ लंबाई कम करें
python -m mlc_llm serve MODEL \
  --max-total-sequence-length 4096  # डिफ़ॉल्ट से घटाएँ

# अधिक आक्रामक क्वांटाइज़ेशन का उपयोग करें
# q8f16_1 से q4f16_1 पर स्विच करें
```

### CUDA संस्करण मेल नहीं खाता

```bash
# CUDA संस्करण जांचें
nvcc --version
nvidia-smi | grep CUDA

# CUDA 12.1 सर्वरों के लिए, इंस्टॉल करें:
pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121

# CUDA 12.2+ सर्वरों के लिए, इंस्टॉल करें:
pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu122 mlc-ai-nightly-cu122
```

{% hint style="danger" %}
**सामान्य चिंता:** MLC-LLM pip व्हील्स CUDA-версन विशिष्ट होते हैं। सुनिश्चित करें कि आपने अपने सर्वर की CUDA वर्शन से मेल खाता सही वेरिएंट इंस्टॉल किया है। उपलब्ध व्हील्स जांचें: [mlc.ai/wheels](https://mlc.ai/wheels).
{% endhint %}

### सर्वर पहुँच योग्य नहीं

```bash
# जांचें कि पोर्ट सुन रहा है
ss -tlnp | grep 8000

# फ़ायरवाल जांचें
iptables -L -n | grep 8000

# पहले स्थानीय रूप से परीक्षण करें
curl http://localhost:8000/v1/models
```

***

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

MLC-LLM की कम्पाइलेशन अप्रोच प्रत्येक GPU टियर पर लगभग अनुकूल थ्रुपुट देती है। मॉडल आकार और बजट के आधार पर चुनें:

| GPU       | VRAM  | Clore.ai कीमत | माध्य/दिन                 | थ्रुपुट (Llama 3 8B Q4) |
| --------- | ----- | ------------- | ------------------------- | ----------------------- |
| RTX 3090  | 24 GB | \~$0.12/घंटा  | 7B–13B मॉडल, बजट सर्विंग  | \~85 tok/s              |
| RTX 4090  | 24 GB | \~$0.70/घंटा  | 7B–34B मॉडल, तेज़ सर्विंग | \~140 tok/s             |
| A100 40GB | 40 GB | \~$1.20/घंटा  | 34B–70B, प्रोडक्शन API    | \~110 tok/s             |
| A100 80GB | 80 GB | \~$2.00/घंटा  | 70B+, मल्टी-मॉडल सर्विंग  | \~130 tok/s             |
| H100 SXM  | 80 GB | \~$3.50/hr    | अधिकतम थ्रुपुट, FP8       | \~280 tok/s             |

**अनुशंसित शुरुआत बिंदु:** RTX 3090 लगभग \~$0.12/hr पर Llama 3 8B और Mistral 7B सर्विंग के लिए सर्वश्रेष्ठ कीमत-प्रदर्शन अनुपात है जब MLC-LLM के माध्यम से उपयोग किया जाए। कम्पाइल्ड कर्नेल उपभोक्ता GPUs से लगभग अधिकतम उपयोगिता निकालते हैं।

70B मॉडलों (उदा., Llama 3 70B Q4) के लिए: A100 40GB (\~$1.20/hr) या टेन्सर पैरेललिज़्म के माध्यम से दो RTX 3090s का उपयोग करें।

***

## संसाधन

* 📦 **Pip व्हील्स:** [mlc.ai/wheels](https://mlc.ai/wheels) (pip के माध्यम से इंस्टॉल करें, Docker Hub इमेज उपलब्ध नहीं है)
* 🐙 **GitHub:** [github.com/mlc-ai/mlc-llm](https://github.com/mlc-ai/mlc-llm)
* 📚 **डॉक्यूमेंटेशन:** [llm.mlc.ai/docs](https://llm.mlc.ai/docs)
* 🤗 **प्री-कम्पाइल्ड मॉडल्स:** [huggingface.co/mlc-ai](https://huggingface.co/mlc-ai)
* 💬 **डिसकोर्ड:** [discord.gg/9Xpy2HGBuD](https://discord.gg/9Xpy2HGBuD)