> 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 active) {% hint style="info" %} **स्थिति (अप्रैल 2026):** Gemma 4 जारी किया गया था **2 अप्रैल 2026** Google द्वारा Gemma ओपन-वेट परिवार की अगली पीढ़ी के रूप में। दो वेरिएंट जारी किए गए हैं: एक **31B डेंस** मॉडल (`google/gemma-4-31b-it`) और एक **लगभग 4B सक्रिय पैरामीटर वाला 26B MoE** (`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 सक्रिय**, जिससे आपको एक छोटे dense मॉडल की inference लागत पर frontier-स्तर के करीब instruction-following मिलता है। Clore.ai उपयोगकर्ताओं के लिए व्यावहारिक निष्कर्ष सरल है — 26B MoE आराम से एक अकेले **RTX 4090 (24GB)** पर FP8 या 4-बिट क्वांटाइजेशन (\~10 tok/s) के साथ चलता है और एक अकेले **H100 80GB** (\~40+ tok/s), जिससे लगभग \~$1.04/घंटा पर मार्केटप्लेस में Gemma-स्तरीय instruction-following संभव हो जाता है। 31B dense वेरिएंट अधिक सक्षम लेकिन अधिक महंगा विकल्प है, जिसे सर्व करने के लिए 2× RTX 4090 या 1× H100 चाहिए। ## मुख्य विशेषताएँ * **MoE आर्किटेक्चर (26B वेरिएंट)** — 26B कुल पैरामीटर, प्रति टोकन लगभग 4B सक्रिय; 26B-स्तरीय गुणवत्ता के लिए 4B-स्तरीय inference लागत * **Dense विकल्प (31B वेरिएंट)** — उन टीमों के लिए जो dense inference की पूर्वानुमेयता और टूलिंग परिपक्वता को पसंद करती हैं * **128K संदर्भ विंडो** — लंबे दस्तावेज़ों पर Q\&A, मध्यम आकार के कोडबेस पर RAG, बहु-चरणीय agent लूप * **मज़बूत निर्देश-अनुसरण** — 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 तैनाती के लिए, चुनें **FP8 पर Gemma 4 26B MoE**. आपको 4090 पर \~10–15 tok/s और H100 पर \~40+ tok/s के साथ शीर्ष Arena गुणवत्ता मिलती है, बिना dense 31B inference की latency लागत के। {% endhint %} *** ## सर्वर आवश्यकताएँ | घटक | 26B MoE (4-बिट, 4090) | 26B MoE (FP8, H100) | 31B Dense (BF16, H100) | | ---------- | ----------------------- | ------------------- | ---------------------- | | GPU VRAM | 24GB | 80GB | 80GB | | System RAM | 32GB | 64GB | 64GB | | डिस्क | 60GB NVMe | 80GB NVMe | 90GB NVMe | | नेटवर्क | HF pull के लिए 100 Mbps | 1 Gbps वरीय | 1 Gbps वरीय | | CUDA | 12.8+ | 12.8+ | 12.8+ | | ड्राइवर | 550+ | 555+ | 555+ | लंबे contexts पर KV cache को संभालने के लिए स्थिर वजन फुटप्रिंट के ऊपर अतिरिक्त \~20% VRAM हेडरूम की योजना बनाएं। vLLM में सेटिंग `--gpu-memory-utilization 0.90` vLLM में एक अच्छा डिफ़ॉल्ट है। *** ## CLORE.AI पर त्वरित परिनियोजन सबसे तेज़ तरीका: एक अकेला GPU किराए पर लें, मानक `vllm/vllm-openai` इमेज खींचें, और मॉडल को OpenAI-संगत API के साथ सर्व करें। नीचे इन गाइडों के बाकी हिस्सों में उपयोग किया गया docker-compose लेआउट है — ऊपर चुने गए वेरिएंट के आधार पर मॉडल नाम और tensor-parallel size समायोजित करें। ### विकल्प 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 # weights डाउनलोड होते समय logs देखें docker compose logs -f vllm ``` {% hint style="info" %} **लाइसेंस सत्यापन:** Hugging Face पर Gemma मॉडल्स के लिए प्रति खाते Google की शर्तों को एक बार स्वीकार करना आवश्यक है। ब्राउज़र में मॉडल पेज खोलें, "Acknowledge license" पर क्लिक करें, फिर export करें `HF_TOKEN` ताकि कंटेनर weights खींच सके। {% 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 community builds को wrap करता है। उम्मीद करें कि quants आधिकारिक रिलीज़ के कुछ दिनों बाद उपलब्ध होंगे। ```bash # जब community GGUF प्रकाशित हो जाए ollama pull gemma4:26b-moe-q4_k_m ollama run gemma4:26b-moe-q4_k_m # OpenAI-संगत API :11434 पर 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 routing approach को दो वाक्यों में संक्षेप में बताइए."}] }' ``` देखें [Ollama गाइड](/guides/guides_v2-hi/language-models/ollama.md) सामान्य सेटअप, मॉडल प्रबंधन, और persistence सुझावों के लिए। *** ## उपयोग के उदाहरण vLLM कंटेनर OpenAI-संगत API उपलब्ध कराता है `:8000`. जो भी OpenAI chat-completions schema बोलता है, वह सीधे काम करता है। ### Curl चैट पूर्णता ```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 routing को बिना उपमाओं के तीन वाक्यों में समझाइए."} ], "max_tokens": 512, "temperature": 0.7 }' ``` ### Python (OpenAI client) ```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) ``` ### स्ट्रीमिंग प्रतिक्रियाएँ ```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 function को 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 checkpoint, instruction-following कार्यों के लिए मापने योग्य गुणवत्ता हानि के बिना BF16 की लगभग आधी memory लेता है। पास करें `--quantization fp8` vLLM को। * **Ada (RTX 4090) पर 4-बिट GPTQ का उपयोग करें।** एक अकेले 4090 पर MoE वेरिएंट के लिए, community GPTQ 4-बिट build व्यावहारिक sweet spot है — \~10–15 tok/s की उम्मीद करें। Ollama के Q4\_K\_M GGUF builds सरल संचालन के साथ समान गुणवत्ता देते हैं। * **31B Dense के लिए tensor parallelism।** 2× RTX 4090 के बीच, पास करें `--tensor-parallel-size 2`. context को उतने पर सीमित रखें जितना आपको वास्तव में चाहिए (`--max-model-len 16384`) — context को हर दोगुना करने पर KV cache footprint लगभग दोगुना हो जाता है। * **MoE के लिए expert parallelism।** 26B MoE के लिए multi-GPU सेटअप पर, vLLM का `--enable-expert-parallel` उच्च batch sizes पर throughput में महत्वपूर्ण बढ़ोतरी दे सकता है। सिंगल-GPU के लिए यह ज़रूरत से ज़्यादा है। * **लंबे contexts के लिए chunked prefill।** 32K से आगे बढ़ते समय, जोड़ें `--enable-chunked-prefill` vLLM में। इससे prefill latency नियंत्रित रहती है और decode path पर रुकावटें नहीं आतीं। * **weights पहले से डाउनलोड करें।** अल्पकालिक Clore rentals के लिए, एक persistent volume mount करें `/root/.cache/huggingface` ताकि बाद के runs 50–60GB डाउनलोड को छोड़ दें। * **सही serving backend चुनें।** vLLM सुरक्षित डिफ़ॉल्ट है। Hopper पर उच्च-concurrency workloads के लिए SGLang अक्सर बेहतर होता है; देखें [vLLM गाइड](/guides/guides_v2-hi/language-models/vllm.md) व्यापक तुलना के लिए। *** ## बेंचमार्क {% hint style="warning" %} **विक्रेता-प्रकाशित आँकड़े — स्वतंत्र सत्यापन लंबित है।** नीचे दिए गए आँकड़े Google के 2 अप्रैल 2026 लॉन्च सामग्री से लिए गए हैं। निजी evaluations पर स्वतंत्र पुनरुत्पादन अभी भी आ रहे हैं। Arena रैंकिंग और factuality स्कोर को दिशात्मक मानें, पूर्ण सत्य नहीं। {% endhint %} | Benchmark | Gemma 4 26B MoE | Gemma 4 31B Dense | संदर्भ | | ----------------------------- | ------------------------------------------------------- | ---------------------------------------------------- | ------------------ | | LMSYS Arena (समग्र) | रिलीज़ पर #3 | रिलीज़ पर लगभग #5 | विक्रेता-रिपोर्टेड | | निर्देश-अनुसरण (IFEval) | विक्रेता की रिपोर्ट के अनुसार Gemma 3 पर मजबूत सुधार | विक्रेता की रिपोर्ट के अनुसार Gemma 3 पर मजबूत सुधार | विक्रेता-रिपोर्टेड | | तथ्यात्मकता (SimpleQA / समान) | Google के अनुसार कई बंद मॉडलों को पीछे छोड़ता है | तुलनीय | विक्रेता-रिपोर्टेड | | बहुभाषी (Global-MMLU) | विक्रेता की रिपोर्ट के अनुसार काफी बड़े मॉडलों के बराबर | अब तक का सर्वश्रेष्ठ Gemma स्कोर | विक्रेता-रिपोर्टेड | Gemma 4 की positioning दलील "प्रति सक्रिय पैरामीटर अधिक उपयोगी" है, न कि "raw HumanEval king"। यदि आपको शुद्ध code generation चाहिए, तो तुलना करें [GLM-5.1](/guides/guides_v2-hi/language-models/glm-5-1.md) (frontier coding) या [Qwen3.5](/guides/guides_v2-hi/language-models/qwen35.md) (सर्वश्रेष्ठ 35B-श्रेणी dense)। यदि आपको long-horizon agentic loops चाहिए, तो GLM-5.1 अभी भी अधिक उपयुक्त tool है। *** ## समस्या निवारण | समस्या | समाधान | | --------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `OutOfMemoryError` 24GB पर 26B MoE लोड करना | FP8 पर स्विच करें (`--quantization fp8`) या 4-बिट (`load_in_4bit=True` Transformers में)। कम करें `--max-model-len` को 16384 तक KV cache छोटा करने के लिए। | | `OutOfMemoryError` H100 पर 31B Dense लोड करना | 32K context पर BF16, 80GB पर बिल्कुल सीमा पर है। घटाएँ `--max-model-len` को 16384 तक या FP8 पर जाएँ। | | Hugging Face डाउनलोड 403 के साथ विफल | आपने मॉडल पेज पर Gemma लाइसेंस स्वीकार नहीं किया है। URL को ब्राउज़र में खोलें, शर्तें स्वीकार करें, फिर ऐसे token के साथ पुनः pull करें जिसमें `read` scope। | | पहला token बहुत धीमा | पहली request पर cold weight load (\~30–60s) और लंबे inputs पर prefill। सर्वर शुरू होने के बाद एक dummy warm-up request चलाएँ। जोड़ें `--enable-chunked-prefill` लंबे-context workloads के लिए। | | बिगड़ा हुआ output / दोहराव चक्र | chat template जाँचें — `tokenizer.apply_chat_template` आवश्यक है; जोड़ें नहीं `system`+`user` strings को मैन्युअली। सेट करें `temperature=0.7` और `top_p=0.95` सामान्य उपयोग के लिए। | | Tool / JSON output अविश्वसनीय | vLLM का उपयोग करें `--guided-decoding-backend` या JSON schema पास करें `response_format`. मॉडल constraints को अच्छी तरह मानता है, लेकिन असंरचित prompts फिर भी भटक सकते हैं। | | `असमर्थित quantization` vLLM में त्रुटि | अप्रैल 2026 के बाद जारी vLLM संस्करण पर अपडेट करें (`pip install -U vllm --pre`). Gemma 4 आर्किटेक्चर को नवीनतम config parsers की आवश्यकता है। | *** ## सामान्य प्रश्न **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 बजट और गुणवत्ता-प्रति-पैरामीटर के लिए Gemma 4 बेहतर है। असाधारण रूप से लंबे context के लिए Llama 4 Scout बेहतर है। **Gemma 4 26B MoE के लिए कितना VRAM चाहिए?** * 4-बिट GGUF / GPTQ: इसमें फिट होता है **24GB** (एकल RTX 4090), \~10–15 tok/s। * FP8: पर आराम से **40GB**, पर तेज़ **80GB** (H100) पर \~40+ tok/s। * BF16 full: \~55GB weights plus KV cache — एक **80GB** कार्ड का प्रबंध करें। **क्या मैं Gemma 4 का व्यावसायिक उपयोग कर सकता हूँ?** हाँ, मानक Gemma उपयोग की शर्तों के तहत। देखें [Gemma निषिद्ध उपयोग नीति](https://ai.google.dev/gemma/prohibited_use_policy) तैनाती से पहले — कुछ विशिष्ट उपयोग मामलों (धोखाधड़ी, CSAM बनाना, अवैध गतिविधि) पर प्रतिबंध हैं, और आपको downstream license notices अपने उपयोगकर्ताओं तक पहुँचानी होंगी। यह Apache 2.0 / MIT मॉडल नहीं है — यह उपयोग नीति के तहत open-weight है। यदि आपको पूरी तरह अप्रतिबंधित लाइसेंस चाहिए, [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 पैरामीटर, multimodal, 1M context। जब आपको raw capability चाहिए और आपके पास मजबूत GPU rack हो, तब DeepSeek-V4 इस्तेमाल करें। जब आप चाहते हों कि Gemma 4 26B MoE पर मजबूत instruction-following मिले, तब इसे इस्तेमाल करें **एक अकेले GPU** और आपके लिए महत्वपूर्ण हो [bare metal](https://clore.ai/bare-metal) Clore पर rentals। 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 builds के साथ स्थानीय परीक्षण का सबसे तेज़ रास्ता * [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.