> 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/gemini-3-1-flash-lite.md). # Gemini 3.1 Flash Lite > **जेमिनी 3.1 फ्लैश लाइट** मार्च 2026 तक, यह Google का सबसे सस्ता और सबसे तेज़ प्रोडक्शन मॉडल है, जिसे 3 मार्च 2026 को जारी किया गया। यह Gemini 3.1 परिवार का API-अनुकूलित टियर है — जो रियल-टाइम चैटबॉट्स, वर्गीकरण पाइपलाइनों, और RAG रिट्रीवल लेयर्स जैसे उच्च-थ्रूपुट, लागत-संवेदी वर्कलोड्स के लिए डिज़ाइन किया गया है। अधिकतम लागत नियंत्रण के लिए इसे Ollama या vLLM के माध्यम से Clore.ai GPUs पर सेल्फ-होस्ट करें। ## Gemini 3.1 Flash Lite क्या है? 3 मार्च 2026 को Gemini 3.1 परिवार के हल्के एंट्री मॉडल के रूप में जारी किया गया (जिसमें 19 फरवरी 2026 का Gemini 3.1 Pro भी शामिल है), Flash Lite कुछ तर्क-गहराई को बहुत कम लेटेंसी और लागत के बदले ट्रेड करता है। यह Google का "तेज़ और सस्ता" टियर के लिए जवाब है — कीमत-प्रदर्शन में GPT-5.4 के मिनी वेरिएंट्स और Claude Sonnet के साथ सीधे प्रतिस्पर्धा करता है। **मुख्य विनिर्देश:** * **मल्टीमोडल**: टेक्स्ट, इमेज, ऑडियो, वीडियो इनपुट * **संदर्भ विंडो**: 1M टोकन (Gemini 3.1 Pro के समान) * **आउटपुट**: प्रति अनुरोध 8K टोकन तक * **लेटेंसी**: छोटे प्रॉम्प्ट्स के लिए \~120ms time-to-first-token (API) * **आर्किटेक्चर**: speculative decoding के साथ Gemini 3.1 Pro से distilled > **नोट:** Gemini 3.1 Flash Lite एक **केवल Google API** मॉडल है — वेट्स सार्वजनिक रूप से जारी नहीं किए गए हैं। यह गाइड (a) Clore.ai इन्फ्रास्ट्रक्चर पर Google Gemini API का उपयोग, और (b) तुलनीय ओपन-सोर्स विकल्पों को कवर करती है जिन्हें आप पूरी तरह सेल्फ-होस्ट कर सकते हैं। ## विकल्प A: Clore.ai सर्वर पर Gemini 3.1 Flash Lite API का उपयोग करें भले ही आप वेट्स को लोकली नहीं चला सकते, फिर भी लंबे समय तक चलने वाली प्रक्रियाओं, ऑटोमेशन पाइपलाइनों और बैच जॉब्स के लिए अपना API-उपयोग करने वाला एप्लिकेशन Clore.ai के सस्ते सर्वरों पर होस्ट करना समझदारी है। ### सेटअप: Clore.ai पर API प्रॉक्सी + FastAPI ```bash # Clore.ai पर एक CPU या हल्का GPU सर्वर किराए पर लें # RTX 3060 (~$0.25/घंटा) API प्रॉक्सी वर्कलोड्स के लिए से कहीं अधिक पर्याप्त है pip install google-generativeai fastapi uvicorn cat > gemini_proxy.py << 'EOF' import google.generativeai as genai from fastapi import FastAPI, HTTPException from pydantic import BaseModel import os genai.configure(api_key=os.environ["GOOGLE_API_KEY"]) model = genai.GenerativeModel("gemini-3.1-flash-lite") app = FastAPI(title="Gemini 3.1 Flash Lite Proxy") class ChatRequest(BaseModel): message: str system_prompt: str = "आप एक सहायक सहायक हैं." max_tokens: int = 2048 @app.post("/chat") async def chat(req: ChatRequest): try: response = model.generate_content( [req.system_prompt, req.message], generation_config=genai.GenerationConfig( max_output_tokens=req.max_tokens, temperature=0.7 ) ) return {"response": response.text, "model": "gemini-3.1-flash-lite"} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.post("/vision") async def vision_chat(image_url: str, prompt: str): import httpx async with httpx.AsyncClient() as client: img_data = await client.get(image_url) import PIL.Image import io image = PIL.Image.open(io.BytesIO(img_data.content)) response = model.generate_content([prompt, image]) return {"response": response.text} if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8080) EOF GOOGLE_API_KEY=your-key uvicorn gemini_proxy:app --host 0.0.0.0 --port 8080 ``` ### उच्च-थ्रूपुट बैच प्रोसेसिंग ```python import google.generativeai as genai import asyncio from typing import List genai.configure(api_key="YOUR_API_KEY") async def batch_classify(texts: List[str], batch_size: int = 50) -> List[str]: """टेक्स्ट को समानांतर बैचों में वर्गीकृत करें — लागत ~$0.001 प्रति 1K टेक्स्ट।""" model = genai.GenerativeModel("gemini-3.1-flash-lite") results = [] for i in range(0, len(texts), batch_size): batch = texts[i:i + batch_size] tasks = [ model.generate_content_async( f"इस टेक्स्ट को POSITIVE, NEGATIVE, या NEUTRAL के रूप में वर्गीकृत करें। केवल एक शब्द में उत्तर दें।\n\nText: {text}" ) for text in batch ] responses = await asyncio.gather(*tasks, return_exceptions=True) results.extend([ r.text.strip() if not isinstance(r, Exception) else "ERROR" for r in responses ]) return results # उदाहरण texts = ["Great product!", "Terrible service.", "It's okay I guess."] labels = asyncio.run(batch_classify(texts)) print(list(zip(texts, labels))) ``` ## विकल्प B: ओपन-सोर्स विकल्प (Clore.ai पर सेल्फ-होस्ट करें) यदि आप बिना API लागत के पूरी तरह लोकल inference चाहते हैं, तो ये मॉडल "तेज़/सस्ता" टियर में Gemini 3.1 Flash Lite के बराबर हैं: ### Gemma 3 4B (Google का ओपन हल्का मॉडल) ```bash # किसी भी GPU पर 6GB+ VRAM के साथ चलता है — यहां तक कि RTX 3060 पर भी docker run --gpus all -d \\ -p 11434:11434 \\ -v ollama_data:/root/.ollama \\ ollama/ollama docker exec -it $(docker ps -q) ollama pull gemma3:4b docker exec -it $(docker ps -q) ollama run gemma3:4b "Explain quantum entanglement simply." ``` ### Qwen3.5 7B (आकार के हिसाब से तेज़, उच्च गुणवत्ता) ```bash docker exec -it $(docker ps -q) ollama pull qwen3.5:7b # ~3.8GB VRAM, RTX 3080 पर ~45 tok/s ``` ### Clore.ai हार्डवेयर पर गति तुलना | मॉडल | VRAM | टोकन/सेकंड (RTX 4090) | लागत/1M टोकन (Clore.ai) | | --------------------------- | --------- | --------------------- | ------------------------------------------ | | Gemini 3.1 Flash Lite (API) | लागू नहीं | \~200 (API) | \~$0.25 इनपुट / $1.50 आउटपुट प्रति 1M टोकन | | Gemma 3 4B (लोकल) | 4GB | 95 tok/s | \~$0.002 (at $2/hr) | | Qwen3.5 7B (लोकल) | 8GB | 78 tok/s | \~$0.005 (at $2/hr) | | Gemma 3 12B (लोकल) | 12GB | 55 tok/s | \~$0.008 (at $2/hr) | | Gemma 3 27B (लोकल) | 20GB | 32 tok/s | \~$0.014 (at $2/hr) | > **निष्कर्ष:** उच्च-मात्रा वर्कलोड्स (>100M टोकन/माह) के लिए, Clore.ai पर Gemma 3 / Qwen3.5 को सेल्फ-होस्ट करना **35–50× सस्ता** Gemini API की तुलना में है। ## Clore.ai पर डिप्लॉय करें ### Flash Lite-स्तर के वर्कलोड्स के लिए अनुशंसित GPU | उपयोग का मामला | अनुशंसित GPU | Clore.ai पर कीमत | | ---------------------- | -------------------------------- | -------------------- | | API प्रॉक्सी / ऑटोमेशन | GPU की आवश्यकता नहीं (CPU सर्वर) | \~$0.05/घंटा | | लोकल 4B मॉडल | RTX 3060 12GB | \~$0.25/घंटा | | लोकल 7B मॉडल | RTX 3080 10GB | \~$0.35/घंटा | | लोकल 27B मॉडल | RTX 4090 24GB | \~$1.20/घंटा (स्पॉट) | ### Clore.ai पर वन-क्लिक Ollama लॉन्च Clore.ai डैशबोर्ड में, चुनें **Ollama** टेम्पलेट्स से: ```bash # या SSH के माध्यम से मैन्युअल रूप से: curl -fsSL https://ollama.com/install.sh | sh ollama serve & ollama pull gemma3:4b ollama run gemma3:4b ``` ## Flash Lite-स्तर के लिए सबसे उपयुक्त उपयोग के मामले 1. **RAG रिट्रीवल लेयर** — तेज़ संदर्भ रैंकिंग, अंतिम जनरेशन नहीं 2. **रियल-टाइम चैटबॉट प्रतिक्रियाएँ** — छोटे प्रश्नों के लिए sub-200ms 3. **दस्तावेज़ वर्गीकरण** — प्रति मिनट हज़ारों दस्तावेज़ प्रोसेस करें 4. **कोड ऑटोकम्प्लीट** — कम-लेटेंसी सुझाव जनरेशन 5. **अनुवाद पाइपलाइन्स** — सामग्री का बैच में कम लागत पर अनुवाद करें 6. **सामग्री मॉडरेशन** — उपयोगकर्ता सामग्री को बड़े पैमाने पर वर्गीकृत करें ## लागत अनुमानक | मासिक वॉल्यूम | Google API लागत | Clore.ai (Gemma 3 4B) | | ------------- | --------------- | -------------------------- | | 10M टोकन | \~$8.75 | \~$3.60 (50hr/mo RTX 3060) | | 100M टोकन | \~$7.00 | \~$3.60 (निरंतर) | | 1B टोकन | \~$70.00 | \~$26 (निरंतर RTX 3060) | > \~200M टोकन/माह से अधिक वॉल्यूम के लिए, Clore.ai पर सेल्फ-होस्टिंग Gemini API लागत से बेहतर है। ## API उपयोग की निगरानी ```python # Gemini API उपयोग और लागत को ट्रैक करें import google.generativeai as genai import json from datetime import datetime genai.configure(api_key="YOUR_API_KEY") def tracked_generate(prompt: str, log_file: str = "usage.jsonl"): model = genai.GenerativeModel("gemini-3.1-flash-lite") response = model.generate_content(prompt) # उपयोग लॉग करें usage = { "timestamp": datetime.utcnow().isoformat(), "prompt_tokens": response.usage_metadata.prompt_token_count, "output_tokens": response.usage_metadata.candidates_token_count, "total_tokens": response.usage_metadata.total_token_count, "estimated_cost_usd": response.usage_metadata.total_token_count / 1_000_000 * 0.07 } with open(log_file, "a") as f: f.write(json.dumps(usage) + "\n") return response.text # उपयोग result = tracked_generate("फ़्रांस की राजधानी क्या है?") print(result) ``` ## संबंधित गाइड्स * [Clore.ai पर Gemma 3](/guides/guides_v2-hi/language-models/gemma3.md) — Google का ओपन-सोर्स मॉडल परिवार * [Ollama गाइड](/guides/guides_v2-hi/language-models/ollama.md) — एक कमांड से किसी भी LLM को लोकली चलाएँ * [RAGFlow](/guides/guides_v2-hi/rag-and-vector-databases/ragflow.md) — RAG पाइपलाइन जो तेज़ मॉडलों के साथ अच्छी तरह काम करती है * [vLLM Serving](/guides/guides_v2-hi/language-models/vllm.md) — उच्च-थ्रूपुट OpenAI-संगत सर्वर * [GPU तुलना](/guides/guides_v2-hi/getting-started/gpu-comparison.md) — अपनी आवश्यकताओं के लिए सबसे सस्ता GPU खोजें *** *अंतिम अपडेट: 16 मार्च 2026 | Gemini 3.1 Flash Lite जारी: 3 मार्च 2026 | वेट्स: केवल API (Google)* --- # 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/gemini-3-1-flash-lite.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.