Caching

Ruajtja në memorie e kontekstit ju lejon të ruani dhe ripërdorni shenjat hyrëse të parallogaritura që dëshironi të përdorni në mënyrë të përsëritur, për shembull kur bëni pyetje të ndryshme për të njëjtin skedar media. Kjo mund të çojë në kursime të kostos dhe shpejtësisë, në varësi të përdorimit. Për një hyrje të detajuar, shihni udhëzuesin e ruajtjes në memorien e kontekstit .

Metoda: cacheContents.krijoj

Krijon burim CachedContent.

Pika përfundimtare

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

Trupi i kërkesës

Trupi i kërkesës përmban një shembull të CachedContent .

Fushat
contents[] object ( Content )

Fakultative. Vetëm hyrje. E pandryshueshme. Përmbajtja në cache.

tools[] object ( Tool )

Fakultative. Vetëm hyrje. E pandryshueshme. Një listë e Tools modeli mund të përdorë për të gjeneruar përgjigjen e radhës

expiration Union type bashkimit
Përcakton se kur do të skadojë ky burim. expiration mund të jetë vetëm një nga sa vijon:
expireTime string ( Timestamp format)

Vula kohore në UTC kur ky burim konsiderohet i skaduar. Kjo ofrohet gjithmonë në dalje, pavarësisht se çfarë është dërguar në hyrje.

Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

vargu ttl string ( Duration format)

Vetëm hyrje. TTL e re për këtë burim, vetëm hyrje.

Një kohëzgjatje në sekonda me deri në nëntë shifra të pjesshme, që mbarojnë me ' s '. Shembull: "3.5s" .

string name

Fakultative. Identifikues. Emri i burimit që i referohet përmbajtjes së memorizuar. Formati: cachedContents/{id}

string displayName

Fakultative. E pandryshueshme. Emri i shfaqur kuptimplotë i krijuar nga përdoruesi i përmbajtjes së memorizuar. Maksimumi 128 karaktere Unicode.

string model

E detyrueshme. E pandryshueshme. Emri i Model që do të përdoret për përmbajtjen e memorizuar Formati: models/{model}

Sistemi i objektit systemInstruction object ( Content )

Fakultative. Vetëm hyrje. E pandryshueshme. Udhëzime për sistemin e grupit të zhvilluesit. Aktualisht vetëm tekst.

Objekti toolConfig object ( ToolConfig )

Fakultative. Vetëm hyrje. E pandryshueshme. Konfigurimi i mjetit. Ky konfigurim është i ndarë për të gjitha mjetet.

Shembull i kërkesës

bazë Nga emri Nga biseda
Python Nyja.js Shkoni Shell 
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
// 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());
cache.js
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)
docs-snippets_test.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
Python Nyja.js Shkoni 
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
// 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.");
cache.js
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)
docs-snippets_test.go
Python Nyja.js Shkoni 
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
// 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()}`);
cache.js
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)

docs-snippets_test.go

Trupi i reagimit

Nëse është i suksesshëm, trupi i përgjigjes përmban një shembull të sapokrijuar të CachedContent .

Metoda: cacheContents.list

Liston Përmbajtjet në Cached.

Pika përfundimtare

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

Parametrat e pyetjes

integer pageSize

Fakultative. Numri maksimal i përmbajtjeve të ruajtura në memorie për t'u kthyer. Shërbimi mund të kthejë më pak se kjo vlerë. Nëse nuk specifikohet, do të kthehen një numër i paracaktuar (nën maksimum) artikujsh. Vlera maksimale është 1000; vlerat mbi 1000 do të detyrohen në 1000.

vargu string pageToken

Fakultative. Një shenjë faqeje, e marrë nga një telefonatë e mëparshme cachedContents.list . Jepni këtë për të rikthyer faqen pasuese.

Gjatë paginimit, të gjithë parametrat e tjerë të dhënë në cachedContents.list duhet të përputhen me thirrjen që ka dhënë tokenin e faqes.

Trupi i kërkesës

Trupi i kërkesës duhet të jetë bosh.

Trupi i reagimit

Përgjigja me listën CachedContents.

Nëse është i suksesshëm, trupi i përgjigjes përmban të dhëna me strukturën e mëposhtme:

Fushat
cachedContents[] object ( CachedContent )

Lista e përmbajtjeve të ruajtura në memorie.

string nextPageToken

Një shenjë, e cila mund të dërgohet si pageToken për të tërhequr faqen tjetër. Nëse kjo fushë hiqet, nuk ka faqe të mëvonshme.

Përfaqësimi JSON 
{
  "cachedContents": [
    {
      object (CachedContent)
    }
  ],
  "nextPageToken": string
}

Metoda: cachedContents.get

Lexon burimin CachedContent.

Pika përfundimtare

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

Parametrat e rrugës

string name

E detyrueshme. Emri i burimit që i referohet hyrjes në cache të përmbajtjes. Formati: cachedContents/{id} Merr formën cachedContents/{cachedcontent} .

Trupi i kërkesës

Trupi i kërkesës duhet të jetë bosh.

Shembull i kërkesës

Python Nyja.js Shkoni Shell 
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
// 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);
cache.js
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)
docs-snippets_test.go
curl "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY"
cache.sh

Trupi i reagimit

Nëse është i suksesshëm, trupi i përgjigjes përmban një shembull të CachedContent .

Metoda: cachedContents.patch

Përditëson burimin CachedContent (vetëm skadimi mund të përditësohet).

Pika përfundimtare

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

Parametrat e rrugës

cachedContent.name string

Fakultative. Identifikues. Emri i burimit që i referohet përmbajtjes së memorizuar. Formati: cachedContents/{id} Merr formën cachedContents/{cachedcontent} .

Parametrat e pyetjes

vargu updateMask string ( FieldMask format)

Lista e fushave për të përditësuar.

Kjo është një listë e ndarë me presje e emrave plotësisht të kualifikuar të fushave. Shembull: "user.displayName,photo" .

Trupi i kërkesës

Trupi i kërkesës përmban një shembull të CachedContent .

Fushat
expiration Union type bashkimit
Përcakton se kur do të skadojë ky burim. expiration mund të jetë vetëm një nga sa vijon:
expireTime string ( Timestamp format)

Vula kohore në UTC kur ky burim konsiderohet i skaduar. Kjo ofrohet gjithmonë në dalje, pavarësisht se çfarë është dërguar në hyrje.

Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

vargu ttl string ( Duration format)

Vetëm hyrje. TTL e re për këtë burim, vetëm hyrje.

Një kohëzgjatje në sekonda me deri në nëntë shifra të pjesshme, që mbarojnë me ' s '. Shembull: "3.5s" .

string name

Fakultative. Identifikues. Emri i burimit që i referohet përmbajtjes së memorizuar. Formati: cachedContents/{id}

Shembull i kërkesës

Python Nyja.js Shkoni Shell 
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
// 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);
cache.js
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)
docs-snippets_test.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

Trupi i reagimit

Nëse është i suksesshëm, trupi i përgjigjes përmban një shembull të CachedContent .

Metoda: cachedContents.fshij

Fshin burimin CachedContent.

Pika përfundimtare

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

Parametrat e rrugës

string name

E detyrueshme. Emri i burimit që i referohet hyrjes në cache të përmbajtjes Formati: cachedContents/{id} Ai merr formën cachedContents/{cachedcontent} .

Trupi i kërkesës

Trupi i kërkesës duhet të jetë bosh.

Shembull i kërkesës

Python Nyja.js Shkoni Shell 
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
// 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);
cache.js
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)
docs-snippets_test.go
curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY"
cache.sh

Trupi i reagimit

Nëse është i suksesshëm, trupi i përgjigjes është një objekt JSON bosh.

Burimi REST: Përmbajtja në memorie të fshehtë

Burimi: CachedContent

Përmbajtja që është përpunuar paraprakisht dhe mund të përdoret në kërkesën e mëvonshme për GenerativeService.

Përmbajtja e memorizuar mund të përdoret vetëm me modelin për të cilin është krijuar.

Fushat
contents[] object ( Content )

Fakultative. Vetëm hyrje. E pandryshueshme. Përmbajtja në cache.

tools[] object ( Tool )

Fakultative. Vetëm hyrje. E pandryshueshme. Një listë e Tools modeli mund të përdorë për të gjeneruar përgjigjen e radhës

createTime string ( Timestamp format)

Vetëm dalje. Koha e krijimit të hyrjes në cache.

Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

Vargu updateTime string ( Timestamp format)

Vetëm dalje. Kur hyrja në cache u përditësua për herë të fundit në kohën UTC.

Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

usageMetadata object ( UsageMetadata )

Vetëm dalje. Metadatat mbi përdorimin e përmbajtjes së memorizuar.

expiration Union type bashkimit
Përcakton se kur do të skadojë ky burim. expiration mund të jetë vetëm një nga sa vijon:
expireTime string ( Timestamp format)

Vula kohore në UTC kur ky burim konsiderohet i skaduar. Kjo ofrohet gjithmonë në dalje, pavarësisht se çfarë është dërguar në hyrje.

Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

vargu ttl string ( Duration format)

Vetëm hyrje. TTL e re për këtë burim, vetëm hyrje.

Një kohëzgjatje në sekonda me deri në nëntë shifra të pjesshme, që mbarojnë me ' s '. Shembull: "3.5s" .

string name

Fakultative. Identifikues. Emri i burimit që i referohet përmbajtjes së memorizuar. Formati: cachedContents/{id}

string displayName

Fakultative. E pandryshueshme. Emri i shfaqur kuptimplotë i krijuar nga përdoruesi i përmbajtjes së memorizuar. Maksimumi 128 karaktere Unicode.

string model

E detyrueshme. E pandryshueshme. Emri i Model që do të përdoret për përmbajtjen e memorizuar Formati: models/{model}

Sistemi i objektit systemInstruction object ( Content )

Fakultative. Vetëm hyrje. E pandryshueshme. Udhëzime për sistemin e grupit të zhvilluesit. Aktualisht vetëm tekst.

Objekti toolConfig object ( ToolConfig )

Fakultative. Vetëm hyrje. E pandryshueshme. Konfigurimi i mjetit. Ky konfigurim është i ndarë për të gjitha mjetet.

Përfaqësimi 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)
  }
}

përmbajtja

Lloji i të dhënave të strukturuar bazë që përmban përmbajtje me shumë pjesë të një mesazhi.

Një Content përfshin një fushë role që përcakton prodhuesin e Content dhe një fushë parts që përmban të dhëna me shumë pjesë që përmban përmbajtjen e kthesës së mesazhit.

Fushat
parts[] object ( Part )

Parts të porositura që përbëjnë një mesazh të vetëm. Pjesët mund të kenë lloje të ndryshme MIME.

role string

Fakultative. Prodhuesi i përmbajtjes. Duhet të jetë ose 'përdorues' ose 'model'.

E dobishme për t'u vendosur për biseda me shumë kthesa, përndryshe mund të lihet bosh ose e pacaktuar.

Përfaqësimi JSON 
{
  "parts": [
    {
      object (Part)
    }
  ],
  "role": string
}

Pjesë

Një lloj i të dhënave që përmban media që është pjesë e një mesazhi Content shumëpjesëshe.

Një Part përbëhet nga të dhëna që kanë një lloj të dhënash të lidhur. Një Part mund të përmbajë vetëm një nga llojet e pranuara në Part.data .

Një Part duhet të ketë një lloj MIME fiks IANA që identifikon llojin dhe nëntipin e medias nëse fusha inlineData është e mbushur me bajt të papërpunuar.

Fushat
data Union type
data mund të jenë vetëm një nga të mëposhtmet:
string text

Teksti në linjë.

Objekti inlineData object ( Blob )

Bajt mediash në linjë.

object ( FunctionCall ) functionCall (FunctionCall)

Një FunctionCall i parashikuar i kthyer nga modeli që përmban një varg që përfaqëson FunctionDeclaration.name me argumentet dhe vlerat e tyre.

object ( FunctionResponse ) functionResponse (FunksionResponse)

Dalja e rezultatit të një FunctionCall që përmban një varg që përfaqëson FunctionDeclaration.name dhe një objekt të strukturuar JSON që përmban ndonjë dalje nga funksioni përdoret si kontekst për modelin.

object ( FileData ) fileData (FileData)

Të dhëna të bazuara në URI.

object ( ExecutableCode ) executableCode (Kodi i ekzekutueshëm)

Kodi i krijuar nga modeli që është menduar të ekzekutohet.

object ( CodeExecutionResult ) codeExecutionResult (CodeExecutionResult)

Rezultati i ekzekutimit të kodit ExecutableCode .

Përfaqësimi JSON 
{

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

Njollë

Bajt mediash të papërpunuara.

Teksti nuk duhet të dërgohet si bajt të papërpunuar, përdorni fushën 'tekst'.

Fushat
string mimeType

Lloji standard MIME IANA i të dhënave burimore. Shembuj: - image/png - image/jpeg Nëse ofrohet një lloj MIME i pambështetur, do të kthehet një gabim. Për një listë të plotë të llojeve të mbështetura, shihni Formatet e skedarëve të mbështetur .

vargu data string ( bytes format)

Bajt të papërpunuara për formatet e medias.

Një varg i koduar me bazë 64.

Përfaqësimi JSON 
{
  "mimeType": string,
  "data": string
}

FunksioniThirrje

Një FunctionCall i parashikuar i kthyer nga modeli që përmban një varg që përfaqëson FunctionDeclaration.name me argumentet dhe vlerat e tyre.

Fushat
string id

Fakultative. ID-ja unike e thirrjes së funksionit. Nëse popullohet, klienti do të ekzekutojë functionCall dhe do ta kthejë përgjigjen me id që përputhet.

string name

E detyrueshme. Emri i funksionit për të thirrur. Duhet të jetë az, AZ, 0-9, ose të përmbajë nënvizime dhe vija, me një gjatësi maksimale 63.

objekti args object ( Struct format)

Fakultative. Parametrat dhe vlerat e funksionit në formatin e objektit JSON.

Përfaqësimi JSON 
{
  "id": string,
  "name": string,
  "args": {
    object
  }
}

Funksioni Përgjigje

Rezultati i daljes nga një FunctionCall që përmban një varg që përfaqëson FunctionDeclaration.name dhe një objekt të strukturuar JSON që përmban ndonjë dalje nga funksioni përdoret si kontekst për modelin. Kjo duhet të përmbajë rezultatin e një FunctionCall të bërë bazuar në parashikimin e modelit.

Fushat
string id

Fakultative. ID-ja e thirrjes së funksionit për këtë përgjigje është. Populluar nga klienti për të përputhur id e thirrjes së funksionit përkatës.

string name

E detyrueshme. Emri i funksionit për të thirrur. Duhet të jetë az, AZ, 0-9, ose të përmbajë nënvizime dhe vija, me një gjatësi maksimale 63.

objekti response object ( Struct format)

E detyrueshme. Përgjigja e funksionit në formatin e objektit JSON.

Përfaqësimi JSON 
{
  "id": string,
  "name": string,
  "response": {
    object
  }
}

Të dhënat e skedarit

Të dhëna të bazuara në URI.

Fushat
string mimeType

Fakultative. Lloji standard MIME IANA i të dhënave burimore.

string fileUri

E detyrueshme. URI.

Përfaqësimi JSON 
{
  "mimeType": string,
  "fileUri": string
}

Kodi i ekzekutueshëm

Kodi i gjeneruar nga modeli që është menduar të ekzekutohet dhe rezultati kthehet në model.

Gjenerohet vetëm kur përdoret mjeti CodeExecution , në të cilin kodi do të ekzekutohet automatikisht dhe gjithashtu do të gjenerohet një CodeExecutionResult përkatës.

Fushat
numërimi i language enum ( Language )

E detyrueshme. Gjuha e programimit të code .

string code

E detyrueshme. Kodi që do të ekzekutohet.

Përfaqësimi JSON 
{
  "language": enum (Language),
  "code": string
}

Gjuha

Gjuhët e programimit të mbështetura për kodin e krijuar.

Enums
LANGUAGE_UNSPECIFIED Gjuhë e paspecifikuar. Kjo vlerë nuk duhet të përdoret.
PYTHON Python >= 3.10, me numpy dhe simpy në dispozicion.

Rezultati i ekzekutimit të kodit

Rezultati i ekzekutimit të kodit ExecutableCode .

Gjenerohet vetëm kur përdoret CodeExecution , dhe gjithmonë ndjek një part që përmban kodin ExecutableCode .

Fushat
numri i outcome enum ( Outcome )

E detyrueshme. Rezultati i ekzekutimit të kodit.

string output

Fakultative. Përmban stdout kur ekzekutimi i kodit është i suksesshëm, stderr ose përshkrim tjetër ndryshe.

Përfaqësimi JSON 
{
  "outcome": enum (Outcome),
  "output": string
}

Rezultati

Numërimi i rezultateve të mundshme të ekzekutimit të kodit.

Enums
OUTCOME_UNSPECIFIED Status i paspecifikuar. Kjo vlerë nuk duhet të përdoret.
OUTCOME_OK Ekzekutimi i kodit përfundoi me sukses.
OUTCOME_FAILED Ekzekutimi i kodit përfundoi por me një dështim. stderr duhet të përmbajë arsyen.
OUTCOME_DEADLINE_EXCEEDED Ekzekutimi i kodit u zhvillua për një kohë të gjatë dhe u anulua. Mund të ketë ose jo një prodhim të pjesshëm.

Mjet

Detajet e veglave që modeli mund të përdorë për të gjeneruar përgjigje.

Një Tool është një pjesë kodi që i mundëson sistemit të ndërveprojë me sisteme të jashtme për të kryer një veprim, ose grup veprimesh, jashtë njohurive dhe qëllimit të modelit.

Fushat
functionDeclarations[] object ( FunctionDeclaration )

Fakultative. Një listë e FunctionDeclarations të disponueshme për modelin që mund të përdoret për thirrjen e funksionit.

Modeli ose sistemi nuk e ekzekuton funksionin. Në vend të kësaj, funksioni i përcaktuar mund të kthehet si një FunctionCall me argumente në anën e klientit për ekzekutim. Modeli mund të vendosë të thërrasë një nëngrup të këtyre funksioneve duke mbushur FunctionCall në përgjigje. Radha tjetër e bisedës mund të përmbajë një FunctionResponse me kontekstin e gjenerimit të "funksionit" të Content.role për kthesën e modelit tjetër.

object ( GoogleSearchRetrieval ) googleSearchRetrieval (GoogleSearchRetrieval)

Fakultative. Mjet rikuperimi që mundësohet nga kërkimi në Google.

object ( CodeExecution ) codeExecution (Ekzekutimi i kodit)

Fakultative. Mundëson modelin të ekzekutojë kodin si pjesë e gjenerimit.

Përfaqësimi JSON 
{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "googleSearchRetrieval": {
    object (GoogleSearchRetrieval)
  },
  "codeExecution": {
    object (CodeExecution)
  },
  "googleSearch": {
    object (GoogleSearch)
  }
}

Deklarata e Funksionit

Paraqitja e strukturuar e një deklarate funksioni siç përcaktohet nga specifikimi OpenAPI 3.03 . Të përfshira në këtë deklaratë janë emri i funksionit dhe parametrat. Kjo Deklaratë Funksioni është një paraqitje e një blloku kodi që mund të përdoret si një Tool nga modeli dhe të ekzekutohet nga klienti.

Fushat
string name

E detyrueshme. Emri i funksionit. Duhet të jetë az, AZ, 0-9, ose të përmbajë nënvizime dhe vija, me një gjatësi maksimale 63.

string description

E detyrueshme. Një përshkrim i shkurtër i funksionit.

objekti parameters object ( Schema )

Fakultative. Përshkruan parametrat e këtij funksioni. Reflekton Open API 3.03 Parametri i vargut të objektit Çelësi: emri i parametrit. Emrat e parametrave janë të ndjeshëm ndaj shkronjave të vogla. Vlera e skemës: Skema që përcakton llojin e përdorur për parametrin.

objekti response object ( Schema )

Fakultative. Përshkruan daljen nga ky funksion në formatin JSON Skema. Reflekton objektin e përgjigjes së hapur API 3.03. Skema përcakton llojin e përdorur për vlerën e përgjigjes së funksionit.

Përfaqësimi JSON 
{
  "name": string,
  "description": string,
  "parameters": {
    object (Schema)
  },
  "response": {
    object (Schema)
  }
}

Skema

Objekti Schema lejon përcaktimin e llojeve të të dhënave hyrëse dhe dalëse. Këto lloje mund të jenë objekte, por edhe primitivë dhe vargje. Përfaqëson një nëngrup të zgjedhur të një objekti skeme OpenAPI 3.0 .

Fushat
type enum ( Type )

E detyrueshme. Lloji i të dhënave.

string format

Fakultative. Formati i të dhënave. Kjo përdoret vetëm për llojet primitive të të dhënave. Formatet e mbështetura: për llojin NUMBER: float, dyfish për llojin INTEGER: int32, int64 për llojin STRING: enum, data-ora

string description

Fakultative. Një përshkrim i shkurtër i parametrit. Kjo mund të përmbajë shembuj të përdorimit. Përshkrimi i parametrit mund të formatohet si Markdown.

boolean nullable

Fakultative. Tregon nëse vlera mund të jetë nule.

string enum[]

Fakultative. Vlerat e mundshme të elementit të Type.STRING me format enum. Për shembull, ne mund të përcaktojmë një Drejtim Enum si: {type:STRING, format:enum, enum:["LINDJE", VERI", "JUG", "PERËNDIM"]}

vargu maxItems string ( int64 format)

Fakultative. Numri maksimal i elementeve për Type.ARRAY.

vargu minItems string ( int64 format)

Fakultative. Numri minimal i elementeve për Type.ARRAY.

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

Fakultative. Vetitë e Llojit.OBJEKT.

Një objekt që përmban një listë të çifteve "key": value . Shembull: { "name": "wrench", "mass": "1.3kg", "count": "3" } .

string required[]

Fakultative. Vetitë e kërkuara të Llojit.OBJEKT.

varg pronësie string propertyOrdering[]

Fakultative. Renditja e pronave. Nuk është një fushë standarde në specifikimet e hapura të api. Përdoret për të përcaktuar rendin e vetive në përgjigje.

objekti items object ( Schema )

Fakultative. Skema e elementeve të Type.ARRAY.

Përfaqësimi JSON 
{
  "type": enum (Type),
  "format": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "maxItems": string,
  "minItems": string,
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "propertyOrdering": [
    string
  ],
  "items": {
    object (Schema)
  }
}

Lloji

Lloji përmban listën e llojeve të të dhënave OpenAPI siç përcaktohet nga https://spec.openapis.org/oas/v3.0.3#data-types

Enums
TYPE_UNSPECIFIED Nuk është specifikuar, nuk duhet të përdoret.
STRING Lloji i vargut.
NUMBER Lloji i numrit.
INTEGER Lloji i plotë.
BOOLEAN Lloji Boolean.
ARRAY Lloji i grupit.
OBJECT Lloji i objektit.

Rikthimi i GoogleSearch

Mjet për marrjen e të dhënave publike të uebit për tokëzim, mundësuar nga Google.

Fushat
object ( DynamicRetrievalConfig ) dynamicRetrievalConfig (DynamicRetrievalConfig)

Specifikon konfigurimin e rikthimit dinamik për burimin e dhënë.

Përfaqësimi JSON 
{
  "dynamicRetrievalConfig": {
    object (DynamicRetrievalConfig)
  }
}

DynamicRetrievalConfig

Përshkruan opsionet për të personalizuar rikthimin dinamik.

Fushat
numërimi i mode enum ( Mode )

Mënyra e parashikuesit që do të përdoret në rikthimin dinamik.

number dynamicThreshold dinamik

Pragu që do të përdoret në rikthimin dinamik. Nëse nuk është caktuar, përdoret një vlerë e paracaktuar e sistemit.

Përfaqësimi JSON 
{
  "mode": enum (Mode),
  "dynamicThreshold": number
}

Modaliteti

Mënyra e parashikuesit që do të përdoret në rikthimin dinamik.

Enums
MODE_UNSPECIFIED Gjithmonë aktivizoni rikthimin.
MODE_DYNAMIC Kryeni rikthimin vetëm kur sistemi vendos se është e nevojshme.

Ekzekutimi i kodit

Ky lloj nuk ka fusha.

Mjet që ekzekuton kodin e krijuar nga modeli dhe automatikisht ia kthen rezultatin modelit.

Shihni gjithashtu ExecutableCode dhe CodeExecutionResult të cilat krijohen vetëm kur përdorni këtë mjet.

Google Search

Ky lloj nuk ka fusha.

Lloji i mjetit GoogleSearch. Mjet për të mbështetur Google Search në Model. Mundësuar nga Google.

ToolConfig

Konfigurimi i mjetit që përmban parametra për specifikimin e përdorimit Tool në kërkesë.

Fushat
object ( FunctionCallingConfig ) functionCallingConfig (FunctionCallingConfig)

Fakultative. Konfigurimi i thirrjes së funksionit.

Përfaqësimi JSON 
{
  "functionCallingConfig": {
    object (FunctionCallingConfig)
  }
}

FunctionCallingConfig

Konfigurimi për përcaktimin e sjelljes së thirrjes së funksionit.

Fushat
numërimi i mode enum ( Mode )

Fakultative. Përcakton mënyrën në të cilën duhet të ekzekutohet thirrja e funksionit. Nëse nuk specifikohet, vlera e paracaktuar do të vendoset në AUTO.

string allowedFunctionNames[]

Fakultative. Një grup emrash funksionesh që, kur sigurohen, kufizon funksionet që modeli do të thërrasë.

Kjo duhet të vendoset vetëm kur modaliteti është ANY. Emrat e funksioneve duhet të përputhen me [FunctionDeclaration.name]. Me modalitetin e vendosur në ANY, modeli do të parashikojë një thirrje funksioni nga grupi i emrave të funksioneve të ofruara.

Përfaqësimi JSON 
{
  "mode": enum (Mode),
  "allowedFunctionNames": [
    string
  ]
}

Modaliteti

Përcakton sjelljen e ekzekutimit për thirrjen e funksionit duke përcaktuar mënyrën e ekzekutimit.

Enums
MODE_UNSPECIFIED Modaliteti i thirrjes së funksionit të papërcaktuar. Kjo vlerë nuk duhet të përdoret.
AUTO Sjellja e parazgjedhur e modelit, modeli vendos të parashikojë ose një thirrje funksioni ose një përgjigje të gjuhës natyrore.
ANY Modeli është i kufizuar që gjithmonë të parashikojë vetëm një thirrje funksioni. Nëse është caktuar "allowedFunctionNames", thirrja e parashikuar e funksionit do të kufizohet në cilindo nga "allowedFunctionNames", përndryshe thirrja e parashikuar e funksionit do të jetë një nga "functionDeclarations" të ofruara.
NONE Modeli nuk do të parashikojë asnjë thirrje funksioni. Sjellja e modelit është e njëjtë si kur nuk kalon asnjë deklaratë funksioni.

Metadata e përdorimit

Metadatat mbi përdorimin e përmbajtjes së memorizuar.

Fushat
totalTokenCount integer

Numri total i argumenteve që konsumon përmbajtja e memorizuar.

Përfaqësimi JSON 
{
  "totalTokenCount": integer
}
,

Ruajtja në memorie e kontekstit ju lejon të ruani dhe ripërdorni shenjat hyrëse të parallogaritura që dëshironi të përdorni në mënyrë të përsëritur, për shembull kur bëni pyetje të ndryshme për të njëjtin skedar media. Kjo mund të çojë në kursime të kostos dhe shpejtësisë, në varësi të përdorimit. Për një hyrje të detajuar, shihni udhëzuesin e ruajtjes në memorien e kontekstit .

Metoda: cacheContents.krijoj

Krijon burimin CachedContent.

Pika përfundimtare

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

Trupi i kërkesës

Trupi i kërkesës përmban një shembull të CachedContent .

Fushat
contents[] object ( Content )

Fakultative. Vetëm hyrje. E pandryshueshme. Përmbajtja në cache.

tools[] object ( Tool )

Fakultative. Vetëm hyrje. E pandryshueshme. Një listë e Tools modeli mund të përdorë për të gjeneruar përgjigjen e radhës

expiration Union type bashkimit
Përcakton se kur do të skadojë ky burim. expiration mund të jetë vetëm një nga sa vijon:
expireTime string ( Timestamp format)

Vula kohore në UTC kur ky burim konsiderohet i skaduar. Kjo ofrohet gjithmonë në dalje, pavarësisht se çfarë është dërguar në hyrje.

Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

vargu ttl string ( Duration format)

Vetëm hyrje. TTL e re për këtë burim, vetëm hyrje.

Një kohëzgjatje në sekonda me deri në nëntë shifra të pjesshme, që mbarojnë me ' s '. Shembull: "3.5s" .

string name

Fakultative. Identifikues. Emri i burimit që i referohet përmbajtjes së memorizuar. Formati: cachedContents/{id}

string displayName

Fakultative. E pandryshueshme. Emri i shfaqur kuptimplotë i krijuar nga përdoruesi i përmbajtjes së memorizuar. Maksimumi 128 karaktere Unicode.

string model

E detyrueshme. E pandryshueshme. Emri i Model që do të përdoret për përmbajtjen e memorizuar Formati: models/{model}

Sistemi i objektit systemInstruction object ( Content )

Fakultative. Vetëm hyrje. E pandryshueshme. Udhëzime për sistemin e grupit të zhvilluesit. Aktualisht vetëm tekst.

Objekti toolConfig object ( ToolConfig )

Fakultative. Vetëm hyrje. E pandryshueshme. Konfigurimi i mjetit. Ky konfigurim është i ndarë për të gjitha mjetet.

Shembull i kërkesës

bazë Nga emri Nga biseda
Python Nyja.js Shkoni Shell 
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
// 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());
cache.js
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)
docs-snippets_test.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
Python Nyja.js Shkoni 
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
// 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.");
cache.js
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)
docs-snippets_test.go
Python Nyja.js Shkoni 
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
// 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()}`);
cache.js
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)

docs-snippets_test.go

Trupi i reagimit

Nëse është i suksesshëm, trupi i përgjigjes përmban një shembull të sapokrijuar të CachedContent .

Metoda: cacheContents.list

Liston Përmbajtjet në Cached.

Pika përfundimtare

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

Parametrat e pyetjes

integer pageSize

Fakultative. Numri maksimal i përmbajtjeve të ruajtura në memorie për t'u kthyer. Shërbimi mund të kthejë më pak se kjo vlerë. Nëse nuk specifikohet, do të kthehen një numër i paracaktuar (nën maksimum) artikujsh. Vlera maksimale është 1000; vlerat mbi 1000 do të detyrohen në 1000.

vargu string pageToken

Fakultative. Një shenjë faqeje, e marrë nga një telefonatë e mëparshme cachedContents.list . Jepni këtë për të rikthyer faqen pasuese.

Gjatë paginimit, të gjithë parametrat e tjerë të dhënë në cachedContents.list duhet të përputhen me thirrjen që ka dhënë tokenin e faqes.

Trupi i kërkesës

Trupi i kërkesës duhet të jetë bosh.

Trupi i reagimit

Përgjigja me listën CachedContents.

Nëse është i suksesshëm, trupi i përgjigjes përmban të dhëna me strukturën e mëposhtme:

Fushat
cachedContents[] object ( CachedContent )

Lista e përmbajtjeve të ruajtura në memorie.

string nextPageToken

Një shenjë, e cila mund të dërgohet si pageToken për të tërhequr faqen tjetër. Nëse kjo fushë hiqet, nuk ka faqe të mëvonshme.

Përfaqësimi JSON 
{
  "cachedContents": [
    {
      object (CachedContent)
    }
  ],
  "nextPageToken": string
}

Metoda: cachedContents.get

Lexon burimin CachedContent.

Pika përfundimtare

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

Parametrat e rrugës

string name

E detyrueshme. Emri i burimit që i referohet hyrjes në cache të përmbajtjes. Formati: cachedContents/{id} Merr formën cachedContents/{cachedcontent} .

Trupi i kërkesës

Trupi i kërkesës duhet të jetë bosh.

Shembull i kërkesës

Python Nyja.js Shkoni Shell 
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
// 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);
cache.js
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)
docs-snippets_test.go
curl "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY"
cache.sh

Trupi i reagimit

Nëse është i suksesshëm, trupi i përgjigjes përmban një shembull të CachedContent .

Metoda: cachedContents.patch

Përditëson burimin CachedContent (vetëm skadimi mund të përditësohet).

Pika përfundimtare

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

Parametrat e rrugës

cachedContent.name string

Fakultative. Identifikues. Emri i burimit që i referohet përmbajtjes së memorizuar. Formati: cachedContents/{id} Merr formën cachedContents/{cachedcontent} .

Parametrat e pyetjes

vargu updateMask string ( FieldMask format)

Lista e fushave për të përditësuar.

Kjo është një listë e ndarë me presje e emrave plotësisht të kualifikuar të fushave. Shembull: "user.displayName,photo" .

Trupi i kërkesës

Trupi i kërkesës përmban një shembull të CachedContent .

Fushat
expiration Union type bashkimit
Përcakton se kur do të skadojë ky burim. expiration mund të jetë vetëm një nga sa vijon:
expireTime string ( Timestamp format)

Vula kohore në UTC kur ky burim konsiderohet i skaduar. Kjo ofrohet gjithmonë në dalje, pavarësisht se çfarë është dërguar në hyrje.

Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

vargu ttl string ( Duration format)

Vetëm hyrje. TTL e re për këtë burim, vetëm hyrje.

Një kohëzgjatje në sekonda me deri në nëntë shifra të pjesshme, që mbarojnë me ' s '. Shembull: "3.5s" .

string name

Fakultative. Identifikues. Emri i burimit që i referohet përmbajtjes së memorizuar. Formati: cachedContents/{id}

Shembull i kërkesës

Python Nyja.js Shkoni Shell 
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
// 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);
cache.js
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)
docs-snippets_test.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

Trupi i reagimit

Nëse është i suksesshëm, trupi i përgjigjes përmban një shembull të CachedContent .

Metoda: cachedContents.fshij

Fshin burimin CachedContent.

Pika përfundimtare

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

Parametrat e rrugës

string name

E detyrueshme. Emri i burimit që i referohet hyrjes në cache të përmbajtjes Formati: cachedContents/{id} Ai merr formën cachedContents/{cachedcontent} .

Trupi i kërkesës

Trupi i kërkesës duhet të jetë bosh.

Shembull i kërkesës

Python Nyja.js Shkoni Shell 
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
// 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);
cache.js
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)
docs-snippets_test.go
curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY"
cache.sh

Trupi i reagimit

Nëse është i suksesshëm, trupi i përgjigjes është një objekt JSON bosh.

Burimi REST: Përmbajtja në memorie të fshehtë

Burimi: CachedContent

Përmbajtja që është përpunuar paraprakisht dhe mund të përdoret në kërkesën e mëvonshme për GenerativeService.

Përmbajtja e memorizuar mund të përdoret vetëm me modelin për të cilin është krijuar.

Fushat
contents[] object ( Content )

Fakultative. Vetëm hyrje. E pandryshueshme. Përmbajtja në cache.

tools[] object ( Tool )

Fakultative. Vetëm hyrje. E pandryshueshme. Një listë e Tools modeli mund të përdorë për të gjeneruar përgjigjen e radhës

createTime string ( Timestamp format)

Vetëm dalje. Koha e krijimit të hyrjes në cache.

Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

Vargu updateTime string ( Timestamp format)

Vetëm dalje. Kur hyrja në cache u përditësua për herë të fundit në kohën UTC.

Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

usageMetadata object ( UsageMetadata )

Vetëm dalje. Metadatat mbi përdorimin e përmbajtjes së memorizuar.

expiration Union type bashkimit
Përcakton se kur do të skadojë ky burim. expiration mund të jetë vetëm një nga sa vijon:
expireTime string ( Timestamp format)

Vula kohore në UTC kur ky burim konsiderohet i skaduar. Kjo ofrohet gjithmonë në dalje, pavarësisht se çfarë është dërguar në hyrje.

Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

vargu ttl string ( Duration format)

Vetëm hyrje. TTL e re për këtë burim, vetëm hyrje.

Një kohëzgjatje në sekonda me deri në nëntë shifra të pjesshme, që mbarojnë me ' s '. Shembull: "3.5s" .

string name

Fakultative. Identifikues. Emri i burimit që i referohet përmbajtjes së memorizuar. Formati: cachedContents/{id}

string displayName

Fakultative. E pandryshueshme. Emri i shfaqur kuptimplotë i krijuar nga përdoruesi i përmbajtjes së memorizuar. Maksimumi 128 karaktere Unicode.

string model

E detyrueshme. E pandryshueshme. Emri i Model që do të përdoret për përmbajtjen e memorizuar Formati: models/{model}

Sistemi i objektit systemInstruction object ( Content )

Fakultative. Vetëm hyrje. E pandryshueshme. Udhëzime për sistemin e grupit të zhvilluesit. Aktualisht vetëm tekst.

Objekti toolConfig object ( ToolConfig )

Fakultative. Vetëm hyrje. E pandryshueshme. Konfigurimi i mjetit. Ky konfigurim është i ndarë për të gjitha mjetet.

Përfaqësimi 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)
  }
}

përmbajtja

Lloji i të dhënave të strukturuar bazë që përmban përmbajtje me shumë pjesë të një mesazhi.

Një Content përfshin një fushë role që përcakton prodhuesin e Content dhe një fushë parts që përmban të dhëna me shumë pjesë që përmban përmbajtjen e kthesës së mesazhit.

Fushat
parts[] object ( Part )

Parts të porositura që përbëjnë një mesazh të vetëm. Pjesët mund të kenë lloje të ndryshme MIME.

role string

Fakultative. Prodhuesi i përmbajtjes. Duhet të jetë ose 'përdorues' ose 'model'.

E dobishme për t'u vendosur për biseda me shumë kthesa, përndryshe mund të lihet bosh ose e pacaktuar.

Përfaqësimi JSON 
{
  "parts": [
    {
      object (Part)
    }
  ],
  "role": string
}

Pjesë

Një lloj i të dhënave që përmban media që është pjesë e një mesazhi Content shumëpjesëshe.

Një Part përbëhet nga të dhëna që kanë një lloj të dhënash të lidhur. Një Part mund të përmbajë vetëm një nga llojet e pranuara në Part.data .

Një Part duhet të ketë një lloj MIME fiks IANA që identifikon llojin dhe nëntipin e medias nëse fusha inlineData është e mbushur me bajt të papërpunuar.

Fushat
data Union type
data mund të jenë vetëm një nga të mëposhtmet:
string text

Teksti në linjë.

Objekti inlineData object ( Blob )

Bajt mediash në linjë.

object ( FunctionCall ) functionCall (FunctionCall)

Një FunctionCall i parashikuar i kthyer nga modeli që përmban një varg që përfaqëson FunctionDeclaration.name me argumentet dhe vlerat e tyre.

object ( FunctionResponse ) functionResponse (FunksionResponse)

Dalja e rezultatit të një FunctionCall që përmban një varg që përfaqëson FunctionDeclaration.name dhe një objekt të strukturuar JSON që përmban ndonjë dalje nga funksioni përdoret si kontekst për modelin.

object ( FileData ) fileData (FileData)

Të dhëna të bazuara në URI.

object ( ExecutableCode ) executableCode (Kodi i ekzekutueshëm)

Kodi i krijuar nga modeli që është menduar të ekzekutohet.

object ( CodeExecutionResult ) codeExecutionResult (CodeExecutionResult)

Rezultati i ekzekutimit të kodit ExecutableCode .

Përfaqësimi JSON 
{

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

Njollë

Bajt mediash të papërpunuara.

Teksti nuk duhet të dërgohet si bajt të papërpunuar, përdorni fushën 'tekst'.

Fushat
string mimeType

Lloji standard MIME IANA i të dhënave burimore. Shembuj: - image/png - image/jpeg Nëse ofrohet një lloj MIME i pambështetur, do të kthehet një gabim. Për një listë të plotë të llojeve të mbështetura, shihni Formatet e skedarëve të mbështetur .

vargu data string ( bytes format)

Bajt të papërpunuara për formatet e medias.

Një varg i koduar me bazë64.

Përfaqësimi JSON 
{
  "mimeType": string,
  "data": string
}

FunctionCall

Një FunctionCall i parashikuar i kthyer nga modeli që përmban një varg që përfaqëson FunctionDeclaration.name me argumentet dhe vlerat e tyre.

Fusha
id string

Fakultative. ID -ja unike e thirrjes së funksionit. Nëse është i populluar, klienti për të ekzekutuar functionCall dhe për të kthyer përgjigjen me id përputhen.

string name

Kërkohet. Emri i funksionit për të thirrur. Duhet të jetë AZ, AZ, 0-9, ose të përmbajë nënvizime dhe dash, me një gjatësi maksimale prej 63.

args object ( Struct format)

Fakultative. Parametrat dhe vlerat e funksionit në formatin e objektit JSON.

Përfaqësimi JSON 
{
  "id": string,
  "name": string,
  "args": {
    object
  }
}

Regjistrim

Rezultati i rezultatit nga një FunctionCall që përmban një varg që përfaqëson FunctionDeclaration.name dhe një objekt të strukturuar JSON që përmban çdo prodhim nga funksioni përdoret si kontekst i modelit. Kjo duhet të përmbajë rezultatin e një FunctionCall të bërë bazuar në parashikimin e modelit.

Fusha
id string

Fakultative. ID e funksionit e quajmë këtë përgjigje. Populluar nga klienti që përputhet me id e thirrjes së funksionit përkatës.

string name

Kërkohet. Emri i funksionit për të thirrur. Duhet të jetë AZ, AZ, 0-9, ose të përmbajë nënvizime dhe dash, me një gjatësi maksimale prej 63.

Objekti response object ( Struct format)

Kërkohet. Përgjigja e funksionit në formatin e objektit JSON.

Përfaqësimi JSON 
{
  "id": string,
  "name": string,
  "response": {
    object
  }
}

Skaj

Të dhëna të bazuara në URI.

Fusha
string mimeType

Fakultative. Lloji standard i IANA MIME i të dhënave të burimit.

fileUri string

Kërkohet. Uri

Përfaqësimi JSON 
{
  "mimeType": string,
  "fileUri": string
}

Kodi i ExecuntaBleable

Kodi i gjeneruar nga modeli që është menduar të ekzekutohet, dhe rezultati i është kthyer modelit.

Gjeneruar vetëm kur përdorni mjetin CodeExecution , në të cilin kodi do të ekzekutohet automatikisht, dhe do të gjenerohet gjithashtu një CodeExecutionResult .

Fusha
language enum ( Language )

Kërkohet. Gjuha e programimit të code .

code string

Kërkohet. Kodi që do të ekzekutohet.

Përfaqësimi JSON 
{
  "language": enum (Language),
  "code": string
}

Gjuha

Gjuhët e programimit të mbështetur për kodin e gjeneruar.

Gypi
LANGUAGE_UNSPECIFIED Gjuhë e paspecifikuar. Kjo vlerë nuk duhet të përdoret.
PYTHON Python> = 3.10, me Numpy dhe Simpy në dispozicion.

CodeEexecutionResultult

Rezultati i ekzekutimit të ExecutableCode .

Gjeneruar vetëm kur përdorni CodeExecution , dhe gjithmonë ndjek një part që përmban ExecutableCode .

Fusha
outcome enum ( Outcome )

Kërkohet. Rezultati i ekzekutimit të kodit.

output string

Fakultative. Përmban STDOUT kur ekzekutimi i kodit është i suksesshëm, STDERR ose përshkrim tjetër përndryshe.

Përfaqësimi JSON 
{
  "outcome": enum (Outcome),
  "output": string
}

Përfundim

Numërimi i rezultateve të mundshme të ekzekutimit të kodit.

Gypi
OUTCOME_UNSPECIFIED Statusi i paspecifikuar. Kjo vlerë nuk duhet të përdoret.
OUTCOME_OK Ekzekutimi i kodit përfundoi me sukses.
OUTCOME_FAILED Ekzekutimi i kodit përfundoi por me një dështim. stderr duhet të përmbajë arsyen.
OUTCOME_DEADLINE_EXCEEDED Ekzekutimi i kodit u zhvillua për shumë kohë, dhe u anulua. Mund ose nuk mund të ketë një prodhim të pjesshëm të pranishëm.

Mjet

Detajet e mjetit që modeli mund të përdorë për të gjeneruar përgjigje.

Një Tool është një pjesë e kodit që i mundëson sistemit të bashkëveprojë me sistemet e jashtme për të kryer një veprim, ose një sërë veprimesh, jashtë njohurive dhe fushëveprimit të modelit.

Fusha
functionDeclarations[] object ( FunctionDeclaration )

Fakultative. Një listë e FunctionDeclarations në dispozicion të modelit që mund të përdoret për thirrjen e funksionit.

Modeli ose sistemi nuk e ekzekuton funksionin. Përkundrazi, funksioni i përcaktuar mund të kthehet si një FunctionCall me argumente në anën e klientit për ekzekutim. Modeli mund të vendosë të thërrasë një nënbashkësi të këtyre funksioneve duke populluar FunctionCall në përgjigje. Kthesa tjetër e bisedës mund të përmbajë një FunctionResponse me Content.role "Funksioni" konteksti i gjenerimit për kthesën e modelit tjetër.

object ( GoogleSearchRetrieval ) googleSearchRetrieval (GoogleSearchRetrieval)

Fakultative. Mjeti i rikthimit që mundësohet nga kërkimi i Google.

Objekti i codeExecution object ( CodeExecution )

Fakultative. Mundëson që modeli të ekzekutojë kodin si pjesë e gjenerimit.

Përfaqësimi JSON 
{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "googleSearchRetrieval": {
    object (GoogleSearchRetrieval)
  },
  "codeExecution": {
    object (CodeExecution)
  },
  "googleSearch": {
    object (GoogleSearch)
  }
}

Deklarata e Funksionit

Përfaqësimi i strukturuar i një deklarate funksioni siç përcaktohet nga specifikimi OpenAPI 3.03 . Të përfshira në këtë deklaratë janë emri i funksionit dhe parametrat. Ky funksion i funksionimit është një përfaqësim i një blloku kodi që mund të përdoret si një Tool nga modeli dhe ekzekutohet nga klienti.

Fusha
string name

Kërkohet. Emri i funksionit. Duhet të jetë AZ, AZ, 0-9, ose të përmbajë nënvizime dhe dash, me një gjatësi maksimale prej 63.

description string

Kërkohet. Një përshkrim i shkurtër i funksionit.

Objekti parameters object ( Schema )

Fakultative. Përshkruan parametrat e këtij funksioni. Pasqyron çelësin e parametrave të parametrit të hapur API 3.03: Emri i parametrit. Emrat e parametrave janë të ndjeshëm ndaj rasteve. Vlera e skemës: Skema që përcakton llojin e përdorur për parametrin.

Objekti response object ( Schema )

Fakultative. Përshkruan daljen nga ky funksion në formatin e skemës JSON. Pasqyron objektin e përgjigjes së hapur API 3.03. Skema përcakton llojin e përdorur për vlerën e përgjigjes së funksionit.

Përfaqësimi JSON 
{
  "name": string,
  "description": string,
  "parameters": {
    object (Schema)
  },
  "response": {
    object (Schema)
  }
}

Skemë

Objekti i Schema lejon përkufizimin e llojeve të të dhënave të hyrjes dhe daljes. Këto lloje mund të jenë objekte, por edhe primitivë dhe vargje. Përfaqëson një nënbashkësi të zgjedhur të një objekti skemash OpenAPI 3.0 .

Fusha
type enum ( Type )

Kërkohet. Lloji i të dhënave.

string format

Fakultative. Formati i të dhënave. Kjo përdoret vetëm për të dhënat primitive. Format e mbështetur: Për llojin e numrit: Float, dyfish për llojin e plotë: Int32, Int64 për llojin e vargut: enum, koha e datës

description string

Fakultative. Një përshkrim i shkurtër i parametrit. Kjo mund të përmbajë shembuj të përdorimit. Përshkrimi i parametrave mund të formatohet si Markdown.

nullable boolean

Fakultative. Tregon nëse vlera mund të jetë e pavlefshme.

enum[] string

Fakultative. Vlerat e mundshme të elementit të llojit.String me format enum. Për shembull, ne mund të përcaktojmë një drejtim enum si: {Lloji: String, Formati: Enum, Enum: ["Lindja", Veri "," Jug "," West "]}

String maxItems string ( int64 format)

Fakultative. Numri maksimal i elementeve për llojin.array.

minItems i Minitetems string ( int64 format)

Fakultative. Numri minimal i elementeve për llojin.array.

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

Fakultative. Karakteristikat e tipit.Object.

Një objekt që përmban një listë të "key": value . Shembull: { "name": "wrench", "mass": "1.3kg", "count": "3" } .

string required[]

Fakultative. Karakteristikat e kërkuara të llojit.Object.

string propertyOrdering[]

Fakultative. Rendi i pronave. Jo një fushë standarde në Spec Open API. Përdoret për të përcaktuar rendin e vetive në përgjigje.

items object ( Schema )

Fakultative. Skema e elementeve të tipit.array.

Përfaqësimi JSON 
{
  "type": enum (Type),
  "format": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "maxItems": string,
  "minItems": string,
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "propertyOrdering": [
    string
  ],
  "items": {
    object (Schema)
  }
}

Lloji

Lloji përmban listën e llojeve të të dhënave OpenAPI siç përcaktohet nga https://spec.openapis.org/oas/v3.0.3#data-types

Gypi
TYPE_UNSPECIFIED Nuk specifikohet, nuk duhet të përdoret.
STRING Lloji i vargut.
NUMBER Lloji i numrit.
INTEGER Lloji i plotë.
BOOLEAN Lloji Boolean.
ARRAY Lloji i vargjeve.
OBJECT Lloji i objektit.

GooglesearchRetrieval

Mjet për të tërhequr të dhënat publike në internet për argumentim, të mundësuar nga Google.

Fusha
object ( DynamicRetrievalConfig ) dynamicRetrievalConfig (DynamicRetrievalConfig)

Specifikon konfigurimin dinamik të rikthimit për burimin e dhënë.

Përfaqësimi JSON 
{
  "dynamicRetrievalConfig": {
    object (DynamicRetrievalConfig)
  }
}

DynamicRetrievalConfig

Përshkruan opsionet për të rregulluar rikthimin dinamik.

Fusha
mode enum ( Mode )

Mënyra e parashikuesit që do të përdoret në rikthimin dinamik.

number dynamicThreshold

Pragu që do të përdoret në rikthimin dinamik. Nëse nuk është vendosur, përdoret një vlerë e paracaktuar e sistemit.

Përfaqësimi JSON 
{
  "mode": enum (Mode),
  "dynamicThreshold": number
}

Modaliteti

Mënyra e parashikuesit që do të përdoret në rikthimin dinamik.

Gypi
MODE_UNSPECIFIED Gjithmonë shkaktoni rikthimin.
MODE_DYNAMIC Drejtoni rikthimin vetëm kur sistemi vendos se është e nevojshme.

Kodifikim

Ky lloj nuk ka fusha.

Mjet që ekzekuton kodin e gjeneruar nga modeli, dhe automatikisht kthen rezultatin në model.

Shihni gjithashtu ExecutableCode dhe CodeExecutionResult të cilat gjenerohen vetëm kur përdorni këtë mjet.

Googlesearch

Ky lloj nuk ka fusha.

Lloji i mjetit GoogleSearch. Mjet për të mbështetur kërkimin e Google në model. Mundësuar nga Google.

ToolConfig

Konfigurimi i mjetit që përmban parametra për specifikimin e përdorimit Tool në kërkesë.

Fusha
Objekti i functionCallingConfig object ( FunctionCallingConfig )

Fakultative. Funksioni duke thirrur konfigurimin.

Përfaqësimi JSON 
{
  "functionCallingConfig": {
    object (FunctionCallingConfig)
  }
}

FunctionCallingConfig

Konfigurimi për specifikimin e sjelljes së thirrjes së funksionit.

Fusha
mode enum ( Mode )

Fakultative. Specifikon modalitetin në të cilin duhet të ekzekutohet thirrja e funksionit. Nëse është i paspecifikuar, vlera e paracaktuar do të vendoset në Auto.

allowedFunctionNames[] string

Fakultative. Një grup i emrave të funksioneve që, kur sigurohet, kufizon funksionet që do të thërrasë modeli.

Kjo duhet të vendoset vetëm kur mënyra është ndonjë. Emrat e funksionit duhet të përputhen me [funksionDeclaration.name]. Me modalitetin e vendosur për çdo, modeli do të parashikojë një thirrje funksioni nga grupi i emrave të funksionit të dhënë.

Përfaqësimi JSON 
{
  "mode": enum (Mode),
  "allowedFunctionNames": [
    string
  ]
}

Modaliteti

Përcakton sjelljen e ekzekutimit për thirrjen e funksionit duke përcaktuar mënyrën e ekzekutimit.

Gypi
MODE_UNSPECIFIED Mënyra e thirrjes së funksionit të paspecifikuar. Kjo vlerë nuk duhet të përdoret.
AUTO Sjellja e modelit të paracaktuar, modeli vendos të parashikojë ose një thirrje funksioni ose një përgjigje të gjuhës natyrore.
ANY Modeli është i kufizuar për të parashikuar gjithmonë një thirrje funksioni vetëm. Nëse vendosen "LejuarFunctionNames", thirrja e parashikuar e funksionit do të kufizohet në cilindo nga "LejuarFunctionNames", përndryshe thirrja e parashikuar e funksionit do të jetë ndonjë nga "funksionet e funksionimit" të siguruar.
NONE Modeli nuk do të parashikojë asnjë thirrje funksioni. Sjellja e modelit është e njëjtë me kur nuk kalon ndonjë deklaratë të funksionit.

USAGEMETADATA

Metadata për përdorimin e përmbajtjes së cached.

Fusha
integer totalTokenCount

Numri i përgjithshëm i shenjave që konsumon përmbajtja e ruajtur.

Përfaqësimi JSON 
{
  "totalTokenCount": integer
}