Gemini Robotics ER

Gemini Robotics ER (embodied reasoning) मॉडल, विज़न-लैंग्वेज मॉडल (वीएलएम) होते हैं. इनकी मदद से रोबोट, असल दुनिया को समझ पाते हैं और उससे इंटरैक्ट कर पाते हैं. ये विज़ुअल डेटा को समझते हैं, स्पैशियल और टेंपोरल रीज़निंग करते हैं, कई चरणों वाले टास्क की योजना बनाते हैं, और रोबोट और टूल को मैनेज करते हैं.

मॉडल

Gemini Robotics ER 2 मॉडल, Gemini Robotics का नया मॉडल है. यह हमारा अपडेट किया गया रीज़निंग मॉडल है. इसकी मदद से, रोबोट अपने आस-पास के माहौल को सटीक तरीके से समझ पाते हैं. यह एम्बॉडिड रीज़निंग की क्षमताओं में माहिर है. जैसे, रोबोट का एजेंटिक ऑर्केस्ट्रेशन (उदाहरण के लिए, वीएलए का इस्तेमाल करना), रोबोट के वीडियो को समझना, जिसमें प्रोग्रेस को समझना और सफलता का पता लगाना, इंस्ट्रूमेंट पढ़ना, पॉइंट करना, और स्पेशल रीज़निंग शामिल है.

Gemini Robotics ER 2 मॉडल में दो मॉडल एंडपॉइंट शामिल हैं:

• gemini-robotics-er-2-preview: यह स्टैंडर्ड ER 2 मॉडल है. यह Gemini 3.5 Flash पर आधारित है. इसमें बेहतर स्पेशल रीज़निंग, वीडियो में खास पल ढूंढने की सुविधा, वीडियो की प्रोग्रेस का आकलन करने की सुविधा, एक साथ कई रोबोट को कंट्रोल करने की सुविधा, और कई चरणों में टूल इस्तेमाल करने की सुविधा मिलती है.
• gemini-robotics-er-2-streaming-preview: इसे Live API का इस्तेमाल करके, रीयल-टाइम में स्ट्रीम करने के लिए ऑप्टिमाइज़ किया गया है. इस मॉडल का इस्तेमाल, कम समय में जवाब देने वाले रोबोट एजेंट के लिए करें. यह लगातार ऑडियो और वीडियो इनपुट को प्रोसेस करता है.

Gemini Robotics ER 1.6 को 31 अगस्त, 2026 को बंद कर दिया गया था. अगर अब भी Gemini Robotics ER 1.6 का इस्तेमाल किया जा रहा है, तो Gemini Robotics ER 2 पर अपग्रेड करें. इसके लिए, अपने एपीआई कॉल में model="gemini-robotics-er-1.6-preview" को model="gemini-robotics-er-2-preview" या model="gemini-robotics-er-2-streaming-preview" से बदलें.

Google AI Studio में Gemini Robotics ER 2 को आज़माएं

रोबोटिक्स की क्षमताएं

Gemini Robotics ER, कई तरह की एम्बॉडीड रिज़निंग की क्षमताओं के साथ काम करता है. ज़्यादा जानने के लिए, कोई सुविधा चुनें:

शुरू करने से पहले

Gemini Robotics ER मॉडल, Gemini Developer API के ज़रिए उपलब्ध हैं. शुरू करने के लिए, Google AI Studio या Google Cloud Console से Gemini API पासकोड बनाएं. इसके बाद, अपना एनवायरमेंट सेट अप करें.

पासकोड के टाइप, सुरक्षा, और Python, JavaScript, और अन्य भाषाओं में पासकोड को कॉन्फ़िगर करने के तरीके के बारे में जानने के लिए, Gemini API पासकोड का इस्तेमाल करना लेख पढ़ें.

शुरू करना

यहां दिए गए उदाहरण में, किसी इमेज में मौजूद ऑब्जेक्ट का पता लगाया गया है. साथ ही, उनके सामान्य किए गए 2D कोऑर्डिनेट और लेबल दिखाए गए हैं. इस आउटपुट को सीधे तौर पर रोबोटिक्स एपीआई या वीएलए मॉडल को पास किया जा सकता है, ताकि रोबोट की कार्रवाइयां जनरेट की जा सकें.

from google import genai

PROMPT = """
          Point to no more than 10 items in the image. The label returned
          should be an identifying name for the object detected.
          The answer should follow the json format: [{"point": ,
          "label": }, ...]. The points are in [y, x] format
          normalized to 0-1000.
        """
client = genai.Client()

uploaded_file = client.files.upload(file="my-image.png")

image_response = client.interactions.create(
    model="gemini-robotics-er-2-preview",
    input=[
        {
            "type": "image",
            "uri": uploaded_file.uri,
            "mime_type": uploaded_file.mime_type
        },
        {"type": "text", "text": PROMPT}
    ],
    generation_config={"thinking_level": "high"},
)

print(image_response.output_text)

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

const PROMPT = `
  Point to no more than 10 items in the image. The label returned
  should be an identifying name for the object detected.
  The answer should follow the json format: [{"point": ,
  "label": }, ...]. The points are in [y, x] format
  normalized to 0-1000.
`;
const client = new GoogleGenAI();

const uploadedFile = await client.files.upload({ file: "my-image.png" });

const imageResponse = await client.interactions.create({
  model: "gemini-robotics-er-2-preview",
  input: [
    {
      type: "image",
      uri: uploadedFile.uri,
      mime_type: uploadedFile.mimeType,
    },
    { type: "text", text: PROMPT },
  ],
  generation_config: { thinking_level: "high" },
});

console.log(imageResponse.output_text);

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.Content;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.GenerationConfig;
import com.google.genai.gaos.models.interactions.ImageContent;
import com.google.genai.gaos.models.interactions.ImageContentMimeType;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.interactions.ThinkingLevel;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import com.google.genai.types.File;
import com.google.genai.types.UploadFileConfig;
import java.util.List;

Client client = new Client();

String prompt =
    "Point to no more than 10 items in the image. The label returned "
        + "should be an identifying name for the object detected. "
        + "The answer should follow the json format: [{\"point\": , "
        + "\"label\": }, ...]. The points are in [y, x] format "
        + "normalized to 0-1000.";

File uploadedFile =
    client.files.upload(
        new java.io.File("my-image.png"),
        UploadFileConfig.builder().mimeType("image/png").build());

Content imageContent =
    ImageContent.builder()
        .uri(uploadedFile.uri().orElse(""))
        .mimeType(ImageContentMimeType.of(uploadedFile.mimeType().orElse("image/png")))
        .build();
Content textContent = TextContent.builder().text(prompt).build();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-robotics-er-2-preview"))
        .input(InteractionsInput.ofContent(List.of(imageContent, textContent)))
        .generationConfig(
            GenerationConfig.builder().thinkingLevel(ThinkingLevel.HIGH).build())
        .build();

Interaction imageResponse =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(imageResponse.outputText().orElse(""));

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    prompt := `Point to no more than 10 items in the image. The label returned
should be an identifying name for the object detected.
The answer should follow the json format: [{"point": ,
"label": }, ...]. The points are in [y, x] format
normalized to 0-1000.`

    uploadedFile, err := client.Files.UploadFromPath(ctx, "my-image.png", &genai.UploadFileConfig{
        MIMEType: "image/png",
    })
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-robotics-er-2-preview"),
            Input: interactions.NewInteractionsInput([]interactions.Content{
                interactions.NewContent(interactions.ImageContent{
                    URI:      genai.Ptr(uploadedFile.URI),
                    MimeType: genai.Ptr(interactions.ImageMimeTypeImagePng),
                }),
                interactions.NewContent(interactions.TextContent{
                    Text: prompt,
                }),
            }),
            GenerationConfig: &interactions.GenerationConfig{
                ThinkingLevel: interactions.ThinkingLevelHigh.ToPointer(),
            },
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

# First, ensure you have the image file locally.
# Encode the image to base64
IMAGE_BASE64=$(base64 -w 0 my-image.png)

curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-robotics-er-2-preview",
    "input": {
      "parts": [
        {
          "inlineData": {
            "mimeType": "image/png",
            "data": "'"${IMAGE_BASE64}"'"
          }
        },
        {
          "text": "Point to no more than 10 items in the image. The label returned should be an identifying name for the object detected. The answer should follow the json format: [{\"point\": [y, x], \"label\": }, ...]. The points are in [y, x] format normalized to 0-1000."
        }
      ]
    },
    "generation_config": {
      "thinking_config": {
        "thinking_level": "high"
      }
    }
  }'

आउटपुट एक JSON कलेक्शन होगा. इसमें ऑब्जेक्ट शामिल होंगे. हर ऑब्जेक्ट में point (सामान्य किए गए [y, x] कोऑर्डिनेट) और ऑब्जेक्ट की पहचान करने वाला label होगा.

[
  {"point": [376, 508], "label": "small banana"},
  {"point": [287, 609], "label": "larger banana"},
  {"point": [223, 303], "label": "pink starfruit"},
  {"point": [435, 172], "label": "paper bag"},
  {"point": [270, 786], "label": "green plastic bowl"},
  {"point": [488, 775], "label": "metal measuring cup"},
  {"point": [673, 580], "label": "dark blue bowl"},
  {"point": [471, 353], "label": "light blue bowl"},
  {"point": [492, 497], "label": "bread"},
  {"point": [525, 429], "label": "lime"}
]

नीचे दी गई इमेज में, इन पॉइंट को दिखाने का तरीका बताया गया है:

यह कैसे काम करता है

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

Gemini Robotics ER भी एजेंटिक है. यह मुश्किल टास्क को छोटे-छोटे टास्क में बाँटता है और उन्हें पूरा करता है. इसके लिए, यह आपके रोबोट के फ़ंक्शन को कॉल करता है या जनरेट किए गए कोड को चलाता है. उदाहरण के लिए, "सेब को कटोरे में रखो" को ढूंढने, पकड़ने, और रखने के चरणों के क्रम में बदल दिया जाता है.

Gemini, टूल कॉल को कैसे पूरा करता है, इस बारे में ज़्यादा जानने के लिए फ़ंक्शन कॉलिंग देखें.

सुरक्षा

Gemini Robotics ER को सुरक्षा को ध्यान में रखकर बनाया गया है. हालांकि, यह आपकी ज़िम्मेदारी है कि आप रोबोट के आस-पास सुरक्षित माहौल बनाए रखें. जनरेटिव एआई मॉडल से गलतियां हो सकती हैं. साथ ही, फ़िज़िकल रोबोट से नुकसान हो सकता है. ज़्यादा जानने के लिए, Gemini Robotics का सुरक्षा पेज पर जाएं.

सबसे सही तरीके

1. आम बोलचाल की भाषा का इस्तेमाल करें. बताएं कि आपको रोबोट से क्या काम करवाना है. अगर कोई शब्द काम नहीं कर रहा है, तो उसका सामान्य समानार्थी शब्द इस्तेमाल करें.

2. विज़ुअल इनपुट को ऑप्टिमाइज़ करें. इमेज भेजने से पहले, छोटे या साफ़ नहीं दिखने वाले ऑब्जेक्ट को काटें या ज़ूम इन करें. रोशनी और कम कलर कंट्रास्ट की वजह से, इंसान की मौजूदगी का पता लगाने की सुविधा पर असर पड़ सकता है.

3. मुश्किल टास्क को चरणों में बांटें. हर चरण को अलग-अलग प्रॉम्प्ट के तौर पर भेजें, ताकि मॉडल का फ़ोकस बना रहे और जवाब ज़्यादा सटीक हो.

4. ज़्यादा सटीक नतीजे पाने के लिए, एक ही क्वेरी को कई बार करें और उसके नतीजों का औसत निकालें. सहमति वाले इस तरीके से, जगह की जानकारी से जुड़े आउटपुट में अंतर कम हो जाता है.

सीमाएं

Gemini Robotics ER का इस्तेमाल करके डेवलपमेंट करते समय, इन सीमाओं का ध्यान रखें:

• एपीआई पासकोड से जुड़ी पाबंदियां: Gemini API, बिना पाबंदी वाले एपीआई पासकोड से मिले अनुरोधों को स्वीकार नहीं करता है. साथ ही, 403 Forbidden गड़बड़ी का मैसेज दिखाता है. AI Studio में पाबंदियां जोड़कर, अपनी एपीआई कुंजी को सुरक्षित करें. ज़्यादा जानकारी के लिए, बिना पाबंदी के इस्तेमाल किए जा सकने वाले एपीआई पासकोड को सुरक्षित करना लेख पढ़ें.
• लेटेंसी बनाम परफ़ॉर्मेंस: मुश्किल क्वेरी, हाई रिज़ॉल्यूशन वाले इनपुट या ज़्यादा सोच-विचार करने की ज़रूरत वाले सवालों को प्रोसेस करने में ज़्यादा समय लग सकता है. सोचने के लेवल के लिए, परफ़ॉर्मेंस और इंतज़ार के समय के बीच बेहतर संतुलन बनाए रखने के लिए, मीडियम लेवल का इस्तेमाल करें.
• गलत जानकारी: सभी लार्ज लैंग्वेज मॉडल की तरह, Gemini Robotics ER मॉडल भी कभी-कभी "गलत जानकारी" दे सकते हैं या गलत जानकारी दे सकते हैं. ऐसा खास तौर पर, अस्पष्ट प्रॉम्प्ट या डिस्ट्रिब्यूशन से बाहर के इनपुट के लिए होता है.
• प्रॉम्प्ट की क्वालिटी पर निर्भरता: आउटपुट की क्वालिटी, इनपुट प्रॉम्प्ट के साफ़ तौर पर दिए जाने पर निर्भर करती है. सटीक और व्यवस्थित प्रॉम्प्ट का इस्तेमाल करें.
• कैलकुलेशन की लागत: मॉडल को चलाने में, खास तौर पर वीडियो इनपुट या ज़्यादा thinking_budget के साथ, कंप्यूटेशनल संसाधनों का इस्तेमाल होता है और लागत लगती है. ज़्यादा जानकारी के लिए, सोचना पेज देखें.
• इनपुट टाइप: हर मोड के लिए तय की गई सीमाओं के बारे में जानने के लिए, यहां दिए गए विषय देखें.
  • इमेज इनपुट
  • वीडियो इनपुट
  • ऑडियो इनपुट

निजता नोटिस

आप स्वीकार करते हैं कि इस दस्तावेज़ में बताए गए मॉडल ("रोबोटिक्स मॉडल"), वीडियो और ऑडियो डेटा का इस्तेमाल करते हैं. ऐसा इसलिए, ताकि वे आपके निर्देशों के मुताबिक काम कर सकें और आपके हार्डवेयर को मूव कर सकें. इसलिए, आपके पास रोबोटिक्स मॉडल को इस तरह से चलाने का विकल्प होता है कि वे पहचान ज़ाहिर करने वाली जानकारी इकट्ठा करें. जैसे, आवाज़, इमेज, और मिलते-जुलते डेटा ("निजी डेटा"). अगर आपने Robotics Models को इस तरह से इस्तेमाल करने का विकल्प चुना है कि वह निजी डेटा इकट्ठा करता है, तो इसका मतलब है कि आपने इस बात पर सहमति दी है कि आप किसी भी ऐसे व्यक्ति को Robotics Models के साथ इंटरैक्ट करने या उसके आस-पास मौजूद रहने की अनुमति नहीं देंगे जिसकी पहचान की जा सकती है. ऐसा तब तक नहीं किया जा सकेगा, जब तक ऐसे व्यक्ति को यह सूचना न दे दी जाए कि उसका निजी डेटा, Gemini API की सेवा की अतिरिक्त शर्तों में बताए गए तरीके से Google को दिया जा सकता है और Google उसका इस्तेमाल कर सकता है. Gemini API की सेवा की अतिरिक्त शर्तें, https://ai.google.dev/gemini-api/terms पर उपलब्ध हैं. इन्हें "शर्तें" कहा जाता है. इसमें "Google आपके डेटा का इस्तेमाल कैसे करता है" सेक्शन में दी गई जानकारी भी शामिल है. आपको यह पक्का करना होगा कि इस तरह की सूचना में, शर्तों में बताए गए तरीके से निजी डेटा को इकट्ठा करने और इस्तेमाल करने की अनुमति दी गई हो. साथ ही, आपको निजी डेटा को इकट्ठा करने और डिस्ट्रिब्यूट करने की प्रोसेस को कम करने के लिए, कारोबार के नज़रिए से सही प्रयास करने होंगे. इसके लिए, आपको चेहरे को धुंधला करने जैसी तकनीकों का इस्तेमाल करना होगा. साथ ही, रोबोटिक्स मॉडल को उन इलाकों में ऑपरेट करना होगा जहां पहचाना जा सकने वाला व्यक्ति नहीं है.

कीमत

शुल्क और उपलब्धता वाले देशों के बारे में ज़्यादा जानकारी के लिए, शुल्क पेज पर जाएं.

मॉडल एंडपॉइंट

आगे क्या करना है

• स्पेशल रीज़निंग — पॉइंटिंग, ट्रैकिंग, बाउंडिंग बॉक्स, ट्रैजेक्ट्री.
• एजेंटिक क्षमताएं — कोड को लागू करना, इंस्ट्रुमेंट को पढ़ना, और इमेज की व्याख्या करना.
• टास्क ऑर्केस्ट्रेशन — कस्टम रोबोट एपीआई के साथ लंबे समय तक चलने वाले टास्क.
• स्ट्रीमिंग के साथ रोबोटिक्स — रीयल-टाइम में दोनों तरफ़ से स्ट्रीमिंग (सिर्फ़ Gemini Robotics ER 2 के लिए).
• वीडियो को समझना — वीडियो में किसी खास पल को ढूंढना और प्रोग्रेस को कैटगरी में बांटना (सिर्फ़ Gemini Robotics ER 2 के लिए).
• Gemini Robotics की सुरक्षा — मॉडल फ़ैमिली के पीछे की सुरक्षा से जुड़ी रिसर्च.