Gemini 3 की डेवलपर गाइड

Gemini 3, अब तक का हमारा सबसे इंटेलिजेंट मॉडल है. इसे बेहतरीन रीज़निंग के आधार पर बनाया गया है. इसे एजेंटिक वर्कफ़्लो, अपने-आप कोडिंग करने, और मुश्किल मल्टीमॉडल टास्क को पूरा करने के लिए डिज़ाइन किया गया है, ताकि किसी भी आइडिया को हकीकत में बदला जा सके. इस गाइड में, Gemini 3 मॉडल फ़ैमिली की मुख्य सुविधाओं के बारे में बताया गया है. साथ ही, यह भी बताया गया है कि इसका ज़्यादा से ज़्यादा फ़ायदा कैसे पाया जा सकता है.

Gemini 3 की सुविधा वाले ऐप्लिकेशन के हमारे कलेक्शन को एक्सप्लोर करें. इससे आपको पता चलेगा कि यह मॉडल, ऐडवांस रीज़निंग, ऑटोनॉमस कोडिंग, और मुश्किल मल्टीमॉडल टास्क को कैसे हैंडल करता है.

कोड की कुछ लाइनों के साथ शुरू करें:

from google import genai

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents="Find the race condition in this multi-threaded C++ snippet: [code here]",
)

print(response.text)

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

async function run() {
  const response = await ai.models.generateContent({
    model: "gemini-3-pro-preview",
    contents: "Find the race condition in this multi-threaded C++ snippet: [code here]",
  });

  console.log(response.text);
}

run();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{
      "parts": [{"text": "Find the race condition in this multi-threaded C++ snippet: [code here]"}]
    }]
  }'

पेश है Gemini 3 सीरीज़

Gemini 3 Pro, नई सीरीज़ का पहला मॉडल है. यह मुश्किल कामों के लिए सबसे अच्छा है. इसके लिए, दुनिया के बारे में ज़्यादा जानकारी और अलग-अलग मोड में ऐडवांस तर्क की ज़रूरत होती है.

Gemini 3 Flash, 3-सीरीज़ का हमारा सबसे नया मॉडल है. इसमें प्रोफ़ेशनल लेवल की इंटेलिजेंस है. साथ ही, यह Flash मॉडल की स्पीड और कीमत में उपलब्ध है.

Nano Banana Pro (इसे Gemini 3 Pro Image भी कहा जाता है), इमेज जनरेट करने वाला अब तक का हमारा सबसे शानदार मॉडल है.

Gemini 3 के सभी मॉडल फ़िलहाल झलक के तौर पर उपलब्ध हैं.

* कीमत हर 10 लाख टोकन के हिसाब से तय की जाती है. हालांकि, कुछ मामलों में यह अलग हो सकती है. ** इमेज की कीमत, रिज़ॉल्यूशन के हिसाब से अलग-अलग होती है. ज़्यादा जानकारी के लिए, कीमत तय करने से जुड़ा पेज देखें.

सीमाओं, कीमत, और ज़्यादा जानकारी के लिए, मॉडल पेज देखें.

Gemini 3 में नई API सुविधाएं

Gemini 3 में नए पैरामीटर जोड़े गए हैं. इन्हें इस तरह से डिज़ाइन किया गया है कि डेवलपर को लेटेन्सी, लागत, और मल्टीमॉडल फ़िडेलिटी पर ज़्यादा कंट्रोल मिल सके.

सोचने का लेवल

Gemini 3 सीरीज़ के मॉडल, डिफ़ॉल्ट रूप से डाइनैमिक थिंकिंग का इस्तेमाल करते हैं, ताकि वे प्रॉम्प्ट के हिसाब से जवाब दे सकें. thinking_level पैरामीटर का इस्तेमाल किया जा सकता है. यह पैरामीटर, जवाब जनरेट करने से पहले मॉडल की इंटरनल रीज़निंग प्रोसेस की ज़्यादा से ज़्यादा डेप्थ को कंट्रोल करता है. Gemini 3, इन लेवल को टोकन की गारंटी के तौर पर नहीं, बल्कि सोचने के लिए उपलब्ध संसाधनों के तौर पर देखता है.

अगर thinking_level के लिए कोई वैल्यू नहीं डाली गई है, तो Gemini 3 डिफ़ॉल्ट रूप से high पर सेट होता है. अगर आपको मुश्किल सवालों के जवाब कम समय में चाहिए, तो मॉडल के सोचने के लेवल को low पर सेट करें.

Gemini 3 Pro और Flash के सोचने के लेवल:

Gemini 3 Pro और Flash, दोनों में सूझ-बूझ के ये लेवल इस्तेमाल किए जा सकते हैं:

• low: इससे इंतज़ार का समय और लागत कम हो जाती है. आसान निर्देशों का पालन करने, चैट करने या ज़्यादा थ्रूपुट वाले ऐप्लिकेशन के लिए सबसे सही
• high (डिफ़ॉल्ट, डाइनैमिक): इससे रीज़निंग की गहराई को ज़्यादा से ज़्यादा किया जाता है. मॉडल को पहले टोकन तक पहुंचने में ज़्यादा समय लग सकता है. हालांकि, आउटपुट ज़्यादा सोच-समझकर दिया जाएगा.

Gemini 3 Flash के सोचने के लेवल

ऊपर दिए गए लेवल के अलावा, Gemini 3 Flash में सोच के ये लेवल भी काम करते हैं. फ़िलहाल, Gemini 3 Pro में ये लेवल काम नहीं करते:

• minimal: यह सेटिंग, ज़्यादातर क्वेरी के लिए “सोचने की ज़रूरत नहीं है” सेटिंग से मेल खाती है. मुश्किल कोडिंग टास्क के लिए, मॉडल बहुत कम सोच-विचार कर सकता है. यह चैट या ज़्यादा थ्रूपुट वाले ऐप्लिकेशन के लिए, लेटेन्सी को कम करता है.

• medium: ज़्यादातर टास्क के लिए, सोच-समझकर जवाब देने वाला मॉडल.

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents="How does AI work?",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="low")
    ),
)

print(response.text)

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

const response = await ai.models.generateContent({
    model: "gemini-3-pro-preview",
    contents: "How does AI work?",
    config: {
      thinkingConfig: {
        thinkingLevel: "low",
      }
    },
  });

console.log(response.text);

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{
      "parts": [{"text": "How does AI work?"}]
    }],
    "generationConfig": {
      "thinkingConfig": {
        "thinkingLevel": "low"
      }
    }
  }'

मीडिया रिज़ॉल्यूशन

Gemini 3 में, media_resolution पैरामीटर की मदद से, मल्टीमॉडल विज़न प्रोसेसिंग को ज़्यादा बारीकी से कंट्रोल करने की सुविधा मिलती है. ज़्यादा रिज़ॉल्यूशन से, मॉडल को छोटे टेक्स्ट को पढ़ने या छोटी-छोटी बारीकियों को पहचानने में मदद मिलती है. हालांकि, इससे टोकन का इस्तेमाल और लेटेन्सी बढ़ जाती है. media_resolution पैरामीटर से यह तय होता है कि हर इनपुट इमेज या वीडियो फ़्रेम के लिए ज़्यादा से ज़्यादा कितने टोकन असाइन किए जाएं.

अब हर मीडिया पार्ट के लिए या ग्लोबल तौर पर रिज़ॉल्यूशन सेट किया जा सकता है. इसके लिए, media_resolution_low, media_resolution_medium, media_resolution_high या media_resolution_ultra_high का इस्तेमाल करें. ग्लोबल तौर पर रिज़ॉल्यूशन सेट करने के लिए, generation_config का इस्तेमाल करें. अल्ट्रा हाई रिज़ॉल्यूशन के लिए, ग्लोबल तौर पर रिज़ॉल्यूशन सेट करने की सुविधा उपलब्ध नहीं है. यह जानकारी उपलब्ध न होने पर, मॉडल मीडिया टाइप के आधार पर सबसे सही डिफ़ॉल्ट सेटिंग का इस्तेमाल करता है.

सुझाई गई सेटिंग

from google import genai
from google.genai import types
import base64

# The media_resolution parameter is currently only available in the v1alpha API version.
client = genai.Client(http_options={'api_version': 'v1alpha'})

response = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents=[
        types.Content(
            parts=[
                types.Part(text="What is in this image?"),
                types.Part(
                    inline_data=types.Blob(
                        mime_type="image/jpeg",
                        data=base64.b64decode("..."),
                    ),
                    media_resolution={"level": "media_resolution_high"}
                )
            ]
        )
    ]
)

print(response.text)

import { GoogleGenAI } from "@google/genai";

// The media_resolution parameter is currently only available in the v1alpha API version.
const ai = new GoogleGenAI({ apiVersion: "v1alpha" });

async function run() {
  const response = await ai.models.generateContent({
    model: "gemini-3-pro-preview",
    contents: [
      {
        parts: [
          { text: "What is in this image?" },
          {
            inlineData: {
              mimeType: "image/jpeg",
              data: "...",
            },
            mediaResolution: {
              level: "media_resolution_high"
            }
          }
        ]
      }
    ]
  });

  console.log(response.text);
}

run();

curl "https://generativelanguage.googleapis.com/v1alpha/models/gemini-3-pro-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{
      "parts": [
        { "text": "What is in this image?" },
        {
          "inlineData": {
            "mimeType": "image/jpeg",
            "data": "..."
          },
          "mediaResolution": {
            "level": "media_resolution_high"
          }
        }
      ]
    }]
  }'

तापमान

हमारा सुझाव है कि Gemini 3 के लिए, टेंपरेचर पैरामीटर को उसकी डिफ़ॉल्ट वैल्यू 1.0 पर सेट रखें.

पिछले मॉडल में, क्रिएटिविटी और डिटरमिनिज़्म को कंट्रोल करने के लिए, अक्सर टेंपरेचर को ट्यून करने से फ़ायदा मिलता था. हालांकि, Gemini 3 की तर्क करने की क्षमताओं को डिफ़ॉल्ट सेटिंग के लिए ऑप्टिमाइज़ किया गया है. तापमान को बदलने (इसे 1.0 से कम पर सेट करने) से, मॉडल के काम करने के तरीके में अनचाहे बदलाव हो सकते हैं. जैसे, जवाब का बार-बार दोहराया जाना या परफ़ॉर्मेंस में गिरावट आना. ऐसा खास तौर पर, गणित के मुश्किल सवालों या तर्क से जुड़े टास्क में होता है.

हस्ताक्षर के बारे में जानकारी

Gemini 3, एपीआई कॉल के दौरान तर्क से जुड़े कॉन्टेक्स्ट को बनाए रखने के लिए, थॉट सिग्नेचर का इस्तेमाल करता है. ये सिग्नेचर, मॉडल की इंटरनल थॉट प्रोसेस के एन्क्रिप्ट किए गए वर्शन होते हैं. यह पक्का करने के लिए कि मॉडल में तर्क देने की क्षमता बनी रहे, आपको अपने अनुरोध में इन सिग्नेचर को मॉडल को ठीक उसी तरह वापस भेजना होगा जिस तरह से वे मिले थे:

• फ़ंक्शन कॉलिंग (सख्ती से लागू): एपीआई, "मौजूदा बातचीत" पर पुष्टि करने की प्रक्रिया को सख्ती से लागू करता है. हस्ताक्षर मौजूद न होने पर, 400 गड़बड़ी दिखेगी.

• टेक्स्ट/चैट: पुष्टि करने की सुविधा को सख्ती से लागू नहीं किया जाता है. हालांकि, हस्ताक्षर शामिल न करने पर, मॉडल के तर्क और जवाब की क्वालिटी खराब हो जाएगी.

• इमेज जनरेट/एडिट करना (सख्त): एपीआई, मॉडल के सभी हिस्सों पर पुष्टि करने की सख्त प्रक्रिया लागू करता है. इसमें thoughtSignature भी शामिल है. हस्ताक्षर मौजूद न होने पर, 400 गड़बड़ी दिखेगी.

फ़ंक्शन कॉलिंग (सटीक पुष्टि)

जब Gemini कोई functionCall जनरेट करता है, तो वह thoughtSignature पर भरोसा करता है, ताकि अगले टर्न में टूल के आउटपुट को सही तरीके से प्रोसेस किया जा सके. "मौजूदा बातचीत" में, मॉडल (functionCall) और उपयोगकर्ता (functionResponse) के वे सभी चरण शामिल होते हैं जो पिछले स्टैंडर्ड उपयोगकर्ता text मैसेज के बाद हुए हैं.

• सिंगल फ़ंक्शन कॉल: functionCall वाले हिस्से में सिग्नेचर होता है. आपको इसे वापस करना होगा.
• पैरलल फ़ंक्शन कॉल: सूची में सिर्फ़ पहले functionCall हिस्से में हस्ताक्षर शामिल होगा. आपको पार्ट्स उसी क्रम में लौटाने होंगे जिस क्रम में आपको मिले थे.
• एक से ज़्यादा चरणों वाला (सीक्वेंशियल): अगर मॉडल किसी टूल को कॉल करता है, नतीजे पाता है, और दूसरे टूल को कॉल करता है (एक ही टर्न में), तो दोनों फ़ंक्शन कॉल के सिग्नेचर होते हैं. आपको इतिहास में सेव किए गए सभी हस्ताक्षर वापस लाने होंगे.

टेक्स्ट और स्ट्रीमिंग

स्टैंडर्ड चैट या टेक्स्ट जनरेट करने के लिए, सिग्नेचर के मौजूद होने की गारंटी नहीं है.

• स्ट्रीमिंग नहीं: जवाब के आखिरी हिस्से में thoughtSignature शामिल हो सकता है. हालांकि, यह हमेशा मौजूद नहीं होता. अगर कोई प्रॉडक्ट वापस आता है, तो आपको उसे वापस भेजना चाहिए, ताकि अच्छी परफ़ॉर्मेंस बनी रहे.
• स्ट्रीमिंग: अगर कोई हस्ताक्षर जनरेट किया जाता है, तो यह ऐसे फ़ाइनल चंक में आ सकता है जिसमें टेक्स्ट का कोई हिस्सा खाली हो. पक्का करें कि आपका स्ट्रीम पार्सर, हस्ताक्षर की जांच करता हो. भले ही, टेक्स्ट फ़ील्ड खाली हो.

इमेज जनरेट और एडिट करने की सुविधा

gemini-3-pro-image-preview के लिए, बातचीत करके बदलाव करने की सुविधा के लिए, थॉट सिग्नेचर ज़रूरी होते हैं. जब मॉडल से किसी इमेज में बदलाव करने के लिए कहा जाता है, तो वह पिछली बारी में मिले thoughtSignature का इस्तेमाल करता है. इससे उसे ओरिजनल इमेज की कंपोज़िशन और लॉजिक को समझने में मदद मिलती है.

• बदलाव करना: जवाब के पहले हिस्से में, text या inlineData के बाद हस्ताक्षर ज़रूर होते हैं. साथ ही, हर inlineData हिस्से में भी हस्ताक्षर होते हैं. गड़बड़ियों से बचने के लिए, आपको इन सभी हस्ताक्षर को वापस भेजना होगा.

कोड के उदाहरण

// Model Response (Turn 1, Step 1)
  {
    "role": "model",
    "parts": [
      {
        "functionCall": { "name": "check_flight", "args": {...} },
        "thoughtSignature": "<Sig_A>" // SAVE THIS
      }
    ]
  }

// User Request (Turn 1, Step 2)
[
  { "role": "user", "parts": [{ "text": "Check flight AA100..." }] },
  { 
    "role": "model", 
    "parts": [
      { 
        "functionCall": { "name": "check_flight", "args": {...} }, 
        "thoughtSignature": "<Sig_A>" // REQUIRED
      } 
    ]
  },
  { "role": "user", "parts": [{ "functionResponse": { "name": "check_flight", "response": {...} } }] }
]

// Model Response (Turn 1, Step 3)
{
  "role": "model",
  "parts": [
    {
      "functionCall": { "name": "book_taxi", "args": {...} },
      "thoughtSignature": "<Sig_B>" // SAVE THIS
    }
  ]
}

// User Request (Turn 1, Step 4)
[
  // ... previous history ...
  { 
    "role": "model", 
    "parts": [
       { "functionCall": { "name": "check_flight", ... }, "thoughtSignature": "<Sig_A>" } 
    ]
  },
  { "role": "user", "parts": [{ "functionResponse": {...} }] },
  { 
    "role": "model", 
    "parts": [
       { "functionCall": { "name": "book_taxi", ... }, "thoughtSignature": "<Sig_B>" } 
    ]
  },
  { "role": "user", "parts": [{ "functionResponse": {...} }] }
]

// User Request (Sending Parallel Results)
[
  {
    "role": "user",
    "parts": [
      { "text": "Check the weather in Paris and London." }
    ]
  },
  {
    "role": "model",
    "parts": [
      // 1. First Function Call has the signature
      {
        "functionCall": { "name": "check_weather", "args": { "city": "Paris" } },
        "thoughtSignature": "<Signature_A>" 
      },
      // 2. Subsequent parallel calls DO NOT have signatures
      {
        "functionCall": { "name": "check_weather", "args": { "city": "London" } }
      } 
    ]
  },
  {
    "role": "user",
    "parts": [
      // 3. Function Responses are grouped together in the next block
      {
        "functionResponse": { "name": "check_weather", "response": { "temp": "15C" } }
      },
      {
        "functionResponse": { "name": "check_weather", "response": { "temp": "12C" } }
      }
    ]
  }
]

// User Request (Follow-up question)
[
  { 
    "role": "user", 
    "parts": [{ "text": "What are the risks of this investment?" }] 
  },
  { 
    "role": "model", 
    "parts": [
      {
        "text": "I need to calculate the risk step-by-step. First, I'll look at volatility...",
        "thoughtSignature": "<Signature_C>" // Recommended to include
      }
    ]
  },
  { 
    "role": "user", 
    "parts": [{ "text": "Summarize that in one sentence." }] 
  }
]

// Model Response (Turn 1)
{
  "role": "model",
  "parts": [
    // 1. First part ALWAYS has a signature (even if text)
    {
      "text": "I will generate a cyberpunk city...",
      "thoughtSignature": "<Signature_D>" 
    },
    // 2. ALL InlineData (Image) parts ALWAYS have signatures
    {
      "inlineData": { ... }, 
      "thoughtSignature": "<Signature_E>" 
    },
  ]
}

// User Request (Turn 2 - Requesting an Edit)
{
  "contents": [
    // History must include ALL signatures received
    {
      "role": "user",
      "parts": [{ "text": "Generate a cyberpunk city" }]
    },
    {
      "role": "model",
      "parts": [
         { "text": "...", "thoughtSignature": "<Signature_D>" },
         { "inlineData": "...", "thoughtSignature": "<Signature_E>" },
      ]
    },
    // New User Prompt
    {
      "role": "user",
      "parts": [{ "text": "Make it daytime." }]
    }
  ]
}

दूसरे मॉडल से माइग्रेट करना

अगर आपको किसी दूसरे मॉडल (जैसे, Gemini 2.5) का इस्तेमाल किया जाता है या Gemini 3 से जनरेट नहीं किया गया कस्टम फ़ंक्शन कॉल डाला जाता है, तो आपके पास मान्य हस्ताक्षर नहीं होगा.

इन खास स्थितियों में, पुष्टि करने की सख्त प्रक्रिया को बायपास करने के लिए, इस फ़ील्ड में यह डमी स्ट्रिंग डालें: "thoughtSignature": "context_engineering_is_the_way_to_go"

टूल की मदद से स्ट्रक्चर्ड आउटपुट जनरेट करना

Gemini 3 मॉडल की मदद से, स्ट्रक्चर्ड आउटपुट को बिल्ट-इन टूल के साथ जोड़ा जा सकता है. इनमें Google Search से जानकारी पाना, यूआरएल का कॉन्टेक्स्ट, और कोड एक्ज़ीक्यूट करना शामिल हैं.

from google import genai
from google.genai import types
from pydantic import BaseModel, Field
from typing import List

class MatchResult(BaseModel):
    winner: str = Field(description="The name of the winner.")
    final_match_score: str = Field(description="The final match score.")
    scorers: List[str] = Field(description="The name of the scorer.")

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents="Search for all details for the latest Euro.",
    config={
        "tools": [
            {"google_search": {}},
            {"url_context": {}}
        ],
        "response_mime_type": "application/json",
        "response_json_schema": MatchResult.model_json_schema(),
    },  
)

result = MatchResult.model_validate_json(response.text)
print(result)

import { GoogleGenAI } from "@google/genai";
import { z } from "zod";
import { zodToJsonSchema } from "zod-to-json-schema";

const ai = new GoogleGenAI({});

const matchSchema = z.object({
  winner: z.string().describe("The name of the winner."),
  final_match_score: z.string().describe("The final score."),
  scorers: z.array(z.string()).describe("The name of the scorer.")
});

async function run() {
  const response = await ai.models.generateContent({
    model: "gemini-3-pro-preview",
    contents: "Search for all details for the latest Euro.",
    config: {
      tools: [
        { googleSearch: {} },
        { urlContext: {} }
      ],
      responseMimeType: "application/json",
      responseJsonSchema: zodToJsonSchema(matchSchema),
    },
  });

  const match = matchSchema.parse(JSON.parse(response.text));
  console.log(match);
}

run();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{
      "parts": [{"text": "Search for all details for the latest Euro."}]
    }],
    "tools": [
      {"googleSearch": {}},
      {"urlContext": {}}
    ],
    "generationConfig": {
        "responseMimeType": "application/json",
        "responseJsonSchema": {
            "type": "object",
            "properties": {
                "winner": {"type": "string", "description": "The name of the winner."},
                "final_match_score": {"type": "string", "description": "The final score."},
                "scorers": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "The name of the scorer."
                }
            },
            "required": ["winner", "final_match_score", "scorers"]
        }
    }
  }'

Image generation

Gemini 3 Pro Image की मदद से, टेक्स्ट प्रॉम्प्ट से इमेज जनरेट की जा सकती हैं और उनमें बदलाव किया जा सकता है. यह किसी प्रॉम्प्ट के बारे में "सोचने" के लिए तर्क का इस्तेमाल करता है. साथ ही, यह रीयल-टाइम डेटा को भी ऐक्सेस कर सकता है. जैसे, मौसम का पूर्वानुमान या स्टॉक चार्ट. इसके बाद, यह Google Search से मिली जानकारी का इस्तेमाल करके, ज़्यादा सटीक इमेज जनरेट करता है.

नई और बेहतर सुविधाएँ:

• 4K और टेक्स्ट रेंडरिंग: 2K और 4K रिज़ॉल्यूशन तक के टेक्स्ट और डायग्राम जनरेट करें.
• भरोसेमंद जानकारी के आधार पर जवाब जनरेट करना: google_search टूल का इस्तेमाल करके, तथ्यों की पुष्टि करें और असल दुनिया की जानकारी के आधार पर इमेज जनरेट करें.
• बातचीत करके इमेज में बदलाव करना: इमेज में बदलाव करने के लिए, Gemini से बातचीत की जा सकती है. जैसे, "बैकग्राउंड में सूर्यास्त की तस्वीर लगाओ"). यह वर्कफ़्लो, सोच के आधार पर जवाब तैयार करने की सुविधा पर निर्भर करता है. इससे, बातचीत के दौरान विज़ुअल कॉन्टेक्स्ट को बनाए रखने में मदद मिलती है.

आस्पेक्ट रेशियो, बदलाव करने के वर्कफ़्लो, और कॉन्फ़िगरेशन के विकल्पों के बारे में पूरी जानकारी के लिए, इमेज जनरेट करने से जुड़ी गाइड देखें.

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-pro-image-preview",
    contents="Generate an infographic of the current weather in Tokyo.",
    config=types.GenerateContentConfig(
        tools=[{"google_search": {}}],
        image_config=types.ImageConfig(
            aspect_ratio="16:9",
            image_size="4K"
        )
    )
)

image_parts = [part for part in response.parts if part.inline_data]

if image_parts:
    image = image_parts[0].as_image()
    image.save('weather_tokyo.png')
    image.show()

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({});

async function run() {
  const response = await ai.models.generateContent({
    model: "gemini-3-pro-image-preview",
    contents: "Generate a visualization of the current weather in Tokyo.",
    config: {
      tools: [{ googleSearch: {} }],
      imageConfig: {
        aspectRatio: "16:9",
        imageSize: "4K"
      }
    }
  });

  for (const part of response.candidates[0].content.parts) {
    if (part.inlineData) {
      const imageData = part.inlineData.data;
      const buffer = Buffer.from(imageData, "base64");
      fs.writeFileSync("weather_tokyo.png", buffer);
    }
  }
}

run();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro-image-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{
      "parts": [{"text": "Generate a visualization of the current weather in Tokyo."}]
    }],
    "tools": [{"googleSearch": {}}],
    "generationConfig": {
        "imageConfig": {
          "aspectRatio": "16:9",
          "imageSize": "4K"
      }
    }
  }'

जवाब का उदाहरण

Gemini 2.5 से माइग्रेट करना

Gemini 3, अब तक का हमारा सबसे बेहतरीन मॉडल है. यह Gemini 2.5 से ज़्यादा बेहतर है. डेटा माइग्रेट करते समय, इन बातों का ध्यान रखें:

• सोच-समझकर जवाब देना: अगर आपने Gemini 2.5 को सोच-समझकर जवाब देने के लिए, पहले मुश्किल प्रॉम्प्ट इंजीनियरिंग (जैसे, चेन ऑफ़ थॉट) का इस्तेमाल किया था, तो thinking_level: "high" और आसान प्रॉम्प्ट के साथ Gemini 3 को आज़माएँ.
• तापमान की सेटिंग: अगर आपके मौजूदा कोड में तापमान को साफ़ तौर पर सेट किया गया है (खास तौर पर, भरोसेमंद आउटपुट के लिए कम वैल्यू पर सेट किया गया है), तो हमारा सुझाव है कि आप इस पैरामीटर को हटा दें. साथ ही, Gemini 3 के डिफ़ॉल्ट तापमान 1.0 का इस्तेमाल करें. इससे, लूपिंग से जुड़ी संभावित समस्याओं से बचा जा सकेगा. साथ ही, मुश्किल टास्क में परफ़ॉर्मेंस में गिरावट नहीं आएगी.
• PDF और दस्तावेज़ को समझना: PDF के लिए, ओसीआर का डिफ़ॉल्ट रिज़ॉल्यूशन बदल गया है. अगर आपने दस्तावेज़ को पार्स करने के लिए, किसी खास तरीके का इस्तेमाल किया है, तो नई media_resolution_high सेटिंग को आज़माएं. इससे यह पक्का किया जा सकेगा कि जानकारी सटीक बनी रहे.
• टोकन का इस्तेमाल: Gemini 3 के डिफ़ॉल्ट सेटिंग पर माइग्रेट करने से, PDF के लिए टोकन का इस्तेमाल बढ़ सकता है. हालांकि, वीडियो के लिए टोकन का इस्तेमाल कम हो सकता है. अगर डिफ़ॉल्ट रिज़ॉल्यूशन ज़्यादा होने की वजह से, अनुरोध अब कॉन्टेक्स्ट विंडो से ज़्यादा हो जाते हैं, तो हमारा सुझाव है कि मीडिया रिज़ॉल्यूशन को साफ़ तौर पर कम करें.
• इमेज सेगमेंटेशन: इमेज सेगमेंटेशन की सुविधाएं (ऑब्जेक्ट के लिए पिक्सल-लेवल के मास्क दिखाना) Gemini 3 Pro या Gemini 3 Flash में काम नहीं करती हैं. जिन कामों के लिए इमेज सेगमेंटेशन की सुविधा की ज़रूरत होती है उनके लिए, हमारा सुझाव है कि आप सूझ-बूझ वाली सुविधा बंद करके Gemini 2.5 Flash का इस्तेमाल जारी रखें या Gemini Robotics-ER 1.5 का इस्तेमाल करें.
• टूल के साथ काम करने की सुविधा: Maps grounding और कंप्यूटर इस्तेमाल करने वाले टूल, Gemini 3 मॉडल के साथ काम नहीं करते. इसलिए, इन्हें माइग्रेट नहीं किया जाएगा. इसके अलावा, फ़िलहाल बिल्ट-इन टूल के साथ फ़ंक्शन कॉलिंग का इस्तेमाल नहीं किया जा सकता.

OpenAI के साथ काम करने की सुविधा

OpenAI के साथ काम करने वाली लेयर का इस्तेमाल करने वाले लोगों के लिए, स्टैंडर्ड पैरामीटर अपने-आप Gemini के बराबर के पैरामीटर पर मैप हो जाते हैं:

• reasoning_effort (OAI) को thinking_level (Gemini) पर मैप किया जाता है. ध्यान दें कि Gemini 3 Flash पर, reasoning_effort मीडियम को thinking_level हाई पर मैप किया जाता है.

प्रॉम्प्ट लिखने के सबसे सही तरीके

Gemini 3, रीज़निंग करने वाला मॉडल है. इससे प्रॉम्प्ट देने का तरीका बदल जाता है.

• सटीक निर्देश: अपने इनपुट प्रॉम्प्ट में कम शब्दों का इस्तेमाल करें. Gemini 3, सीधे और साफ़ तौर पर दिए गए निर्देशों का सबसे अच्छा जवाब देता है. यह पुराने मॉडल के लिए इस्तेमाल की गई, ज़्यादा शब्दों वाली या बहुत मुश्किल प्रॉम्प्ट इंजीनियरिंग तकनीकों का ज़्यादा विश्लेषण कर सकता है.
• जवाब में शब्दों का इस्तेमाल: डिफ़ॉल्ट रूप से, Gemini 3 कम शब्दों में जवाब देता है. यह सीधे तौर पर और असरदार तरीके से जवाब देने को प्राथमिकता देता है. अगर आपको अपने इस्तेमाल के उदाहरण के लिए, ज़्यादा बातचीत करने वाले या "चैट करने वाले" पर्सोना की ज़रूरत है, तो आपको प्रॉम्प्ट में मॉडल को साफ़ तौर पर बताना होगा. उदाहरण के लिए, "इसे एक दोस्त की तरह, बातचीत करने वाले असिस्टेंट के तौर पर समझाओ").
• कॉन्टेक्स्ट मैनेजमेंट: बड़े डेटासेट (जैसे, पूरी किताबें, कोडबेस या लंबे वीडियो) के साथ काम करते समय, अपने खास निर्देश या सवाल प्रॉम्प्ट के आखिर में रखें. ऐसा डेटा के कॉन्टेक्स्ट के बाद करें. मॉडल के जवाब को दिए गए डेटा के हिसाब से बनाने के लिए, अपने सवाल की शुरुआत "ऊपर दी गई जानकारी के आधार पर..." जैसे वाक्यांश से करें.

प्रॉम्प्ट इंजीनियरिंग गाइड में, प्रॉम्प्ट डिज़ाइन करने की रणनीतियों के बारे में ज़्यादा जानें.

अक्सर पूछे जाने वाले सवाल

1. Gemini 3 के लिए, जानकारी अपडेट होने की आखिरी तारीख क्या है? Gemini 3 मॉडल के लिए, जानकारी के अपडेट होने की आखिरी तारीख जनवरी 2025 है. ज़्यादा नई जानकारी पाने के लिए, खोज के नतीजों से जुड़ी जानकारी टूल का इस्तेमाल करें.

2. कॉन्टेक्स्ट विंडो की सीमाएं क्या हैं? Gemini 3 मॉडल, 10 लाख टोकन वाली कॉन्टेक्स्ट विंडो के साथ काम करते हैं. साथ ही, ये 64 हज़ार टोकन तक का आउटपुट दे सकते हैं.

3. क्या Gemini 3 को बिना किसी शुल्क के इस्तेमाल किया जा सकता है? Gemini API में Gemini 3 Flash gemini-3-flash-preview का इस्तेमाल बिना किसी शुल्क के किया जा सकता है. Google AI Studio में, Gemini 3 Pro और Flash, दोनों को बिना किसी शुल्क के आज़माया जा सकता है. हालांकि, फ़िलहाल Gemini API में gemini-3-pro-preview के लिए, बिना किसी शुल्क वाला टियर उपलब्ध नहीं है.

4. क्या मेरा पुराना thinking_budget कोड अब भी काम करेगा? हां, thinking_budget अब भी पुराने सिस्टम के साथ काम करता है. हालांकि, हमारा सुझाव है कि आप thinking_level पर माइग्रेट करें, ताकि आपको बेहतर परफ़ॉर्मेंस मिल सके. एक ही अनुरोध में दोनों का इस्तेमाल न करें.

5. क्या Gemini 3, Batch API के साथ काम करता है? हां, Gemini 3, Batch API के साथ काम करता है.

6. क्या कॉन्टेक्स्ट को कैश मेमोरी में सेव करने की सुविधा काम करती है? हां, Gemini 3 के लिए कॉन्टेक्स्ट को कैश मेमोरी में सेव करने की सुविधा उपलब्ध है.

7. Gemini 3 में किन टूल का इस्तेमाल किया जा सकता है? Gemini 3, Google Search, फ़ाइल खोजने, कोड चलाने, और यूआरएल के कॉन्टेक्स्ट के साथ काम करता है. यह आपके कस्टम टूल के लिए, स्टैंडर्ड फ़ंक्शन कॉलिंग की सुविधा भी देता है. हालांकि, यह सुविधा बिल्ट-इन टूल के साथ काम नहीं करती. कृपया ध्यान दें कि फ़िलहाल, Google Maps से मिली जानकारी का इस्तेमाल करना और कंप्यूटर का इस्तेमाल करना जैसी सुविधाएं उपलब्ध नहीं हैं.

अगले चरण

• Gemini 3 Cookbook का इस्तेमाल शुरू करना
• थिंकिंग लेवल और थिंकिंग बजट से थिंकिंग लेवल पर माइग्रेट करने के तरीके के बारे में जानने के लिए, Cookbook की गाइड देखें.