Interactions API

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

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

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

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

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

• अपना कोडिंग एजेंट सेट अप करें: Gemini Docs एमसीपी से कनेक्ट करें और 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 में इंटरैक्शन देखना

यह एपीआई, पैसे चुकाकर लिए जाने वाले टियर में शामिल प्रोजेक्ट के लिए, 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 को डेवलप करने के लिए, आपके सुझाव, शिकायत या राय अहम है. Google के एआई डेवलपर कम्यूनिटी फ़ोरम पर अपने विचार शेयर करें, गड़बड़ियों की शिकायत करें या सुविधाओं का अनुरोध करें.

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

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