> 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/gemma4.md). # Gemma 4 (26B MoE, 4B सक्रिय) {% hint style="info" %} **स्थिति (अप्रैल 2026):** Gemma 4 को जारी किया गया था **2 अप्रैल, 2026** को Google द्वारा Gemma ओपन-वेट परिवार की अगली पीढ़ी के रूप में। दो वेरिएंट उपलब्ध हैं: एक **31B डेंस** मॉडल (`google/gemma-4-31b-it`) और एक **26B MoE, लगभग 4B सक्रिय पैरामीटर के साथ** (`google/gemma-4-26b-it`). दोनों को मानक **Gemma उपयोग शर्तों** के अंतर्गत [huggingface.co/google/gemma-4-26b-it](https://huggingface.co/google/gemma-4-26b-it) और [huggingface.co/google/gemma-4-31b-it](https://huggingface.co/google/gemma-4-31b-it). {% endhint %} पर प्रकाशित किया गया है। Gemma 4, Gemma लाइन में Google की पहली MoE प्रविष्टि है और पहली Gemma रिलीज़ है जो LMSYS Arena के शीर्ष तक पहुँची (विक्रेता रिपोर्टें **रिलीज़ पर कुल #3**बताती हैं, और तथ्यात्मकता तथा निर्देश-पालन में कई बंद मॉडलों को पीछे छोड़ती हैं)। मुख्य संख्या MoE वेरिएंट की है: **कुल 26B पैरामीटर, प्रति टोकन लगभग 4B सक्रिय**जो आपको छोटे डेंस मॉडल की इनफरेंस लागत पर लगभग फ्रंटियर-स्तर का निर्देश-पालन देता है। Clore.ai उपयोगकर्ताओं के लिए व्यावहारिक निष्कर्ष सरल है — 26B MoE एक अकेले **RTX 4090 (24GB)** पर FP8 या 4-बिट क्वांटाइज़ेशन के साथ आराम से चलता है (\~10 tok/s) और एक अकेले **H100 80GB** पर प्रोडक्शन-ग्रेड थ्रूपुट (\~40+ tok/s) देता है, जिससे Gemma-स्तरीय निर्देश-पालन मार्केटप्लेस पर लगभग $0.5–2/दिन की लागत में संभव हो जाता है। 31B डेंस वेरिएंट अधिक सक्षम लेकिन अधिक महंगा भाई है, जिसे सर्व करने के लिए 2× RTX 4090 या 1× H100 चाहिए। ## मुख्य विशेषताएँ * **MoE आर्किटेक्चर (26B वेरिएंट)** — 26B कुल पैरामीटर, प्रति टोकन लगभग 4B सक्रिय; 26B-श्रेणी की गुणवत्ता के लिए 4B-श्रेणी की इनफरेंस लागत चुकाएँ * **डेंस विकल्प (31B वेरिएंट)** — उन टीमों के लिए जो डेंस इनफरेंस की पूर्वानुमेयता और टूलिंग की परिपक्वता पसंद करती हैं * **128K कॉन्टेक्स्ट विंडो** — लंबे दस्तावेज़ों पर Q\&A, मध्यम आकार के कोडबेस पर RAG, मल्टी-टर्न एजेंट लूप * **मजबूत निर्देश-पालन** — Gemma 4 को खास तौर पर टूल उपयोग, संरचित आउटपुट, और बाधाओं का निष्ठापूर्वक पालन करने के लिए ट्यून किया गया है * **बहुभाषी** — Gemma 3 की पूरी बहुभाषी कवरेज आगे लाई गई है, साथ ही एक विस्तारित गैर-अंग्रेज़ी बेंचमार्क सूट * **ओपन वेट्स, Gemma शर्तें** — अधिकांश व्यावसायिक उपयोग के लिए मुफ़्त; आगे बढ़ाने से पहले [Gemma निषिद्ध उपयोग नीति](https://ai.google.dev/gemma/prohibited_use_policy) की समीक्षा करें * **प्रथम श्रेणी टूलिंग** — vLLM, SGLang, Ollama, और Hugging Face Transformers में डिफ़ॉल्ट रूप से समर्थित ## अपना वेरिएंट चुनें | वेरिएंट | कुल पैरामीटर | सक्रिय | कॉन्टेक्स्ट | अनुशंसित क्वांट | अनुशंसित Clore GPU | | ---------------------------------------- | ------------ | --------------- | ----------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------- | | **Gemma 4 26B MoE** (`gemma-4-26b-it`) | 26B | \~4B प्रति टोकन | 128K | FP8 या 4-बिट GPTQ | 1× [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=gemma4) (24GB, क्वांटाइज़्ड) | | **Gemma 4 31B Dense** (`gemma-4-31b-it`) | 31B | 31B (सभी) | 128K | FP8 या BF16 | 1× [H100](https://clore.ai/rent-h100.html?utm_source=docs\&utm_medium=guide\&utm_campaign=gemma4) (80GB, BF16) | {% hint style="success" %} **व्यावहारिक चयन:** 90% सिंगल-GPU डिप्लॉयमेंट्स के लिए **Gemma 4 26B MoE on FP8**चुनें। आपको 4090 पर \~10–15 tok/s और H100 पर \~40+ tok/s के साथ Arena-स्तरीय गुणवत्ता मिलेगी, बिना डेंस 31B इनफरेंस की लेटेंसी लागत के। {% endhint %} *** ## सर्वर आवश्यकताएँ | घटक | 26B MoE (4-बिट, 4090) | 26B MoE (FP8, H100) | 31B Dense (BF16, H100) | | ---------- | ----------------------- | ------------------- | ---------------------- | | GPU VRAM | 24GB | 80GB | 80GB | | सिस्टम RAM | 32GB | 64GB | 64GB | | डिस्क | 60GB NVMe | 80GB NVMe | 90GB NVMe | | नेटवर्क | HF pull के लिए 100 Mbps | 1 Gbps बेहतर | 1 Gbps बेहतर | | CUDA | 12.1+ | 12.4+ | 12.4+ | | ड्राइवर | 550+ | 555+ | 555+ | लंबे कॉन्टेक्स्ट में KV cache को संभालने के लिए स्थिर वेट फुटप्रिंट के ऊपर लगभग 20% अतिरिक्त VRAM हेडरूम की योजना बनाएँ। `--gpu-memory-utilization 0.90` को vLLM में सेट करना एक अच्छा डिफ़ॉल्ट है। *** ## CLORE.AI पर त्वरित डिप्लॉय सबसे तेज़ रास्ता: एक अकेला GPU किराए पर लें, मानक `vllm/vllm-openai` इमेज खींचें, और मॉडल को OpenAI-संगत API के साथ सर्व करें। नीचे वह docker-compose लेआउट है जिसका उपयोग इन गाइड्स के बाकी हिस्सों में किया गया है — ऊपर चुने गए वेरिएंट के आधार पर मॉडल नाम और tensor-parallel आकार समायोजित करें। ### विकल्प A — एक अकेले GPU पर Gemma 4 26B MoE (vLLM, FP8) ```yaml version: "3.8" services: vllm: image: vllm/vllm-openai:latest ports: - "8000:8000" environment: - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN} volumes: - hf_cache:/root/.cache/huggingface command: > --model google/gemma-4-26b-it --quantization fp8 --max-model-len 32768 --gpu-memory-utilization 0.90 --served-model-name gemma-4-26b --trust-remote-code deploy: resources: reservations: devices: - driver: nvidia count: 1 capabilities: [gpu] shm_size: "8gb" volumes: hf_cache: ``` ```bash # इसे शुरू करें HF_TOKEN=hf_xxx docker compose up -d # वेट्स डाउनलोड होते समय लॉग्स देखें docker compose logs -f vllm ``` {% hint style="info" %} **लाइसेंस गेटिंग:** Hugging Face पर Gemma मॉडल के लिए प्रति खाते Google की शर्तों को एक बार स्वीकार करना आवश्यक है। ब्राउज़र में मॉडल पेज पर जाएँ, "Acknowledge license" पर क्लिक करें, फिर `HF_TOKEN` export करें ताकि कंटेनर वेट्स खींच सके। {% endhint %} ### विकल्प B — H100 पर Gemma 4 31B Dense (vLLM, BF16) ```bash docker run --gpus all -p 8000:8000 \ -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --ipc=host \ vllm/vllm-openai:latest \ --model google/gemma-4-31b-it \ --dtype bfloat16 \ --max-model-len 32768 \ --gpu-memory-utilization 0.90 \ --served-model-name gemma-4-31b ``` ### विकल्प C — 2× RTX 4090 पर Gemma 4 31B Dense (FP8, tensor-parallel) ```bash docker run --gpus all -p 8000:8000 \ -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --ipc=host \ vllm/vllm-openai:latest \ --model google/gemma-4-31b-it \ --quantization fp8 \ --tensor-parallel-size 2 \ --max-model-len 16384 \ --gpu-memory-utilization 0.90 \ --served-model-name gemma-4-31b ``` ### विकल्प D — Ollama के साथ त्वरित स्थानीय परीक्षण लैपटॉप-स्तरीय प्रयोग के लिए, Ollama GGUF समुदाय बिल्ड्स को रैप करता है। अपेक्षा करें कि क्वांट्स आधिकारिक रिलीज़ के कुछ दिनों बाद उपलब्ध होंगे। ```bash # एक बार जब समुदाय GGUF प्रकाशित हो जाए ollama pull gemma4:26b-moe-q4_k_m ollama run gemma4:26b-moe-q4_k_m # :11434 पर OpenAI-संगत API curl http://localhost:11434/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "gemma4:26b-moe-q4_k_m", "messages": [{"role":"user","content":"दो वाक्यों में MoE रूटिंग दृष्टिकोण का सार बताइए."}] }' ``` देखें [Ollama गाइड](/guides/guides_v2-hi/language-models/ollama.md) सामान्य सेटअप, मॉडल प्रबंधन, और persistence सुझावों के लिए। *** ## उपयोग उदाहरण vLLM कंटेनर एक OpenAI-संगत API को `:8000`पर एक्सपोज़ करता है। जो कुछ भी OpenAI chat-completions schema बोलता है, वह सीधे काम करता है। ### Curl chat completion ```bash curl http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "gemma-4-26b", "messages": [ {"role": "system", "content": "आप एक सावधान तकनीकी लेखक हैं."}, {"role": "user", "content": "उपमाओं का उपयोग किए बिना MoE रूटिंग को तीन वाक्यों में समझाइए."} ], "max_tokens": 512, "temperature": 0.7 }' ``` ### Python (OpenAI क्लाइंट) ```python from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY") resp = client.chat.completions.create( model="gemma-4-26b", messages=[ {"role": "system", "content": "आप सादा पाठ में उत्तर देते हैं, कोई markdown नहीं."}, {"role": "user", "content": "Go HTTP handler के लिए 5-बिंदुओं वाली code review checklist दीजिए."}, ], temperature=0.7, max_tokens=1024, ) print(resp.choices[0].message.content) ``` ### Streaming responses ```python from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY") stream = client.chat.completions.create( model="gemma-4-26b", messages=[{"role": "user", "content": "Distributed inference पर एक हाइकु लिखिए."}], stream=True, max_tokens=128, ) for chunk in stream: delta = chunk.choices[0].delta.content if delta: print(delta, end="", flush=True) print() ``` ### Hugging Face Transformers (ऑफ़लाइन उपयोग) ```python import torch from transformers import AutoModelForCausalLM, AutoTokenizer model_name = "google/gemma-4-26b-it" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.bfloat16, device_map="auto", load_in_4bit=True, # MoE एक अकेले 24GB कार्ड में फिट हो जाता है ) messages = [ {"role": "user", "content": "पठनीयता के लिए इस Python फ़ंक्शन को refactor करें:\n\ndef f(x): return [i for i in x if i%2==0 and i>10]"}, ] input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device) output = model.generate(input_ids, max_new_tokens=512, do_sample=True, temperature=0.7) print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True)) ``` *** ## प्रदर्शन सुझाव * **Hopper पर FP8 का उपयोग करें।** H100 पर FP8 चेकपॉइंट BF16 की तुलना में लगभग आधी मेमोरी लेता है, और निर्देश-पालन कार्यों में गुणवत्ता का कोई मापनीय नुकसान नहीं होता। इसे vLLM को पास करें `--quantization fp8` । * **Ada (RTX 4090) पर 4-बिट GPTQ का उपयोग करें।** एक अकेले 4090 पर MoE वेरिएंट के लिए, समुदाय द्वारा बना GPTQ 4-बिट बिल्ड व्यावहारिक रूप से सबसे अच्छा विकल्प है — \~10–15 tok/s की अपेक्षा करें। Ollama के Q4\_K\_M GGUF बिल्ड सरल संचालन के साथ समान गुणवत्ता देते हैं। * **31B Dense के लिए tensor parallelism।** 2× RTX 4090 पर, पास करें `--tensor-parallel-size 2`। कॉन्टेक्स्ट को उतना ही रखें जितना वास्तव में चाहिए (`--max-model-len 16384`) — कॉन्टेक्स्ट के हर दोगुने होने पर KV cache फुटप्रिंट लगभग दोगुना हो जाता है। * **MoE के लिए expert parallelism।** 26B MoE के लिए multi-GPU सेटअप पर, vLLM का `--enable-expert-parallel` उच्च batch sizes पर throughput में उल्लेखनीय वृद्धि दे सकता है। सिंगल-GPU के लिए यह ज़रूरत से ज़्यादा है। * **लंबे कॉन्टेक्स्ट के लिए chunked prefill।** 32K से आगे बढ़ते समय, vLLM में `--enable-chunked-prefill` जोड़ें। यह prefill latency को नियंत्रित रखता है और decode path पर stalls को रोकता है। * **वेट्स पहले से खींचें।** अस्थायी Clore rentals के लिए, `/root/.cache/huggingface` पर एक persistent volume माउंट करें ताकि बाद के रन 50–60GB डाउनलोड छोड़ दें। * **सही serving backend चुनें।** vLLM सुरक्षित डिफ़ॉल्ट है। SGLang अक्सर Hopper पर उच्च-concurrency workloads में जीतता है; व्यापक तुलना के लिए देखें [vLLM गाइड](/guides/guides_v2-hi/language-models/vllm.md) । *** ## बेंचमार्क {% hint style="warning" %} **विक्रेता द्वारा प्रकाशित संख्याएँ — स्वतंत्र सत्यापन लंबित।** नीचे दिए गए आंकड़े Google की 2 अप्रैल, 2026 लॉन्च सामग्री से आए हैं। निजी evals पर स्वतंत्र पुनरुत्पादन अभी भी आ रहे हैं। Arena रैंकिंग और factuality स्कोर को दिशा-सूचक मानें, पूर्ण नहीं। {% endhint %} | बेंचमार्क | Gemma 4 26B MoE | Gemma 4 31B Dense | संदर्भ | | ----------------------------- | ------------------------------------------------------------ | ------------------------------------------------ | ------------------ | | LMSYS Arena (कुल) | रिलीज़ पर #3 | रिलीज़ पर लगभग #5 | विक्रेता-रिपोर्टेड | | निर्देश-पालन (IFEval) | विक्रेता Gemma 3 पर मजबूत सुधार रिपोर्ट करते हैं | विक्रेता Gemma 3 पर मजबूत सुधार रिपोर्ट करते हैं | विक्रेता-रिपोर्टेड | | तथ्यात्मकता (SimpleQA / समान) | Google के अनुसार कई बंद मॉडलों से बेहतर | तुलनीय | विक्रेता-रिपोर्टेड | | बहुभाषी (Global-MMLU) | विक्रेता बहुत बड़े मॉडलों के बराबर प्रदर्शन रिपोर्ट करते हैं | अब तक का सर्वश्रेष्ठ Gemma स्कोर | विक्रेता-रिपोर्टेड | Gemma 4 की पोज़िशनिंग दलील है "प्रति सक्रिय पैरामीटर अधिक उपयोगी," न कि "कच्चा HumanEval राजा।" यदि आपको शुद्ध code generation चाहिए, तो इसकी तुलना करें [GLM-5.1](/guides/guides_v2-hi/language-models/glm-5-1.md) (फ्रंटियर कोडिंग) या [Qwen3.5](/guides/guides_v2-hi/language-models/qwen35.md) (सर्वश्रेष्ठ 35B-श्रेणी का डेंस)। यदि आपको लंबे-क्षितिज वाले agentic loops चाहिए, तो GLM-5.1 अभी भी अधिक उपयुक्त उपकरण है। *** ## समस्या निवारण | समस्या | समाधान | | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `OutOfMemoryError` 24GB पर 26B MoE लोड करते समय | FP8 (`--quantization fp8`) या 4-bit (`Transformers में load_in_4bit=True` ) पर स्विच करें। KV cache छोटा करने के लिए `--max-model-len` को 16384 पर घटाएँ। | | `OutOfMemoryError` H100 पर 31B Dense लोड करते समय | 32K कॉन्टेक्स्ट पर BF16 80GB पर ठीक सीमा पर है। `--max-model-len` को 16384 पर घटाएँ या FP8 पर जाएँ। | | Hugging Face डाउनलोड 403 के साथ विफल होता है | आपने model page पर Gemma लाइसेंस स्वीकार नहीं किया है। URL को ब्राउज़र में खोलें, शर्तें स्वीकार करें, फिर ऐसे टोकन के साथ पुनः pull करें जिसमें `read` scope हो। | | बहुत धीमा पहला टोकन | ठंडा वेट लोड (\~30–60s पहली रिक्वेस्ट पर) और लंबे इनपुट पर prefill। सर्वर शुरू होने के बाद एक dummy warm-up request चलाएँ। लंबे-कॉन्टेक्स्ट workloads के लिए जोड़ें `--enable-chunked-prefill` । | | विकृत आउटपुट / repetition loops | chat template जाँचें — `tokenizer.apply_chat_template` आवश्यक है; `system`+`user` strings को मैन्युअली concatenate न करें। सेट करें `temperature=0.7` और `top_p=0.95` सामान्य उपयोग के लिए। | | Tool / JSON आउटपुट अविश्वसनीय | vLLM के `--guided-decoding-backend` का उपयोग करें या JSON schema को `response_format`के माध्यम से पास करें। मॉडल constraints को अच्छी तरह मानता है, लेकिन असंरचित prompts फिर भी भटक सकते हैं। | | `unsupported quantization` त्रुटि in vLLM | अप्रैल 2026 के बाद जारी vLLM संस्करण में अपडेट करें (`pip install -U vllm --pre`)। Gemma 4 आर्किटेक्चर को नवीनतम config parsers चाहिए। | *** ## FAQ **Gemma 4 बनाम Llama 4?** अलग-अलग कामों के लिए अलग आकार। [Llama 4 Scout](/guides/guides_v2-hi/language-models/llama4.md) 109B/17B-active है और इसका मुख्य आकर्षण 10M context है — जब आपको मॉडल में बहुत बड़े inputs डालने हों तब यह बेहतरीन है। Gemma 4 26B MoE कुल पैरामीटर में कहीं छोटा है (26B बनाम 109B), प्रति टोकन कम पैरामीटर सक्रिय करता है (4B बनाम 17B), और instruction-following तथा factuality के लिए अधिक सख्ती से ट्यून किया गया है। तंग VRAM बजट और quality-per-parameter के लिए Gemma 4 जीतता है। absurd context length के लिए Llama 4 Scout जीतता है। **Gemma 4 26B MoE के लिए कितनी VRAM चाहिए?** * 4-bit GGUF / GPTQ: फिट होता है **24GB** (एकल RTX 4090), \~10–15 tok/s। * FP8: आराम से चलता है **40GB**पर, तेज़ चलता है **80GB** (H100) पर \~40+ tok/s के साथ। * BF16 full: \~55GB वेट्स plus KV cache — योजना बनाएँ **80GB** कार्ड के लिए। **क्या मैं Gemma 4 का व्यावसायिक उपयोग कर सकता हूँ?** हाँ, मानक Gemma उपयोग शर्तों के अंतर्गत। डिप्लॉय करने से पहले [Gemma निषिद्ध उपयोग नीति](https://ai.google.dev/gemma/prohibited_use_policy) की समीक्षा करें — कुछ उपयोग मामलों (धोखा, CSAM बनाना, अवैध गतिविधि) पर प्रतिबंध हैं, और आपको downstream license notices अपने उपयोगकर्ताओं तक पहुँचाने होंगे। यह Apache 2.0 / MIT मॉडल नहीं है — यह usage policy के तहत open-weight है। यदि आपको पूरी तरह unrestricted license चाहिए, [Qwen3.5](/guides/guides_v2-hi/language-models/qwen35.md) (Apache 2.0) या [GLM-5.1](/guides/guides_v2-hi/language-models/glm-5-1.md) (MIT) विकल्प हैं। **Gemma 4 बनाम DeepSeek-V4?** [DeepSeek-V4](/guides/guides_v2-hi/language-models/deepseek-v4.md) एक अलग वजन वर्ग है — लगभग 1T params, multimodal, 1M context. जब आपको कच्ची क्षमता चाहिए और आपके पास गंभीर GPU rack हो, तब DeepSeek-V4 का उपयोग करें। जब आप एक **एकल GPU** पर मजबूत instruction-following चाहते हों और Clore पर लगभग $1–2/दिन किराये की परवाह करते हों, तब Gemma 4 26B MoE का उपयोग करें। Gemma 4 “4090 पर फिट होने वाला सबसे अच्छा मॉडल” उम्मीदवार है; DeepSeek-V4 “मैं 8× H200 के लिए भुगतान करूँगा” उम्मीदवार है। **क्या Gemma 4 vision / multimodal inputs का समर्थन करता है?** Gemma 4 की मुख्य रिलीज़ text-only instruction-tuned है (`*-it`)। Google ने ऐतिहासिक रूप से text releases के बाद PaliGemma vision variants जारी किए हैं — अपडेट के लिए [huggingface.co/google](https://huggingface.co/google) पर नज़र रखें। आज के लिए image-capable open model के रूप में देखें [Kimi K2.5](/guides/guides_v2-hi/language-models/kimi-k2.md) या [Llama 4 Scout](/guides/guides_v2-hi/language-models/llama4.md). *** ## संबंधित गाइड्स * [vLLM](/guides/guides_v2-hi/language-models/vllm.md) — इस गाइड में उपयोग किया गया production serving backend * [Ollama](/guides/guides_v2-hi/language-models/ollama.md) — GGUF बिल्ड्स के साथ स्थानीय परीक्षण का सबसे तेज़ रास्ता * [Llama 4](/guides/guides_v2-hi/language-models/llama4.md) — 10M context वाला Meta का MoE विकल्प * [GLM-5.1](/guides/guides_v2-hi/language-models/glm-5-1.md) — frontier-स्तरीय coding MoE (744B/40B-active), जब Gemma का size class पर्याप्त न हो * [Qwen3.5](/guides/guides_v2-hi/language-models/qwen35.md) — Apache-2.0 35B dense, दूसरा मजबूत single-GPU विकल्प * [Gemma 3](/guides/guides_v2-hi/language-models/gemma3.md) — पूर्ववर्ती पीढ़ी, migration के लिए उपयोगी baseline ### लिंक * [Hugging Face पर Gemma 4 26B MoE](https://huggingface.co/google/gemma-4-26b-it) * [Hugging Face पर Gemma 4 31B Dense](https://huggingface.co/google/gemma-4-31b-it) * [Gemma उपयोग शर्तों](https://ai.google.dev/gemma/terms) * [Gemma निषिद्ध उपयोग नीति](https://ai.google.dev/gemma/prohibited_use_policy) * [vLLM दस्तावेज़](https://docs.vllm.ai) * [SGLang repo](https://github.com/sgl-project/sglang) --- # 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/gemma4.md?ask=&goal= ``` `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.