Caching

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

तरीका: cachedContents.create

CachedContent रिसॉर्स बनाता है.

एंडपॉइंट

पोस्ट https://generativelanguage.googleapis.com/v1beta/cachedContents

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

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

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

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

tools[] object (Tool)

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

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

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

आरएफ़सी3339 यूटीसी के "Zulu" फ़ॉर्मैट में एक टाइमस्टैंप, नैनोसेकंड रिज़ॉल्यूशन और नौ दशमलव अंकों के साथ. उदाहरण के लिए: "2014-10-02T15:01:23Z" और "2014-10-02T15:01:23.045123456Z".

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)

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

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

सामान्य

Python

import google.generativeai as genai

document = genai.upload_file(path=media / "a11.txt")
model_name = "gemini-1.5-flash-001"
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction="You are an expert analyzing transcripts.",
    contents=[document],
)
print(cache)

model = genai.GenerativeModel.from_cached_content(cache)
response = model.generate_content("Please summarize this transcript")
print(response.text)

Node.js

// Make sure to include these imports:
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
// import { GoogleGenerativeAI } from "@google/generative-ai";
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: uploadResult.file.uri,
            mimeType: uploadResult.file.mimeType,
          },
        },
      ],
    },
  ],
});

console.log(cacheResult);

const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModelFromCachedContent(cacheResult);
const result = await model.generateContent(
  "Please summarize this transcript.",
);
console.log(result.response.text());

शुरू करें

file, err := client.UploadFileFromPath(ctx,
	filepath.Join(testDataDir, "a11.txt"),
	&genai.UploadFileOptions{MIMEType: "text/plain"})
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)
fd := genai.FileData{URI: file.URI}

argcc := &genai.CachedContent{
	Model:             "gemini-1.5-flash-001",
	SystemInstruction: genai.NewUserContent(genai.Text("You are an expert analyzing transcripts.")),
	Contents:          []*genai.Content{genai.NewUserContent(fd)},
}
cc, err := client.CreateCachedContent(ctx, argcc)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteCachedContent(ctx, cc.Name)

modelWithCache := client.GenerativeModelFromCachedContent(cc)
prompt := "Please summarize this transcript"
resp, err := modelWithCache.GenerateContent(ctx, genai.Text(prompt))
if err != nil {
	log.Fatal(err)
}

printResponse(resp)

शेल

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=$GOOGLE_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=$GOOGLE_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
      "contents": [
        {
          "parts":[{
            "text": "Please summarize this transcript"
          }],
          "role": "user"
        },
      ],
      "cachedContent": "'$CACHE_NAME'"
    }'

नाम

Python

import google.generativeai as genai

document = genai.upload_file(path=media / "a11.txt")
model_name = "gemini-1.5-flash-001"
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction="You are an expert analyzing transcripts.",
    contents=[document],
)
cache_name = cache.name  # Save the name for later

# Later
cache = genai.caching.CachedContent.get(cache_name)
apollo_model = genai.GenerativeModel.from_cached_content(cache)
response = apollo_model.generate_content("Find a lighthearted moment from this transcript")
print(response.text)

Node.js

// Make sure to include these imports:
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
// import { GoogleGenerativeAI } from "@google/generative-ai";
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: uploadResult.file.uri,
            mimeType: uploadResult.file.mimeType,
          },
        },
      ],
    },
  ],
});
const cacheName = cacheResult.name; // Save the name for later.

// Later
const getCacheResult = await cacheManager.get(cacheName);
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModelFromCachedContent(getCacheResult);
model.generateContent("Please summarize this transcript.");

शुरू करें

file, err := client.UploadFileFromPath(ctx, filepath.Join(testDataDir, "a11.txt"), nil)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)
fd := genai.FileData{URI: file.URI}

argcc := &genai.CachedContent{
	Model:             "gemini-1.5-flash-001",
	SystemInstruction: genai.NewUserContent(genai.Text("You are an expert analyzing transcripts.")),
	Contents:          []*genai.Content{genai.NewUserContent(fd)},
}
cc, err := client.CreateCachedContent(ctx, argcc)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteCachedContent(ctx, cc.Name)

// Save the name for later
cacheName := cc.Name

// ... Later
cc2, err := client.GetCachedContent(ctx, cacheName)
if err != nil {
	log.Fatal(err)
}
modelWithCache := client.GenerativeModelFromCachedContent(cc2)
prompt := "Find a lighthearted moment from this transcript"
resp, err := modelWithCache.GenerateContent(ctx, genai.Text(prompt))
if err != nil {
	log.Fatal(err)
}

printResponse(resp)

चैट से

Python

import google.generativeai as genai

model_name = "gemini-1.5-flash-001"
system_instruction = "You are an expert analyzing transcripts."

model = genai.GenerativeModel(model_name=model_name, system_instruction=system_instruction)
chat = model.start_chat()
document = genai.upload_file(path=media / "a11.txt")
response = chat.send_message(["Hi, could you summarize this transcript?", document])
print("\n\nmodel:  ", response.text)
response = chat.send_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 = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction=system_instruction,
    contents=chat.history,
)
model = genai.GenerativeModel.from_cached_content(cached_content=cache)

# Continue the chat where you left off.
chat = model.start_chat()
response = chat.send_message(
    "I didn't understand that last part, could you explain it in simpler language?"
)
print("\n\nmodel:  ", response.text)

Node.js

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash-001" });
const chat = model.startChat();

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

let result = await chat.sendMessage([
  "Hi, could you summarize this transcript?",
  {
    fileData: {
      fileUri: uploadResult.file.uri,
      mimeType: uploadResult.file.mimeType,
    },
  },
]);
console.log(`\n\nmodel: ${result.response.text()}`);
result = await chat.sendMessage(
  "Okay, could you tell me more about the trans-lunar injection",
);
console.log(`\n\nmodel: ${result.response.text()}`);

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: await chat.getHistory(),
});

const newModel = genAI.getGenerativeModelFromCachedContent(cacheResult);

const newChat = newModel.startChat();
result = await newChat.sendMessage(
  "I didn't understand that last part, could you explain it in simpler language?",
);
console.log(`\n\nmodel: ${result.response.text()}`);

शुरू करें

file, err := client.UploadFileFromPath(ctx, filepath.Join(testDataDir, "a11.txt"), nil)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)
fd := genai.FileData{URI: file.URI}

modelName := "gemini-1.5-flash-001"
model := client.GenerativeModel(modelName)
model.SystemInstruction = genai.NewUserContent(genai.Text("You are an expert analyzing transcripts."))

cs := model.StartChat()
resp, err := cs.SendMessage(ctx, genai.Text("Hi, could you summarize this transcript?"), fd)
if err != nil {
	log.Fatal(err)
}

resp, err = cs.SendMessage(ctx, genai.Text("Okay, could you tell me more about the trans-lunar injection"))
if err != nil {
	log.Fatal(err)
}

// To cache the conversation so far, pass the chat history as the list of
// contents.

argcc := &genai.CachedContent{
	Model:             modelName,
	SystemInstruction: model.SystemInstruction,
	Contents:          cs.History,
}
cc, err := client.CreateCachedContent(ctx, argcc)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteCachedContent(ctx, cc.Name)

modelWithCache := client.GenerativeModelFromCachedContent(cc)
cs = modelWithCache.StartChat()
resp, err = cs.SendMessage(ctx, genai.Text("I didn't understand that last part, could you please explain it in simpler language?"))
if err != nil {
	log.Fatal(err)
}
printResponse(resp)

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

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

तरीका: cachedContents.list

CachedContents की सूची बनाता है.

एंडपॉइंट

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

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

pageSize integer

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

pageToken string

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

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

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

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

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

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

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

फ़ील्ड
cachedContents[] object (CachedContent)

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

nextPageToken string

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

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

तरीका: cacheContents.get

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

एंडपॉइंट

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

पाथ पैरामीटर

name string

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

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

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

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

Python

import google.generativeai as genai

document = genai.upload_file(path=media / "a11.txt")
model_name = "gemini-1.5-flash-001"
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction="You are an expert analyzing transcripts.",
    contents=[document],
)
print(genai.caching.CachedContent.get(name=cache.name))

Node.js

// Make sure to include these imports:
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: uploadResult.file.uri,
            mimeType: uploadResult.file.mimeType,
          },
        },
      ],
    },
  ],
});
const cacheGetResult = await cacheManager.get(cacheResult.name);
console.log(cacheGetResult);

शुरू करें

file, err := client.UploadFileFromPath(ctx, filepath.Join(testDataDir, "a11.txt"), nil)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)
fd := genai.FileData{URI: file.URI}

argcc := &genai.CachedContent{
	Model:             "gemini-1.5-flash-001",
	SystemInstruction: genai.NewUserContent(genai.Text("You are an expert analyzing transcripts.")),
	Contents:          []*genai.Content{genai.NewUserContent(fd)},
}
cc, err := client.CreateCachedContent(ctx, argcc)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteCachedContent(ctx, cc.Name)

// Save the name for later
cacheName := cc.Name

// ... Later
cc2, err := client.GetCachedContent(ctx, cacheName)
if err != nil {
	log.Fatal(err)
}
modelWithCache := client.GenerativeModelFromCachedContent(cc2)
prompt := "Find a lighthearted moment from this transcript"
resp, err := modelWithCache.GenerateContent(ctx, genai.Text(prompt))
if err != nil {
	log.Fatal(err)
}

printResponse(resp)

शेल

curl "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GOOGLE_API_KEY"

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

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

तरीका: cachedContents.patch

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

एंडपॉइंट

पैच 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. बताता है कि इस संसाधन की समयसीमा कब खत्म होगी. expiration इनमें से कोई एक हो सकता है:
expireTime string (Timestamp format)

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

आरएफ़सी3339 यूटीसी के "Zulu" फ़ॉर्मैट में एक टाइमस्टैंप, नैनोसेकंड रिज़ॉल्यूशन और नौ दशमलव अंकों के साथ. उदाहरण के लिए: "2014-10-02T15:01:23Z" और "2014-10-02T15:01:23.045123456Z".

ttl string (Duration format)

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

सेकंड में एक अवधि, जिसमें ज़्यादा से ज़्यादा नौ दशमलव अंक होते हैं और जो 's' पर खत्म होता है. उदाहरण: "3.5s".

name string

ज़रूरी नहीं. आइडेंटिफ़ायर. कैश मेमोरी में सेव किए गए कॉन्टेंट का नाम. फ़ॉर्मैट: cachedContents/{id}

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

Python

import google.generativeai as genai

import datetime

document = genai.upload_file(path=media / "a11.txt")
model_name = "gemini-1.5-flash-001"
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction="You are an expert analyzing transcripts.",
    contents=[document],
)

# You can update the ttl
cache.update(ttl=datetime.timedelta(hours=2))
print(f"After update:\n {cache}")

# Or you can update the expire_time
cache.update(expire_time=datetime.datetime.now() + datetime.timedelta(minutes=15))

Node.js

// Make sure to include these imports:
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: uploadResult.file.uri,
            mimeType: uploadResult.file.mimeType,
          },
        },
      ],
    },
  ],
});
console.log("initial cache data:", cacheResult);
const cacheUpdateResult = await cacheManager.update(cacheResult.name, {
  cachedContent: {
    // 2 hours
    ttlSeconds: 60 * 60 * 2,
  },
});
console.log("updated cache data:", cacheUpdateResult);

शुरू करें

file, err := client.UploadFileFromPath(ctx,
	filepath.Join(testDataDir, "a11.txt"),
	&genai.UploadFileOptions{MIMEType: "text/plain"})
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

शेल

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

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

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

तरीका: cachedContents.delete

CachedContent रिसॉर्स मिटाता है.

एंडपॉइंट

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

पाथ पैरामीटर

name string

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

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

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

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

Python

import google.generativeai as genai

document = genai.upload_file(path=media / "a11.txt")
model_name = "gemini-1.5-flash-001"
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction="You are an expert analyzing transcripts.",
    contents=[document],
)
cache.delete()

Node.js

// Make sure to include these imports:
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: uploadResult.file.uri,
            mimeType: uploadResult.file.mimeType,
          },
        },
      ],
    },
  ],
});
await cacheManager.delete(cacheResult.name);

शुरू करें

file, err := client.UploadFileFromPath(ctx,
	filepath.Join(testDataDir, "a11.txt"),
	&genai.UploadFileOptions{MIMEType: "text/plain"})
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

शेल

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

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

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

REST रिसॉर्स: cachedContents

रिसॉर्स: CachedContent

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

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

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

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

tools[] object (Tool)

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

createTime string (Timestamp format)

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

आरएफ़सी3339 यूटीसी के "Zulu" फ़ॉर्मैट में एक टाइमस्टैंप, नैनोसेकंड रिज़ॉल्यूशन और नौ दशमलव अंकों के साथ. उदाहरण के लिए: "2014-10-02T15:01:23Z" और "2014-10-02T15:01:23.045123456Z".

updateTime string (Timestamp format)

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

आरएफ़सी3339 यूटीसी के "Zulu" फ़ॉर्मैट में एक टाइमस्टैंप, नैनोसेकंड रिज़ॉल्यूशन और नौ दशमलव अंकों के साथ. उदाहरण के लिए: "2014-10-02T15:01:23Z" और "2014-10-02T15:01:23.045123456Z".

usageMetadata object (UsageMetadata)

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

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

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

आरएफ़सी3339 यूटीसी के "Zulu" फ़ॉर्मैट में एक टाइमस्टैंप, नैनोसेकंड रिज़ॉल्यूशन और नौ दशमलव अंकों के साथ. उदाहरण के लिए: "2014-10-02T15:01:23Z" और "2014-10-02T15:01:23.045123456Z".

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)
  },

  // Union field expiration can be only one of the following:
  "expireTime": string,
  "ttl": string
  // End of list of possible types for union field expiration.
  "name": string,
  "displayName": string,
  "model": string,
  "systemInstruction": {
    object (Content)
  },
  "toolConfig": {
    object (ToolConfig)
  }
}

सामग्री

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

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

फ़ील्ड
parts[] object (Part)

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

role string

ज़रूरी नहीं. कॉन्टेंट का प्रोड्यूसर. यह 'उपयोगकर्ता' या 'मॉडल' में से कोई एक होना चाहिए.

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

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

भाग

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

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

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

फ़ील्ड

यूनियन फ़ील्ड data.

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

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

  // Union field data can be only one of the following:
  "text": string,
  "inlineData": {
    object (Blob)
  },
  "functionCall": {
    object (FunctionCall)
  },
  "functionResponse": {
    object (FunctionResponse)
  },
  "fileData": {
    object (FileData)
  },
  "executableCode": {
    object (ExecutableCode)
  },
  "codeExecutionResult": {
    object (CodeExecutionResult)
  }
  // End of list of possible types for union field data.
}

ब्लॉब

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

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

फ़ील्ड
mimeType string

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

data string (bytes format)

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

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

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

FunctionCall

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

फ़ील्ड
name string

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

args object (Struct format)

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

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

FunctionResponse

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

फ़ील्ड
name string

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

response object (Struct format)

ज़रूरी है. JSON ऑब्जेक्ट फ़ॉर्मैट में फ़ंक्शन का रिस्पॉन्स.

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

FileData

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

फ़ील्ड
mimeType string

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

fileUri string

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

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

ExecutableCode

मॉडल से जनरेट किया गया कोड, जिसे चलाया जाना है और मॉडल को मिला नतीजा.

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

फ़ील्ड
language enum (Language)

ज़रूरी है. code की प्रोग्रामिंग भाषा.

code string

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

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

भाषा

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

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

CodeExecutionResult

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

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

फ़ील्ड
outcome enum (Outcome)

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

output string

ज़रूरी नहीं. कोड लागू होने पर, इसमें स्टर्डआउट होता है. इसके अलावा, कोड लागू न होने पर इसमें स्टर्डआउट या कोई अन्य जानकारी होती है.

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

नतीजा

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

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

टूल

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

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

फ़ील्ड
functionDeclarations[] object (FunctionDeclaration)

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

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

googleSearchRetrieval object (GoogleSearchRetrieval)

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

codeExecution object (CodeExecution)

ज़रूरी नहीं. जनरेशन के हिस्से के तौर पर कोड चलाने के लिए, मॉडल को चालू करता है.

JSON के काेड में दिखाना
{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "googleSearchRetrieval": {
    object (GoogleSearchRetrieval)
  },
  "codeExecution": {
    object (CodeExecution)
  }
}

FunctionDeclaration

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

फ़ील्ड
name string

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

description string

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

parameters object (Schema)

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

JSON के काेड में दिखाना
{
  "name": string,
  "description": string,
  "parameters": {
    object (Schema)
  }
}

स्कीमा

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

फ़ील्ड
type enum (Type)

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

format string

ज़रूरी नहीं. डेटा का फ़ॉर्मैट. इसका इस्तेमाल सिर्फ़ शुरुआती डेटा टाइप के लिए किया जाता है. इस्तेमाल किए जा सकने वाले फ़ॉर्मैट: NUMBER टाइप के लिए: float, double INTEGER टाइप के लिए: int32, int64 STRING टाइप के लिए: enum

description string

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

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 के लिए ज़रूरी प्रॉपर्टी.

items object (Schema)

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

JSON के काेड में दिखाना
{
  "type": enum (Type),
  "format": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "maxItems": string,
  "minItems": string,
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "items": {
    object (Schema)
  }
}

टाइप

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

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

GoogleSearchRetrieval

Google का यह टूल, सार्वजनिक वेब डेटा को इकट्ठा करता है, ताकि उसे ग्राउंडिंग के लिए इस्तेमाल किया जा सके.

फ़ील्ड
dynamicRetrievalConfig object (DynamicRetrievalConfig)

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

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

DynamicRetrievalConfig

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

फ़ील्ड
mode enum (Mode)

डाइनैमिक रीट्रिवल में इस्तेमाल किए जाने वाले प्रिडिक्टर का मोड.

dynamicThreshold number

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

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

मोड

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

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

CodeExecution

इस टाइप में कोई फ़ील्ड नहीं होता.

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

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

ToolConfig

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

फ़ील्ड
functionCallingConfig object (FunctionCallingConfig)

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

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

FunctionCallingConfig

फ़ंक्शन कॉलिंग व्यवहार तय करने के लिए कॉन्फ़िगरेशन.

फ़ील्ड
mode enum (Mode)

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

allowedFunctionNames[] string

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

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

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

मोड

फ़ंक्शन कॉल करने के लिए, फ़ंक्शन के लागू होने का तरीका तय करता है.

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

UsageMetadata

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

फ़ील्ड
totalTokenCount integer

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

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