Interactions API

Interactions API, Gemini मॉडल और एजेंटों के साथ काम करने का सबसे अच्छा तरीक़ा है. जून 2026 से, यह सामान्य तौर पर उपलब्ध है. साथ ही, सभी नए प्रोजेक्ट के लिए इसका सुझाव दिया जाता है. हालांकि, अब इसे लेगसी माना जाता है, लेकिन ओरिजनल generateContent एपीआई का इस्तेमाल अब भी किया जा सकता है.

Interactions API का इस्तेमाल क्यों करना चाहिए?

• सभी ऐप्लिकेशन के लिए यूनिवर्सल इंटरफ़ेस: इसे इस्तेमाल के हर तरीके के लिए स्टैंडर्ड इंटरफ़ेस के तौर पर डिज़ाइन किया गया है. इसमें सिंगल-टर्न टेक्स्ट जनरेशन, मल्टीमॉडल अंडरस्टैंडिंग, स्ट्रक्चर्ड आउटपुट, टूल ऑर्केस्ट्रेशन, और एजेंटिक वर्कफ़्लो शामिल हैं.
• मॉडल और एजेंट के लिए एक ही एपीआई: स्टैंडर्ड Gemini मॉडल के साथ-साथ, सीधे तौर पर खास एजेंट (जैसे, Deep Research और कस्टम मैनेज किए गए एजेंट) को कॉल करने के लिए, एक ही यूनीफ़ाइड एंडपॉइंट और पैटर्न.
• नई सुविधाएं: जैसे, previous_interaction_id का इस्तेमाल करके सर्वर-साइड बातचीत की स्थिति को वैकल्पिक तौर पर सेव करना, डीबग करने और यूज़र इंटरफ़ेस रेंडर करने के लिए, एक्ज़ीक्यूशन के चरणों को मॉनिटर करना, और background=true का इस्तेमाल करके लंबे समय तक चलने वाले टास्क के लिए बैकग्राउंड एक्ज़ीक्यूशन.
• कैश मेमोरी के हिट रेट ज़्यादा होने पर लागत कम होना: सिलसिलेवार बातचीत का इस्तेमाल करते समय, सर्वर-साइड स्टेट मैनेजमेंट की सुविधा चालू करने पर, हर बार के हिसाब से कॉन्टेक्स्ट को ज़्यादा बेहतर तरीके से कैश मेमोरी में सेव किया जा सकता है. इससे टोकन की लागत कम हो जाती है.
• नई सुविधाएं कहाँ लॉन्च होंगी: आने वाले समय में, सभी नए मॉडल, मल्टीमॉडल सुविधाएँ, टूल, और एजेंटिक सुविधाएँ, Interactions API पर लॉन्च होंगी.

डिफ़ॉल्ट रूप से, Interactions API अनुरोधों को सेव करता है, ताकि previous_interaction_id का इस्तेमाल करके, सर्वर-साइड स्टेट मैनेजमेंट की सुविधाओं का फ़ायदा लिया जा सके. store=false को सेट करके, स्टेटलेस व्यवहार के लिए ऑप्ट इन किया जा सकता है. ज़्यादा जानकारी के लिए, डेटा के रखरखाव सेक्शन देखें.

अपनी प्रोफ़ाइल बनाना शुरू करें

• कोडिंग एजेंट सेट अप करना: Gemini Docs MCP से कनेक्ट करें और gemini-api-dev स्किल इंस्टॉल करें. इससे आपके असिस्टेंट को डेवलपर के लिए उपलब्ध नए दस्तावेज़ों और सबसे सही तरीकों का सीधा ऐक्सेस मिलेगा. ज़्यादा जानकारी के लिए, कोडिंग एजेंट सेट अप करने से जुड़ी गाइड देखें
• generateContent से माइग्रेट करें: अगर आपने पहले से ही इंटिग्रेशन किया हुआ है, तो Interactions API पर माइग्रेट करने के लिए, माइग्रेशन गाइड देखें.
• शुरू करें: Interactions API का इस्तेमाल शुरू करने से जुड़ी गाइड में दिए गए चरणों का पालन करें.

सुविधा की गाइड

इन गाइड की मदद से, Interactions API की खास सुविधाओं के बारे में जानें. इन पेजों पर मौजूद टॉगल का इस्तेमाल करके, generateContent और Interactions API के बीच स्विच किया जा सकता है:

• टेक्स्ट जनरेट करने की सुविधा
• इमेज जनरेट करना
• इमेज की बारीक़ी से पहचान
• ऑडियो को समझना
• वीडियो को समझना
• दस्तावेज़ की प्रोसेसिंग
• फ़ंक्शन कॉलिंग
• स्ट्रक्चर्ड आउटपुट
• Deep Research एजेंट
• Flex inference
• प्राथमिकता का अनुमान लगाना

Interactions API कैसे काम करता है

Interactions API, मुख्य संसाधन Interaction पर आधारित है. Interaction का मतलब है कि बातचीत या टास्क पूरा हो गया है. यह सेशन रिकॉर्ड के तौर पर काम करता है. इसमें इंटरैक्शन का पूरा इतिहास, एक्ज़ीक्यूशन के चरणों के क्रम के तौर पर शामिल होता है. इन चरणों में मॉडल के सुझाव, सर्वर-साइड या क्लाइंट-साइड टूल कॉल और नतीजे (जैसे, function_call और function_result) और फ़ाइनल model_output शामिल हैं. स्टोर किए गए संसाधन (interactions.get के ज़रिए वापस पाया गया) में, पूरे कॉन्टेक्स्ट के लिए user_input चरण भी शामिल होते हैं. हालांकि, interactions.create से मिले जवाब में सिर्फ़ मॉडल से जनरेट किए गए चरण शामिल होते हैं.

interactions.create पर कॉल करने का मतलब है कि आपने एक नई Interaction संसाधन बनाया है:

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Tell me a short story about a time-traveling lighthouse."
)

print(interaction.output_text)

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

const client = new GoogleGenAI();

const interaction = await client.interactions.create({
  model: "gemini-3.8-flash",
  input: "Tell me a short story about a time-traveling lighthouse.",
});

console.log(interaction.output_text);

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
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.operations.CreateInteractionRequestBody;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.of("Tell me a short story about a time-traveling lighthouse."))
        .build();

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

System.out.println(interaction.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)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash"),
            Input: interactions.NewInteractionsInput("Tell me a short story about a time-traveling lighthouse."),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -d '{
    "model": "gemini-3.8-flash",
    "input": "Tell me a short story about a time-traveling lighthouse."
  }'

सर्वर-साइड स्टेट मैनेजमेंट

बातचीत जारी रखने के लिए, previous_interaction_id पैरामीटर का इस्तेमाल करके, पूरी हो चुकी बातचीत के id का इस्तेमाल किया जा सकता है. सर्वर इस आईडी का इस्तेमाल, बातचीत का इतिहास वापस पाने के लिए करता है. इससे आपको चैट का पूरा इतिहास फिर से भेजने की ज़रूरत नहीं पड़ती:

from google import genai

client = genai.Client()

# 1. First turn
turn1 = client.interactions.create(
    model="gemini-3.8-flash",
    input="Hi, my name is Phil."
)

# 2. Second turn (chained using previous_interaction_id)
turn2 = client.interactions.create(
    model="gemini-3.8-flash",
    input="What is my name?",
    previous_interaction_id=turn1.id
)

print(turn2.output_text)

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

const client = new GoogleGenAI();

// 1. First turn
const turn1 = await client.interactions.create({
  model: "gemini-3.8-flash",
  input: "Hi, my name is Phil.",
});

// 2. Second turn (chained using previous_interaction_id)
const turn2 = await client.interactions.create({
  model: "gemini-3.8-flash",
  input: "What is my name?",
  previous_interaction_id: turn1.id,
});

console.log(turn2.output_text);

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
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.operations.CreateInteractionRequestBody;

Client client = new Client();

// 1. First turn
Interaction turn1 =
    client
        .interactions
        .create(
            CreateInteractionRequestBody.of(
                CreateModelInteraction.builder()
                    .model(Model.of("gemini-3.8-flash"))
                    .input(InteractionsInput.of("Hi, my name is Phil."))
                    .build()))
        .interaction()
        .get();

// 2. Second turn (chained using previousInteractionId)
Interaction turn2 =
    client
        .interactions
        .create(
            CreateInteractionRequestBody.of(
                CreateModelInteraction.builder()
                    .model(Model.of("gemini-3.8-flash"))
                    .input(InteractionsInput.of("What is my name?"))
                    .previousInteractionId(turn1.id().get())
                    .build()))
        .interaction()
        .get();

System.out.println(turn2.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)
    }

    // 1. First turn
    turn1, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash"),
            Input: interactions.NewInteractionsInput("Hi, my name is Phil."),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    // 2. Second turn (chained using PreviousInteractionID)
    turn2, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model:                 interactions.Model("gemini-3.8-flash"),
            Input:                 interactions.NewInteractionsInput("What is my name?"),
            PreviousInteractionID: turn1.Interaction.ID,
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    if turn2.Interaction.OutputText != nil {
        fmt.Println(*turn2.Interaction.OutputText)
    }
}

# Replace PREVIOUS_INTERACTION_ID with the id returned from the first turn
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -d '{
    "model": "gemini-3.8-flash",
    "input": "What is my name?",
    "previous_interaction_id": "PREVIOUS_INTERACTION_ID"
  }'

previous_interaction_id पैरामीटर, सिर्फ़ बातचीत के इतिहास (इनपुट और आउटपुट) को सेव करता है. इसके लिए, previous_interaction_id का इस्तेमाल किया जाता है. अन्य पैरामीटर, इंटरैक्शन के स्कोप वाले पैरामीटर होते हैं. ये सिर्फ़ उस इंटरैक्शन पर लागू होते हैं जिसे फ़िलहाल जनरेट किया जा रहा है:

• tools
• system_instruction
• generation_config (इसमें thinking_level, temperature वगैरह शामिल हैं)

इसका मतलब है कि अगर आपको इन पैरामीटर को लागू करना है, तो आपको हर नई बातचीत में इन्हें फिर से तय करना होगा. सर्वर-साइड स्टेट मैनेजमेंट का इस्तेमाल करना ज़रूरी नहीं है. हर अनुरोध में बातचीत का पूरा इतिहास भेजकर, बिना स्टेट वाले मोड में भी काम किया जा सकता है.

डेटा स्टोरेज और रखरखाव

डिफ़ॉल्ट रूप से, एपीआई सभी इंटरैक्शन ऑब्जेक्ट (store=true) को सेव करता है, ताकि सर्वर-साइड स्टेट मैनेजमेंट की सुविधाओं (previous_interaction_id के साथ), बैकग्राउंड एक्ज़ीक्यूशन (background=true का इस्तेमाल करके) और जांचने की क्षमता के मकसद से इनका इस्तेमाल आसान हो सके.

• पैसे चुकाकर ली जाने वाली सदस्यता: सिस्टम, इंटरैक्शन को 55 दिनों तक सेव रखता है.
• मुफ़्त टियर: सिस्टम, इंटरैक्शन को एक दिन तक सेव रखता है.

अगर आपको ऐसा नहीं करना है, तो अपने अनुरोध में store=false सेट करें. यह कंट्रोल, स्टेट मैनेजमेंट से अलग है. आपके पास किसी भी इंटरैक्शन के लिए स्टोरेज से ऑप्ट आउट करने का विकल्प होता है. हालांकि, ध्यान दें कि store=false, बैकग्राउंड में एक्ज़ीक्यूट होने की सुविधा के साथ काम नहीं करता. साथ ही, यह बाद के टर्न के लिए previous_interaction_id का इस्तेमाल करने से रोकता है.

पैसे चुकाकर इस्तेमाल किए जाने वाले टियर के प्रोजेक्ट के लिए, डेटा बनाए रखने की अवधि को AI Studio में कॉन्फ़िगर किया जा सकता है. इससे, प्रोजेक्ट स्टोरेज से लॉग को मिटाने के लिए, 7, 14, 28 या 55 दिनों के बाद अपने-आप मार्क किया जा सकता है. डेटा को कम समय तक सेव रखने से, पिछली बातचीत का डेटा वापस पाने में समस्या आ सकती है.

delete तरीके का इस्तेमाल करके, सेव किए गए इंटरैक्शन को किसी भी समय मिटाया जा सकता है. इसके लिए, इंटरैक्शन आईडी की ज़रूरत होती है. AI Studio में जाकर, सेव किए गए इंटरैक्शन के लॉग देखे और मैनेज किए जा सकते हैं. इनमें प्रोजेक्ट स्टोरेज से लॉग मिटाना भी शामिल है.

डेटा के रखरखाव की अवधि खत्म होने के बाद, आपका डेटा अपने-आप मिट जाएगा.

इंटरैक्शन ऑब्जेक्ट को शर्तों के मुताबिक प्रोसेस किया जाता है.

AI Studio में इंटरैक्शन देखना

यह कुकी, Paid Tier वाले प्रोजेक्ट के लिए store=true का इस्तेमाल करके किए गए Interactions API के अनुरोधों को सेव करती है. इन्हें सीधे तौर पर Google AI Studio के लॉग पेज पर देखा जा सकता है. ज़्यादा जानकारी के लिए, लॉग गाइड देखें.

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

• कैश हिट रेट: इंप्लिसिट कैशिंग, स्टेटफ़ुल और स्टेटलेस, दोनों मोड में काम करती है. इसके बारे में जानने के लिए, क्विकस्टार्ट गाइड देखें. बातचीत जारी रखने के लिए, previous_interaction_id (स्टेटफ़ुल) का इस्तेमाल करने से सिस्टम को बातचीत के इतिहास के लिए, इंप्लिसिट कैश मेमोरी का इस्तेमाल करने में आसानी होती है. इससे परफ़ॉर्मेंस बेहतर होती है और लागत कम होती है.
• एजेंट और मॉडल के साथ इंटरैक्शन को मिक्स करना: आपके पास बातचीत के दौरान, एजेंट और मॉडल के साथ इंटरैक्शन को मिक्स करने का विकल्प होता है. उदाहरण के लिए, शुरुआती डेटा इकट्ठा करने के लिए, Deep Research एजेंट जैसे किसी खास एजेंट का इस्तेमाल किया जा सकता है. इसके बाद, फ़ॉलो-अप टास्क के लिए, Gemini के स्टैंडर्ड मॉडल का इस्तेमाल किया जा सकता है. जैसे, खास जानकारी देना या फ़ॉर्मैट बदलना. इन चरणों को previous_interaction_id से लिंक किया जा सकता है.

ऐसे मॉडल और एजेंट जिन पर यह सुविधा काम करती है

एसडीके

Interactions API को ऐक्सेस करने के लिए, Google GenAI SDK टूल के नए वर्शन का इस्तेमाल किया जा सकता है.

• Python में, यह 2.3.0 वर्शन से google-genai पैकेज है.
• JavaScript पर, यह 2.3.0 वर्शन से @google/genai पैकेज है.
• Go पर, यह google.golang.org/genai पैकेज है.
• Java में, यह com.google.genai:google-genai पैकेज है.

लाइब्रेरी पेज पर जाकर, एसडीके इंस्टॉल करने के तरीके के बारे में ज़्यादा जानें.

सीमाएं

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

नीचे दी गई सुविधाएं, generateContent एपीआई के साथ काम करती हैं. हालांकि, ये सुविधाएं Interactions API में अभी उपलब्ध नहीं हैं:

• Batch API
• फ़ंक्शन को अपने-आप कॉल करने की सुविधा (Python)
• एक्सप्लिसिट कैश मेमोरी: ध्यान दें कि सर्वर साइड पर इंप्लिसिट कैश मेमोरी, Interactions API में previous_interaction_id के ज़रिए उपलब्ध होती है.
• सुरक्षा सेटिंग: Interactions API में, सुरक्षा से जुड़ी कस्टम सेटिंग का इस्तेमाल नहीं किया जा सकता.

सुझाव/राय दें या शिकायत करें

Interactions API को बेहतर बनाने के लिए, आपका सुझाव/राय या शिकायत हमारे लिए अहम है. अपने विचार शेयर करें, गड़बड़ियों की शिकायत करें या सुविधाओं का अनुरोध करें. इसके लिए, हमारे Google AI डेवलपर कम्यूनिटी फ़ोरम पर जाएं.

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

• Interactions API की क्विकस्टार्ट नोटबुक आज़माएं.
• Gemini Deep Research एजेंट के बारे में ज़्यादा जानें.