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 का इस्तेमाल करने वाले एजेंट को अतिरिक्त जानकारी ट्रैक करनी पड़ सकती है. उदाहरण के लिए, यह उस फ़ाइल/सोर्स का नाम हो सकता है जिससे पार्ट बना है. इसके अलावा, यह एक से ज़्यादा पार्ट स्ट्रीम को मल्टीप्लेक्स करने का तरीका भी हो सकता है.

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 को लागू करने का नतीजा.

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

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

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

  // data
  "text": string,
  "inlineData": {
    object (Blob)
  },
  "functionCall": {
    object (FunctionCall)
  },
  "functionResponse": {
    object (FunctionResponse)
  },
  "fileData": {
    object (FileData)
  },
  "executableCode": {
    object (ExecutableCode)
  },
  "codeExecutionResult": {
    object (CodeExecutionResult)
  }
  // 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 के साथ-साथ अंडरस्कोर और डैश शामिल होने चाहिए. इसकी लंबाई ज़्यादा से ज़्यादा 64 वर्ण होनी चाहिए.

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 के साथ-साथ अंडरस्कोर और डैश शामिल होने चाहिए. इसकी लंबाई ज़्यादा से ज़्यादा 64 वर्ण होनी चाहिए.

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
language enum (Language)

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

code string

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

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

भाषा

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

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

CodeExecutionResult

ExecutableCode को लागू करने का नतीजा.

यह सिर्फ़ CodeExecution का इस्तेमाल करने पर जनरेट होता है. साथ ही, यह हमेशा part के बाद आता है, जिसमें ExecutableCode शामिल होता है.

Fields
outcome enum (Outcome)

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

output string

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

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

नतीजा

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

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

VideoMetadata

मेटाडेटा में, इनपुट वीडियो कॉन्टेंट के बारे में जानकारी होती है.

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
}

टूल

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

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

अगला आईडी: 12

Fields
functionDeclarations[] object (FunctionDeclaration)

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

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

googleSearchRetrieval object (GoogleSearchRetrieval)

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

codeExecution object (CodeExecution)

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

computerUse object (ComputerUse)

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

urlContext object (UrlContext)

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

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)
  },
  "googleMaps": {
    object (GoogleMaps)
  }
}

FunctionDeclaration

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

Fields
name string

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

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 फ़ील्ड वाले स्कीमा भेजने वाले डेवलपर को unknown-field वाली गड़बड़ियां न मिलें.

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 की मदद से, वेब पर मौजूद सार्वजनिक डेटा को खोजने का टूल.

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)

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

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

इंटरवल

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

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

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
}

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
retrievalResources[] object (RetrievalResource)

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

retrievalConfig object (RetrievalConfig)

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

JSON के काेड में दिखाना 
{
  "retrievalResources": [
    {
      object (RetrievalResource)
    }
  ],
  "retrievalConfig": {
    object (RetrievalConfig)
  }
}

RetrievalResource

सिमेंटिक तरीके से जानकारी पाने के लिए संसाधन.

Fields
ragStoreName string

ज़रूरी है. सिमैंटिक रिट्रीवल रिसॉर्स का नाम, जिससे जानकारी वापस लानी है. उदाहरण: ragStores/my-rag-store-123

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

RetrievalConfig

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

Fields
metadataFilter string

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

topK integer

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

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

GoogleMaps

GoogleMaps टूल, उपयोगकर्ता की क्वेरी के लिए भू-स्थानिक संदर्भ उपलब्ध कराता है.

Fields
enableWidget boolean

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

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

ToolConfig

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

Fields
functionCallingConfig object (FunctionCallingConfig)

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

retrievalConfig object (RetrievalConfig)

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

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

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
}