Caching

El almacenamiento en caché de contexto te permite guardar y reutilizar tokens de entrada procesados previamente que deseas usar repetidamente, por ejemplo, cuando haces diferentes preguntas sobre el mismo archivo multimedia. Esto puede generar ahorros de costos y velocidad, según el uso. Para obtener una introducción detallada, consulta la guía Almacenamiento en caché de contexto.

Método: cachedContents.create

Crea el recurso CachedContent.

Extremo

publicación https://generativelanguage.googleapis.com/v1beta/cachedContents

Cuerpo de la solicitud

El cuerpo de la solicitud contiene una instancia de CachedContent.

Campos
contents[] object (Content)

Opcional. Solo entrada. Inmutable. Es el contenido que se almacenará en caché.

tools[] object (Tool)

Opcional. Solo entrada. Inmutable. Una lista de Tools que el modelo puede usar para generar la siguiente respuesta

Campo de unión expiration. Especifica cuándo vencerá este recurso. Las direcciones (expiration) solo pueden ser una de las siguientes opciones:
expireTime string (Timestamp format)

Marca de tiempo en UTC del momento en que este recurso se consideró vencido. Esto siempre se proporciona en la salida, sin importar si se envió en la entrada.

Una marca de tiempo en formato RFC3339 UTC “Zulú”, con una resolución de nanosegundos y hasta nueve dígitos fraccionarios. Ejemplos: "2014-10-02T15:01:23Z" y "2014-10-02T15:01:23.045123456Z".

ttl string (Duration format)

Solo entrada. Nuevo TTL para este recurso, solo entrada.

Una duración en segundos con hasta nueve dígitos decimales, que terminan en “s”. Ejemplo: "3.5s".

name string

Opcional. Identificador. Es el nombre del recurso que hace referencia al contenido almacenado en caché. Formato: cachedContents/{id}

displayName string

Opcional. Inmutable. Es el nombre visible significativo generado por el usuario del contenido almacenado en caché. Máximo 128 caracteres Unicode.

model string

Obligatorio. Inmutable. Es el nombre del Model que se usará para el contenido almacenado en caché. Formato: models/{model}

systemInstruction object (Content)

Opcional. Solo entrada. Inmutable. Instrucción del sistema establecida por el desarrollador. Por el momento, solo se admite texto.

toolConfig object (ToolConfig)

Opcional. Solo entrada. Inmutable. Configuración de la herramienta Esta configuración se comparte para todas las herramientas.

Ejemplo de solicitud

Básico

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

Go

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

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

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

printResponse(resp)

Una caracola

wget https://storage.googleapis.com/generativeai-downloads/data/a11.txt
echo '{
  "model": "models/gemini-1.5-flash-001",
  "contents":[
    {
      "parts":[
        {
          "inline_data": {
            "mime_type":"text/plain",
            "data": "'$(base64 $B64FLAGS a11.txt)'"
          }
        }
      ],
    "role": "user"
    }
  ],
  "systemInstruction": {
    "parts": [
      {
        "text": "You are an expert at analyzing transcripts."
      }
    ]
  },
  "ttl": "300s"
}' > request.json

curl -X POST "https://generativelanguage.googleapis.com/v1beta/cachedContents?key=$GOOGLE_API_KEY" \
 -H 'Content-Type: application/json' \
 -d @request.json \
 > cache.json

CACHE_NAME=$(cat cache.json | grep '"name":' | cut -d '"' -f 4 | head -n 1)

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-001:generateContent?key=$GOOGLE_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
      "contents": [
        {
          "parts":[{
            "text": "Please summarize this transcript"
          }],
          "role": "user"
        },
      ],
      "cachedContent": "'$CACHE_NAME'"
    }'

Nombre del remitente

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

Go

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

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

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

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

printResponse(resp)

Desde el 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()}`);

Go

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

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

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

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

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

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

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

Cuerpo de la respuesta

Si el proceso se realiza de forma correcta, el cuerpo de la respuesta contiene una instancia recién creada de CachedContent.

Método: cacheContents.list

Enumera CachedContents.

Extremo

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

Parámetros de consulta

pageSize integer

Opcional. Es la cantidad máxima de contenido almacenado en caché que se mostrará. El servicio puede mostrar menos que este valor. Si no se especifica, se devolverá una cantidad de elementos predeterminada (inferior al máximo). El valor máximo es 1,000; valores superiores a 1,000 se convertirán en 1,000.

pageToken string

Opcional. Un token de página, recibido desde una llamada cachedContents.list anterior. Proporciona esto para recuperar la página siguiente.

Cuando se pagina, todos los demás parámetros proporcionados a cachedContents.list deben coincidir con la llamada que proporcionó el token de la página.

Cuerpo de la solicitud

El cuerpo de la solicitud debe estar vacío.

Cuerpo de la respuesta

Respuesta con la lista CachedContents.

Si se ejecuta correctamente, el cuerpo de la respuesta contendrá datos con la siguiente estructura:

Campos
cachedContents[] object (CachedContent)

Es una lista del contenido almacenado en caché.

nextPageToken string

Un token, que se puede enviar como pageToken para recuperar la página siguiente. Si se omite este campo, no habrá páginas siguientes.

Representación JSON
{
  "cachedContents": [
    {
      object (CachedContent)
    }
  ],
  "nextPageToken": string
}

Método: cachedContents.get

Lee el recurso CachedContent.

Extremo

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

Parámetros de ruta

name string

Obligatorio. Es el nombre del recurso que hace referencia a la entrada de caché de contenido. Formato: cachedContents/{id} Toma la forma cachedContents/{cachedcontent}.

Cuerpo de la solicitud

El cuerpo de la solicitud debe estar vacío.

Ejemplo de solicitud

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

Go

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

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

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

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

printResponse(resp)

Una caracola

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

Cuerpo de la respuesta

Si se ejecuta de forma correcta, el cuerpo de la respuesta contiene una instancia de CachedContent.

Método: cachedContents.patch

Actualiza el recurso CachedContent (solo se puede actualizar el vencimiento).

Extremo

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

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

Parámetros de ruta

cachedContent.name string

Opcional. Identificador. El nombre del recurso que hace referencia al contenido almacenado en caché. Formato: cachedContents/{id} Tiene el formato cachedContents/{cachedcontent}.

Parámetros de consulta

updateMask string (FieldMask format)

La lista de campos que se deben actualizar.

Esta es una lista separada por comas de los nombres de campos totalmente calificados. Ejemplo: "user.displayName,photo".

Cuerpo de la solicitud

El cuerpo de la solicitud contiene una instancia de CachedContent.

Campos
Campo de unión expiration. Especifica cuándo vencerá este recurso. Las direcciones (expiration) solo pueden ser una de las siguientes opciones:
expireTime string (Timestamp format)

Marca de tiempo en UTC del momento en que este recurso se consideró vencido. Esto siempre se proporciona en la salida, sin importar si se envió en la entrada.

Una marca de tiempo en formato RFC3339 UTC “Zulú”, con una resolución de nanosegundos y hasta nueve dígitos fraccionarios. Ejemplos: "2014-10-02T15:01:23Z" y "2014-10-02T15:01:23.045123456Z".

ttl string (Duration format)

Solo entrada. Nuevo TTL para este recurso, solo entrada.

Una duración en segundos con hasta nueve dígitos decimales, que terminan en “s”. Ejemplo: "3.5s".

name string

Opcional. Identificador. Es el nombre del recurso que hace referencia al contenido almacenado en caché. Formato: cachedContents/{id}

Ejemplo de solicitud

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

Go

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

Una caracola

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

Cuerpo de la respuesta

Si se ejecuta de forma correcta, el cuerpo de la respuesta contiene una instancia de CachedContent.

Método: cacheContents.delete

Borra el recurso CachedContent.

Extremo

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

Parámetros de ruta

name string

Obligatorio. El nombre del recurso que hace referencia a la entrada de la caché de contenido Formato: cachedContents/{id} Toma la forma cachedContents/{cachedcontent}.

Cuerpo de la solicitud

El cuerpo de la solicitud debe estar vacío.

Ejemplo de solicitud

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

Go

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

Una caracola

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

Cuerpo de la respuesta

Si se ejecuta correctamente, el cuerpo de la respuesta está vacío.

Recurso de REST: cachedContents

Recurso: CachedContent

Contenido procesado previamente que puede usarse en solicitudes posteriores a GenerativeService.

El contenido almacenado en caché solo se puede usar con el modelo para el que se creó.

Campos
contents[] object (Content)

Opcional. Solo entrada. Inmutable. Es el contenido que se almacenará en caché.

tools[] object (Tool)

Opcional. Solo entrada. Inmutable. Una lista de Tools que el modelo puede usar para generar la siguiente respuesta

createTime string (Timestamp format)

Solo salida. Es la hora de creación de la entrada de caché.

Una marca de tiempo en formato RFC3339 UTC “Zulú”, con una resolución de nanosegundos y hasta nueve dígitos fraccionarios. Ejemplos: "2014-10-02T15:01:23Z" y "2014-10-02T15:01:23.045123456Z".

updateTime string (Timestamp format)

Solo salida. Es la última vez que se actualizó la entrada de la caché en la hora UTC.

Una marca de tiempo en formato RFC3339 UTC “Zulú”, con una resolución de nanosegundos y hasta nueve dígitos fraccionarios. Ejemplos: "2014-10-02T15:01:23Z" y "2014-10-02T15:01:23.045123456Z".

usageMetadata object (UsageMetadata)

Solo salida. Metadatos sobre el uso del contenido almacenado en caché

Campo de unión expiration. Especifica cuándo vencerá este recurso. Las direcciones (expiration) solo pueden ser una de las siguientes opciones:
expireTime string (Timestamp format)

Marca de tiempo en UTC del momento en que este recurso se consideró vencido. Esto siempre se proporciona en la salida, sin importar si se envió en la entrada.

Una marca de tiempo en formato RFC3339 UTC “Zulú”, con una resolución de nanosegundos y hasta nueve dígitos fraccionarios. Ejemplos: "2014-10-02T15:01:23Z" y "2014-10-02T15:01:23.045123456Z".

ttl string (Duration format)

Solo entrada. Nuevo TTL para este recurso, solo entrada.

Una duración en segundos con hasta nueve dígitos decimales, que terminan en “s”. Ejemplo: "3.5s".

name string

Opcional. Identificador. Es el nombre del recurso que hace referencia al contenido almacenado en caché. Formato: cachedContents/{id}

displayName string

Opcional. Inmutable. Es el nombre visible significativo generado por el usuario del contenido almacenado en caché. Máximo 128 caracteres Unicode.

model string

Obligatorio. Inmutable. Es el nombre del Model que se usará para el contenido almacenado en caché. Formato: models/{model}

systemInstruction object (Content)

Opcional. Solo entrada. Inmutable. Instrucción del sistema establecida por el desarrollador. Por el momento, solo se admite texto.

toolConfig object (ToolConfig)

Opcional. Solo entrada. Inmutable. Configuración de la herramienta Esta configuración se comparte para todas las herramientas.

Representación 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)
  }
}

Contenido

El tipo de datos estructurados base que incluye contenido de varias partes de un mensaje.

Un Content incluye un campo role que designa al productor del Content y un campo parts que contiene datos de varias partes que contienen el contenido del turno del mensaje.

Campos
parts[] object (Part)

Se ordenaron Parts que constituyen un solo mensaje. Las partes pueden tener diferentes tipos de MIME.

role string

Opcional. Es el productor del contenido. Debe ser "user" o "model".

Es útil para configurar conversaciones de varios turnos. De lo contrario, se puede dejar en blanco o sin configurar.

Representación JSON
{
  "parts": [
    {
      object (Part)
    }
  ],
  "role": string
}

Pieza

Un tipo de datos que contiene elementos multimedia y que forma parte de un mensaje Content de varias partes.

Un Part consta de datos que tienen un tipo de datos asociado. Un Part solo puede contener uno de los tipos aceptados en Part.data.

Un Part debe tener un tipo de MIME de IANA fijo que identifique el tipo y el subtipo del contenido multimedia si el campo inlineData se llena con bytes sin procesar.

Campos

Campo de unión data.

data puede ser una de las siguientes opciones:

text string

Texto intercalado

inlineData object (Blob)

Bytes de contenido multimedia intercalados

functionCall object (FunctionCall)

Un FunctionCall predicho que muestra el modelo que contiene una cadena que representa el FunctionDeclaration.name con los argumentos y sus valores.

functionResponse object (FunctionResponse)

El resultado de una FunctionCall que contiene una cadena que representa el FunctionDeclaration.name y un objeto JSON estructurado que contiene cualquier resultado de la función se usa como contexto para el modelo.

fileData object (FileData)

Datos basados en URI.

executableCode object (ExecutableCode)

Es el código que genera el modelo y que se debe ejecutar.

codeExecutionResult object (CodeExecutionResult)

Es el resultado de ejecutar ExecutableCode.

Representación 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.
}

BLOB

Bytes de medios sin procesar.

El texto no se debe enviar como bytes sin procesar; utiliza el argumento "texto" .

Campos
mimeType string

Es el tipo de MIME estándar de IANA de los datos de origen. Ejemplos: - imagen/png - imagen/jpeg Si se proporciona un tipo de MIME no admitido, se mostrará un error. Para obtener una lista completa de los tipos admitidos, consulta Formatos de archivo compatibles.

data string (bytes format)

Bytes sin procesar para formatos multimedia.

String codificada en base64.

Representación JSON
{
  "mimeType": string,
  "data": string
}

FunctionCall

El modelo muestra un FunctionCall predicho que contiene una cadena que representa FunctionDeclaration.name con los argumentos y sus valores.

Campos
name string

Obligatorio. El nombre de la función a la que se llamará. Debe tener caracteres de la A a la Z (mayúsculas o minúsculas), o números del 0 al 9, o contener guiones bajos y guiones, con una longitud máxima de 63.

args object (Struct format)

Opcional. Los parámetros y valores de la función en formato de objeto JSON

Representación JSON
{
  "name": string,
  "args": {
    object
  }
}

FunctionResponse

El resultado de una FunctionCall que contiene una cadena que representa el FunctionDeclaration.name y un objeto JSON estructurado que contiene cualquier resultado de la función se usa como contexto para el modelo. Debe contener el resultado de un FunctionCall realizado en función de la predicción del modelo.

Campos
name string

Obligatorio. El nombre de la función a la que se llamará. Debe ser a-z, A-Z, del 0 al 9 o contener guiones bajos y guiones, con una longitud máxima de 63.

response object (Struct format)

Obligatorio. La respuesta de la función en formato de objeto JSON.

Representación JSON
{
  "name": string,
  "response": {
    object
  }
}

FileData

Datos basados en URI.

Campos
mimeType string

Opcional. Es el tipo de MIME estándar de IANA de los datos de origen.

fileUri string

Obligatorio. URI.

Representación JSON
{
  "mimeType": string,
  "fileUri": string
}

ExecutableCode

Es el código que genera el modelo y que se debe ejecutar, y el resultado que se muestra al modelo.

Solo se genera cuando se usa la herramienta CodeExecution, en la que el código se ejecutará automáticamente y también se generará el CodeExecutionResult correspondiente.

Campos
language enum (Language)

Obligatorio. Es el lenguaje de programación de code.

code string

Obligatorio. Es el código que se ejecutará.

Representación JSON
{
  "language": enum (Language),
  "code": string
}

Idioma

Lenguajes de programación admitidos para el código generado.

Enumeraciones
LANGUAGE_UNSPECIFIED Idioma no especificado. No se debe usar este valor.
PYTHON Python >= 3.10, con NumPy y Simpy disponibles.

CodeExecutionResult

Es el resultado de ejecutar ExecutableCode.

Solo se genera cuando se usa CodeExecution y siempre sigue a un part que contiene ExecutableCode.

Campos
outcome enum (Outcome)

Obligatorio. Resultado de la ejecución de código.

output string

Opcional. Contiene stdout cuando la ejecución del código es correcta, stderr o alguna otra descripción de lo contrario.

Representación JSON
{
  "outcome": enum (Outcome),
  "output": string
}

Resultado

Enumeración de los posibles resultados de la ejecución de código.

Enumeraciones
OUTCOME_UNSPECIFIED Estado sin especificar. No se debe usar este valor.
OUTCOME_OK La ejecución de código se completó correctamente.
OUTCOME_FAILED Se completó la ejecución del código, pero con un error. stderr debe contener el motivo.
OUTCOME_DEADLINE_EXCEEDED La ejecución del código se ejecutó demasiado tiempo y se canceló. Puede haber o no una salida parcial presente.

Herramienta

Detalles de la herramienta que el modelo puede usar para generar una respuesta.

Un Tool es un fragmento de código que permite que el sistema interactúe con sistemas externos para realizar una acción, o un conjunto de acciones, fuera del conocimiento y el alcance del modelo.

Campos
functionDeclarations[] object (FunctionDeclaration)

Opcional. Una lista de FunctionDeclarations disponible para el modelo que se puede usar en la llamada a función.

El modelo o el sistema no ejecutan la función. En su lugar, la función definida se puede mostrar como una FunctionCall con argumentos para la ejecución del cliente. El modelo puede decidir llamar a un subconjunto de estas funciones poblando FunctionCall en la respuesta. El siguiente turno de conversación puede contener un FunctionResponse con la "función" Content.role. generativo para el próximo turno del modelo.

codeExecution object (CodeExecution)

Opcional. Permite que el modelo ejecute código como parte de la generación.

Representación JSON
{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "codeExecution": {
    object (CodeExecution)
  }
}

FunctionDeclaration

Representación estructurada de una declaración de función según lo definido por la especificación de OpenAPI 3.03. En esta declaración, se incluyen el nombre y los parámetros de la función. Esta FunctionDeclaration es una representación de un bloque de código que el modelo puede usar como Tool y que el cliente puede ejecutar.

Campos
name string

Obligatorio. Es el nombre de la función. Debe tener caracteres de la A a la Z (mayúsculas o minúsculas), o números del 0 al 9, o contener guiones bajos y guiones, con una longitud máxima de 63.

description string

Obligatorio. Es una breve descripción de la función.

parameters object (Schema)

Opcional. Describe los parámetros de esta función. Refleja la clave de cadena del objeto de parámetros de la API abierta 3.03: el nombre del parámetro. Los nombres de los parámetros distinguen mayúsculas de minúsculas. Valor del esquema: Es el esquema que define el tipo que se usa para el parámetro.

Representación JSON
{
  "name": string,
  "description": string,
  "parameters": {
    object (Schema)
  }
}

Esquema

El objeto Schema permite definir los tipos de datos de entrada y salida. Estos tipos pueden ser objetos, pero también primitivos y arrays. Representa un subconjunto selecto de un objeto de esquema de OpenAPI 3.0.

Campos
type enum (Type)

Obligatorio. Tipo de datos.

format string

Opcional. El formato de los datos. Esto solo se usa para tipos de datos primitivos. Formatos compatibles: para el tipo de NUMBER: flotante, doble para el tipo INTEGER: int32, int64 para el tipo de STRING: enum

description string

Opcional. Una breve descripción del parámetro. Esto podría incluir ejemplos de uso. La descripción del parámetro puede tener el formato Markdown.

nullable boolean

Opcional. Indica si el valor puede ser nulo.

enum[] string

Opcional. Valores posibles del elemento de Type.STRING con el formato de enumeración. Por ejemplo, podemos definir una dirección enum de la siguiente manera : {type:STRING, format:enum, enum:["EAST", NORTH", "SOUTH", "WEST"]}

maxItems string (int64 format)

Opcional. Cantidad máxima de elementos para Type.ARRAY.

minItems string (int64 format)

Opcional. Es la cantidad mínima de elementos para Type.ARRAY.

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

Opcional. Propiedades de Type.OBJECT.

Es un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

required[] string

Opcional. Propiedades obligatorias de Type.OBJECT.

items object (Schema)

Opcional. Esquema de los elementos de Type.ARRAY.

Representación JSON
{
  "type": enum (Type),
  "format": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "maxItems": string,
  "minItems": string,
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "items": {
    object (Schema)
  }
}

Tipo

Type contiene la lista de tipos de datos de OpenAPI, como se define en https://spec.openapis.org/oas/v3.0.3#data-types.

Enumeraciones
TYPE_UNSPECIFIED No se especifica. No se debe usar.
STRING Tipo de cadena.
NUMBER Tipo de número.
INTEGER Es un tipo de número entero.
BOOLEAN Tipo booleano.
ARRAY Tipo de array.
OBJECT Tipo de objeto.

CodeExecution

Este tipo no tiene campos.

Es una herramienta que ejecuta el código generado por el modelo y muestra automáticamente el resultado al modelo.

Consulta también ExecutableCode y CodeExecutionResult, que solo se generan cuando se usa esta herramienta.

ToolConfig

La configuración de la herramienta que contiene parámetros para especificar el uso de Tool en la solicitud.

Campos
functionCallingConfig object (FunctionCallingConfig)

Opcional. Configuración de llamadas a función

Representación JSON
{
  "functionCallingConfig": {
    object (FunctionCallingConfig)
  }
}

FunctionCallingConfig

Configuración para especificar el comportamiento de la llamada a función.

Campos
mode enum (Mode)

Opcional. Especifica el modo en el que se debe ejecutar la llamada a función. Si no se especifica, el valor predeterminado será AUTO.

allowedFunctionNames[] string

Opcional. Un conjunto de nombres de funciones que, cuando se proporcionan, limita las funciones que llamará el modelo.

Esto solo debe configurarse cuando el Modo es ANY. Los nombres de las funciones deben coincidir con [FunctionDeclaration.name]. Con el modo establecido en CUALQUIERA, el modelo predecirá una llamada a función del conjunto de nombres de función proporcionados.

Representación JSON
{
  "mode": enum (Mode),
  "allowedFunctionNames": [
    string
  ]
}

Modo

Define el comportamiento de ejecución de la llamada a función con la definición del modo de ejecución.

Enumeraciones
MODE_UNSPECIFIED Modo de llamada a función no especificado. No se debe usar este valor.
AUTO Comportamiento predeterminado del modelo: el modelo decide predecir una llamada a función o una respuesta de lenguaje natural.
ANY El modelo está limitado para predecir siempre solo una llamada a función. Si se establece "allowedFunctionNames", la llamada a función prevista se limitará a cualquiera de "allowedFunctionNames"; de lo contrario, la llamada a función prevista será cualquiera de las "functionDeclarations" proporcionadas.
NONE El modelo no predecirá ninguna llamada a función. El comportamiento del modelo es el mismo que cuando no se pasan declaraciones de funciones.

UsageMetadata

Metadatos sobre el uso del contenido almacenado en caché

Campos
totalTokenCount integer

Cantidad total de tokens que consume el contenido almacenado en caché.

Representación JSON
{
  "totalTokenCount": integer
}