Caching

Méthode: cacheContents.create

Crée une ressource CachedContent.

Point de terminaison

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

Corps de la requête

Le corps de la requête contient une instance de CachedContent.

Exemple de requête

Standard

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());

Nom de l'expéditeur

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.");

À partir d'un 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()}`);

Corps de la réponse

Si la requête aboutit, le corps de la réponse contient une nouvelle instance de CachedContent.

Méthode: cacheContents.list

Répertorie les CachedContents.

Point de terminaison

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

Paramètres de requête

pageSize integer

Facultatif. Nombre maximal de contenus mis en cache à renvoyer. Le service peut renvoyer un nombre inférieur à cette valeur. Si aucune valeur n'est spécifiée, un nombre par défaut (inférieur au nombre maximal) d'éléments est renvoyé. La valeur maximale est 1 000. Les valeurs supérieures sont réduites à 1 000.

pageToken string

Facultatif. Jeton de page reçu d'un appel cachedContents.list précédent. Fournissez-le pour récupérer la page suivante.

Lors de la pagination, tous les autres paramètres fournis à cachedContents.list doivent correspondre à l'appel ayant fourni le jeton de page.

Corps de la requête

Le corps de la requête doit être vide.

Corps de la réponse

Réponse avec la liste CachedContents.

Si la requête aboutit, le corps de la réponse contient des données qui ont la structure suivante :

Champs
cachedContents[] object (CachedContent)

Liste des contenus mis en cache.

nextPageToken string

Jeton pouvant être envoyé en tant que pageToken pour récupérer la page suivante. Si ce champ est omis, il n'y a pas d'autres pages.

Représentation JSON 
{
  "cachedContents": [
    {
      object (CachedContent)
    }
  ],
  "nextPageToken": string
}

Méthode: cacheContents.get

Lit la ressource CachedContent.

Point de terminaison

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

Paramètres de chemin d'accès

name string

Obligatoire. Nom de ressource faisant référence à l'entrée du cache de contenu. Format: cachedContents/{id}. Il se présente sous la forme cachedContents/{cachedcontent}.

Corps de la requête

Le corps de la requête doit être vide.

Exemple de requête

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);

Corps de la réponse

Si la requête aboutit, le corps de la réponse contient une instance de CachedContent.

Méthode: cacheContents.patch

Met à jour la ressource CachedContent (seul le délai d'expiration peut être mis à jour).

Point de terminaison

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

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

Paramètres de chemin d'accès

cachedContent.name string

Facultatif. Identifiant. Nom de la ressource faisant référence au contenu mis en cache. Format: cachedContents/{id}. Il se présente sous la forme cachedContents/{cachedcontent}.

Paramètres de requête

updateMask string (FieldMask format)

Liste des champs à mettre à jour.

Il s'agit d'une liste de noms de champs complets séparés par une virgule. Exemple : "user.displayName,photo"

Corps de la requête

Le corps de la requête contient une instance de CachedContent.

Exemple de requête

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);

Corps de la réponse

Si la requête aboutit, le corps de la réponse contient une instance de CachedContent.

Méthode: cacheContents.delete

Supprime la ressource CachedContent.

Point de terminaison

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

Paramètres de chemin d'accès

name string

Obligatoire. Nom de ressource faisant référence à l'entrée du cache de contenu. Format: cachedContents/{id}. Il se présente sous la forme cachedContents/{cachedcontent}.

Corps de la requête

Le corps de la requête doit être vide.

Exemple de requête

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);

Corps de la réponse

Si la requête aboutit, le corps de la réponse est vide.

Ressource REST: CacheContents

Ressource: CachedContent

Contenu qui a été prétraité et qui peut être utilisé dans les requêtes ultérieures envoyées à GenerativeService.

Le contenu mis en cache ne peut être utilisé qu'avec le modèle pour lequel il a été créé.

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

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

Facultatif. Uniquement en entrée. Immuable. Contenu à mettre en cache.

tools[] object (Tool)

Facultatif. Uniquement en entrée. Immuable. Liste de Tools que le modèle peut utiliser pour générer la réponse suivante

createTime string (Timestamp format)

Uniquement en sortie. Heure de création de l'entrée de cache.

Horodatage au format RFC3339 UTC "Zulu", avec une résolution de l'ordre de la nanoseconde et jusqu'à neuf chiffres décimaux. Exemples : "2014-10-02T15:01:23Z" et "2014-10-02T15:01:23.045123456Z".

updateTime string (Timestamp format)

Uniquement en sortie. Date et heure de la dernière mise à jour de l'entrée de cache en temps UTC.

Horodatage au format RFC3339 UTC "Zulu", avec une résolution de l'ordre de la nanoseconde et jusqu'à neuf chiffres décimaux. Exemples : "2014-10-02T15:01:23Z" et "2014-10-02T15:01:23.045123456Z".

usageMetadata object (UsageMetadata)

Uniquement en sortie. Métadonnées sur l'utilisation du contenu mis en cache.

Champ d'union expiration. Indique la date d'expiration de cette ressource. expiration ne peut être qu'un des éléments suivants :
expireTime string (Timestamp format)

Code temporel en UTC du moment où cette ressource est considérée comme expirée. Cette valeur est toujours fournie en sortie, quelle que soit ce qui a été envoyé en entrée.

Horodatage au format RFC3339 UTC "Zulu", avec une résolution de l'ordre de la nanoseconde et jusqu'à neuf chiffres décimaux. Exemples : "2014-10-02T15:01:23Z" et "2014-10-02T15:01:23.045123456Z".

ttl string (Duration format)

Uniquement en entrée. Nouvelle valeur TTL pour cette ressource, en entrée uniquement.

Durée en secondes avec neuf chiffres au maximum après la virgule et se terminant par "s". Exemple : "3.5s"

name string

Facultatif. Identifiant. Nom de la ressource faisant référence au contenu mis en cache. Format : cachedContents/{id}

displayName string

Facultatif. Immuable. Nom à afficher explicite, généré par l'utilisateur, pour le contenu mis en cache 128 caractères Unicode au maximum.

model string

Obligatoire. Immuable. Nom du Model à utiliser pour le format de contenu mis en cache: models/{model}

systemInstruction object (Content)

Facultatif. Uniquement en entrée. Immuable. Instruction concernant le système défini par le développeur. Texte uniquement pour le moment.

toolConfig object (ToolConfig)

Facultatif. Uniquement en entrée. Immuable. Configuration de l'outil. Cette configuration est partagée pour tous les outils.

Contenu

Type de données structurées de base contenant le contenu d'un message en plusieurs parties.

Un Content inclut un champ role désignant le producteur de l'Content et un champ parts contenant des données en plusieurs parties incluant le contenu du tour du message.

Représentation JSON 
{
  "parts": [
    {
      object (Part)
    }
  ],
  "role": string
}
Champs
parts[] object (Part)

Parts ordonnés qui constituent un seul message. Les parties peuvent avoir différents types MIME.

role string

Facultatif. Producteur du contenu. Doit être soit "user", ou "model".

Utile à configurer pour les conversations multitours. Sinon, peut être laissé vide ou non défini.

Partie

Type de données contenant du contenu multimédia faisant partie d'un message Content en plusieurs parties.

Un Part est constitué de données auxquelles un type de données est associé. Un élément Part ne peut contenir qu'un seul des types acceptés dans Part.data.

Un Part doit avoir un type MIME IANA fixe identifiant le type et le sous-type du contenu multimédia si le champ inlineData est rempli d'octets bruts.

Représentation JSON 
{

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

Champ d'union data.

data ne peut être qu'un des éléments suivants :

text string

Texte intégré.

inlineData object (Blob)

Octets multimédias intégrés.

functionCall object (FunctionCall)

Une FunctionCall prédite renvoyée par le modèle et qui contient une chaîne représentant FunctionDeclaration.name avec les arguments et leurs valeurs.

functionResponse object (FunctionResponse)

Le résultat d'une FunctionCall contenant une chaîne représentant l'FunctionDeclaration.name et un objet JSON structuré contenant toute sortie de la fonction est utilisé comme contexte pour le modèle.

fileData object (FileData)

Données basées sur l'URI.

executableCode object (ExecutableCode)

Code généré par le modèle devant être exécuté.

codeExecutionResult object (CodeExecutionResult)

Résultat de l'exécution de ExecutableCode.

Blob

Octets multimédias bruts.

Le texte ne doit pas être envoyé sous forme d'octets bruts, utilisez la valeur .

Représentation JSON 
{
  "mimeType": string,
  "data": string
}
Champs
mimeType string

Type MIME standard de l'IANA des données sources. Exemples: - image/png - image/jpeg Si un type MIME non pris en charge est fourni, une erreur s'affiche. Pour obtenir la liste complète des types de fichiers compatibles, consultez Formats de fichiers acceptés.

data string (bytes format)

Octets bruts pour les formats multimédias.

Chaîne encodée en base64.

FunctionCall

Une FunctionCall prédite renvoyée par le modèle et qui contient une chaîne représentant FunctionDeclaration.name avec les arguments et leurs valeurs.

Représentation JSON 
{
  "name": string,
  "args": {
    object
  }
}
Champs
name string

Obligatoire. Nom de la fonction à appeler. Doit être a-z, A-Z ou 0-9, ou contenir des traits de soulignement et des tirets, avec une longueur maximale de 63.

args object (Struct format)

Facultatif. Paramètres et valeurs de la fonction au format d'objet JSON.

FunctionResponse

Le résultat d'une FunctionCall contenant une chaîne représentant l'FunctionDeclaration.name et un objet JSON structuré contenant toute sortie de la fonction est utilisé comme contexte pour le modèle. Il doit contenir le résultat d'une FunctionCall basée sur la prédiction du modèle.

Représentation JSON 
{
  "name": string,
  "response": {
    object
  }
}
Champs
name string

Obligatoire. Nom de la fonction à appeler. Doit être a-z, A-Z ou 0-9, ou contenir des traits de soulignement et des tirets, avec une longueur maximale de 63.

response object (Struct format)

Obligatoire. Réponse de la fonction au format d'objet JSON.

FileData

Données basées sur l'URI.

Représentation JSON 
{
  "mimeType": string,
  "fileUri": string
}
Champs
mimeType string

Facultatif. Type MIME standard de l'IANA des données sources.

fileUri string

Obligatoire. URI.

ExecutableCode

Code généré par le modèle à exécuter et résultat renvoyé au modèle.

Généré uniquement lors de l'utilisation de l'outil CodeExecution, dans lequel le code sera automatiquement exécuté et un CodeExecutionResult correspondant sera également généré.

Représentation JSON 
{
  "language": enum (Language),
  "code": string
}
Champs
language enum (Language)

Obligatoire. Langage de programmation de code.

code string

Obligatoire. Code à exécuter.

Langue

Langages de programmation compatibles avec le code généré.

Enums
LANGUAGE_UNSPECIFIED Langue non spécifiée. Cette valeur ne doit pas être utilisée.
PYTHON Python 3.10 ou version ultérieure, avec numpy et simpy disponibles

CodeExecutionResult

Résultat de l'exécution de ExecutableCode.

Générée uniquement lors de l'utilisation de CodeExecution et suit toujours une part contenant la ExecutableCode.

Représentation JSON 
{
  "outcome": enum (Outcome),
  "output": string
}
Champs
outcome enum (Outcome)

Obligatoire. Résultat de l'exécution du code.

output string

Facultatif. Contient "stdout" lorsque l'exécution du code a réussi, "stderr" ou une autre description dans le cas contraire.

Résultat

Énumération des résultats possibles de l'exécution du code.

Enums
OUTCOME_UNSPECIFIED État non spécifié. Cette valeur ne doit pas être utilisée.
OUTCOME_OK L'exécution du code a bien été effectuée.
OUTCOME_FAILED L'exécution du code s'est terminée, mais avec un échec. stderr doit contenir le motif.
OUTCOME_DEADLINE_EXCEEDED L'exécution du code a duré trop longtemps et a été annulée. Il peut y avoir ou non une sortie partielle.

Outil

Détails de l'outil que le modèle peut utiliser pour générer une réponse.

Un Tool est un extrait de code qui permet au système d'interagir avec des systèmes externes pour effectuer une ou plusieurs actions, en dehors des connaissances et du champ d'application du modèle.

Représentation JSON 
{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "codeExecution": {
    object (CodeExecution)
  }
}
Champs
functionDeclarations[] object (FunctionDeclaration)

Facultatif. Liste des FunctionDeclarations disponibles pour le modèle et qui peuvent être utilisés pour l'appel de fonction.

Le modèle ou le système n'exécute pas la fonction. À la place, la fonction définie peut être renvoyée sous la forme d'un [FunctionCall][content.part.function_call] avec des arguments côté client pour exécution. Le modèle peut décider d'appeler un sous-ensemble de ces fonctions en insérant [FunctionCall][content.part.function_call] dans la réponse. Le prochain tour de conversation peut contenir une [FunctionResponse][content.part.function_response] avec la "fonction" [content.role]. de génération de contexte pour le prochain tour du modèle.

codeExecution object (CodeExecution)

Facultatif. Permet au modèle d'exécuter du code lors de la génération.

FunctionDeclaration

Représentation structurée d'une déclaration de fonction telle que définie par la spécification OpenAPI 3.03. Cette déclaration comprend le nom et les paramètres de la fonction. Cette FunctionDeclaration est une représentation d'un bloc de code qui peut être utilisé comme Tool par le modèle et exécuté par le client.

Représentation JSON 
{
  "name": string,
  "description": string,
  "parameters": {
    object (Schema)
  }
}
Champs
name string

Obligatoire. Nom de la fonction. Doit être a-z, A-Z ou 0-9, ou contenir des traits de soulignement et des tirets, avec une longueur maximale de 63.

description string

Obligatoire. Brève description de la fonction.

parameters object (Schema)

Facultatif. Décrit les paramètres de cette fonction. Reflète la clé de la chaîne de l'objet du paramètre Open API 3.03: nom du paramètre. Les noms des paramètres sont sensibles à la casse. "Schema Value" : le schéma définissant le type utilisé pour le paramètre.

Schéma

L'objet Schema permet de définir les types de données d'entrée et de sortie. Ces types peuvent être des objets, mais aussi des primitives et des tableaux. Représente un sous-ensemble sélectionné d'un objet de schéma OpenAPI 3.0.

Représentation JSON 
{
  "type": enum (Type),
  "format": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "items": {
    object (Schema)
  }
}
Champs
type enum (Type)

Obligatoire. Type de données

format string

Facultatif. Format des données. Cette méthode n'est utilisée que pour les types de données primitifs. Formats compatibles: pour le type NUMBER: float, double pour le type INTEGER: int32, int64 pour le type STRING: enum

description string

Facultatif. Brève description du paramètre. Il peut contenir des exemples d'utilisation. La description du paramètre peut être au format Markdown.

nullable boolean

Facultatif. Indique si la valeur peut être nulle.

enum[] string

Facultatif. Valeurs possibles de l'élément de Type.STRING au format enum. Par exemple, nous pouvons définir une direction d'énumération comme suit : {type:STRING, format:enum, enum:["EAST", NORTH", "SOUTH", "WEST"]}

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

Facultatif. Propriétés du Type.OBJECT.

Objet contenant une liste de paires "key": value. Exemple : { "name": "wrench", "mass": "1.3kg", "count": "3" }.

required[] string

Facultatif. Propriétés obligatoires de Type.OBJECT.

items object (Schema)

Facultatif. Schéma des éléments de Type.ARRAY.

Type

Le type contient la liste des types de données OpenAPI tels que définis par https://spec.openapis.org/oas/v3.0.3#data-types

Enums
TYPE_UNSPECIFIED Non spécifié, ne doit pas être utilisé.
STRING Type de chaîne.
NUMBER Type de nombre.
INTEGER Type entier.
BOOLEAN Type booléen.
ARRAY Type de tableau.
OBJECT Type d'objet.

CodeExecution

Ce type ne comporte aucun champ.

Outil qui exécute le code généré par le modèle et renvoie automatiquement le résultat au modèle.

Consultez également ExecutableCode et CodeExecutionResult, qui ne sont générés que lorsque vous utilisez cet outil.

ToolConfig

Configuration de l'outil contenant des paramètres permettant de spécifier l'utilisation de Tool dans la requête.

Représentation JSON 
{
  "functionCallingConfig": {
    object (FunctionCallingConfig)
  }
}
Champs
functionCallingConfig object (FunctionCallingConfig)

Facultatif. Configuration de l'appel de fonction.

FunctionCallingConfig

Configuration permettant de spécifier le comportement d'appel de fonction.

Représentation JSON 
{
  "mode": enum (Mode),
  "allowedFunctionNames": [
    string
  ]
}
Champs
mode enum (Mode)

Facultatif. Spécifie le mode d'exécution de l'appel de fonction. Si aucune valeur n'est spécifiée, la valeur par défaut sera définie sur AUTO.

allowedFunctionNames[] string

Facultatif. Ensemble de noms de fonctions qui, lorsqu'ils sont fournis, limitent les fonctions que le modèle va appeler.

Ce paramètre ne doit être défini que lorsque le mode est défini sur "TOUS". Les noms de fonctions doivent correspondre à [FunctionDeclaration.name]. Lorsque le mode est défini sur N'IMPORTE LAQUELLE, le modèle va prédire un appel de fonction à partir de l'ensemble des noms de fonction fournis.

Mode

Définit le comportement d'exécution pour l'appel de fonction en définissant le mode d'exécution.

Enums
MODE_UNSPECIFIED Mode d'appel de fonction non spécifié. Cette valeur ne doit pas être utilisée.
AUTO Comportement par défaut du modèle : le modèle décide de prédire soit un appel de fonction, soit une réponse en langage naturel.
ANY Le modèle est contraint de toujours prédire un appel de fonction uniquement. Si "allowedFunctionNames" sont définis, l'appel de fonction prédit est limité à l'une des valeurs "allowedFunctionNames", sinon l'appel de la fonction prédite est l'une des "functionDeclarations" fournies.
NONE Le modèle ne prédirea aucun appel de fonction. Le comportement du modèle est le même que lorsqu'il ne transmet aucune déclaration de fonction.

UsageMetadata

Métadonnées sur l'utilisation du contenu mis en cache.

Représentation JSON 
{
  "totalTokenCount": integer
}
Champs
totalTokenCount integer

Nombre total de jetons utilisés par le contenu mis en cache.