# Llama 4 (Scout & Maverick)

Meta का Llama 4, अप्रैल 2025 में जारी, एक मौलिक बदलाव को दर्शाता है **विशेषज्ञों का मिश्रण (Mixture of Experts, 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  | 11.8+       | 12.0+        | 12.0+         |

**अनुशंसित Clore.ai GPU**: RTX 4090 24GB (\~$0.5–2/दिन) Scout के लिए — सर्वोत्तम मूल्य

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

### Ollama को API सर्वर के रूप में उपयोग करना

```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 सेटअप (प्रोडक्शन)

उच्च थ्रूपुट वाले प्रोडक्शन वर्कलोड के लिए:

```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": "You are a helpful assistant."},
        {"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": "आप एक सहायक कोडिंग असिस्टेंट हैं."},
    {"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 इमेज का उपयोग करते हुए
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 क्यों मायने रखता है

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

* **70B+ डेंस मॉडलों जैसा ही गुणवत्ता** VRAM लागत के एक हिस्से पर
* **एकल RTX 4090 पर फिट होता है** क्वांटाइज़्ड मोड में
* **10M टोकन संदर्भ** — पूरा कोडबेस, लंबे दस्तावेज़, पुस्तकें प्रोसेस करें
* **किराए पर सस्ता** — $0.5–2/दिन के बजाय 70B मॉडलों के लिए $6–12/दिन

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

* **Scout Q4 से शुरू करें**: RTX 4090 पर कीमत के लिहाज से सर्वश्रेष्ठ — $0.5–2/दिन, 95% उपयोग मामलों को कवर करता है
* **उपयोग करें `--max-model-len` सावधानी से**: आवश्यकता से अधिक संदर्भ सेट न करें — यह VRAM आरक्षित करता है। 8192 से शुरू करें, आवश्यकतानुसार बढ़ाएँ
* **Maverick के लिए टेन्सर पैरालल**: Maverick के लिए 4× RTX 4090 मशीनें किराए पर लें; उपयोग करें `--tensor-parallel-size 4`
* **HuggingFace लॉगिन आवश्यक**: `huggingface-cli login` — पहले आपको HF पर Llama लाइसेंस स्वीकार करना होगा
* **त्वरित टेस्ट के लिए Ollama, प्रोडक्शन के लिए vLLM**: Ollama सेटअप में तेज़ है; vLLM API सर्विंग के लिए उच्च थ्रूपुट देता है
* **GPU मेमोरी की निगरानी करें**: `watch 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: 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:

```
GET https://docs.clore.ai/guides/guides_v2-hi/language-models/llama4.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.