Caching

Mit dem Kontext-Caching können Sie vorab berechnete Eingabe-Tokens speichern und wiederverwenden, die Sie wiederholt verwenden möchten, z. B. wenn Sie verschiedene Fragen zur selben Mediendatei stellen. Je nach Nutzung kann dies zu Kosten- und Geschwindigkeitsvorteilen führen. Eine ausführliche Einführung finden Sie im Leitfaden Kontext-Caching.

Methode: cachedContents.create

Erstellt eine CachedContent-Ressource.

Endpunkt

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

Anfragetext

Der Anfragetext enthält eine Instanz von CachedContent.

Felder
contents[] object (Content)

Optional. Nur Eingabe. Nicht veränderbar. Die Inhalte, die im Cache gespeichert werden sollen.

tools[] object (Tool)

Optional. Nur Eingabe. Nicht veränderbar. Eine Liste der Tools, die das Modell zum Generieren der nächsten Antwort verwenden kann

expiration Union type
Gibt an, wann diese Ressource abläuft. Für expiration ist nur einer der folgenden Werte zulässig:
expireTime string (Timestamp format)

Der Zeitstempel in UTC, der angibt, wann diese Ressource als abgelaufen gilt. Dies wird immer bei der Ausgabe angegeben, ungeachtet dessen, was bei der Eingabe gesendet wurde.

Verwendet RFC 3339, wobei die generierte Ausgabe immer Z-normalisiert ist und 0, 3, 6 oder 9 Nachkommastellen verwendet. Andere Offsets als „Z“ werden ebenfalls akzeptiert. Beispiele: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" oder "2014-10-02T15:01:23+05:30".

ttl string (Duration format)

Nur Eingabe. Neue TTL für diese Ressource, nur Eingabe.

Die Dauer in Sekunden mit bis zu neun Nachkommastellen und am Ende mit "s". Beispiel: "3.5s".

displayName string

Optional. Nicht veränderbar. Der von Nutzern erstellte aussagekräftige Anzeigename der im Cache gespeicherten Inhalte. Maximal 128 Unicode-Zeichen.

model string

Erforderlich. Nicht veränderbar. Der Name des Model, der für zwischengespeicherte Inhalte verwendet werden soll. Format: models/{model}

systemInstruction object (Content)

Optional. Nur Eingabe. Nicht veränderbar. Vom Entwickler festgelegte Systemanweisung. Derzeit nur Text.

toolConfig object (ToolConfig)

Optional. Nur Eingabe. Nicht veränderbar. Toolkonfiguration Diese Konfiguration wird für alle Tools freigegeben.

Beispielanfrage

Einfach

Python

from google import genai
from google.genai import types

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

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

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

Node.js

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

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

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

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

Ok

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

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

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

Muschel

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

Name des Absenders

Python

from google import genai
from google.genai import types

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

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

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

Node.js

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

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

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

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

Ok

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

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

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

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

Über einen Chat

Python

from google import genai
from google.genai import types

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

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

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

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

Node.js

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

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

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

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

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

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

Ok

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

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

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

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

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

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

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

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

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

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

Antworttext

Bei Erfolg enthält der Antworttext eine neu erstellte Instanz von CachedContent.

Methode: cachedContents.list

Listet CachedContents auf.

Endpunkt

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

Abfrageparameter

pageSize integer

Optional. Die maximale Anzahl der zurückzugebenden Inhalte im Cache. Der Dienst gibt möglicherweise weniger als diesen Wert zurück. Falls nicht angegeben, wird eine Standardanzahl von Elementen (unter dem Maximum) zurückgegeben. Der Höchstwert beträgt 1.000. Werte über 1.000 werden implizit auf 1.000 umgewandelt.

pageToken string

Optional. Ein Seitentoken, das von einem vorherigen cachedContents.list-Aufruf empfangen wurde. Geben Sie dieses an, um die nachfolgende Seite abzurufen.

Beim Paginieren müssen alle anderen für cachedContents.list bereitgestellten Parameter mit dem Aufruf übereinstimmen, der das Seitentoken bereitgestellt hat.

Anfragetext

Der Anfragetext muss leer sein.

Antworttext

Antwort mit der Liste „CachedContents“.

Bei Erfolg enthält der Antworttext Daten mit der folgenden Struktur:

Felder
cachedContents[] object (CachedContent)

Liste der im Cache gespeicherten Inhalte.

nextPageToken string

Ein Token, das als pageToken gesendet werden kann, um die nächste Seite abzurufen. Wenn dieses Feld weggelassen wird, gibt es keine nachfolgenden Seiten.

JSON-Darstellung 
{
  "cachedContents": [
    {
      object (CachedContent)
    }
  ],
  "nextPageToken": string
}

Methode: cachedContents.get

Liest die CachedContent-Ressource.

Endpunkt

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

Pfadparameter

name string

Erforderlich. Der Ressourcenname, der auf den Inhaltscache-Eintrag verweist. Format: cachedContents/{id} Sie nimmt die Form cachedContents/{cachedcontent} an.

Anfragetext

Der Anfragetext muss leer sein.

Beispielanfrage

Python

from google import genai

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

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

Node.js

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

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

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

Ok

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

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

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

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

Muschel

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

Antworttext

Wenn der Vorgang erfolgreich abgeschlossen wurde, enthält der Antworttext eine Instanz von CachedContent.

Methode: cachedContents.patch

Aktualisiert die CachedContent-Ressource. Nur das Ablaufdatum kann aktualisiert werden.

Endpunkt

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

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

Pfadparameter

cachedContent.name string

Nur Ausgabe. ID. Der Ressourcenname, der sich auf die im Cache gespeicherten Inhalte bezieht. Format: cachedContents/{id} Sie nimmt die Form cachedContents/{cachedcontent} an.

Abfrageparameter

updateMask string (FieldMask format)

Die Liste der zu aktualisierenden Felder.

Dies ist eine durch Kommas getrennte Liste vollständig qualifizierter Feldnamen. Beispiel: "user.displayName,photo".

Anfragetext

Der Anfragetext enthält eine Instanz von CachedContent.

Felder
expiration Union type
Gibt an, wann diese Ressource abläuft. Für expiration ist nur einer der folgenden Werte zulässig:
expireTime string (Timestamp format)

Der Zeitstempel in UTC, der angibt, wann diese Ressource als abgelaufen gilt. Dies wird immer bei der Ausgabe angegeben, ungeachtet dessen, was bei der Eingabe gesendet wurde.

Verwendet RFC 3339, wobei die generierte Ausgabe immer Z-normalisiert ist und 0, 3, 6 oder 9 Nachkommastellen verwendet. Andere Offsets als „Z“ werden ebenfalls akzeptiert. Beispiele: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" oder "2014-10-02T15:01:23+05:30".

ttl string (Duration format)

Nur Eingabe. Neue TTL für diese Ressource, nur Eingabe.

Die Dauer in Sekunden mit bis zu neun Nachkommastellen und am Ende mit "s". Beispiel: "3.5s".

Beispielanfrage

Python

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

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

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

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

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

Node.js

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

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

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

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

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

Ok

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

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

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

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

Muschel

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

Antworttext

Wenn der Vorgang erfolgreich abgeschlossen wurde, enthält der Antworttext eine Instanz von CachedContent.

Methode: cachedContents.delete

Löscht die CachedContent-Ressource.

Endpunkt

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

Pfadparameter

name string

Erforderlich. Der Ressourcenname, der auf den Inhaltscacheeintrag verweist. Format: cachedContents/{id}. Er hat das Format cachedContents/{cachedcontent}.

Anfragetext

Der Anfragetext muss leer sein.

Beispielanfrage

Python

from google import genai

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

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

Node.js

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

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

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

Ok

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

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

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

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

Muschel

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

Antworttext

Wenn der Vorgang erfolgreich abgeschlossen wurde, ist der Antworttext ein leeres JSON-Objekt.

REST-Ressource: cachedContents

Ressource: CachedContent

Inhalte, die vorverarbeitet wurden und in nachfolgenden Anfragen an GenerativeService verwendet werden können.

Zwischengespeicherte Inhalte können nur mit dem Modell verwendet werden, für das sie erstellt wurden.

Felder
contents[] object (Content)

Optional. Nur Eingabe. Nicht veränderbar. Die Inhalte, die im Cache gespeichert werden sollen.

tools[] object (Tool)

Optional. Nur Eingabe. Nicht veränderbar. Eine Liste der Tools, die das Modell zum Generieren der nächsten Antwort verwenden kann

createTime string (Timestamp format)

Nur Ausgabe. Erstellungszeit des Cache-Eintrags.

Verwendet RFC 3339, wobei die generierte Ausgabe immer Z-normalisiert ist und 0, 3, 6 oder 9 Nachkommastellen verwendet. Andere Offsets als „Z“ werden ebenfalls akzeptiert. Beispiele: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" oder "2014-10-02T15:01:23+05:30".

updateTime string (Timestamp format)

Nur Ausgabe. Wann der Cacheeintrag zuletzt in UTC aktualisiert wurde.

Verwendet RFC 3339, wobei die generierte Ausgabe immer Z-normalisiert ist und 0, 3, 6 oder 9 Nachkommastellen verwendet. Andere Offsets als „Z“ werden ebenfalls akzeptiert. Beispiele: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" oder "2014-10-02T15:01:23+05:30".

usageMetadata object (UsageMetadata)

Nur Ausgabe. Metadaten zur Nutzung der im Cache gespeicherten Inhalte.

expiration Union type
Gibt an, wann diese Ressource abläuft. Für expiration ist nur einer der folgenden Werte zulässig:
expireTime string (Timestamp format)

Der Zeitstempel in UTC, der angibt, wann diese Ressource als abgelaufen gilt. Dies wird immer bei der Ausgabe angegeben, ungeachtet dessen, was bei der Eingabe gesendet wurde.

Verwendet RFC 3339, wobei die generierte Ausgabe immer Z-normalisiert ist und 0, 3, 6 oder 9 Nachkommastellen verwendet. Andere Offsets als „Z“ werden ebenfalls akzeptiert. Beispiele: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" oder "2014-10-02T15:01:23+05:30".

ttl string (Duration format)

Nur Eingabe. Neue TTL für diese Ressource, nur Eingabe.

Die Dauer in Sekunden mit bis zu neun Nachkommastellen und am Ende mit "s". Beispiel: "3.5s".

name string

Nur Ausgabe. ID. Der Ressourcenname, der sich auf die im Cache gespeicherten Inhalte bezieht. Format: cachedContents/{id}

displayName string

Optional. Nicht veränderbar. Der von Nutzern erstellte aussagekräftige Anzeigename der im Cache gespeicherten Inhalte. Maximal 128 Unicode-Zeichen.

model string

Erforderlich. Nicht veränderbar. Der Name des Model, der für zwischengespeicherte Inhalte verwendet werden soll. Format: models/{model}

systemInstruction object (Content)

Optional. Nur Eingabe. Nicht veränderbar. Vom Entwickler festgelegte Systemanweisung. Derzeit nur Text.

toolConfig object (ToolConfig)

Optional. Nur Eingabe. Nicht veränderbar. Toolkonfiguration Diese Konfiguration wird für alle Tools freigegeben.

JSON-Darstellung 
{
  "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)
  }
}

Inhalt

Der strukturierte Basisdatentyp, der mehrteilige Inhalte einer Nachricht enthält.

Ein Content enthält ein role-Feld, das den Ersteller des Content angibt, und ein parts-Feld mit mehrteiligen Daten, die den Inhalt des Nachrichten-Turns enthalten.

Felder
parts[] object (Part)

Geordnete Parts, aus denen eine einzelne Nachricht besteht. Teile können unterschiedliche MIME-Typen haben.

role string

Optional. Der Produzent des Inhalts. Muss entweder „user“ oder „model“ sein.

Nützlich für Unterhaltungen, die mehrere Themen enthalten. Andernfalls kann das Feld leer bleiben oder nicht festgelegt werden.

JSON-Darstellung 
{
  "parts": [
    {
      object (Part)
    }
  ],
  "role": string
}

Teil

Ein Datentyp mit Medien, die Teil einer mehrteiligen Content-Nachricht sind.

Ein Part besteht aus Daten, denen ein Datentyp zugeordnet ist. Ein Part kann nur einen der akzeptierten Typen in Part.data enthalten.

Ein Part muss einen festen IANA-MIME-Typ haben, der den Typ und Untertyp der Medien angibt, wenn das Feld inlineData mit Rohbytes gefüllt ist.

Felder
thought boolean

Optional. Gibt an, ob der Teil vom Modell generiert wurde.

thoughtSignature string (bytes format)

Optional. Eine opake Signatur für den Gedanken, damit er in nachfolgenden Anfragen wiederverwendet werden kann.

Ein base64-codierter String.

partMetadata object (Struct format)

Benutzerdefinierte Metadaten, die mit dem Teil verknüpft sind. Agents, die genai.Part als Inhaltsdarstellung verwenden, müssen möglicherweise zusätzliche Informationen im Blick behalten. Das kann beispielsweise der Name einer Datei oder Quelle sein, aus der der Teil stammt, oder eine Möglichkeit, mehrere Teilstreams zu multiplexen.

data Union type
Für data ist nur einer der folgenden Werte zulässig:
text string

Inline-Text

inlineData object (Blob)

Inline-Mediabytes.

functionCall object (FunctionCall)

Ein vorhergesagter FunctionCall, der vom Modell zurückgegeben wird und einen String enthält, der FunctionDeclaration.name mit den Argumenten und ihren Werten enthält.

functionResponse object (FunctionResponse)

Die Ergebnisausgabe eines FunctionCall, der einen String enthält, der FunctionDeclaration.name darstellt, und ein strukturiertes JSON-Objekt mit der Ausgabe der Funktion wird als Kontext für das Modell verwendet.

fileData object (FileData)

URI-basierte Daten.

executableCode object (ExecutableCode)

Vom Modell generierter Code, der ausgeführt werden soll.

codeExecutionResult object (CodeExecutionResult)

Ergebnis der Ausführung von ExecutableCode.

metadata Union type
Steuert die zusätzliche Vorverarbeitung von Daten. Für metadata ist nur einer der folgenden Werte zulässig:
videoMetadata object (VideoMetadata)

Optional. Videometadaten Die Metadaten sollten nur angegeben werden, wenn die Videodaten in „inlineData“ oder „fileData“ präsentiert werden.

JSON-Darstellung 
{
  "thought": boolean,
  "thoughtSignature": string,
  "partMetadata": {
    object
  },

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

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

Blob

Rohmediabytes.

Text sollte nicht als Rohbytes gesendet werden. Verwenden Sie das Feld „text“.

Felder
mimeType string

Der IANA-Standard-MIME-Typ der Quelldaten. Beispiele: – image/png – image/jpeg Wenn ein nicht unterstützter MIME-Typ angegeben wird, wird ein Fehler zurückgegeben. Eine vollständige Liste der unterstützten Typen finden Sie unter Unterstützte Dateiformate.

data string (bytes format)

Rohbyte für Medienformate.

Ein base64-codierter String.

JSON-Darstellung 
{
  "mimeType": string,
  "data": string
}

FunctionCall

Ein vorhergesagter FunctionCall, der vom Modell zurückgegeben wird und einen String enthält, der FunctionDeclaration.name mit den Argumenten und ihren Werten enthält.

Felder
id string

Optional. Die eindeutige ID des Funktionsaufrufs. Wenn dieser Wert angegeben ist, wird der Client verwendet, um den functionCall auszuführen und die Antwort mit dem entsprechenden id zurückzugeben.

name string

Erforderlich. Der Name der aufzurufenden Funktion. Muss a–z, A–Z, 0–9 sein oder Unterstriche und Bindestriche enthalten. Die maximale Länge beträgt 64.

args object (Struct format)

Optional. Die Funktionsparameter und -werte im JSON-Objektformat.

JSON-Darstellung 
{
  "id": string,
  "name": string,
  "args": {
    object
  }
}

FunctionResponse

Die Ergebnisausgabe von einem FunctionCall, der einen String mit der FunctionDeclaration.name und ein strukturiertes JSON-Objekt mit der Ausgabe der Funktion enthält, wird als Kontext für das Modell verwendet. Hier sollte das Ergebnis einerFunctionCall auf Grundlage der Modellvorhersage enthalten sein.

Felder
id string

Optional. Die ID des Funktionsaufrufs, auf den sich diese Antwort bezieht. Wird vom Client ausgefüllt, um dem entsprechenden Funktionsaufruf id zu entsprechen.

name string

Erforderlich. Der Name der aufzurufenden Funktion. Muss a–z, A–Z, 0–9 sein oder Unterstriche und Bindestriche enthalten. Die maximale Länge beträgt 64.

response object (Struct format)

Erforderlich. Die Funktionsantwort im JSON-Objektformat. Aufrufer können beliebige Schlüssel verwenden, die der Syntax der Funktion entsprechen, um die Funktionsausgabe zurückzugeben, z.B. „output“ oder „result“. Insbesondere wenn der Funktionsaufruf nicht ausgeführt werden konnte, kann die Antwort einen „error“-Schlüssel enthalten, um dem Modell Fehlerdetails zurückzugeben.

parts[] object (FunctionResponsePart)

Optional. Geordnete Parts, die eine Funktionsantwort bilden. Teile können unterschiedliche IANA-MIME-Typen haben.

willContinue boolean

Optional. Signale, dass der Funktionsaufruf fortgesetzt wird und weitere Antworten zurückgegeben werden, wodurch der Funktionsaufruf in einen Generator umgewandelt wird. Gilt nur für NON_BLOCKING-Funktionsaufrufe, wird ansonsten ignoriert. Wenn sie auf „false“ gesetzt ist, werden zukünftige Antworten nicht berücksichtigt. Es ist zulässig, leere response mit willContinue=False zurückzugeben, um zu signalisieren, dass der Funktionsaufruf abgeschlossen ist. Dadurch kann die Modellgenerierung trotzdem ausgelöst werden. Um die Generierung zu vermeiden und den Funktionsaufruf abzuschließen, setzen Sie zusätzlich scheduling auf SILENT.

scheduling enum (Scheduling)

Optional. Gibt an, wie die Antwort in der Unterhaltung geplant werden soll. Gilt nur für NON_BLOCKING-Funktionsaufrufe, wird ansonsten ignoriert. Die Standardeinstellung ist WHEN_IDLE.

JSON-Darstellung 
{
  "id": string,
  "name": string,
  "response": {
    object
  },
  "parts": [
    {
      object (FunctionResponsePart)
    }
  ],
  "willContinue": boolean,
  "scheduling": enum (Scheduling)
}

FunctionResponsePart

Ein Datentyp mit Medien, die Teil einer FunctionResponse-Nachricht sind.

Ein FunctionResponsePart besteht aus Daten, denen ein Datentyp zugeordnet ist. Ein FunctionResponsePart kann nur einen der akzeptierten Typen in FunctionResponsePart.data enthalten.

Ein FunctionResponsePart muss einen festen IANA-MIME-Typ haben, der den Typ und Untertyp der Medien angibt, wenn das Feld inlineData mit Rohbytes gefüllt ist.

Felder
data Union type
Die Daten des Funktionsantwortteils. Für data ist nur einer der folgenden Werte zulässig:
inlineData object (FunctionResponseBlob)

Inline-Mediabytes.

JSON-Darstellung 
{

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

FunctionResponseBlob

Rohe Mediendaten für die Funktionsantwort.

Text sollte nicht als Rohbytes gesendet werden. Verwenden Sie das Feld „FunctionResponse.response“.

Felder
mimeType string

Der IANA-Standard-MIME-Typ der Quelldaten. Beispiele: – image/png – image/jpeg Wenn ein nicht unterstützter MIME-Typ angegeben wird, wird ein Fehler zurückgegeben. Eine vollständige Liste der unterstützten Typen finden Sie unter Unterstützte Dateiformate.

data string (bytes format)

Rohbyte für Medienformate.

Ein base64-codierter String.

JSON-Darstellung 
{
  "mimeType": string,
  "data": string
}

Wird geplant

Gibt an, wie die Antwort in der Unterhaltung geplant werden soll.

Enums
SCHEDULING_UNSPECIFIED Dieser Wert wird nicht verwendet.
SILENT Füge das Ergebnis nur dem Unterhaltungskontext hinzu. Unterbrich oder löse die Generierung nicht aus.
WHEN_IDLE Fügen Sie das Ergebnis dem Unterhaltungskontext hinzu und fordern Sie die Generierung der Ausgabe an, ohne die laufende Generierung zu unterbrechen.
INTERRUPT Das Ergebnis wird dem Unterhaltungskontext hinzugefügt, die laufende Generierung wird unterbrochen und es wird aufgefordert, eine Ausgabe zu generieren.

FileData

URI-basierte Daten.

Felder
mimeType string

Optional. Der IANA-Standard-MIME-Typ der Quelldaten.

fileUri string

Erforderlich. URI.

JSON-Darstellung 
{
  "mimeType": string,
  "fileUri": string
}

ExecutableCode

Vom Modell generierter Code, der ausgeführt werden soll, und das Ergebnis, das an das Modell zurückgegeben wird.

Wird nur generiert, wenn das CodeExecution-Tool verwendet wird. In diesem Fall wird der Code automatisch ausgeführt und ein entsprechendes CodeExecutionResult wird ebenfalls generiert.

Felder
language enum (Language)

Erforderlich. Programmiersprache des code.

code string

Erforderlich. Der auszuführende Code.

JSON-Darstellung 
{
  "language": enum (Language),
  "code": string
}

Sprache

Unterstützte Programmiersprachen für den generierten Code.

Enums
LANGUAGE_UNSPECIFIED Sprache nicht angegeben. Dieser Wert sollte nicht verwendet werden.
PYTHON Python >= 3.10 mit numpy und simpy.

CodeExecutionResult

Ergebnis der Ausführung von ExecutableCode.

Wird nur bei Verwendung von CodeExecution generiert und folgt immer auf ein part mit dem ExecutableCode.

Felder
outcome enum (Outcome)

Erforderlich. Ergebnis der Codeausführung.

output string

Optional. Enthält stdout, wenn die Codeausführung erfolgreich ist, andernfalls stderr oder eine andere Beschreibung.

JSON-Darstellung 
{
  "outcome": enum (Outcome),
  "output": string
}

Ergebnis

Auflistung der möglichen Ergebnisse der Codeausführung.

Enums
OUTCOME_UNSPECIFIED Nicht angegebener Status. Dieser Wert sollte nicht verwendet werden.
OUTCOME_OK Die Codeausführung wurde erfolgreich abgeschlossen.
OUTCOME_FAILED Die Codeausführung wurde abgeschlossen, aber mit einem Fehler. stderr sollte den Grund enthalten.
OUTCOME_DEADLINE_EXCEEDED Die Codeausführung dauerte zu lange und wurde abgebrochen. Möglicherweise ist eine Teilausgabe vorhanden.

VideoMetadata

Metadaten beschreiben den eingegebenen Videocontent.

Felder
startOffset string (Duration format)

Optional. Startversatz des Videos.

Die Dauer in Sekunden mit bis zu neun Nachkommastellen und am Ende mit "s". Beispiel: "3.5s".

endOffset string (Duration format)

Optional. Endversatz des Videos.

Die Dauer in Sekunden mit bis zu neun Nachkommastellen und am Ende mit "s". Beispiel: "3.5s".

fps number

Optional. Die Framerate des Videos, das an das Modell gesendet wurde. Wenn keine Angabe erfolgt, beträgt der Standardwert 1,0. Der FPS-Bereich ist (0,0, 24,0].

JSON-Darstellung 
{
  "startOffset": string,
  "endOffset": string,
  "fps": number
}

Tool

Tool-Details, die das Modell zum Generieren einer Antwort verwenden kann.

Eine Tool ist ein Code, der es dem System ermöglicht, mit externen Systemen zu interagieren, um eine Aktion oder eine Reihe von Aktionen außerhalb des Wissens und Umfangs des Modells auszuführen.

Nächste ID: 12

Felder
functionDeclarations[] object (FunctionDeclaration)

Optional. Eine Liste der FunctionDeclarations, die für das Modell verfügbar sind und für Funktionsaufrufe verwendet werden können.

Das Modell oder System führt die Funktion nicht aus. Stattdessen kann die definierte Funktion als FunctionCall mit Argumenten zur Ausführung an die Clientseite zurückgegeben werden. Das Modell kann entscheiden, eine Teilmenge dieser Funktionen aufzurufen, indem es FunctionCall in der Antwort ausfüllt. Der nächste Gesprächsbeitrag kann ein FunctionResponse mit dem Generierungskontext Content.role „function“ für den nächsten Modellbeitrag enthalten.

googleSearchRetrieval object (GoogleSearchRetrieval)

Optional. Abruftool, das auf der Google Suche basiert.

codeExecution object (CodeExecution)

Optional. Ermöglicht dem Modell, im Rahmen der Generierung Code auszuführen.

computerUse object (ComputerUse)

Optional. Tool zur Unterstützung der direkten Interaktion des Modells mit dem Computer. Wenn diese Option aktiviert ist, werden automatisch funktionsspezifische Funktionsdeklarationen für die Computernutzung eingefügt.

urlContext object (UrlContext)

Optional. Tool zur Unterstützung des Abrufs von URL-Kontext.

googleMaps object (GoogleMaps)

Optional. Tool, mit dem die Antwort des Modells mit dem geografischen Kontext der Nutzeranfrage verknüpft werden kann.

JSON-Darstellung 
{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "googleSearchRetrieval": {
    object (GoogleSearchRetrieval)
  },
  "codeExecution": {
    object (CodeExecution)
  },
  "googleSearch": {
    object (GoogleSearch)
  },
  "computerUse": {
    object (ComputerUse)
  },
  "urlContext": {
    object (UrlContext)
  },
  "fileSearch": {
    object (FileSearch)
  },
  "googleMaps": {
    object (GoogleMaps)
  }
}

FunctionDeclaration

Strukturierte Darstellung einer Funktionsdeklaration gemäß der Definition der OpenAPI 3.03-Spezifikation. Diese Deklaration enthält den Funktionsnamen und die Parameter. Diese FunctionDeclaration ist eine Darstellung eines Codeblocks, der vom Modell als Tool verwendet und vom Client ausgeführt werden kann.

Felder
name string

Erforderlich. Der Name der Funktion. Muss a–z, A–Z, 0–9 sein oder Unterstriche, Doppelpunkte, Punkte und Bindestriche enthalten. Die maximale Länge beträgt 64.

description string

Erforderlich. Eine kurze Beschreibung der Funktion.

behavior enum (Behavior)

Optional. Gibt das Funktionsverhalten an. Wird derzeit nur von der Methode „BidiGenerateContent“ unterstützt.

parameters object (Schema)

Optional. Beschreibt die Parameter für diese Funktion. Entspricht dem Stringschlüssel des Parameterobjekts in der Open API 3.03: dem Namen des Parameters. Bei Parameternamen wird die Groß-/Kleinschreibung beachtet. Schema Value: Das Schema, das den für den Parameter verwendeten Typ definiert.

parametersJsonSchema value (Value format)

Optional. Beschreibt die Parameter der Funktion im JSON-Schemaformat. Das Schema muss ein Objekt beschreiben, dessen Attribute die Parameter der Funktion sind. Beispiel:

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

Dieses Feld und parameters schließen sich gegenseitig aus.

response object (Schema)

Optional. Beschreibt die Ausgabe dieser Funktion im JSON-Schemaformat. Entspricht dem Response-Objekt von OpenAPI 3.0.3. Das Schema definiert den Typ, der für den Antwortwert der Funktion verwendet wird.

responseJsonSchema value (Value format)

Optional. Beschreibt die Ausgabe dieser Funktion im JSON-Schemaformat. Der im Schema angegebene Wert ist der Antwortwert der Funktion.

Dieses Feld und response schließen sich gegenseitig aus.

JSON-Darstellung 
{
  "name": string,
  "description": string,
  "behavior": enum (Behavior),
  "parameters": {
    object (Schema)
  },
  "parametersJsonSchema": value,
  "response": {
    object (Schema)
  },
  "responseJsonSchema": value
}

Schema

Mit dem Schema-Objekt können Eingabe- und Ausgabedatentypen definiert werden. Diese Typen können Objekte, aber auch primitive Datentypen und Arrays sein. Stellt eine ausgewählte Teilmenge eines OpenAPI 3.0-Schemaobjekts dar.

Felder
type enum (Type)

Erforderlich. Datentyp

format string

Optional. Das Format der Daten. Jeder Wert ist zulässig, aber die meisten lösen keine spezielle Funktion aus.

title string

Optional. Der Titel des Schemas.

description string

Optional. Eine kurze Beschreibung des Parameters. Darin könnten Anwendungsbeispiele enthalten sein. Die Parameterbeschreibung kann als Markdown formatiert werden.

nullable boolean

Optional. Gibt an, ob der Wert null sein darf.

enum[] string

Optional. Mögliche Werte des Elements vom Typ STRING im enum-Format. Beispiel : {type:STRING, format:enum, enum:["EAST", NORTH", "SOUTH", "WEST"]}

maxItems string (int64 format)

Optional. Maximale Anzahl der Elemente für Type.ARRAY.

minItems string (int64 format)

Optional. Mindestanzahl der Elemente für Type.ARRAY.

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

Optional. Attribute von Type.OBJECT.

Ein Objekt, das eine Liste von "key": value-Paaren enthält. Beispiel: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

required[] string

Optional. Erforderliche Eigenschaften von Type.OBJECT.

minProperties string (int64 format)

Optional. Mindestanzahl der Eigenschaften für Type.OBJECT.

maxProperties string (int64 format)

Optional. Maximale Anzahl der Eigenschaften für Type.OBJECT.

minLength string (int64 format)

Optional. SCHEMA-FELDER FÜR TYP STRING Mindestlänge des Typs STRING

maxLength string (int64 format)

Optional. Maximale Länge von Type.STRING

pattern string

Optional. Muster des Typs STRING, um einen String auf einen regulären Ausdruck zu beschränken.

example value (Value format)

Optional. Beispiel für das Objekt. Wird nur ausgefüllt, wenn das Objekt das Stammobjekt ist.

anyOf[] object (Schema)

Optional. Der Wert sollte anhand eines oder mehrerer der Unterschemas in der Liste validiert werden.

propertyOrdering[] string

Optional. Die Reihenfolge der Eigenschaften. Kein Standardfeld in der OpenAPI-Spezifikation. Wird verwendet, um die Reihenfolge der Attribute in der Antwort zu bestimmen.

default value (Value format)

Optional. Standardwert des Felds. Gemäß JSON-Schema ist dieses Feld für Dokumentationsgeneratoren vorgesehen und hat keine Auswirkungen auf die Validierung. Es ist daher hier enthalten und wird ignoriert, damit Entwickler, die Schemas mit dem Feld default senden, keine Fehler wegen unbekannter Felder erhalten.

items object (Schema)

Optional. Schema der Elemente von Type.ARRAY.

minimum number

Optional. SCHEMAFELDER FÜR TYP „INTEGER“ UND „NUMBER“ Mindestwert des Typs „INTEGER“ und „NUMBER“

maximum number

Optional. Maximaler Wert des Typs „INTEGER“ und „NUMBER“

JSON-Darstellung 
{
  "type": enum (Type),
  "format": string,
  "title": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "maxItems": string,
  "minItems": string,
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "minProperties": string,
  "maxProperties": string,
  "minLength": string,
  "maxLength": string,
  "pattern": string,
  "example": value,
  "anyOf": [
    {
      object (Schema)
    }
  ],
  "propertyOrdering": [
    string
  ],
  "default": value,
  "items": {
    object (Schema)
  },
  "minimum": number,
  "maximum": number
}

Typ

„Type“ enthält die Liste der OpenAPI-Datentypen, wie in https://spec.openapis.org/oas/v3.0.3#data-types definiert.

Enums
TYPE_UNSPECIFIED Nicht angegeben, sollte nicht verwendet werden.
STRING String-Typ.
NUMBER Nummerntyp
INTEGER Ganzzahltyp.
BOOLEAN Boolescher Typ.
ARRAY Array-Typ.
OBJECT Objekttyp.
NULL Null-Typ.

Verhalten

Definiert das Verhalten der Funktion. Die Standardeinstellung ist BLOCKING.

Enums
UNSPECIFIED Dieser Wert wird nicht verwendet.
BLOCKING Wenn diese Option festgelegt ist, wartet das System auf den Empfang der Funktionsantwort, bevor es die Unterhaltung fortsetzt.
NON_BLOCKING Wenn diese Option festgelegt ist, wartet das System nicht auf den Empfang der Funktionsantwort. Stattdessen wird versucht, Funktionsantworten zu verarbeiten, sobald sie verfügbar sind, während die Unterhaltung zwischen dem Nutzer und dem Modell fortgesetzt wird.

GoogleSearchRetrieval

Tool zum Abrufen öffentlicher Webdaten für die Fundierung, unterstützt von Google.

Felder
dynamicRetrievalConfig object (DynamicRetrievalConfig)

Gibt die Konfiguration für den dynamischen Abruf für die angegebene Quelle an.

JSON-Darstellung 
{
  "dynamicRetrievalConfig": {
    object (DynamicRetrievalConfig)
  }
}

DynamicRetrievalConfig

Hier werden die Optionen zum Anpassen der dynamischen Abfrage beschrieben.

Felder
mode enum (Mode)

Der Modus des Vorhersageparameters, der für den dynamischen Abruf verwendet werden soll.

dynamicThreshold number

Der Schwellenwert, der beim dynamischen Abrufen verwendet werden soll. Wenn nicht festgelegt, wird ein Systemstandardwert verwendet.

JSON-Darstellung 
{
  "mode": enum (Mode),
  "dynamicThreshold": number
}

Modus

Der Modus des Vorhersageparameters, der für den dynamischen Abruf verwendet werden soll.

Enums
MODE_UNSPECIFIED Abruf immer auslösen
MODE_DYNAMIC Abruf nur ausführen, wenn das System dies für erforderlich hält.

CodeExecution

Dieser Typ hat keine Felder.

Tool, das vom Modell generierten Code ausführt und das Ergebnis automatisch an das Modell zurückgibt.

Siehe auch ExecutableCode und CodeExecutionResult, die nur bei Verwendung dieses Tools generiert werden.

GoogleSearch

GoogleSearch-Tooltyp. Tool zur Unterstützung der Google Suche im Modell. Powered by Google

Felder
timeRangeFilter object (Interval)

Optional. Suchergebnisse nach einem bestimmten Zeitraum filtern. Wenn Kunden eine Startzeit festlegen, müssen sie auch eine Endzeit festlegen (und umgekehrt).

JSON-Darstellung 
{
  "timeRangeFilter": {
    object (Interval)
  }
}

Intervall

Stellt ein Zeitintervall dar, das als Zeitstempelstart (einschließlich) und Zeitstempelende (ausschließlich) codiert ist.

Der Start muss kleiner oder gleich dem Ende sein. Wenn der Start dem Ende entspricht, ist das Intervall leer (die Zeit ist null). Wenn sowohl der Start als auch das Ende nicht angegeben sind, entspricht das Intervall einer beliebigen Zeit.

Felder
startTime string (Timestamp format)

Optional. Eingeschlossener Start des Intervalls.

Wenn angegeben, muss ein Zeitstempel, der diesem Intervall entspricht, gleich dem Start sein oder darauf folgen.

Verwendet RFC 3339, wobei die generierte Ausgabe immer Z-normalisiert ist und 0, 3, 6 oder 9 Nachkommastellen verwendet. Andere Offsets als „Z“ werden ebenfalls akzeptiert. Beispiele: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" oder "2014-10-02T15:01:23+05:30".

endTime string (Timestamp format)

Optional. Ausgeschlossenes Ende des Intervalls.

Wenn angegeben, muss ein Zeitstempel, der diesem Intervall entspricht, vor dem Ende liegen.

Verwendet RFC 3339, wobei die generierte Ausgabe immer Z-normalisiert ist und 0, 3, 6 oder 9 Nachkommastellen verwendet. Andere Offsets als „Z“ werden ebenfalls akzeptiert. Beispiele: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" oder "2014-10-02T15:01:23+05:30".

JSON-Darstellung 
{
  "startTime": string,
  "endTime": string
}

ComputerUse

Tooltyp „Computernutzung“.

Felder
environment enum (Environment)

Erforderlich. Die Umgebung, in der der Vorgang ausgeführt wird.

excludedPredefinedFunctions[] string

Optional. Standardmäßig sind vordefinierte Funktionen im endgültigen Modellaufruf enthalten. Einige können explizit davon ausgeschlossen werden, automatisch einbezogen zu werden. Das kann zwei Zwecke haben: 1. Verwendung eines eingeschränkteren / anderen Aktionsraums. 2. Die Definitionen / Anweisungen vordefinierter Funktionen werden verbessert.

JSON-Darstellung 
{
  "environment": enum (Environment),
  "excludedPredefinedFunctions": [
    string
  ]
}

Umgebung

Stellt die Umgebung dar, in der der Vorgang ausgeführt wird, z. B. ein Webbrowser.

Enums
ENVIRONMENT_UNSPECIFIED Die Standardeinstellung ist „Browser“.
ENVIRONMENT_BROWSER Funktioniert in einem Webbrowser.

UrlContext

Dieser Typ hat keine Felder.

Tool zur Unterstützung des Abrufs von URL-Kontext.

FileSearch

Das Tool „FileSearch“ ruft Wissen aus Semantic Retrieval-Korpora ab. Dateien werden mit der ImportFile API in Semantic Retrieval-Korpora importiert.

Felder
retrievalResources[] object (RetrievalResource)

Erforderlich. Semantische Abrufsressourcen, aus denen abgerufen werden soll. Derzeit wird nur ein Korpus unterstützt. Möglicherweise wird in Zukunft die Unterstützung mehrerer Korpora eingeführt.

retrievalConfig object (RetrievalConfig)

Optional. Die Konfiguration für den Abruf.

JSON-Darstellung 
{
  "retrievalResources": [
    {
      object (RetrievalResource)
    }
  ],
  "retrievalConfig": {
    object (RetrievalConfig)
  }
}

RetrievalResource

Die semantische Abrufsressource, aus der abgerufen werden soll.

Felder
ragStoreName string

Erforderlich. Der Name der semantischen Abrufsressource, aus der abgerufen werden soll. Beispiel: ragStores/my-rag-store-123

JSON-Darstellung 
{
  "ragStoreName": string
}

RetrievalConfig

Konfiguration des semantischen Abrufs.

Felder
metadataFilter string

Optional. Metadatenfilter, der auf die semantischen Abrufdokumente und ‑chunks angewendet werden soll.

topK integer

Optional. Die Anzahl der semantischen Abruf-Chunks, die abgerufen werden sollen.

JSON-Darstellung 
{
  "metadataFilter": string,
  "topK": integer
}

GoogleMaps

Das GoogleMaps-Tool, das den geografischen Kontext für die Anfrage des Nutzers bereitstellt.

Felder
enableWidget boolean

Optional. Gibt an, ob in den GroundingMetadata der Antwort ein Widget-Kontext-Token zurückgegeben werden soll. Entwickler können das Widget-Kontext-Token verwenden, um ein Google Maps-Widget mit georäumlichem Kontext zu den Orten zu rendern, auf die sich das Modell in der Antwort bezieht.

JSON-Darstellung 
{
  "enableWidget": boolean
}

ToolConfig

Die Tool-Konfiguration mit Parametern zur Angabe der Tool-Verwendung in der Anfrage.

Felder
functionCallingConfig object (FunctionCallingConfig)

Optional. Konfiguration für Funktionsaufrufe.

retrievalConfig object (RetrievalConfig)

Optional. Konfiguration für den Abruf.

JSON-Darstellung 
{
  "functionCallingConfig": {
    object (FunctionCallingConfig)
  },
  "retrievalConfig": {
    object (RetrievalConfig)
  }
}

FunctionCallingConfig

Konfiguration zum Angeben des Verhaltens von Funktionsaufrufen.

Felder
mode enum (Mode)

Optional. Gibt den Modus an, in dem Funktionsaufrufe ausgeführt werden sollen. Wenn nicht angegeben, wird der Standardwert auf AUTO festgelegt.

allowedFunctionNames[] string

Optional. Eine Reihe von Funktionsnamen, die die vom Modell aufgerufenen Funktionen einschränken.

Sollte nur festgelegt werden, wenn der Modus „ANY“ oder „VALIDATED“ ist. Funktionsnamen sollten mit [FunctionDeclaration.name] übereinstimmen. Wenn diese Option festgelegt ist, sagt das Modell einen Funktionsaufruf nur anhand der zulässigen Funktionsnamen voraus.

JSON-Darstellung 
{
  "mode": enum (Mode),
  "allowedFunctionNames": [
    string
  ]
}

Modus

Definiert das Ausführungsverhalten für Funktionsaufrufe durch Festlegen des Ausführungsmodus.

Enums
MODE_UNSPECIFIED Nicht angegebener Modus für Funktionsaufrufe. Dieser Wert sollte nicht verwendet werden.
AUTO Standardmäßiges Modellverhalten: Das Modell entscheidet, ob ein Funktionsaufruf oder eine Antwort in natürlicher Sprache vorhergesagt werden soll.
ANY Das Modell ist darauf beschränkt, immer nur einen Funktionsaufruf vorherzusagen. Wenn „allowedFunctionNames“ festgelegt ist, wird der vorhergesagte Funktionsaufruf auf einen der „allowedFunctionNames“ beschränkt. Andernfalls ist der vorhergesagte Funktionsaufruf einer der bereitgestellten „functionDeclarations“.
NONE Das Modell sagt keinen Funktionsaufruf vorher. Das Modell verhält sich genauso, als würden keine Funktionsdeklarationen übergeben.
VALIDATED Das Modell entscheidet, ob ein Funktionsaufruf oder eine Antwort in natürlicher Sprache vorhergesagt werden soll, validiert Funktionsaufrufe aber mit eingeschränkter Dekodierung. Wenn „allowedFunctionNames“ festgelegt ist, wird der vorhergesagte Funktionsaufruf auf einen der „allowedFunctionNames“ beschränkt. Andernfalls ist der vorhergesagte Funktionsaufruf einer der bereitgestellten „functionDeclarations“.

RetrievalConfig

Konfiguration für den Abruf.

Felder
latLng object (LatLng)

Optional. Der Standort des Nutzers.

languageCode string

Optional. Der Sprachcode des Nutzers. Sprachcode für Inhalte. Verwenden Sie Sprachentags, die von BCP47 definiert werden.

JSON-Darstellung 
{
  "latLng": {
    object (LatLng)
  },
  "languageCode": string
}

LatLng

Ein Objekt, das ein Paar aus Breiten- und Längengrad darstellt. Es wird als Paar aus Werten vom Typ „Double“ (Breiten- und Längengrad) ausgedrückt. Sofern nicht anders angegeben, muss dieses Objekt dem WGS84-Standard entsprechen. Die Werte müssen innerhalb normalisierter Bereiche liegen.

Felder
latitude number

Der Breitengrad in Grad. Er muss im Bereich [-90,0, +90,0] liegen.

longitude number

Der Längengrad in Grad. Er muss im Bereich [-180,0, +180,0] liegen.

JSON-Darstellung 
{
  "latitude": number,
  "longitude": number
}

UsageMetadata

Metadaten zur Nutzung der im Cache gespeicherten Inhalte.

Felder
totalTokenCount integer

Gesamtzahl der Tokens, die durch die Inhalte im Cache verbraucht werden.

JSON-Darstellung 
{
  "totalTokenCount": integer
}