Caching

Methode: cacheContents.create

Erstellt eine CachedContent-Ressource.

Endpunkt

<ph type="x-smartling-placeholder"></ph> Beitrag https://generativelanguage.googleapis.com/v1beta/cachedContents
.

Anfragetext

Der Anfragetext enthält eine Instanz von CachedContent.

Beispielanfrage

Einfach

Python

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

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

Node.js

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

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

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

console.log(cacheResult);

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

Von Name

Python

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

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

Node.js

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

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

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

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

Über den Chat

Python

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

model = genai.GenerativeModel(model_name=model_name, system_instruction=system_instruction)
chat = model.start_chat()
document = genai.upload_file(path=media / "a11.txt")
response = chat.send_message(["Hi, could you summarize this transcript?", document])
print("\n\nmodel:  ", response.text)
response = chat.send_message(
    ["Okay, could you tell me more about the trans-lunar injection"]
)
print("\n\nmodel:  ", response.text)

# To cache the conversation so far, pass the chat history as the list of "contents".
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction=system_instruction,
    contents=chat.history,
)
model = genai.GenerativeModel.from_cached_content(cached_content=cache)

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

Node.js

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

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

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

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

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

const newModel = genAI.getGenerativeModelFromCachedContent(cacheResult);

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

Antworttext

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

Methode: cacheContents.list

Listet CachedContents auf.

Endpunkt

<ph type="x-smartling-placeholder"></ph> erhalten https://generativelanguage.googleapis.com/v1beta/cachedContents
.

Abfrageparameter

pageSize integer

Optional. Die maximale Anzahl der im Cache gespeicherten Inhalte, die zurückgegeben werden sollen. Der Dienst gibt möglicherweise weniger als diesen Wert zurück. Wenn nicht angegeben, wird eine Standardanzahl von Elementen (unter der maximalen Anzahl) 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 diese 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: cacheContents.get

Liest Ressource vom Typ „CachedContent“.

Endpunkt

<ph type="x-smartling-placeholder"></ph> erhalten https://generativelanguage.googleapis.com/v1beta/{name=cachedContents/*}
.

Pfadparameter

name string

Erforderlich. Der Ressourcenname, der sich auf den Eintrag im Inhaltscache bezieht. Format: cachedContents/{id}. Sie hat das Format cachedContents/{cachedcontent}.

Anfragetext

Der Anfragetext muss leer sein.

Beispielanfrage

Python

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

Node.js

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

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

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

Antworttext

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

Methode: cacheContents.patch

Aktualisiert die CachedContent-Ressource (nur die Ablaufzeit kann aktualisiert werden).

Endpunkt

<ph type="x-smartling-placeholder"></ph> Patch https://generativelanguage.googleapis.com/v1beta/{cachedContent.name=cachedContents/*}
.

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

Pfadparameter

cachedContent.name string

Optional. Kennung. Der Ressourcenname, der sich auf den im Cache gespeicherten Inhalt bezieht. Format: cachedContents/{id}. Sie hat das Format cachedContents/{cachedcontent}.

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.

Beispielanfrage

Python

import datetime

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

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

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

Node.js

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

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

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

Antworttext

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

Methode: cacheContents.delete

Löscht die CachedContent-Ressource.

Endpunkt

<ph type="x-smartling-placeholder"></ph> Löschen https://generativelanguage.googleapis.com/v1beta/{name=cachedContents/*}
.

Pfadparameter

name string

Erforderlich. Der Ressourcenname, der sich auf den Eintrag im Inhaltscache bezieht: cachedContents/{id}. Er hat das Format cachedContents/{cachedcontent}.

Anfragetext

Der Anfragetext muss leer sein.

Beispielanfrage

Python

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

Node.js

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

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

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

Antworttext

Wenn der Vorgang erfolgreich ist, ist der Antworttext leer.

REST-Ressource: cacheContents

Ressource: CachedContent

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

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

JSON-Darstellung 
{
  "contents": [
    {
      object (Content)
    }
  ],
  "tools": [
    {
      object (Tool)
    }
  ],
  "createTime": string,
  "updateTime": string,
  "usageMetadata": {
    object (UsageMetadata)
  },

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

Optional. Nur Eingabe. Nicht veränderbar. Der im Cache zu speichernde Inhalt.

tools[] object (Tool)

Optional. Nur Eingabe. Nicht veränderbar. Eine Liste von Tools, die das Modell verwenden kann, um die nächste Antwort zu generieren

createTime string (Timestamp format)

Nur Ausgabe. Erstellungszeit des Cache-Eintrags.

Ein Zeitstempel im Format RFC3339 UTC "Zulu" mit einer Auflösung im Nanosekundenbereich und bis zu neun Nachkommastellen. Beispiele: "2014-10-02T15:01:23Z" und "2014-10-02T15:01:23.045123456Z".

updateTime string (Timestamp format)

Nur Ausgabe. Zeitpunkt der letzten Aktualisierung des Cache-Eintrags in UTC.

Ein Zeitstempel im Format RFC3339 UTC "Zulu" mit einer Auflösung im Nanosekundenbereich und bis zu neun Nachkommastellen. Beispiele: "2014-10-02T15:01:23Z" und "2014-10-02T15:01:23.045123456Z".

usageMetadata object (UsageMetadata)

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

Union-Feld expiration. 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, unabhängig davon, was bei der Eingabe gesendet wurde.

Ein Zeitstempel im Format RFC3339 UTC "Zulu" mit einer Auflösung im Nanosekundenbereich und bis zu neun Nachkommastellen. Beispiele: "2014-10-02T15:01:23Z" und "2014-10-02T15:01:23.045123456Z".

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

Optional. Kennung. Der Ressourcenname, der sich auf den im Cache gespeicherten Inhalt bezieht. Format: cachedContents/{id}

displayName string

Optional. Nicht veränderbar. Der vom Nutzer generierte aussagekräftige Anzeigename des im Cache gespeicherten Inhalts. Maximal 128 Unicode-Zeichen.

model string

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

systemInstruction object (Content)

Optional. Nur Eingabe. Nicht veränderbar. Systemanweisung für Entwicklersatz. Derzeit nur Text.

toolConfig object (ToolConfig)

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

Inhalt

Der grundlegende strukturierte Datentyp, der den mehrteiligen Inhalt einer Nachricht enthält.

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

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

Parts bestellt, die eine einzelne Nachricht bilden. Teile können unterschiedliche MIME-Typen haben.

role string

Optional. Der Produzent des Contents. Muss entweder „user“ sein oder 'Modell' [model].

Nützlich zum Festlegen für Unterhaltungen mit mehreren Schritten. Andernfalls können Sie das Feld leer lassen oder die Festlegung aufheben.

Teil

Datentyp mit Medien, der Teil einer mehrteiligen Content-Nachricht ist.

Eine 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 des Mediums identifiziert, wenn das Feld inlineData mit Rohbyte gefüllt ist.

JSON-Darstellung 
{

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

Union-Feld data.

Für data ist nur einer der folgenden Werte zulässig:

text string

Inline-Text

inlineData object (Blob)

Inline-Mediabyte.

functionCall object (FunctionCall)

Eine vorhergesagte FunctionCall, die vom Modell zurückgegeben wird und einen String enthält, der die FunctionDeclaration.name mit den Argumenten und ihren Werten darstellt.

functionResponse object (FunctionResponse)

Die Ergebnisausgabe einer FunctionCall, die einen String enthält, der die FunctionDeclaration.name und ein strukturiertes JSON-Objekt mit einer Ausgabe der Funktion enthält, 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.

Blob

Roh-Mediabyte.

Text sollte nicht als Rohbyte gesendet werden. Verwenden Sie stattdessen „Text“. ein.

JSON-Darstellung 
{
  "mimeType": string,
  "data": string
}
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 Dateiformate finden Sie unter Unterstützte Dateiformate.

data string (bytes format)

Rohbyte für Medienformate.

Ein base64-codierter String.

FunctionCall

Eine vorhergesagte FunctionCall, die vom Modell zurückgegeben wird und einen String enthält, der die FunctionDeclaration.name mit den Argumenten und ihren Werten darstellt.

JSON-Darstellung 
{
  "name": string,
  "args": {
    object
  }
}
Felder
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 63.

args object (Struct format)

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

FunctionResponse

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

JSON-Darstellung 
{
  "name": string,
  "response": {
    object
  }
}
Felder
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 63.

response object (Struct format)

Erforderlich. Die Funktionsantwort im JSON-Objektformat.

FileData

URI-basierte Daten.

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

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

fileUri string

Erforderlich. URI.

ExecutableCode

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

Wird nur bei Verwendung des CodeExecution-Tools generiert. Darin wird der Code automatisch ausgeführt und eine entsprechende CodeExecutionResult wird generiert.

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

Erforderlich. Programmiersprache von code.

code string

Erforderlich. Der Code, der ausgeführt werden soll.

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, numpy und simpy sind verfügbar.

CodeExecutionResult

Ergebnis der Ausführung von ExecutableCode.

Wird nur bei Verwendung der CodeExecution generiert und folgt immer einer part, die ExecutableCode enthält.

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

Erforderlich. Ergebnis der Codeausführung.

output string

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

Ergebnis

Aufzählung möglicher Ergebnisse der Codeausführung.

Enums
OUTCOME_UNSPECIFIED Unbekannter Status. Dieser Wert sollte nicht verwendet werden.
OUTCOME_OK Codeausführung wurde abgeschlossen.
OUTCOME_FAILED Die Codeausführung wurde beendet, aber ein Fehler ist aufgetreten. stderr sollte den Grund enthalten.
OUTCOME_DEADLINE_EXCEEDED Die Codeausführung lief zu lange und wurde abgebrochen. Möglicherweise ist eine unvollständige Ausgabe vorhanden.

Tool

Tooldetails, die das Modell zum Generieren einer Antwort verwenden kann.

Eine Tool ist ein Code-Snippet, das es dem System ermöglicht, mit externen Systemen zu interagieren, um eine Aktion oder eine Reihe von Aktionen auszuführen, ohne das Wissen und den Umfang des Modells zu überschreiten.

JSON-Darstellung 
{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "codeExecution": {
    object (CodeExecution)
  }
}
Felder
functionDeclarations[] object (FunctionDeclaration)

Optional. Eine Liste der für das Modell verfügbaren FunctionDeclarations, die für Funktionsaufrufe verwendet werden kann.

Das Modell oder System führt die Funktion nicht aus. Stattdessen kann die definierte Funktion als [FunctionCall][content.part.function_call] mit Argumenten auf der Clientseite zur Ausführung zurückgegeben werden. Das Modell kann entscheiden, eine Teilmenge dieser Funktionen aufzurufen, indem es [FunctionCall][content.part.function_call] in die Antwort einfügt. Die nächste Unterhaltungsrunde kann [FunctionResponse][content.part.function_response] mit der "Funktion" [content.role] enthalten. Generierungskontext für die nächste Modellreihe.

codeExecution object (CodeExecution)

Optional. Ermöglicht dem Modell, Code als Teil der Generierung auszuführen.

FunctionDeclaration

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

JSON-Darstellung 
{
  "name": string,
  "description": string,
  "parameters": {
    object (Schema)
  }
}
Felder
name string

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

description string

Erforderlich. Eine kurze Beschreibung der Funktion.

parameters object (Schema)

Optional. Beschreibt die Parameter dieser Funktion. Entspricht dem Stringschlüssel des OpenAPI 3.03-Parameterobjekts: dem Namen des Parameters. Bei Parameternamen wird zwischen Groß- und Kleinschreibung unterschieden. Schemawert: das Schema, das den für den Parameter verwendeten Typ definiert.

Schema

Mit dem Objekt Schema können Eingabe- und Ausgabedatentypen definiert werden. Bei diesen Typen kann es sich um Objekte, aber auch um Primitive und Arrays handeln. Stellt eine ausgewählte Teilmenge eines OpenAPI 3.0-Schemaobjekts dar.

JSON-Darstellung 
{
  "type": enum (Type),
  "format": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "items": {
    object (Schema)
  }
}
Felder
type enum (Type)

Erforderlich. Datentyp.

format string

Optional. Das Format der Daten. Dies wird nur für primitive Datentypen verwendet. Unterstützte Formate: für Typ NUMBER: float, double für INTEGER-Typ: int32, int64 für Typ STRING: enum

description string

Optional. Eine kurze Beschreibung des Parameters. Diese können Anwendungsbeispiele enthalten. Die Parameterbeschreibung kann als Markdown formatiert sein.

nullable boolean

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

enum[] string

Optional. Mögliche Werte des Elements vom Typ.STRING im enum-Format. Beispielsweise können wir eine Enum-Richtung so definieren : {type:STRING, format:enum, enum:["EAST", NORTH", "SOUTH", "WEST"]}.

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

Optional. Eigenschaften des Typs 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 vom Typ.OBJECT.

items object (Schema)

Optional. Schema der Elemente von Type.ARRAY.

Typ

„Type“ (Typ) enthält die Liste der OpenAPI-Datentypen gemäß https://spec.openapis.org/oas/v3.0.3#data-types.

Enums
TYPE_UNSPECIFIED Nicht angegeben, sollte nicht verwendet werden.
STRING Stringtyp.
NUMBER Zahlentyp.
INTEGER Ganzzahltyp.
BOOLEAN Boolescher Typ.
ARRAY Arraytyp.
OBJECT Objekttyp.

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.

ToolConfig

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

JSON-Darstellung 
{
  "functionCallingConfig": {
    object (FunctionCallingConfig)
  }
}
Felder
functionCallingConfig object (FunctionCallingConfig)

Optional. Konfiguration für Funktionsaufruf.

FunctionCallingConfig

Konfiguration zum Festlegen des Verhaltens bei Funktionsaufrufen.

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

Optional. Gibt den Modus an, in dem Funktionsaufrufe ausgeführt werden sollen. Wenn keine Vorgabe erfolgt, wird der Standardwert AUTOMATISCH festgelegt.

allowedFunctionNames[] string

Optional. Eine Reihe von Funktionsnamen, die, sofern angegeben, die vom Modell aufrufenden Funktionen einschränkt.

Sollte nur festgelegt werden, wenn für den Modus ANY festgelegt ist. Funktionsnamen müssen mit [FunctionDeclaration.name] übereinstimmen. Wenn der Modus auf ANY gesetzt ist, sagt das Modell einen Funktionsaufruf aus dem Satz von Funktionsnamen vorher.

Modus

Definiert das Ausführungsverhalten für Funktionsaufrufe, indem der Ausführungsmodus definiert wird.

Enums
MODE_UNSPECIFIED Nicht spezifizierter Funktionsaufrufmodus. Dieser Wert sollte nicht verwendet werden.
AUTO Das Standardverhalten des Modells. Das Modell entscheidet, ob ein Funktionsaufruf oder eine Antwort in natürlicher Sprache vorhergesagt wird.
ANY Das Modell ist darauf beschränkt, immer nur einen Funktionsaufruf vorherzusagen. Wenn „allowedFunctionNames“ festgelegt sind, ist der vorhergesagte Funktionsaufruf auf einen der "allowedFunctionNames"-Funktionen beschränkt. Andernfalls ist der vorhergesagte Funktionsaufruf ein beliebiger der bereitgestellten "functionDeclarations".
NONE Das Modell sagt keinen Funktionsaufruf vorher. Das Modellverhalten entspricht dem, wenn keine Funktionsdeklarationen übergeben werden.

UsageMetadata

Metadaten zur Nutzung der im Cache gespeicherten Inhalte.

JSON-Darstellung 
{
  "totalTokenCount": integer
}
Felder
totalTokenCount integer

Gesamtzahl der Tokens, die der im Cache gespeicherte Inhalt verbraucht.