Caching

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

तरीका: cachedContents.create

यह CachedContent संसाधन बनाता है.

एंडपॉइंट

post https://generativelanguage.googleapis.com/v1beta/cachedContents

अनुरोध का मुख्य भाग

अनुरोध के मुख्य भाग में CachedContent का उदाहरण है.

फ़ील्ड
contents[] object (Content)

ज़रूरी नहीं. सिर्फ़ इनपुट के लिए. इम्यूटेबल. कैश मेमोरी में सेव किया जाने वाला कॉन्टेंट.

tools[] object (Tool)

ज़रूरी नहीं. सिर्फ़ इनपुट के लिए. इम्यूटेबल. Tools मॉडल, अगला जवाब जनरेट करने के लिए इनका इस्तेमाल कर सकता है

expiration Union type
इससे पता चलता है कि यह संसाधन कब खत्म होगा. expiration इनमें से सिर्फ़ एक हो सकता है:
expireTime string (Timestamp format)

यूटीसी में टाइमस्टैंप, जिससे पता चलता है कि यह संसाधन कब खत्म हो जाएगा. यह जानकारी, इनपुट में दी गई जानकारी के बावजूद, आउटपुट में हमेशा दी जाती है.

यह आरएफ़सी 3339 का इस्तेमाल करता है. इसमें जनरेट किया गया आउटपुट हमेशा Z-नॉर्मलाइज़ किया जाएगा और इसमें 0, 3, 6 या 9 फ़्रैक्शनल अंक इस्तेमाल किए जाएंगे. "Z" के अलावा, अन्य ऑफ़सेट भी स्वीकार किए जाते हैं. उदाहरण: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" या "2014-10-02T15:01:23+05:30".

ttl string (Duration format)

सिर्फ़ इनपुट के लिए. इस संसाधन के लिए नया टीटीएल, सिर्फ़ इनपुट करें.

यह अवधि सेकंड में होती है. इसमें नौ दशमलव अंक तक हो सकते हैं. इसके आखिर में 's' होता है. उदाहरण: "3.5s".

displayName string

ज़रूरी नहीं. इम्यूटेबल. कैश किए गए कॉन्टेंट का यूज़र जनरेटेड डिसप्ले नेम. ज़्यादा से ज़्यादा 128 यूनिकोड वर्ण.

model string

ज़रूरी है. इम्यूटेबल. कैश किए गए कॉन्टेंट के लिए इस्तेमाल किए जाने वाले Model का नाम. फ़ॉर्मैट: models/{model}

systemInstruction object (Content)

ज़रूरी नहीं. सिर्फ़ इनपुट के लिए. इम्यूटेबल. डेवलपर ने सिस्टम के लिए निर्देश सेट किए हैं. फ़िलहाल, सिर्फ़ टेक्स्ट के तौर पर उपलब्ध है.

toolConfig object (ToolConfig)

ज़रूरी नहीं. सिर्फ़ इनपुट के लिए. इम्यूटेबल. टूल का कॉन्फ़िगरेशन. यह कॉन्फ़िगरेशन सभी टूल के लिए शेयर किया जाता है.

अनुरोध का उदाहरण

सामान्य

Python

from google import genai
from google.genai import types

client = genai.Client()
document = client.files.upload(file=media / "a11.txt")
model_name = "gemini-1.5-flash-001"

cache = client.caches.create(
    model=model_name,
    config=types.CreateCachedContentConfig(
        contents=[document],
        system_instruction="You are an expert analyzing transcripts.",
    ),
)
print(cache)

response = client.models.generate_content(
    model=model_name,
    contents="Please summarize this transcript",
    config=types.GenerateContentConfig(cached_content=cache.name),
)
print(response.text)
cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);
const modelName = "gemini-1.5-flash-001";

const contents = [
  createUserContent(createPartFromUri(document.uri, document.mimeType)),
];

const cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: contents,
    systemInstruction: "You are an expert analyzing transcripts.",
  },
});
console.log("Cache created:", cache);

const response = await ai.models.generateContent({
  model: modelName,
  contents: "Please summarize this transcript",
  config: { cachedContent: cache.name },
});
console.log("Response text:", response.text);
cache.js

ऐप पर जाएं

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"), 
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromURI(document.URI, document.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}
cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents: contents,
	SystemInstruction: genai.NewContentFromText(
		"You are an expert analyzing transcripts.", genai.RoleUser,
	),
})
if err != nil {
	log.Fatal(err)
}
fmt.Println("Cache created:")
fmt.Println(cache)

// Use the cache for generating content.
response, err := client.Models.GenerateContent(
	ctx,
	modelName,
	genai.Text("Please summarize this transcript"),
	&genai.GenerateContentConfig{
		CachedContent: cache.Name,
	},
)
if err != nil {
	log.Fatal(err)
}
printResponse(response)
cache.go

शेल

wget https://storage.googleapis.com/generativeai-downloads/data/a11.txt
echo '{
  "model": "models/gemini-1.5-flash-001",
  "contents":[
    {
      "parts":[
        {
          "inline_data": {
            "mime_type":"text/plain",
            "data": "'$(base64 $B64FLAGS a11.txt)'"
          }
        }
      ],
    "role": "user"
    }
  ],
  "systemInstruction": {
    "parts": [
      {
        "text": "You are an expert at analyzing transcripts."
      }
    ]
  },
  "ttl": "300s"
}' > request.json

curl -X POST "https://generativelanguage.googleapis.com/v1beta/cachedContents?key=$GEMINI_API_KEY" \
 -H 'Content-Type: application/json' \
 -d @request.json \
 > cache.json

CACHE_NAME=$(cat cache.json | grep '"name":' | cut -d '"' -f 4 | head -n 1)

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-001:generateContent?key=$GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
      "contents": [
        {
          "parts":[{
            "text": "Please summarize this transcript"
          }],
          "role": "user"
        },
      ],
      "cachedContent": "'$CACHE_NAME'"
    }'
cache.sh

From name

Python

from google import genai
from google.genai import types

client = genai.Client()
document = client.files.upload(file=media / "a11.txt")
model_name = "gemini-1.5-flash-001"

cache = client.caches.create(
    model=model_name,
    config=types.CreateCachedContentConfig(
        contents=[document],
        system_instruction="You are an expert analyzing transcripts.",
    ),
)
cache_name = cache.name  # Save the name for later

# Later retrieve the cache
cache = client.caches.get(name=cache_name)
response = client.models.generate_content(
    model=model_name,
    contents="Find a lighthearted moment from this transcript",
    config=types.GenerateContentConfig(cached_content=cache.name),
)
print(response.text)
cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);
const modelName = "gemini-1.5-flash-001";

const contents = [
  createUserContent(createPartFromUri(document.uri, document.mimeType)),
];

const cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: contents,
    systemInstruction: "You are an expert analyzing transcripts.",
  },
});
const cacheName = cache.name; // Save the name for later

// Later retrieve the cache
const retrievedCache = await ai.caches.get({ name: cacheName });
const response = await ai.models.generateContent({
  model: modelName,
  contents: "Find a lighthearted moment from this transcript",
  config: { cachedContent: retrievedCache.name },
});
console.log("Response text:", response.text);
cache.js

ऐप पर जाएं

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromURI(document.URI, document.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}
cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents:          contents,
	SystemInstruction: genai.NewContentFromText(
		"You are an expert analyzing transcripts.", genai.RoleUser,
	),
})
if err != nil {
	log.Fatal(err)
}
cacheName := cache.Name

// Later retrieve the cache.
cache, err = client.Caches.Get(ctx, cacheName, &genai.GetCachedContentConfig{})
if err != nil {
	log.Fatal(err)
}

response, err := client.Models.GenerateContent(
	ctx,
	modelName,
	genai.Text("Find a lighthearted moment from this transcript"),
	&genai.GenerateContentConfig{
		CachedContent: cache.Name,
	},
)
if err != nil {
	log.Fatal(err)
}
fmt.Println("Response from cache (create from name):")
printResponse(response)
cache.go

चैट से

Python

from google import genai
from google.genai import types

client = genai.Client()
model_name = "gemini-1.5-flash-001"
system_instruction = "You are an expert analyzing transcripts."

# Create a chat session with the given system instruction.
chat = client.chats.create(
    model=model_name,
    config=types.GenerateContentConfig(system_instruction=system_instruction),
)
document = client.files.upload(file=media / "a11.txt")

response = chat.send_message(
    message=["Hi, could you summarize this transcript?", document]
)
print("\n\nmodel:  ", response.text)
response = chat.send_message(
    message=["Okay, could you tell me more about the trans-lunar injection"]
)
print("\n\nmodel:  ", response.text)

# To cache the conversation so far, pass the chat history as the list of contents.
cache = client.caches.create(
    model=model_name,
    config={
        "contents": chat.get_history(),
        "system_instruction": system_instruction,
    },
)
# Continue the conversation using the cached content.
chat = client.chats.create(
    model=model_name,
    config=types.GenerateContentConfig(cached_content=cache.name),
)
response = chat.send_message(
    message="I didn't understand that last part, could you explain it in simpler language?"
)
print("\n\nmodel:  ", response.text)
cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const modelName = "gemini-1.5-flash-001";
const systemInstruction = "You are an expert analyzing transcripts.";

// Create a chat session with the system instruction.
const chat = ai.chats.create({
  model: modelName,
  config: { systemInstruction: systemInstruction },
});
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);

let response = await chat.sendMessage({
  message: createUserContent([
    "Hi, could you summarize this transcript?",
    createPartFromUri(document.uri, document.mimeType),
  ]),
});
console.log("\n\nmodel:", response.text);

response = await chat.sendMessage({
  message: "Okay, could you tell me more about the trans-lunar injection",
});
console.log("\n\nmodel:", response.text);

// To cache the conversation so far, pass the chat history as the list of contents.
const chatHistory = chat.getHistory();
const cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: chatHistory,
    systemInstruction: systemInstruction,
  },
});

// Continue the conversation using the cached content.
const chatWithCache = ai.chats.create({
  model: modelName,
  config: { cachedContent: cache.name },
});
response = await chatWithCache.sendMessage({
  message:
    "I didn't understand that last part, could you explain it in simpler language?",
});
console.log("\n\nmodel:", response.text);
cache.js

ऐप पर जाएं

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
systemInstruction := "You are an expert analyzing transcripts."

// Create initial chat with a system instruction.
chat, err := client.Chats.Create(ctx, modelName, &genai.GenerateContentConfig{
	SystemInstruction: genai.NewContentFromText(systemInstruction, genai.RoleUser),
}, nil)
if err != nil {
	log.Fatal(err)
}

document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}

// Send first message with the transcript.
parts := make([]genai.Part, 2)
parts[0] = genai.Part{Text: "Hi, could you summarize this transcript?"}
parts[1] = genai.Part{
	FileData: &genai.FileData{
		FileURI :      document.URI,
		MIMEType: document.MIMEType,
	},
}

// Send chat message.
resp, err := chat.SendMessage(ctx, parts...)
if err != nil {
	log.Fatal(err)
}
fmt.Println("\n\nmodel: ", resp.Text())

resp, err = chat.SendMessage(
	ctx, 
	genai.Part{
		Text: "Okay, could you tell me more about the trans-lunar injection",
	},
)
if err != nil {
	log.Fatal(err)
}
fmt.Println("\n\nmodel: ", resp.Text())

// To cache the conversation so far, pass the chat history as the list of contents.
cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents:          chat.History(false),
	SystemInstruction: genai.NewContentFromText(systemInstruction, genai.RoleUser),
})
if err != nil {
	log.Fatal(err)
}

// Continue the conversation using the cached history.
chat, err = client.Chats.Create(ctx, modelName, &genai.GenerateContentConfig{
	CachedContent: cache.Name,
}, nil)
if err != nil {
	log.Fatal(err)
}

resp, err = chat.SendMessage(
	ctx, 
	genai.Part{
		Text: "I didn't understand that last part, could you explain it in simpler language?",
	},
)
if err != nil {
	log.Fatal(err)
}
fmt.Println("\n\nmodel: ", resp.Text())
cache.go

जवाब का मुख्य भाग

अनुरोध पूरा होने पर, जवाब के मुख्य हिस्से में CachedContent का नया इंस्टेंस शामिल किया जाता है.

तरीका: cachedContents.list

Lists CachedContents.

एंडपॉइंट

get https://generativelanguage.googleapis.com/v1beta/cachedContents

क्वेरी पैरामीटर

pageSize integer

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

pageToken string

ज़रूरी नहीं. यह एक पेज टोकन है, जो पिछले cachedContents.list कॉल से मिला था. अगला पेज पाने के लिए, यह जानकारी दें.

पेज नंबर के हिसाब से डेटा दिखाने के दौरान, cachedContents.list को दिए गए अन्य सभी पैरामीटर, पेज टोकन देने वाले कॉल से मेल खाने चाहिए.

अनुरोध का मुख्य भाग

अनुरोध का मुख्य हिस्सा खाली होना चाहिए.

जवाब का मुख्य भाग

CachedContents की सूची के साथ जवाब.

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

Fields
cachedContents[] object (CachedContent)

कैश किए गए कॉन्टेंट की सूची.

nextPageToken string

यह एक टोकन है. इसका इस्तेमाल pageToken के तौर पर किया जा सकता है, ताकि अगला पेज वापस पाया जा सके. अगर इस फ़ील्ड को खाली छोड़ा जाता है, तो इसके बाद कोई पेज नहीं होता.

JSON के काेड में दिखाना 
{
  "cachedContents": [
    {
      object (CachedContent)
    }
  ],
  "nextPageToken": string
}

तरीका: cachedContents.get

यह CachedContent संसाधन को पढ़ता है.

एंडपॉइंट

get https://generativelanguage.googleapis.com/v1beta/{name=cachedContents/*}

पाथ पैरामीटर

name string

ज़रूरी है. कॉन्टेंट की कैश मेमोरी में सेव की गई एंट्री का रेफ़रंस देने वाला संसाधन का नाम. फ़ॉर्मैट: cachedContents/{id} यह cachedContents/{cachedcontent} के फ़ॉर्म में होता है.

अनुरोध का मुख्य भाग

अनुरोध का मुख्य हिस्सा खाली होना चाहिए.

अनुरोध का उदाहरण

Python

from google import genai

client = genai.Client()
document = client.files.upload(file=media / "a11.txt")
model_name = "gemini-1.5-flash-001"

cache = client.caches.create(
    model=model_name,
    config={
        "contents": [document],
        "system_instruction": "You are an expert analyzing transcripts.",
    },
)
print(client.caches.get(name=cache.name))
cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);
const modelName = "gemini-1.5-flash-001";

const contents = [
  createUserContent(createPartFromUri(document.uri, document.mimeType)),
];

const cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: contents,
    systemInstruction: "You are an expert analyzing transcripts.",
  },
});
const retrievedCache = await ai.caches.get({ name: cache.name });
console.log("Retrieved Cache:", retrievedCache);
cache.js

ऐप पर जाएं

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromURI(document.URI, document.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents:          contents,
	SystemInstruction: genai.NewContentFromText(
		"You are an expert analyzing transcripts.", genai.RoleUser,
	),
})
if err != nil {
	log.Fatal(err)
}

cache, err = client.Caches.Get(ctx, cache.Name, &genai.GetCachedContentConfig{})
if err != nil {
	log.Fatal(err)
}
fmt.Println("Retrieved cache:")
fmt.Println(cache)
cache.go

शेल

curl "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY"
cache.sh

जवाब का मुख्य भाग

कामयाब रहने पर, जवाब के मुख्य हिस्से में CachedContent का एक इंस्टेंस शामिल किया जाता है.

तरीका: cachedContents.patch

यह CachedContent संसाधन को अपडेट करता है. सिर्फ़ समयसीमा खत्म होने की तारीख को अपडेट किया जा सकता है.

एंडपॉइंट

patch https://generativelanguage.googleapis.com/v1beta/{cachedContent.name=cachedContents/*}

PATCH https://generativelanguage.googleapis.com/v1beta/{cachedContent.name=cachedContents/*}

पाथ पैरामीटर

cachedContent.name string

सिर्फ़ आउटपुट के लिए. आइडेंटिफ़ायर. कैश किए गए कॉन्टेंट का रेफ़रंस देने वाले संसाधन का नाम. फ़ॉर्मैट: cachedContents/{id} यह cachedContents/{cachedcontent} के फ़ॉर्म में होता है.

क्वेरी पैरामीटर

updateMask string (FieldMask format)

अपडेट किए जाने वाले फ़ील्ड की सूची.

यह फ़ील्ड के पूरी तरह से क्वालिफ़ाइड नामों की कॉमा से अलग की गई सूची है. उदाहरण: "user.displayName,photo".

अनुरोध का मुख्य भाग

अनुरोध के मुख्य भाग में CachedContent का उदाहरण है.

फ़ील्ड
expiration Union type
इससे पता चलता है कि यह संसाधन कब खत्म होगा. expiration इनमें से सिर्फ़ एक हो सकता है:
expireTime string (Timestamp format)

यूटीसी में टाइमस्टैंप, जिससे पता चलता है कि यह संसाधन कब खत्म हो जाएगा. यह जानकारी, इनपुट में दी गई जानकारी के बावजूद, आउटपुट में हमेशा दी जाती है.

यह आरएफ़सी 3339 का इस्तेमाल करता है. इसमें जनरेट किया गया आउटपुट हमेशा Z-नॉर्मलाइज़ किया जाएगा और इसमें 0, 3, 6 या 9 फ़्रैक्शनल अंक इस्तेमाल किए जाएंगे. "Z" के अलावा, अन्य ऑफ़सेट भी स्वीकार किए जाते हैं. उदाहरण: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" या "2014-10-02T15:01:23+05:30".

ttl string (Duration format)

सिर्फ़ इनपुट के लिए. इस संसाधन के लिए नया टीटीएल, सिर्फ़ इनपुट करें.

यह अवधि सेकंड में होती है. इसमें नौ दशमलव अंक तक हो सकते हैं. इसके आखिर में 's' होता है. उदाहरण: "3.5s".

अनुरोध का उदाहरण

Python

from google import genai
from google.genai import types
import datetime

client = genai.Client()
document = client.files.upload(file=media / "a11.txt")
model_name = "gemini-1.5-flash-001"

cache = client.caches.create(
    model=model_name,
    config={
        "contents": [document],
        "system_instruction": "You are an expert analyzing transcripts.",
    },
)

# Update the cache's time-to-live (ttl)
ttl = f"{int(datetime.timedelta(hours=2).total_seconds())}s"
client.caches.update(
    name=cache.name, config=types.UpdateCachedContentConfig(ttl=ttl)
)
print(f"After update:\n {cache}")

# Alternatively, update the expire_time directly
# Update the expire_time directly in valid RFC 3339 format (UTC with a "Z" suffix)
expire_time = (
    (
        datetime.datetime.now(datetime.timezone.utc)
        + datetime.timedelta(minutes=15)
    )
    .isoformat()
    .replace("+00:00", "Z")
)
client.caches.update(
    name=cache.name,
    config=types.UpdateCachedContentConfig(expire_time=expire_time),
)
cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);
const modelName = "gemini-1.5-flash-001";

const contents = [
  createUserContent(createPartFromUri(document.uri, document.mimeType)),
];

let cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: contents,
    systemInstruction: "You are an expert analyzing transcripts.",
  },
});

// Update the cache's time-to-live (ttl)
const ttl = `${2 * 3600}s`; // 2 hours in seconds
cache = await ai.caches.update({
  name: cache.name,
  config: { ttl },
});
console.log("After update (TTL):", cache);

// Alternatively, update the expire_time directly (in RFC 3339 format with a "Z" suffix)
const expireTime = new Date(Date.now() + 15 * 60000)
  .toISOString()
  .replace(/\.\d{3}Z$/, "Z");
cache = await ai.caches.update({
  name: cache.name,
  config: { expireTime: expireTime },
});
console.log("After update (expire_time):", cache);
cache.js

ऐप पर जाएं

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromURI(document.URI, document.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents:          contents,
	SystemInstruction: genai.NewContentFromText(
		"You are an expert analyzing transcripts.", genai.RoleUser,
	),
})
if err != nil {
	log.Fatal(err)
}

_, err = client.Caches.Delete(ctx, cache.Name, &genai.DeleteCachedContentConfig{})
if err != nil {
	log.Fatal(err)
}
fmt.Println("Cache deleted:", cache.Name)
cache.go

शेल

curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY" \
 -H 'Content-Type: application/json' \
 -d '{"ttl": "600s"}'
cache.sh

जवाब का मुख्य भाग

कामयाब रहने पर, जवाब के मुख्य हिस्से में CachedContent का एक इंस्टेंस शामिल किया जाता है.

तरीका: cachedContents.delete

यह CachedContent संसाधन को मिटाता है.

एंडपॉइंट

delete https://generativelanguage.googleapis.com/v1beta/{name=cachedContents/*}

पाथ पैरामीटर

name string

ज़रूरी है. कॉन्टेंट कैश मेमोरी की एंट्री का रेफ़रंस देने वाला संसाधन का नाम फ़ॉर्मैट: cachedContents/{id} यह cachedContents/{cachedcontent} के फ़ॉर्म में होता है.

अनुरोध का मुख्य भाग

अनुरोध का मुख्य हिस्सा खाली होना चाहिए.

अनुरोध का उदाहरण

Python

from google import genai

client = genai.Client()
document = client.files.upload(file=media / "a11.txt")
model_name = "gemini-1.5-flash-001"

cache = client.caches.create(
    model=model_name,
    config={
        "contents": [document],
        "system_instruction": "You are an expert analyzing transcripts.",
    },
)
client.caches.delete(name=cache.name)
cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);
const modelName = "gemini-1.5-flash-001";

const contents = [
  createUserContent(createPartFromUri(document.uri, document.mimeType)),
];

const cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: contents,
    systemInstruction: "You are an expert analyzing transcripts.",
  },
});
await ai.caches.delete({ name: cache.name });
console.log("Cache deleted:", cache.name);
cache.js

ऐप पर जाएं

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromURI(document.URI, document.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents:          contents,
	SystemInstruction: genai.NewContentFromText(
		"You are an expert analyzing transcripts.", genai.RoleUser,
	),
})
if err != nil {
	log.Fatal(err)
}

_, err = client.Caches.Delete(ctx, cache.Name, &genai.DeleteCachedContentConfig{})
if err != nil {
	log.Fatal(err)
}
fmt.Println("Cache deleted:", cache.Name)
cache.go

शेल

curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY"
cache.sh

जवाब का मुख्य भाग

अगर अनुरोध पूरा हो जाता है, तो जवाब के मुख्य हिस्से में एक खाली JSON ऑब्जेक्ट होता है.

REST रिसॉर्स: cachedContents

संसाधन: CachedContent

ऐसा कॉन्टेंट जिसे पहले से प्रोसेस किया गया है और जिसका इस्तेमाल, GenerativeService के अगले अनुरोध में किया जा सकता है.

कैश किए गए कॉन्टेंट का इस्तेमाल सिर्फ़ उसी मॉडल के साथ किया जा सकता है जिसके लिए इसे बनाया गया था.

Fields
contents[] object (Content)

ज़रूरी नहीं. सिर्फ़ इनपुट के लिए. इम्यूटेबल. कैश मेमोरी में सेव किया जाने वाला कॉन्टेंट.

tools[] object (Tool)

ज़रूरी नहीं. सिर्फ़ इनपुट के लिए. इम्यूटेबल. Tools मॉडल, अगला जवाब जनरेट करने के लिए इनका इस्तेमाल कर सकता है

createTime string (Timestamp format)

सिर्फ़ आउटपुट के लिए. कैश मेमोरी की एंट्री बनाए जाने का समय.

यह आरएफ़सी 3339 का इस्तेमाल करता है. इसमें जनरेट किया गया आउटपुट हमेशा Z-नॉर्मलाइज़ किया जाएगा और इसमें 0, 3, 6 या 9 फ़्रैक्शनल अंक इस्तेमाल किए जाएंगे. "Z" के अलावा, अन्य ऑफ़सेट भी स्वीकार किए जाते हैं. उदाहरण: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" या "2014-10-02T15:01:23+05:30".

updateTime string (Timestamp format)

सिर्फ़ आउटपुट के लिए. यूटीसी के मुताबिक, कैश मेमोरी की एंट्री को आखिरी बार कब अपडेट किया गया था.

यह आरएफ़सी 3339 का इस्तेमाल करता है. इसमें जनरेट किया गया आउटपुट हमेशा Z-नॉर्मलाइज़ किया जाएगा और इसमें 0, 3, 6 या 9 फ़्रैक्शनल अंक इस्तेमाल किए जाएंगे. "Z" के अलावा, अन्य ऑफ़सेट भी स्वीकार किए जाते हैं. उदाहरण: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" या "2014-10-02T15:01:23+05:30".

usageMetadata object (UsageMetadata)

सिर्फ़ आउटपुट के लिए. कैश मेमोरी में सेव किए गए कॉन्टेंट के इस्तेमाल से जुड़ा मेटाडेटा.

expiration Union type
इससे पता चलता है कि यह संसाधन कब खत्म होगा. expiration इनमें से सिर्फ़ एक हो सकता है:
expireTime string (Timestamp format)

यूटीसी में टाइमस्टैंप, जिससे पता चलता है कि यह संसाधन कब खत्म हो जाएगा. यह जानकारी, इनपुट में दी गई जानकारी के बावजूद, आउटपुट में हमेशा दी जाती है.

यह आरएफ़सी 3339 का इस्तेमाल करता है. इसमें जनरेट किया गया आउटपुट हमेशा Z-नॉर्मलाइज़ किया जाएगा और इसमें 0, 3, 6 या 9 फ़्रैक्शनल अंक इस्तेमाल किए जाएंगे. "Z" के अलावा, अन्य ऑफ़सेट भी स्वीकार किए जाते हैं. उदाहरण: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" या "2014-10-02T15:01:23+05:30".

ttl string (Duration format)

सिर्फ़ इनपुट के लिए. इस संसाधन के लिए नया टीटीएल, सिर्फ़ इनपुट करें.

यह अवधि सेकंड में होती है. इसमें नौ दशमलव अंक तक हो सकते हैं. इसके आखिर में 's' होता है. उदाहरण: "3.5s".

name string

सिर्फ़ आउटपुट के लिए. आइडेंटिफ़ायर. कैश किए गए कॉन्टेंट का रेफ़रंस देने वाले संसाधन का नाम. फ़ॉर्मैट: cachedContents/{id}

displayName string

ज़रूरी नहीं. इम्यूटेबल. कैश किए गए कॉन्टेंट का यूज़र जनरेटेड डिसप्ले नेम. ज़्यादा से ज़्यादा 128 यूनिकोड वर्ण.

model string

ज़रूरी है. इम्यूटेबल. कैश किए गए कॉन्टेंट के लिए इस्तेमाल किए जाने वाले Model का नाम. फ़ॉर्मैट: models/{model}

systemInstruction object (Content)

ज़रूरी नहीं. सिर्फ़ इनपुट के लिए. इम्यूटेबल. डेवलपर ने सिस्टम के लिए निर्देश सेट किए हैं. फ़िलहाल, सिर्फ़ टेक्स्ट के तौर पर उपलब्ध है.

toolConfig object (ToolConfig)

ज़रूरी नहीं. सिर्फ़ इनपुट के लिए. इम्यूटेबल. टूल का कॉन्फ़िगरेशन. यह कॉन्फ़िगरेशन सभी टूल के लिए शेयर किया जाता है.

JSON के काेड में दिखाना 
{
  "contents": [
    {
      object (Content)
    }
  ],
  "tools": [
    {
      object (Tool)
    }
  ],
  "createTime": string,
  "updateTime": string,
  "usageMetadata": {
    object (UsageMetadata)
  },

  // expiration
  "expireTime": string,
  "ttl": string
  // Union type
  "name": string,
  "displayName": string,
  "model": string,
  "systemInstruction": {
    object (Content)
  },
  "toolConfig": {
    object (ToolConfig)
  }
}

सामग्री

यह एक बुनियादी स्ट्रक्चर्ड डेटाटाइप है. इसमें मैसेज का कई हिस्सों वाला कॉन्टेंट शामिल होता है.

Content में एक role फ़ील्ड होता है, जो Content के प्रोड्यूसर के बारे में बताता है. साथ ही, इसमें एक parts फ़ील्ड होता है, जिसमें कई हिस्सों वाला डेटा होता है. इस डेटा में मैसेज टर्न का कॉन्टेंट होता है.

Fields
parts[] object (Part)

क्रम से लगाए गए Parts, जो एक मैसेज बनाते हैं. अलग-अलग हिस्सों के MIME टाइप अलग-अलग हो सकते हैं.

role string

ज़रूरी नहीं. कॉन्टेंट बनाने वाला. इसकी वैल्यू 'user' या 'model' होनी चाहिए.

इसका इस्तेमाल, कई बार बातचीत करने के लिए किया जाता है. अगर ऐसा नहीं करना है, तो इसे खाली छोड़ा जा सकता है या अनसेट किया जा सकता है.

JSON के काेड में दिखाना 
{
  "parts": [
    {
      object (Part)
    }
  ],
  "role": string
}

भाग

यह एक डेटाटाइप है, जिसमें ऐसा मीडिया शामिल होता है जो कई हिस्सों वाले Content मैसेज का हिस्सा होता है.

Part में ऐसा डेटा होता है जिसका डेटाटाइप उससे जुड़ा होता है. Part में, Part.data में स्वीकार किए गए टाइप में से सिर्फ़ एक टाइप हो सकता है.

अगर inlineData फ़ील्ड में रॉ बाइट भरी गई हैं, तो Part में IANA का तय किया गया MIME टाइप होना चाहिए. इससे मीडिया के टाइप और सबटाइप की पहचान होती है.

Fields
thought boolean

ज़रूरी नहीं. इससे पता चलता है कि जवाब का यह हिस्सा मॉडल ने जनरेट किया है या नहीं.

thoughtSignature string (bytes format)

ज़रूरी नहीं. विचार के लिए एक ओपेक हस्ताक्षर, ताकि इसे बाद के अनुरोधों में फिर से इस्तेमाल किया जा सके.

base64 कोड में बदली गई स्ट्रिंग.

partMetadata object (Struct format)

पार्ट से जुड़ा कस्टम मेटाडेटा. कॉन्टेंट दिखाने के लिए genai.Part का इस्तेमाल करने वाले एजेंट को अतिरिक्त जानकारी ट्रैक करनी पड़ सकती है. उदाहरण के लिए, यह उस फ़ाइल/सोर्स का नाम हो सकता है जिससे पार्ट बना है. इसके अलावा, यह एक से ज़्यादा पार्ट स्ट्रीम को मल्टीप्लेक्स करने का तरीका भी हो सकता है.

mediaResolution object (MediaResolution)

ज़रूरी नहीं. इनपुट मीडिया के लिए मीडिया रिज़ॉल्यूशन.

data Union type
data इनमें से सिर्फ़ एक हो सकता है:
text string

इनलाइन टेक्स्ट.

inlineData object (Blob)

इनलाइन मीडिया बाइट.

functionCall object (FunctionCall)

मॉडल से मिली अनुमानित FunctionCall, जिसमें FunctionDeclaration.name को दिखाने वाली स्ट्रिंग होती है. इसमें आर्ग्युमेंट और उनकी वैल्यू शामिल होती हैं.

functionResponse object (FunctionResponse)

FunctionCall के नतीजे के तौर पर मिले आउटपुट का इस्तेमाल मॉडल के कॉन्टेक्स्ट के तौर पर किया जाता है. इस आउटपुट में, FunctionDeclaration.name को दिखाने वाली स्ट्रिंग और फ़ंक्शन से मिले किसी भी आउटपुट को दिखाने वाला स्ट्रक्चर्ड JSON ऑब्जेक्ट शामिल होता है.

fileData object (FileData)

यूआरआई पर आधारित डेटा.

executableCode object (ExecutableCode)

मॉडल ने ऐसा कोड जनरेट किया है जिसे लागू किया जाना है.

codeExecutionResult object (CodeExecutionResult)

ExecutableCode को एक्ज़ीक्यूट करने का नतीजा.

toolCall object (ToolCall)

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

toolResponse object (ToolResponse)

सर्वर-साइड ToolCall के एक्ज़ीक्यूशन का आउटपुट. इस फ़ील्ड में, क्लाइंट ToolCall को लागू करने के नतीजों की जानकारी भरता है.

metadata Union type
यह विकल्प, डेटा की अतिरिक्त प्रीप्रोसेसिंग को कंट्रोल करता है. metadata इनमें से सिर्फ़ एक हो सकता है:
videoMetadata object (VideoMetadata)

ज़रूरी नहीं. वीडियो का मेटाडेटा. मेटाडेटा सिर्फ़ तब दिया जाना चाहिए, जब वीडियो डेटा को inlineData या fileData में दिखाया गया हो.

JSON के काेड में दिखाना 
{
  "thought": boolean,
  "thoughtSignature": string,
  "partMetadata": {
    object
  },
  "mediaResolution": {
    object (MediaResolution)
  },

  // data
  "text": string,
  "inlineData": {
    object (Blob)
  },
  "functionCall": {
    object (FunctionCall)
  },
  "functionResponse": {
    object (FunctionResponse)
  },
  "fileData": {
    object (FileData)
  },
  "executableCode": {
    object (ExecutableCode)
  },
  "codeExecutionResult": {
    object (CodeExecutionResult)
  },
  "toolCall": {
    object (ToolCall)
  },
  "toolResponse": {
    object (ToolResponse)
  }
  // Union type

  // metadata
  "videoMetadata": {
    object (VideoMetadata)
  }
  // Union type
}

ब्लॉब

मीडिया के रॉ बाइट.

टेक्स्ट को रॉ बाइट के तौर पर नहीं भेजा जाना चाहिए. इसके लिए, 'text' फ़ील्ड का इस्तेमाल करें.

Fields
mimeType string

सोर्स डेटा का IANA स्टैंडर्ड MIME टाइप. उदाहरण: - image/png - image/jpeg अगर ऐसा एमआईएमई टाइप दिया जाता है जो काम नहीं करता, तो गड़बड़ी का मैसेज दिखेगा. इस्तेमाल किए जा सकने वाले फ़ाइल फ़ॉर्मैट की पूरी सूची देखने के लिए, इस्तेमाल किए जा सकने वाले फ़ाइल फ़ॉर्मैट पर जाएं.

data string (bytes format)

मीडिया फ़ॉर्मैट के लिए रॉ बाइट.

base64 कोड में बदली गई स्ट्रिंग.

JSON के काेड में दिखाना 
{
  "mimeType": string,
  "data": string
}

FunctionCall

मॉडल से मिली अनुमानित FunctionCall, जिसमें FunctionDeclaration.name को दिखाने वाली स्ट्रिंग होती है. इसमें आर्ग्युमेंट और उनकी वैल्यू शामिल होती हैं.

Fields
id string

ज़रूरी नहीं. फ़ंक्शन कॉल का यूनीक आइडेंटिफ़ायर. अगर यह फ़ील्ड भरा गया है, तो क्लाइंट को functionCall को लागू करना होगा और मैच करने वाले id के साथ जवाब देना होगा.

name string

ज़रूरी है. कॉल किए जाने वाले फ़ंक्शन का नाम. इसमें a-z, A-Z, 0-9 के साथ-साथ अंडरस्कोर और डैश शामिल होने चाहिए. इसकी लंबाई ज़्यादा से ज़्यादा 128 वर्ण होनी चाहिए.

args object (Struct format)

ज़रूरी नहीं. JSON ऑब्जेक्ट फ़ॉर्मैट में फ़ंक्शन के पैरामीटर और वैल्यू.

JSON के काेड में दिखाना 
{
  "id": string,
  "name": string,
  "args": {
    object
  }
}

FunctionResponse

FunctionCall से मिले नतीजे के आउटपुट का इस्तेमाल मॉडल के कॉन्टेक्स्ट के तौर पर किया जाता है. इस आउटपुट में, FunctionDeclaration.name को दिखाने वाली स्ट्रिंग और फ़ंक्शन से मिले किसी भी आउटपुट को दिखाने वाला स्ट्रक्चर्ड JSON ऑब्जेक्ट शामिल होता है. इसमें मॉडल के अनुमान के आधार पर किए गए FunctionCall का नतीजा होना चाहिए.

Fields
id string

ज़रूरी नहीं. यह आइडेंटिफ़ायर, उस फ़ंक्शन कॉल का होता है जिसके लिए यह जवाब दिया गया है. क्लाइंट इस फ़ील्ड में वैल्यू भरता है, ताकि यह फ़ंक्शन कॉल id से मैच हो सके.

name string

ज़रूरी है. कॉल किए जाने वाले फ़ंक्शन का नाम. इसमें a-z, A-Z, 0-9 के साथ-साथ अंडरस्कोर और डैश शामिल होने चाहिए. इसकी लंबाई ज़्यादा से ज़्यादा 128 वर्ण होनी चाहिए.

response object (Struct format)

ज़रूरी है. JSON ऑब्जेक्ट फ़ॉर्मैट में फ़ंक्शन का रिस्पॉन्स. फ़ंक्शन का आउटपुट पाने के लिए, कॉलर अपनी पसंद की किसी भी ऐसी कुंजी का इस्तेमाल कर सकते हैं जो फ़ंक्शन के सिंटैक्स के मुताबिक हो.उदाहरण के लिए, "output", "result" वगैरह. खास तौर पर, अगर फ़ंक्शन कॉल को पूरा नहीं किया जा सका, तो जवाब में "error" कुंजी हो सकती है. इससे मॉडल को गड़बड़ी की जानकारी मिलती है.

parts[] object (FunctionResponsePart)

ज़रूरी नहीं. क्रम से लगाए गए Parts, जो फ़ंक्शन के जवाब बनाते हैं. इनके अलग-अलग IANA MIME टाइप हो सकते हैं.

willContinue boolean

ज़रूरी नहीं. इससे पता चलता है कि फ़ंक्शन कॉल जारी है और ज़्यादा जवाब मिलेंगे. इससे फ़ंक्शन कॉल, जनरेटर में बदल जाता है. यह सिर्फ़ NON_BLOCKING फ़ंक्शन कॉल पर लागू होता है. अन्य मामलों में इसे अनदेखा कर दिया जाता है. अगर इसे 'गलत है' पर सेट किया जाता है, तो आगे के जवाबों पर विचार नहीं किया जाएगा. फ़ंक्शन कॉल पूरा होने का सिग्नल देने के लिए, willContinue=False के साथ खाली response को वापस लाने की अनुमति है. इससे मॉडल जनरेट हो सकता है. जनरेशन को ट्रिगर होने से रोकने और फ़ंक्शन कॉल को पूरा करने के लिए, scheduling को SILENT पर सेट करें.

scheduling enum (Scheduling)

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

JSON के काेड में दिखाना 
{
  "id": string,
  "name": string,
  "response": {
    object
  },
  "parts": [
    {
      object (FunctionResponsePart)
    }
  ],
  "willContinue": boolean,
  "scheduling": enum (Scheduling)
}

FunctionResponsePart

यह एक डेटाटाइप है, जिसमें FunctionResponse मैसेज का हिस्सा बनने वाला मीडिया शामिल होता है.

FunctionResponsePart में ऐसा डेटा होता है जिसका डेटाटाइप उससे जुड़ा होता है. FunctionResponsePart में, FunctionResponsePart.data में स्वीकार किए गए टाइप में से सिर्फ़ एक टाइप हो सकता है.

अगर inlineData फ़ील्ड में रॉ बाइट भरी गई हैं, तो FunctionResponsePart में IANA का तय किया गया MIME टाइप होना चाहिए. इससे मीडिया के टाइप और सबटाइप की पहचान होती है.

फ़ील्ड
data Union type
फ़ंक्शन के जवाब वाले हिस्से का डेटा. data इनमें से सिर्फ़ एक हो सकता है:
inlineData object (FunctionResponseBlob)

इनलाइन मीडिया बाइट.

JSON के काेड में दिखाना 
{

  // data
  "inlineData": {
    object (FunctionResponseBlob)
  }
  // Union type
}

FunctionResponseBlob

फ़ंक्शन के जवाब के लिए, रॉ मीडिया बाइट.

टेक्स्ट को रॉ बाइट के तौर पर नहीं भेजा जाना चाहिए. इसके लिए, 'FunctionResponse.response' फ़ील्ड का इस्तेमाल करें.

Fields
mimeType string

सोर्स डेटा का IANA स्टैंडर्ड MIME टाइप. उदाहरण: - image/png - image/jpeg अगर ऐसा एमआईएमई टाइप दिया जाता है जो काम नहीं करता, तो गड़बड़ी का मैसेज दिखेगा. इस्तेमाल किए जा सकने वाले फ़ाइल फ़ॉर्मैट की पूरी सूची देखने के लिए, इस्तेमाल किए जा सकने वाले फ़ाइल फ़ॉर्मैट पर जाएं.

data string (bytes format)

मीडिया फ़ॉर्मैट के लिए रॉ बाइट.

base64 कोड में बदली गई स्ट्रिंग.

JSON के काेड में दिखाना 
{
  "mimeType": string,
  "data": string
}

शेड्यूलिंग

इससे पता चलता है कि बातचीत में जवाब को कैसे शेड्यूल किया जाना चाहिए.

Enums
SCHEDULING_UNSPECIFIED इस वैल्यू का इस्तेमाल नहीं किया गया है.
SILENT नतीजे को सिर्फ़ बातचीत के कॉन्टेक्स्ट में जोड़ें. जनरेट करने की प्रोसेस को न तो रोकें और न ही ट्रिगर करें.
WHEN_IDLE नतीजे को बातचीत के कॉन्टेक्स्ट में जोड़ें और जनरेट हो रहे आउटपुट में रुकावट डाले बिना, आउटपुट जनरेट करने के लिए प्रॉम्प्ट करें.
INTERRUPT नतीजे को बातचीत के कॉन्टेक्स्ट में जोड़ता है, जनरेट हो रहे कॉन्टेंट को रोकता है, और आउटपुट जनरेट करने के लिए प्रॉम्प्ट करता है.

FileData

यूआरआई पर आधारित डेटा.

Fields
mimeType string

ज़रूरी नहीं. सोर्स डेटा का IANA स्टैंडर्ड MIME टाइप.

fileUri string

ज़रूरी है. यूआरआई.

JSON के काेड में दिखाना 
{
  "mimeType": string,
  "fileUri": string
}

ExecutableCode

मॉडल से जनरेट किया गया ऐसा कोड जिसे एक्ज़ीक्यूट किया जाना है. साथ ही, मॉडल को नतीजा वापस भेजा जाता है.

यह सिर्फ़ CodeExecution टूल का इस्तेमाल करने पर जनरेट होता है. इसमें कोड अपने-आप लागू हो जाएगा. साथ ही, इससे मिलता-जुलता CodeExecutionResult भी जनरेट होगा.

Fields
id string

ज़रूरी नहीं. ExecutableCode हिस्से का यूनीक आइडेंटिफ़ायर. सर्वर, मैच करने वाले id के साथ CodeExecutionResult दिखाता है.

language enum (Language)

ज़रूरी है. code की प्रोग्रामिंग लैंग्वेज.

code string

ज़रूरी है. लागू किया जाने वाला कोड.

JSON के काेड में दिखाना 
{
  "id": string,
  "language": enum (Language),
  "code": string
}

भाषा

जनरेट किए गए कोड के लिए, इस्तेमाल की जा सकने वाली प्रोग्रामिंग भाषाएँ.

Enums
LANGUAGE_UNSPECIFIED भाषा के बारे में जानकारी नहीं दी गई है. इस वैल्यू का इस्तेमाल नहीं किया जाना चाहिए.
PYTHON Python >= 3.10, जिसमें numpy और simpy उपलब्ध हों. Python डिफ़ॉल्ट भाषा है.

CodeExecutionResult

ExecutableCode को एक्ज़ीक्यूट करने का नतीजा.

यह सिर्फ़ तब जनरेट होता है, जब CodeExecution टूल का इस्तेमाल किया जाता है.

Fields
id string

ज़रूरी नहीं. ExecutableCode का आइडेंटिफ़ायर, जिसके लिए यह नतीजा दिखाया गया है. यह फ़ील्ड सिर्फ़ तब भरा जाता है, जब इससे जुड़े ExecutableCode में कोई आईडी मौजूद हो.

outcome enum (Outcome)

ज़रूरी है. कोड को चलाने का नतीजा.

output string

ज़रूरी नहीं. अगर कोड को सही तरीके से लागू किया जाता है, तो इसमें stdout होता है. अगर ऐसा नहीं होता है, तो इसमें stderr या अन्य जानकारी होती है.

JSON के काेड में दिखाना 
{
  "id": string,
  "outcome": enum (Outcome),
  "output": string
}

नतीजा

कोड को चलाने के संभावित नतीजों की गिनती.

Enums
OUTCOME_UNSPECIFIED स्थिति की जानकारी नहीं दी गई है. इस वैल्यू का इस्तेमाल नहीं किया जाना चाहिए.
OUTCOME_OK कोड को लागू कर दिया गया है. output में stdout शामिल होता है. अगर कोई stdout मौजूद नहीं है, तो यह फ़ील्ड मौजूद नहीं होगा.
OUTCOME_FAILED कोड नहीं चल सका. output में stderr और stdout शामिल होता है.
OUTCOME_DEADLINE_EXCEEDED कोड को बहुत देर तक चलाया गया. इसलिए, इसे रद्द कर दिया गया. ऐसा हो सकता है कि output मौजूद हो या न हो.

ToolCall

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

Fields
id string

ज़रूरी नहीं. टूल कॉल का यूनीक आइडेंटिफ़ायर. सर्वर, टूल से मिले जवाब को मैचिंग id के साथ दिखाता है.

toolType enum (ToolType)

ज़रूरी है. कॉल किए गए टूल का टाइप.

args object (Struct format)

ज़रूरी नहीं. टूल कॉल के आर्ग्युमेंट. उदाहरण: {"arg1" : "value1", "arg2" : "value2" , ...}

JSON के काेड में दिखाना 
{
  "id": string,
  "toolType": enum (ToolType),
  "args": {
    object
  }
}

ToolType

फ़ंक्शन कॉल में टूल का टाइप.

Enums
TOOL_TYPE_UNSPECIFIED टूल के टाइप की जानकारी नहीं है.
GOOGLE_SEARCH_WEB Google का खोज टूल, Tool.google_search.search_types.web_search से मैप होता है.
GOOGLE_SEARCH_IMAGE इमेज खोजने का टूल, Tool.google_search.search_types.image_search पर मैप करता है.
URL_CONTEXT यूआरएल कॉन्टेक्स्ट टूल, Tool.url_context से मैप करता है.
GOOGLE_MAPS Google Maps टूल, Tool.google_maps पर मैप करता है.

ToolResponse

सर्वर-साइड पर ToolCall को लागू करने का आउटपुट. इस मैसेज में, टूल को शुरू करने के नतीजे शामिल हैं. इस टूल को मॉडल से ToolCall ने शुरू किया था. क्लाइंट को इस ToolResponse को एपीआई को वापस भेजना चाहिए. इसके लिए, उसे Content मैसेज में ToolCall के साथ, अगले टर्न में ऐसा करना होगा.

Fields
id string

ज़रूरी नहीं. यह जवाब जिस टूल कॉल के लिए है उसका आइडेंटिफ़ायर.

toolType enum (ToolType)

ज़रूरी है. कॉल किए गए टूल का टाइप, जो ToolCall में मौजूद toolType से मेल खाता है.

response object (Struct format)

ज़रूरी नहीं. टूल से मिला जवाब.

JSON के काेड में दिखाना 
{
  "id": string,
  "toolType": enum (ToolType),
  "response": {
    object
  }
}

VideoMetadata

बंद कर दिया गया है: इसके बजाय, GenerateContentRequest.processing_options का इस्तेमाल करें. मेटाडेटा में, इनपुट वीडियो कॉन्टेंट के बारे में जानकारी होती है.

Fields
startOffset string (Duration format)

ज़रूरी नहीं. वीडियो शुरू होने का ऑफ़सेट.

यह अवधि सेकंड में होती है. इसमें नौ दशमलव अंक तक हो सकते हैं. इसके आखिर में 's' होता है. उदाहरण: "3.5s".

endOffset string (Duration format)

ज़रूरी नहीं. वीडियो का आखिरी ऑफ़सेट.

यह अवधि सेकंड में होती है. इसमें नौ दशमलव अंक तक हो सकते हैं. इसके आखिर में 's' होता है. उदाहरण: "3.5s".

fps number

ज़रूरी नहीं. मॉडल को भेजे गए वीडियो का फ़्रेम रेट. अगर कोई वैल्यू तय नहीं की गई है, तो डिफ़ॉल्ट वैल्यू 1.0 होगी. एफ़पीएस की रेंज (0.0, 24.0] है.

JSON के काेड में दिखाना 
{
  "startOffset": string,
  "endOffset": string,
  "fps": number
}

MediaResolution

टोकनाइज़ेशन के लिए मीडिया रिज़ॉल्यूशन.

फ़ील्ड
value Union type
मीडिया का रिज़ॉल्यूशन लेवल. value इनमें से सिर्फ़ एक हो सकता है:
level enum (Level)

दिए गए मीडिया के लिए इस्तेमाल की गई टोकनाइज़ेशन क्वालिटी. के लिए Gemini API की सहायता .

JSON के काेड में दिखाना 
{

  // value
  "level": enum (Level)
  // Union type
}

लेवल

मीडिया का रिज़ॉल्यूशन लेवल.

Enums
MEDIA_RESOLUTION_UNSPECIFIED मीडिया का रिज़ॉल्यूशन सेट नहीं किया गया है.
MEDIA_RESOLUTION_LOW मीडिया का रिज़ॉल्यूशन कम पर सेट है.
MEDIA_RESOLUTION_MEDIUM मीडिया का रिज़ॉल्यूशन मीडियम पर सेट किया गया है.
MEDIA_RESOLUTION_HIGH मीडिया का रिज़ॉल्यूशन, हाई पर सेट हो.
MEDIA_RESOLUTION_ULTRA_HIGH मीडिया का रिज़ॉल्यूशन अल्ट्रा हाई पर सेट है.

टूल

टूल की वह जानकारी जिसका इस्तेमाल मॉडल, जवाब जनरेट करने के लिए कर सकता है.

Tool एक ऐसा कोड होता है जिसकी मदद से सिस्टम, बाहरी सिस्टम के साथ इंटरैक्ट कर पाता है. इससे मॉडल के दायरे से बाहर जाकर कोई कार्रवाई या कार्रवाइयों का सेट किया जा सकता है.

अगला आईडी: 15

Fields
functionDeclarations[] object (FunctionDeclaration)

ज़रूरी नहीं. मॉडल के लिए उपलब्ध FunctionDeclarations की सूची. इनका इस्तेमाल फ़ंक्शन कॉल करने के लिए किया जा सकता है.

मॉडल या सिस्टम, फ़ंक्शन को पूरा नहीं करता है. इसके बजाय, तय किए गए फ़ंक्शन को क्लाइंट साइड पर FunctionCall के तौर पर दिखाया जा सकता है, ताकि क्लाइंट साइड पर इसे लागू किया जा सके. मॉडल, इन फ़ंक्शन के सबसेट को कॉल करने का फ़ैसला कर सकता है. इसके लिए, वह जवाब में FunctionCall भरता है. अगले मॉडल टर्न के लिए, बातचीत के अगले टर्न में Content.role "फ़ंक्शन" जनरेशन कॉन्टेक्स्ट के साथ FunctionResponse शामिल हो सकता है.

googleSearchRetrieval object (GoogleSearchRetrieval)

ज़रूरी नहीं. यह जानकारी वापस पाने का टूल है, जो Google Search की मदद से काम करता है.

codeExecution object (CodeExecution)

ज़रूरी नहीं. इस सुविधा की मदद से, मॉडल जनरेट करने के दौरान कोड को लागू कर पाता है.

computerUse object (ComputerUse)

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

urlContext object (UrlContext)

ज़रूरी नहीं. यूआरएल के कॉन्टेक्स्ट को वापस पाने में मदद करने वाला टूल.

mcpServers[] object (McpServer)

ज़रूरी नहीं. कनेक्ट करने के लिए एमसीपी सर्वर.

googleMaps object (GoogleMaps)

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

JSON के काेड में दिखाना 
{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "googleSearchRetrieval": {
    object (GoogleSearchRetrieval)
  },
  "codeExecution": {
    object (CodeExecution)
  },
  "googleSearch": {
    object (GoogleSearch)
  },
  "computerUse": {
    object (ComputerUse)
  },
  "urlContext": {
    object (UrlContext)
  },
  "fileSearch": {
    object (FileSearch)
  },
  "mcpServers": [
    {
      object (McpServer)
    }
  ],
  "googleMaps": {
    object (GoogleMaps)
  }
}

FunctionDeclaration

OpenAPI 3.03 स्पेसिफ़िकेशन के मुताबिक, फ़ंक्शन के एलान का स्ट्रक्चर्ड प्रज़ेंटेशन. इस एलान में, फ़ंक्शन का नाम और पैरामीटर शामिल होते हैं. यह FunctionDeclaration, कोड के एक ब्लॉक का प्रतिनिधित्व करता है. इसका इस्तेमाल मॉडल, Tool के तौर पर कर सकता है. साथ ही, इसे क्लाइंट एक्ज़ीक्यूट कर सकता है.

Fields
name string

ज़रूरी है. फ़ंक्शन का नाम. इसमें a-z, A-Z, 0-9 के साथ-साथ अंडरस्कोर, कोलन, बिंदु, और डैश शामिल होने चाहिए. इसकी लंबाई ज़्यादा से ज़्यादा 128 वर्ण होनी चाहिए.

description string

ज़रूरी है. फ़ंक्शन के बारे में कम शब्दों में जानकारी.

behavior enum (Behavior)

ज़रूरी नहीं. इससे फ़ंक्शन के व्यवहार के बारे में पता चलता है. फ़िलहाल, यह सिर्फ़ BidiGenerateContent तरीके के साथ काम करता है.

parameters object (Schema)

ज़रूरी नहीं. इस फ़ंक्शन के पैरामीटर के बारे में बताता है. यह Open API 3.03 पैरामीटर ऑब्जेक्ट स्ट्रिंग कुंजी को दिखाता है: पैरामीटर का नाम. पैरामीटर के नाम केस-सेंसिटिव होते हैं. स्कीमा वैल्यू: वह स्कीमा जो पैरामीटर के लिए इस्तेमाल किए गए टाइप को तय करती है.

parametersJsonSchema value (Value format)

ज़रूरी नहीं. JSON स्कीमा फ़ॉर्मैट में, फ़ंक्शन के पैरामीटर के बारे में बताता है. स्कीमा में ऐसे ऑब्जेक्ट के बारे में बताया जाना चाहिए जिसकी प्रॉपर्टी, फ़ंक्शन के पैरामीटर हों. उदाहरण के लिए:

{
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "age": { "type": "integer" }
  },
  "additionalProperties": false,
  "required": ["name", "age"],
  "propertyOrdering": ["name", "age"]
}

यह फ़ील्ड, parameters के साथ काम नहीं करता.

response object (Schema)

ज़रूरी नहीं. इस फ़ंक्शन के आउटपुट के बारे में JSON स्कीमा फ़ॉर्मैट में बताता है. यह Open API 3.03 रिस्पॉन्स ऑब्जेक्ट को दिखाता है. स्कीमा, फ़ंक्शन की रिस्पॉन्स वैल्यू के लिए इस्तेमाल किए गए टाइप को तय करता है.

responseJsonSchema value (Value format)

ज़रूरी नहीं. इस फ़ंक्शन के आउटपुट के बारे में JSON स्कीमा फ़ॉर्मैट में बताता है. स्कीमा में दी गई वैल्यू, फ़ंक्शन की रिस्पॉन्स वैल्यू होती है.

यह फ़ील्ड, response के साथ काम नहीं करता.

JSON के काेड में दिखाना 
{
  "name": string,
  "description": string,
  "behavior": enum (Behavior),
  "parameters": {
    object (Schema)
  },
  "parametersJsonSchema": value,
  "response": {
    object (Schema)
  },
  "responseJsonSchema": value
}

स्कीमा

Schema ऑब्जेक्ट की मदद से, इनपुट और आउटपुट डेटा टाइप तय किए जा सकते हैं. ये टाइप ऑब्जेक्ट के साथ-साथ प्रिमिटिव और ऐरे भी हो सकते हैं. यह OpenAPI 3.0 स्कीमा ऑब्जेक्ट के चुने गए सबसेट को दिखाता है.

Fields
type enum (Type)

ज़रूरी है. डेटा टाइप.

format string

ज़रूरी नहीं. डेटा का फ़ॉर्मैट. कोई भी वैल्यू इस्तेमाल की जा सकती है. हालांकि, ज़्यादातर वैल्यू से कोई खास सुविधा ट्रिगर नहीं होती.

title string

ज़रूरी नहीं. स्कीमा का टाइटल.

description string

ज़रूरी नहीं. पैरामीटर के बारे में कम शब्दों में जानकारी. इसमें इस्तेमाल के उदाहरण शामिल हो सकते हैं. पैरामीटर की जानकारी को मार्कडाउन के तौर पर फ़ॉर्मैट किया जा सकता है.

nullable boolean

ज़रूरी नहीं. इससे पता चलता है कि वैल्यू शून्य हो सकती है या नहीं.

enum[] string

ज़रूरी नहीं. enum फ़ॉर्मैट में Type.STRING के एलिमेंट की संभावित वैल्यू. उदाहरण के लिए, हम Enum Direction को इस तरह से तय कर सकते हैं : {type:STRING, format:enum, enum:["EAST", NORTH", "SOUTH", "WEST"]}

maxItems string (int64 format)

ज़रूरी नहीं. Type.ARRAY के लिए एलिमेंट की ज़्यादा से ज़्यादा संख्या.

minItems string (int64 format)

ज़रूरी नहीं. Type.ARRAY के लिए एलिमेंट की कम से कम संख्या.

properties map (key: string, value: object (Schema))

ज़रूरी नहीं. Type.OBJECT की प्रॉपर्टी.

एक ऑब्जेक्ट, जिसमें "key": value जोड़े की सूची शामिल हो. उदाहरण: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

required[] string

ज़रूरी नहीं. Type.OBJECT की ज़रूरी प्रॉपर्टी.

minProperties string (int64 format)

ज़रूरी नहीं. Type.OBJECT के लिए प्रॉपर्टी की कम से कम संख्या.

maxProperties string (int64 format)

ज़रूरी नहीं. Type.OBJECT के लिए प्रॉपर्टी की ज़्यादा से ज़्यादा संख्या.

minLength string (int64 format)

ज़रूरी नहीं. TYPE.STRING के लिए स्कीमा फ़ील्ड, Type.STRING की कम से कम लंबाई

maxLength string (int64 format)

ज़रूरी नहीं. Type.STRING की ज़्यादा से ज़्यादा लंबाई

pattern string

ज़रूरी नहीं. Type.STRING का पैटर्न, ताकि किसी स्ट्रिंग को रेगुलर एक्सप्रेशन तक सीमित किया जा सके.

example value (Value format)

ज़रूरी नहीं. ऑब्जेक्ट का उदाहरण. यह सिर्फ़ तब पॉप्युलेट होगा, जब ऑब्जेक्ट रूट हो.

anyOf[] object (Schema)

ज़रूरी नहीं. वैल्यू की पुष्टि, सूची में मौजूद किसी भी (एक या उससे ज़्यादा) सबस्कीमा के हिसाब से की जानी चाहिए.

propertyOrdering[] string

ज़रूरी नहीं. प्रॉपर्टी का क्रम. यह ओपन एपीआई स्पेसिफ़िकेशन में स्टैंडर्ड फ़ील्ड नहीं है. इसका इस्तेमाल, रिस्पॉन्स में प्रॉपर्टी के क्रम का पता लगाने के लिए किया जाता है.

default value (Value format)

ज़रूरी नहीं. फ़ील्ड की डिफ़ॉल्ट वैल्यू. JSON स्कीमा के मुताबिक, इस फ़ील्ड का इस्तेमाल दस्तावेज़ जनरेट करने वालों के लिए किया जाता है. इससे पुष्टि पर कोई असर नहीं पड़ता. इसलिए, इसे यहां शामिल किया गया है और अनदेखा किया गया है, ताकि default फ़ील्ड वाले स्कीमा भेजने वाले डेवलपर को, 'अनजान फ़ील्ड' वाली गड़बड़ियां न मिलें.

items object (Schema)

ज़रूरी नहीं. Type.ARRAY के एलिमेंट का स्कीमा.

minimum number

ज़रूरी नहीं. टाइप INTEGER और NUMBER के लिए स्कीमा फ़ील्ड, Type.INTEGER और Type.NUMBER की कम से कम वैल्यू

maximum number

ज़रूरी नहीं. Type.INTEGER और Type.NUMBER की ज़्यादा से ज़्यादा वैल्यू

JSON के काेड में दिखाना 
{
  "type": enum (Type),
  "format": string,
  "title": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "maxItems": string,
  "minItems": string,
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "minProperties": string,
  "maxProperties": string,
  "minLength": string,
  "maxLength": string,
  "pattern": string,
  "example": value,
  "anyOf": [
    {
      object (Schema)
    }
  ],
  "propertyOrdering": [
    string
  ],
  "default": value,
  "items": {
    object (Schema)
  },
  "minimum": number,
  "maximum": number
}

टाइप

टाइप में, OpenAPI के डेटा टाइप की सूची होती है. इन्हें https://spec.openapis.org/oas/v3.0.3#data-types में बताया गया है

Enums
TYPE_UNSPECIFIED यह तय नहीं किया गया है. इसका इस्तेमाल नहीं किया जाना चाहिए.
STRING स्ट्रिंग टाइप.
NUMBER नंबर टाइप.
INTEGER पूर्णांक टाइप.
BOOLEAN बूलियन टाइप.
ARRAY ऐरे का टाइप.
OBJECT ऑब्जेक्ट का टाइप.
NULL नल टाइप.

व्यवहार

इससे फ़ंक्शन के व्यवहार के बारे में पता चलता है. यह डिफ़ॉल्ट रूप से BLOCKING पर सेट होता है.

Enums
UNSPECIFIED इस वैल्यू का इस्तेमाल नहीं किया गया है.
BLOCKING अगर यह सेट है, तो सिस्टम बातचीत जारी रखने से पहले, फ़ंक्शन के जवाब का इंतज़ार करेगा.
NON_BLOCKING अगर यह विकल्प सेट है, तो सिस्टम फ़ंक्शन के जवाब का इंतज़ार नहीं करेगा. इसके बजाय, यह फ़ंक्शन के जवाबों को तब तक मैनेज करने की कोशिश करेगा, जब तक वे उपलब्ध नहीं हो जाते. साथ ही, यह उपयोगकर्ता और मॉडल के बीच बातचीत को जारी रखेगा.

GoogleSearchRetrieval

यह Google का टूल है. इसकी मदद से, सार्वजनिक वेब डेटा को वापस लाया जा सकता है, ताकि Gemini को जवाब देने के लिए ज़्यादा जानकारी मिल सके.

Fields
dynamicRetrievalConfig object (DynamicRetrievalConfig)

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

JSON के काेड में दिखाना 
{
  "dynamicRetrievalConfig": {
    object (DynamicRetrievalConfig)
  }
}

DynamicRetrievalConfig

इस कुकी में, डाइनैमिक तौर पर डेटा पाने की सुविधा को पसंद के मुताबिक बनाने के विकल्पों के बारे में जानकारी होती है.

Fields
mode enum (Mode)

डाइनैमिक तौर पर डेटा पाने के लिए, अनुमान लगाने वाले टूल का इस्तेमाल किया जाने वाला मोड.

dynamicThreshold number

डाइनैमिक तौर पर डेटा पाने के लिए इस्तेमाल किया जाने वाला थ्रेशोल्ड. अगर यह सेट नहीं है, तो सिस्टम की डिफ़ॉल्ट वैल्यू का इस्तेमाल किया जाता है.

JSON के काेड में दिखाना 
{
  "mode": enum (Mode),
  "dynamicThreshold": number
}

मोड

डाइनैमिक तौर पर डेटा पाने के लिए, अनुमान लगाने वाले टूल का इस्तेमाल किया जाने वाला मोड.

Enums
MODE_UNSPECIFIED डेटा हमेशा वापस पाने की सुविधा चालू रहती है.
MODE_DYNAMIC सिर्फ़ तब डेटा वापस पाएं, जब सिस्टम को लगे कि ऐसा करना ज़रूरी है.

CodeExecution

इस टाइप के लिए कोई फ़ील्ड नहीं है.

यह एक ऐसा टूल है जो मॉडल से जनरेट किए गए कोड को लागू करता है. साथ ही, मॉडल को अपने-आप नतीजे दिखाता है.

ExecutableCode और CodeExecutionResult भी देखें. ये सिर्फ़ इस टूल का इस्तेमाल करने पर जनरेट होते हैं.

GoogleSearch

GoogleSearch टूल का टाइप. मॉडल में Google Search की सुविधा देने वाला टूल. Google की ओर से उपलब्ध कराया गया.

Fields
timeRangeFilter object (Interval)

ज़रूरी नहीं. खोज के नतीजों को किसी खास समयसीमा के हिसाब से फ़िल्टर करें. अगर खरीदार शुरू होने का समय सेट करते हैं, तो उन्हें खत्म होने का समय भी सेट करना होगा. इसके उलट, अगर वे खत्म होने का समय सेट करते हैं, तो उन्हें शुरू होने का समय भी सेट करना होगा.

searchTypes object (SearchTypes)

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

JSON के काेड में दिखाना 
{
  "timeRangeFilter": {
    object (Interval)
  },
  "searchTypes": {
    object (SearchTypes)
  }
}

इंटरवल

यह टाइम इंटरवल को दिखाता है. इसे टाइमस्टैंप के तौर पर कोड किया जाता है. इसमें टाइमस्टैंप के शुरू होने का समय (शामिल है) और टाइमस्टैंप के खत्म होने का समय (शामिल नहीं है) होता है.

शुरू होने की तारीख, खत्म होने की तारीख से पहले या उसके बराबर होनी चाहिए. शुरू होने और खत्म होने का समय एक जैसा होने पर, इंटरवल खाली होता है. इसका मतलब है कि यह किसी भी समय से मेल नहीं खाता. शुरू और खत्म होने का समय तय न होने पर, अंतराल किसी भी समय से मेल खाता है.

Fields
startTime string (Timestamp format)

ज़रूरी नहीं. समय अंतराल शुरू होने का समय शामिल है.

अगर इस इंटरवल के हिसाब से कोई टाइमस्टैंप दिया गया है, तो वह शुरू होने के समय के बराबर या उसके बाद का होना चाहिए.

यह आरएफ़सी 3339 का इस्तेमाल करता है. इसमें जनरेट किया गया आउटपुट हमेशा Z-नॉर्मलाइज़ किया जाएगा और इसमें 0, 3, 6 या 9 फ़्रैक्शनल अंक इस्तेमाल किए जाएंगे. "Z" के अलावा, अन्य ऑफ़सेट भी स्वीकार किए जाते हैं. उदाहरण: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" या "2014-10-02T15:01:23+05:30".

endTime string (Timestamp format)

ज़रूरी नहीं. इंटरवल खत्म होने का समय (अलग से उपलब्ध).

अगर यह तय किया गया है, तो इस इंटरवल से मेल खाने वाला टाइमस्टैंप, खत्म होने के समय से पहले का होना चाहिए.

यह आरएफ़सी 3339 का इस्तेमाल करता है. इसमें जनरेट किया गया आउटपुट हमेशा Z-नॉर्मलाइज़ किया जाएगा और इसमें 0, 3, 6 या 9 फ़्रैक्शनल अंक इस्तेमाल किए जाएंगे. "Z" के अलावा, अन्य ऑफ़सेट भी स्वीकार किए जाते हैं. उदाहरण: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" या "2014-10-02T15:01:23+05:30".

JSON के काेड में दिखाना 
{
  "startTime": string,
  "endTime": string
}

SearchTypes

GoogleSearch टूल पर अलग-अलग तरह की खोजें चालू की जा सकती हैं.

Fields
JSON के काेड में दिखाना 
{
  "webSearch": {
    object (WebSearch)
  },
  "imageSearch": {
    object (ImageSearch)
  }
}

WebSearch

इस टाइप के लिए कोई फ़ील्ड नहीं है.

ग्राउंडिंग और उससे जुड़े कॉन्फ़िगरेशन के लिए स्टैंडर्ड वेब सर्च.

ImageSearch

इस टाइप के लिए कोई फ़ील्ड नहीं है.

ग्राउंडिंग और उससे जुड़े कॉन्फ़िगरेशन के लिए इमेज खोज.

ComputerUse

कंप्यूटर के इस्तेमाल से जुड़ा टूल टाइप.

Fields
environment enum (Environment)

ज़रूरी है. जिस एनवायरमेंट में कार्रवाई की जा रही है.

excludedPredefinedFunctions[] string

ज़रूरी नहीं. डिफ़ॉल्ट रूप से, पहले से तय किए गए फ़ंक्शन, फ़ाइनल मॉडल कॉल में शामिल होते हैं. इनमें से कुछ को, अपने-आप शामिल होने से साफ़ तौर पर रोका जा सकता है. इससे दो फ़ायदे हो सकते हैं: 1. ज़्यादा पाबंदी वाले / अलग ऐक्शन स्पेस का इस्तेमाल करना. 2. पहले से तय किए गए फ़ंक्शन की परिभाषाओं / निर्देशों को बेहतर बनाना.

JSON के काेड में दिखाना 
{
  "environment": enum (Environment),
  "excludedPredefinedFunctions": [
    string
  ]
}

एनवायरमेंट

यह उस एनवायरमेंट को दिखाता है जिसमें कार्रवाई की जा रही है. जैसे, वेब ब्राउज़र.

Enums
ENVIRONMENT_UNSPECIFIED डिफ़ॉल्ट रूप से, यह ब्राउज़र पर सेट होता है.
ENVIRONMENT_BROWSER यह वेब ब्राउज़र पर काम करता है.

UrlContext

इस टाइप के लिए कोई फ़ील्ड नहीं है.

यूआरएल के कॉन्टेक्स्ट को वापस पाने में मदद करने वाला टूल.

FileSearch

यह FileSearch टूल है, जो सिमैंटिक रिट्रीवल कॉर्पस से जानकारी हासिल करता है. ImportFile API का इस्तेमाल करके, फ़ाइलों को सिमैंटिक रिट्रीवल कॉर्पस में इंपोर्ट किया जाता है.

Fields
fileSearchStoreNames[] string

ज़रूरी है. उन fileSearchStores के नाम जिनसे डेटा वापस पाना है. उदाहरण: fileSearchStores/my-file-search-store-123

metadataFilter string

ज़रूरी नहीं. सिमैंटिक तौर पर जानकारी पाने के लिए इस्तेमाल किए जाने वाले दस्तावेज़ों और चंक पर लागू करने के लिए मेटाडेटा फ़िल्टर.

topK integer

ज़रूरी नहीं. सिमैंटिक तरीके से खोजे गए डेटा के कितने हिस्सों को वापस पाना है.

JSON के काेड में दिखाना 
{
  "fileSearchStoreNames": [
    string
  ],
  "metadataFilter": string,
  "topK": integer
}

McpServer

MCPServer एक ऐसा सर्वर होता है जिसे मॉडल, कार्रवाइयां करने के लिए कॉल कर सकता है. यह एक ऐसा सर्वर है जो एमसीपी प्रोटोकॉल लागू करता है. अगला आईडी: 5

Fields
name string

MCPServer का नाम.

transport Union type
MCPServer से कनेक्ट करने के लिए इस्तेमाल किया जाने वाला ट्रांसपोर्ट. transport इनमें से सिर्फ़ एक हो सकता है:
streamableHttpTransport object (StreamableHttpTransport)

एक ऐसा ट्रांसपोर्ट जो एचटीटीपी अनुरोधों और जवाबों को स्ट्रीम कर सकता है.

JSON के काेड में दिखाना 
{
  "name": string,

  // transport
  "streamableHttpTransport": {
    object (StreamableHttpTransport)
  }
  // Union type
}

StreamableHttpTransport

एक ऐसा ट्रांसपोर्ट जो एचटीटीपी अनुरोधों और जवाबों को स्ट्रीम कर सकता है. अगला आईडी: 6

Fields
url string

MCPServer एंडपॉइंट का पूरा यूआरएल. उदाहरण: "https://api.example.com/mcp"

headers map (key: string, value: string)

ज़रूरी नहीं: अगर ज़रूरी हो, तो पुष्टि करने वाले हेडर, टाइमआउट वगैरह के लिए फ़ील्ड.

एक ऑब्जेक्ट, जिसमें "key": value जोड़े की सूची शामिल हो. उदाहरण: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

timeout string (Duration format)

सामान्य कार्रवाइयों के लिए एचटीटीपी टाइमआउट.

यह अवधि सेकंड में होती है. इसमें नौ दशमलव अंक तक हो सकते हैं. इसके आखिर में 's' होता है. उदाहरण: "3.5s".

sseReadTimeout string (Duration format)

एसएसई रीड ऑपरेशन के लिए टाइम आउट.

यह अवधि सेकंड में होती है. इसमें नौ दशमलव अंक तक हो सकते हैं. इसके आखिर में 's' होता है. उदाहरण: "3.5s".

terminateOnClose boolean

ट्रांसपोर्ट बंद होने पर, क्लाइंट सेशन बंद करना है या नहीं.

JSON के काेड में दिखाना 
{
  "url": string,
  "headers": {
    string: string,
    ...
  },
  "timeout": string,
  "sseReadTimeout": string,
  "terminateOnClose": boolean
}

GoogleMaps

GoogleMaps टूल, उपयोगकर्ता की क्वेरी के लिए जियोस्पेशल कॉन्टेक्स्ट उपलब्ध कराता है.

Fields
enableWidget boolean

ज़रूरी नहीं. जवाब के GroundingMetadata में विजेट कॉन्टेक्स्ट टोकन दिखाना है या नहीं. डेवलपर, विजेट कॉन्टेक्स्ट टोकन का इस्तेमाल करके Google Maps विजेट को रेंडर कर सकते हैं. इसमें उन जगहों से जुड़ा भू-स्थानिक कॉन्टेक्स्ट होता है जिनके बारे में मॉडल ने जवाब में बताया है.

JSON के काेड में दिखाना 
{
  "enableWidget": boolean
}

ToolConfig

टूल कॉन्फ़िगरेशन में ऐसे पैरामीटर होते हैं जिनसे अनुरोध में Tool के इस्तेमाल के बारे में जानकारी मिलती है.

Fields
functionCallingConfig object (FunctionCallingConfig)

ज़रूरी नहीं. फ़ंक्शन कॉल करने की सुविधा का कॉन्फ़िगरेशन.

retrievalConfig object (RetrievalConfig)

ज़रूरी नहीं. डेटा वापस पाने का कॉन्फ़िगरेशन.

includeServerSideToolInvocations boolean

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

JSON के काेड में दिखाना 
{
  "functionCallingConfig": {
    object (FunctionCallingConfig)
  },
  "retrievalConfig": {
    object (RetrievalConfig)
  },
  "includeServerSideToolInvocations": boolean
}

FunctionCallingConfig

फ़ंक्शन कॉल करने के तरीके के बारे में बताने के लिए कॉन्फ़िगरेशन.

Fields
mode enum (Mode)

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

allowedFunctionNames[] string

ज़रूरी नहीं. फ़ंक्शन के नामों का एक सेट. इसे उपलब्ध कराने पर, मॉडल सिर्फ़ उन फ़ंक्शन को कॉल करेगा.

इसे सिर्फ़ तब सेट किया जाना चाहिए, जब मोड ANY या VALIDATED हो. फ़ंक्शन के नाम, [FunctionDeclaration.name] से मेल खाने चाहिए. इस विकल्प को सेट करने पर, मॉडल सिर्फ़ उन फ़ंक्शन के नाम से फ़ंक्शन कॉल का अनुमान लगाएगा जिनकी अनुमति दी गई है.

JSON के काेड में दिखाना 
{
  "mode": enum (Mode),
  "allowedFunctionNames": [
    string
  ]
}

मोड

यह फ़ंक्शन कॉल करने के तरीके के बारे में बताता है. इसके लिए, यह फ़ंक्शन कॉल करने का मोड तय करता है.

Enums
MODE_UNSPECIFIED फ़ंक्शन कॉलिंग मोड की जानकारी नहीं दी गई है. इस वैल्यू का इस्तेमाल नहीं किया जाना चाहिए.
AUTO मॉडल का डिफ़ॉल्ट व्यवहार, मॉडल यह तय करता है कि फ़ंक्शन कॉल का अनुमान लगाना है या सामान्य भाषा में जवाब देना है.
ANY मॉडल को हमेशा सिर्फ़ फ़ंक्शन कॉल का अनुमान लगाने के लिए सीमित किया जाता है. अगर "allowedFunctionNames" सेट किए गए हैं, तो अनुमानित फ़ंक्शन कॉल, "allowedFunctionNames" में से किसी एक तक सीमित रहेगा. ऐसा न होने पर, अनुमानित फ़ंक्शन कॉल, उपलब्ध कराए गए "functionDeclarations" में से कोई एक होगा.
NONE मॉडल, किसी भी फ़ंक्शन कॉल का अनुमान नहीं लगाएगा. मॉडल का व्यवहार वैसा ही होता है जैसा फ़ंक्शन के किसी भी एलान को पास न करने पर होता है.
VALIDATED मॉडल यह तय करता है कि फ़ंक्शन कॉल का अनुमान लगाना है या सामान्य भाषा में जवाब देना है. हालांकि, यह फ़ंक्शन कॉल की पुष्टि, सीमित डिकोडिंग की मदद से करेगा. अगर "allowedFunctionNames" सेट किए गए हैं, तो अनुमानित फ़ंक्शन कॉल, "allowedFunctionNames" में से किसी एक तक सीमित रहेगा. ऐसा न होने पर, अनुमानित फ़ंक्शन कॉल, उपलब्ध कराए गए "functionDeclarations" में से कोई एक होगा.

RetrievalConfig

डेटा वापस पाने का कॉन्फ़िगरेशन.

Fields
latLng object (LatLng)

ज़रूरी नहीं. उपयोगकर्ता की जगह.

languageCode string

ज़रूरी नहीं. उपयोगकर्ता की भाषा का कोड. कॉन्टेंट के लिए भाषा कोड. BCP47 के हिसाब से तय किए गए भाषा टैग का इस्तेमाल करें.

JSON के काेड में दिखाना 
{
  "latLng": {
    object (LatLng)
  },
  "languageCode": string
}

LatLng

यह ऑब्जेक्ट, अक्षांश/देशांतर की जोड़ी को दिखाता है. इसे डबल के तौर पर दिखाया जाता है, ताकि अक्षांश और देशांतर की डिग्री को दिखाया जा सके. जब तक अलग से कोई जानकारी न दी जाए, तब तक इस ऑब्जेक्ट को WGS84 स्टैंडर्ड के मुताबिक होना चाहिए. वैल्यू, सामान्य की गई सीमाओं के अंदर होनी चाहिए.

Fields
latitude number

डिग्री में अक्षांश. यह [-90.0, +90.0] की रेंज में होना चाहिए.

longitude number

डिग्री में देशांतर. यह [-180.0, +180.0] की रेंज में होना चाहिए.

JSON के काेड में दिखाना 
{
  "latitude": number,
  "longitude": number
}

UsageMetadata

कैश मेमोरी में सेव किए गए कॉन्टेंट के इस्तेमाल से जुड़ा मेटाडेटा.

Fields
totalTokenCount integer

कैश किए गए कॉन्टेंट के लिए इस्तेमाल किए गए टोकन की कुल संख्या.

JSON के काेड में दिखाना 
{
  "totalTokenCount": integer
}