> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/language-models/mlc-llm.md).

# MLC-LLM

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

> 🌟 **20,000+ GitHub स्टार्स** | MLC AI टीम द्वारा अनुरक्षित | Apache-2.0 लाइसेंस

***

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

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

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

* **सार्वभौमिक हार्डवेयर समर्थन** — NVIDIA CUDA, AMD ROCm, Apple Metal, Vulkan, WebGPU
* **OpenAI-संगत REST API** — मौजूदा वर्कफ़्लो के लिए बिना बदलाव वाला प्रतिस्थापन
* **कई मॉडल प्रारूप** — Llama, Mistral, Gemma, Phi, Qwen, Falcon, और भी बहुत कुछ
* **4-बिट / 8-बिट क्वांटीकरण** — उपभोक्ता GPU पर बड़े मॉडल चलाएँ
* **चैट इंटरफ़ेस** — तुरंत परीक्षण के लिए अंतर्निर्मित वेब 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.8.1-devel-ubuntu22.04` Clore.ai पर अपने बेस इमेज के रूप में।
{% endhint %}

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

```
Docker इमेज: nvidia/cuda:12.8.1-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": "आप एक सहायक सहायक हैं."},
        {"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 का हेडरूम छोड़ें। `q4f16_1` 7B मॉडल को सामान्य वर्कलोड पर कुल मिलाकर लगभग 6–7GB की आवश्यकता होती है।
{% endhint %}

***

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

कई GPUs की आवश्यकता वाले बड़े मॉडलों (70B+) के लिए:

```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"थ्रूपुट: {tokens/elapsed:.1f} tokens/sec")
```

***

## Docker Compose सेटअप

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

```yaml
version: '3.8'
services:
  mlc-llm:
    image: nvidia/cuda:12.8.1-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.8 सर्वरों के लिए, इंस्टॉल करें:
pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121

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

{% hint style="danger" %}
**आम गलती:** MLC-LLM pip wheels CUDA संस्करण-विशिष्ट होते हैं। सुनिश्चित करें कि अपने सर्वर के CUDA संस्करण से मेल खाने वाला सही वैरिएंट इंस्टॉल करें। उपलब्ध wheels यहाँ देखें [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.07–0.21/hr                             | 7B–13B मॉडल, बजट सर्विंग  | \~85 tok/s              |
| RTX 4090  | 24 GB | $0.14–0.42/hr                             | 7B–34B मॉडल, तेज़ सर्विंग | \~140 tok/s             |
| A100 40GB | 40 GB | [bare metal](https://clore.ai/bare-metal) | 34B–70B, प्रोडक्शन API    | \~110 tok/s             |
| A100 80GB | 80 GB | [bare metal](https://clore.ai/bare-metal) | 70B+, बहु-मॉडल सर्विंग    | \~130 tok/s             |
| H100 SXM  | 80 GB | \~$1.04/घंटा                              | अधिकतम थ्रूपुट, FP8       | \~280 tok/s             |

**अनुशंसित प्रारंभिक बिंदु:** $0.07–0.21/घंटा पर RTX 3090, MLC-LLM के माध्यम से Llama 3 8B और Mistral 7B सर्विंग के लिए मूल्य-प्रदर्शन अनुपात के लिहाज़ से सबसे अच्छा है। संकलित कर्नेल्स उपभोक्ता GPUs से लगभग-अधिकतम उपयोगिता निकालते हैं।

70B मॉडलों के लिए (उदा., Llama 3 70B Q4): A100 40GB ([bare metal](https://clore.ai/bare-metal)) या tensor parallelism के माध्यम से दो 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:** [discord.gg/9Xpy2HGBuD](https://discord.gg/9Xpy2HGBuD)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/language-models/mlc-llm.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.