Caching

Método: cacheContents.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.

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

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

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

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

Muestra una lista de CachedContents.

Extremo

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

Parámetros de consulta

pageSize integer

Opcional. 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)

Lista de 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: cacheContents.get

Lee el recurso CachedContent.

Extremo

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

Cuerpo de la respuesta

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

Método: cacheContents.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} Toma la forma 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.

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

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

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

Cuerpo de la respuesta

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

Recurso de REST: cacheContents

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ó.

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)
  }
}
Campos
contents[] object (Content)

Opcional. Solo entrada. Inmutable. 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. 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. La fecha en que la entrada de caché se actualizó por última vez 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 vence 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. El nombre del recurso que hace referencia al contenido almacenado en caché. Formato: cachedContents/{id}

displayName string

Opcional. Inmutable. Es el nombre visible significativo que genera el usuario del contenido almacenado en caché. Se admiten hasta 128 caracteres Unicode.

model string

Obligatorio. Inmutable. El nombre de 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. Actualmente, solo texto.

toolConfig object (ToolConfig)

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

Contenido

Es 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 de Content y un campo parts que contiene datos de varias partes con el contenido del turno del mensaje.

Representación JSON 
{
  "parts": [
    {
      object (Part)
    }
  ],
  "role": string
}
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 "modelo".

Es útil para establecer conversaciones de varios turnos. De lo contrario, puedes dejarlas en blanco o no establecerse.

Pieza

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

Una Part consiste en 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.

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.
}
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)

El modelo muestra un FunctionCall predicho que contiene una cadena que representa 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 que debe ejecutarse.

codeExecutionResult object (CodeExecutionResult)

Resultado de la ejecución de ExecutableCode

BLOB

Bytes de medios sin procesar.

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

Representación JSON 
{
  "mimeType": string,
  "data": string
}
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 admitidos.

data string (bytes format)

Bytes sin procesar para formatos multimedia.

String codificada en base64.

FunctionCall

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

Representación JSON 
{
  "name": string,
  "args": {
    object
  }
}
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.

args object (Struct format)

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

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.

Representación JSON 
{
  "name": string,
  "response": {
    object
  }
}
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.

FileData

Datos basados en URI.

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

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

fileUri string

Obligatorio. URI

ExecutableCode

El código que genera el modelo que debe ejecutarse 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.

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

Obligatorio. Lenguaje de programación de code.

code string

Obligatorio. El código que se ejecutará.

Idioma

Lenguajes de programación compatibles con 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

Resultado de la ejecución de ExecutableCode

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

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

Obligatorio. Resultado de la ejecución del 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.

Resultado

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

Enumeraciones
OUTCOME_UNSPECIFIED Estado sin especificar. No se debe usar este valor.
OUTCOME_OK La ejecución del 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.

Representación JSON 
{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "codeExecution": {
    object (CodeExecution)
  }
}
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 sistema no ejecuta la función. En su lugar, la función definida se puede mostrar como una [FunctionCall][content.part.function_call] con argumentos para la ejecución del cliente. El modelo puede decidir llamar a un subconjunto de estas funciones propagando [FunctionCall][content.part.function_call] en la respuesta. El próximo turno de conversación puede contener una [FunctionResponse][content.part.function_response] con la “función” [content.role]. más contexto de generación para el próximo turno del modelo.

codeExecution object (CodeExecution)

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

FunctionDeclaration

Representación estructurada de una declaración de función como se define en 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.

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

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

description string

Obligatorio. 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ámetro de Open API 3.03: el nombre del parámetro. Los nombres de parámetros distinguen mayúsculas de minúsculas. Valor de esquema: el esquema que define el tipo que se usa para el parámetro.

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 seleccionado de un objeto de esquema de OpenAPI 3.0.

Representación JSON 
{
  "type": enum (Type),
  "format": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "items": {
    object (Schema)
  }
}
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"]}

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.

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 especificado, no debe usarse.
STRING Tipo de cadena.
NUMBER Tipo de número.
INTEGER 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 le muestra el resultado automáticamente.

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.

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

Opcional. Configuración de llamada a función.

FunctionCallingConfig

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

Representación JSON 
{
  "mode": enum (Mode),
  "allowedFunctionNames": [
    string
  ]
}
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 configurado en ANY, el modelo predecirá una llamada a función a partir del conjunto de nombres de función proporcionado.

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 En el 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 es "allowedFunctionNames" , la llamada a función predicha se limitará a cualquiera de las “allowedFunctionNames”, de lo contrario, será cualquiera de las “functionDeclarations”.
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é.

Representación JSON 
{
  "totalTokenCount": integer
}
Campos
totalTokenCount integer

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