> 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/llama4.md).

# Llama 4 (Scout & Maverick)

Clore.ai GPUs पर Meta Llama 4 Scout & Maverick MoE मॉडल चलाएँ

Meta का Llama 4, अप्रैल 2025 में जारी, की ओर एक मूलभूत बदलाव का संकेत देता है **विशेषज्ञों का मिश्रण (MoE)** आर्किटेक्चर। हर टोकन के लिए सभी पैरामीटर सक्रिय करने के बजाय, Llama 4 प्रत्येक टोकन को विशेषीकृत "एक्सपर्ट" उप-नेटवर्क्स तक भेजता है — जिससे कंप्यूट लागत के एक अंश पर अत्याधुनिक प्रदर्शन मिलता है। दो ओपन-वेट मॉडल उपलब्ध हैं: **Scout** (एकल-GPU के लिए आदर्श) और **Maverick** (बहु-GPU का पावरहाउस)।

## मुख्य विशेषताएँ

* **MoE आर्किटेक्चर**: प्रति टोकन केवल 17B पैरामीटर सक्रिय (कुल 109B/400B में से)
* **विशाल कॉन्टेक्स्ट विंडोज़**: Scout 10M टोकन का समर्थन करता है, Maverick 1M टोकन का समर्थन करता है
* **मूल रूप से मल्टीमोडल**: बॉक्स से बाहर ही टेक्स्ट और इमेज दोनों को समझता है
* **दो मॉडल**: Scout (16 एक्सपर्ट, एकल-GPU के लिए अनुकूल) और Maverick (128 एक्सपर्ट, बहु-GPU)
* **प्रतिस्पर्धी प्रदर्शन**: Scout, Gemma 3 27B के बराबर है; Maverick, GPT-4o श्रेणी के मॉडल्स से मुकाबला करता है
* **ओपन वेट्स**: Llama Community License (अधिकांश व्यावसायिक उपयोगों के लिए मुफ़्त)

## मॉडल वेरिएंट

| मॉडल         | कुल पैरामीटर | सक्रिय पैरामीटर | एक्सपर्ट्स | संदर्भ | न्यूनतम VRAM (Q4) | न्यूनतम VRAM (FP16) |
| ------------ | ------------ | --------------- | ---------- | ------ | ----------------- | ------------------- |
| **Scout**    | 109B         | 17B             | 16         | 10M    | 12GB              | 80GB                |
| **Maverick** | 400B         | 17B             | 128        | 1M     | 48GB (मल्टी)      | 320GB (मल्टी)       |

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

| घटक   | Scout (Q4)  | Scout (FP16) | Maverick (Q4) |
| ----- | ----------- | ------------ | ------------- |
| GPU   | 1× RTX 4090 | 1× H100      | 4× RTX 4090   |
| VRAM  | 24GB        | 80GB         | 4×24GB        |
| RAM   | 32GB        | 64GB         | 128GB         |
| डिस्क | 50GB        | 120GB        | 250GB         |
| CUDA  | 12.8+       | 12.8+        | 12.8+         |

**अनुशंसित Clore.ai GPU**: Scout के लिए RTX 4090 24GB ($0.14–0.42/घंटा) — सबसे बेहतर मूल्य

## Ollama के साथ त्वरित शुरुआत

Llama 4 को चालू करने का सबसे तेज़ तरीका:

```bash
# Ollama इंस्टॉल करें
curl -fsSL https://ollama.com/install.sh | sh

# Scout चलाएँ (क्वांटाइज़्ड, ~12GB VRAM)
ollama run llama4-scout

# लंबे कॉन्टेक्स्ट के लिए (ज़्यादा VRAM का उपयोग करता है)
ollama run llama4-scout --ctx-size 32768
```

### API सर्वर के रूप में Ollama

```bash
# बैकग्राउंड में सर्वर शुरू करें
ollama serve &

# मॉडल डाउनलोड करें
ollama pull llama4-scout

# OpenAI-संगत API के माध्यम से क्वेरी करें
curl http://localhost:11434/v1/chat/completions \\
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama4-scout",
    "messages": [{"role": "user", "content": "MoE आर्किटेक्चर को 3 वाक्यों में समझाएँ"}]
  }'
```

## vLLM सेटअप (प्रोडक्शन)

उच्च throughput वाले प्रोडक्शन वर्कलोड के लिए:

```bash
# vLLM इंस्टॉल करें
pip install vllm

# सिंगल GPU पर Scout सर्व करें (क्वांटाइज़्ड)
vllm serve meta-llama/Llama-4-Scout-17B-16E-Instruct \\
  --max-model-len 32768 \\
  --gpu-memory-utilization 0.90

# 2 GPUs पर Scout सर्व करें (लंबा कॉन्टेक्स्ट)
vllm serve meta-llama/Llama-4-Scout-17B-16E-Instruct \\
  --tensor-parallel-size 2 \\
  --max-model-len 128000 \\
  --gpu-memory-utilization 0.90

# 4 GPUs पर Maverick सर्व करें
vllm serve meta-llama/Llama-4-Maverick-17B-128E-Instruct \\
  --tensor-parallel-size 4 \\
  --max-model-len 65536
```

### vLLM सर्वर को क्वेरी करें

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="meta-llama/Llama-4-Scout-17B-16E-Instruct",
    messages=[
        {"role": "system", "content": "आप एक सहायक सहायक हैं."},
        {"role": "user", "content": "Fibonacci संख्याओं की गणना करने के लिए एक Python फ़ंक्शन लिखें"}
    ],
    temperature=0.7,
    max_tokens=1024
)
print(response.choices[0].message.content)
```

## HuggingFace Transformers

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "meta-llama/Llama-4-Scout-17B-16E-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True  # 24GB GPUs के लिए 4-बिट क्वांटाइज़ेशन
)

messages = [
    {"role": "system", "content": "आप एक सहायक coding assistant हैं."},
    {"role": "user", "content": "FastAPI के साथ एक REST API लिखें जो todo सूची को प्रबंधित करे"}
]

input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
output = model.generate(input_ids, max_new_tokens=2048, temperature=0.7, do_sample=True)
print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True))
```

## Docker त्वरित शुरुआत

```bash
# vLLM Docker image का उपयोग करते हुए
docker run --gpus all -p 8000:8000 \\
  -v ~/.cache/huggingface:/root/.cache/huggingface \\
  vllm/vllm-openai:latest \
  --model meta-llama/Llama-4-Scout-17B-16E-Instruct \\
  --max-model-len 32768
```

## Clore.ai पर MoE क्यों महत्वपूर्ण है

पारंपरिक dense मॉडल (जैसे Llama 3.3 70B) को भारी VRAM चाहिए क्योंकि सभी 70B पैरामीटर सक्रिय होते हैं। Llama 4 Scout में कुल 109B हैं लेकिन प्रति टोकन केवल 17B सक्रिय होते हैं — यानी:

* **70B+ dense मॉडल्स जैसी ही गुणवत्ता** VRAM लागत के एक अंश पर
* **एक ही RTX 4090 पर फिट हो जाता है** क्वांटाइज़्ड मोड में
* **10M टोकन कॉन्टेक्स्ट** — पूरे कोडबेस, लंबे दस्तावेज़, किताबें प्रोसेस करें
* **किराए पर लेना सस्ता** — 70B मॉडल्स के लिए मल्टी-GPU रिग की बजाय $0.14–0.42/घंटा पर एक RTX 4090

## Clore.ai उपयोगकर्ताओं के लिए सुझाव

* **Scout Q4 से शुरू करें**: RTX 4090 पर पैसे का सबसे बेहतर मूल्य — $0.14–0.42/घंटा, 95% उपयोग-केस कवर करता है
* **उपयोग करें `--max-model-len` समझदारी से**: जितने कॉन्टेक्स्ट की ज़रूरत हो उससे ज़्यादा सेट न करें — यह VRAM आरक्षित करता है। 8192 से शुरू करें, आवश्यकता अनुसार बढ़ाएँ
* **Maverick के लिए Tensor Parallel**: Maverick के लिए 4× RTX 4090 मशीनें किराए पर लें; उपयोग करें `--tensor-parallel-size 4`
* **HuggingFace लॉगिन आवश्यक**: `huggingface-cli login` — आपको पहले HF पर Llama लाइसेंस स्वीकार करना होगा
* **त्वरित परीक्षणों के लिए Ollama, उत्पादन के लिए vLLM**: Ollama सेटअप करने में तेज़ है; vLLM API सर्विंग के लिए अधिक throughput देता है
* **GPU मेमोरी मॉनिटर करें**: `nvidia-smi देखें` — MoE मॉडल लंबे सीक्वेंस पर VRAM में स्पाइक कर सकते हैं

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

| समस्या                             | समाधान                                                                                            |
| ---------------------------------- | ------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError`                 | कम करें `--max-model-len`, Q4 क्वांटाइज़ेशन का उपयोग करें, या GPU अपग्रेड करें                    |
| मॉडल डाउनलोड विफल होता है          | चलाएँ `huggingface-cli login` और hf.co पर Llama 4 लाइसेंस स्वीकार करें                            |
| धीमी जनरेशन                        | सुनिश्चित करें कि GPU उपयोग में है (`nvidia-smi`); जांचें `--gpu-memory-utilization`              |
| स्टार्टअप पर vLLM क्रैश हो जाता है | कॉन्टेक्स्ट लंबाई कम करें; सुनिश्चित करें कि CUDA 11.8+ इंस्टॉल है                                |
| Ollama गलत मॉडल दिखाता है          | चलाएँ `सत्यापित करने के लिए ollama list` कि; `ollama rm` + `ollama pull` पुनः डाउनलोड करने के लिए |

## अधिक पढ़ें

* [Meta Llama 4 ब्लॉग पोस्ट](https://llama.meta.com/)
* [HuggingFace मॉडल कार्ड](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E-Instruct)
* [vLLM दस्तावेज़ीकरण](https://docs.vllm.ai/)
* [Ollama मॉडल लाइब्रेरी](https://ollama.com/library/llama4-scout)


---

# 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/llama4.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.