Using files

La API de Gemini admite la carga de archivos multimedia por separado de la entrada de la instrucción, lo que permite que tus archivos multimedia se reutilicen en varias solicitudes y varias instrucciones. Para obtener más detalles, consulta la guía Cómo generar instrucciones con contenido multimedia.

Método: media.upload

Sube datos a un ragStore, los preprocesa y los divide en fragmentos antes de almacenarlos en un documento de RagStore.

Extremo

  • URI de carga para las solicitudes de carga de medios:
post https://generativelanguage.googleapis.com/upload/v1beta/{ragStoreName=ragStores/*}:uploadToRagStore
  • URI de metadatos para las solicitudes de metadatos únicamente:
post https://generativelanguage.googleapis.com/v1beta/{ragStoreName=ragStores/*}:uploadToRagStore

Parámetros de ruta

ragStoreName string

Obligatorio. Inmutable. Nombre del RagStore en el que se subirá el archivo. Ejemplo: ragStores/my-rag-store-123 Toma la forma ragStores/{ragstore}.

Cuerpo de la solicitud

El cuerpo de la solicitud contiene datos con la siguiente estructura:

Campos
displayName string

Opcional. Es el nombre visible del documento creado.

customMetadata[] object (CustomMetadata)

Son los metadatos personalizados que se asociarán con los datos.

chunkingConfig object (ChunkingConfig)

Opcional. Es la configuración para indicarle al servicio cómo dividir los datos en fragmentos. Si no se proporcionan, el servicio usará parámetros predeterminados.

mimeType string

Opcional. Tipo de MIME de los datos. Si no se proporciona, se inferirá del contenido subido.

Cuerpo de la respuesta

Es una copia de google.longrunning.Operation. Debemos copiarlo porque, para interactuar con Scotty, necesitamos agregar un campo específico de Scotty que no se puede agregar en el proto de Operation de nivel superior.

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

Campos
name string

El nombre asignado por el servidor, que solo es único dentro del mismo servicio que originalmente lo muestra. Si usas la asignación HTTP predeterminada, el name debe ser un nombre de recurso que termine con operations/{unique_id}.

metadata object

Metadatos específicos del servicio asociados con la operación. Por lo general, contiene información de progreso y metadatos comunes, como la fecha de creación. Puede que algunos servicios no proporcionen estos metadatos. Cualquier método que muestra una operación de larga duración debe documentar el tipo de metadatos, si corresponde.

Un objeto que contiene campos de un tipo arbitrario. Un campo adicional "@type" contiene una URI que identifica el tipo. Ejemplo: { "id": 1234, "@type": "types.example.com/standard/id" }.

done boolean

Si el valor es false, significa que la operación aún está en progreso. Si es true, la operación está completa, y error o response están disponibles.

result Union type
El resultado de la operación, que puede ser un error o una response válida. Si done == false, no se establecen error ni response. Si done == true, se puede establecer error o response. Es posible que algunos servicios no proporcionen el resultado. result puede ser uno de los siguientes:
error object (Status)

El resultado de error de la operación en caso de falla o cancelación.

response object

La respuesta normal y correcta de la operación. Si el método original no muestra datos en caso de éxito, como Delete, la respuesta es google.protobuf.Empty. Si el método original es Get, Create o Update estándar, la respuesta debe ser el recurso. Para otros métodos, la respuesta debe tener el tipo XxxResponse, en la que Xxx es el nombre del método original. Por ejemplo, si el nombre del método original es TakeSnapshot(), el tipo de respuesta inferido es TakeSnapshotResponse.

Un objeto que contiene campos de un tipo arbitrario. Un campo adicional "@type" contiene una URI que identifica el tipo. Ejemplo: { "id": 1234, "@type": "types.example.com/standard/id" }.

Representación JSON
{
  "name": string,
  "metadata": {
    "@type": string,
    field1: ...,
    ...
  },
  "done": boolean,

  // result
  "error": {
    object (Status)
  },
  "response": {
    "@type": string,
    field1: ...,
    ...
  }
  // Union type
}

ChunkingConfig

Son parámetros para indicarle al servicio cómo dividir el archivo en fragmentos. Se inspiran en google3/cloud/ai/platform/extension/lib/retrieval/config/chunker_config.proto.

Campos
config Union type
Es la configuración de fragmentación que se usará. config puede ser una de las siguientes opciones:
whiteSpaceConfig object (WhiteSpaceConfig)

Es la configuración de división en fragmentos de espacios en blanco.

Representación JSON
{

  // config
  "whiteSpaceConfig": {
    object (WhiteSpaceConfig)
  }
  // Union type
}

WhiteSpaceConfig

Es la configuración de un algoritmo de fragmentación de espacios en blanco [delimitado por espacios en blanco].

Campos
maxTokensPerChunk integer

Es la cantidad máxima de tokens por fragmento. En este algoritmo de fragmentación, los tokens se definen como palabras. Nota: Definimos los tokens como palabras divididas por espacios en blanco, a diferencia del resultado de un tokenizador. Actualmente, la ventana de contexto del modelo de incorporación de Gemini más reciente (a partir del 17/4/2025) es de 8,192 tokens. Suponemos que la palabra promedio tiene 5 caracteres. Por lo tanto, establecemos el límite superior en 2**9, que son 512 palabras o 2,560 tokens, suponiendo que, en el peor de los casos, haya un carácter por token. Esta es una estimación conservadora que tiene como objetivo evitar el desbordamiento de la ventana de contexto.

maxOverlapTokens integer

Es la cantidad máxima de tokens superpuestos entre dos fragmentos adyacentes.

Representación JSON
{
  "maxTokensPerChunk": integer,
  "maxOverlapTokens": integer
}

Método: files.get

Obtiene los metadatos del File especificado.

Extremo

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

Parámetros de ruta

name string

Obligatorio. Es el nombre del File que se obtendrá. Ejemplo: files/abc-123 Toma la forma files/{file}.

Cuerpo de la solicitud

El cuerpo de la solicitud debe estar vacío.

Ejemplo de solicitud

Python

from google import genai

client = genai.Client()
myfile = client.files.upload(file=media / "poem.txt")
file_name = myfile.name
print(file_name)  # "files/*"

myfile = client.files.get(name=file_name)
print(myfile)

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const myfile = await ai.files.upload({
  file: path.join(media, "poem.txt"),
});
const fileName = myfile.name;
console.log(fileName);

const fetchedFile = await ai.files.get({ name: fileName });
console.log(fetchedFile);

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
myfile, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "poem.txt"), 
	&genai.UploadFileConfig{
		MIMEType: "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
fileName := myfile.Name
fmt.Println(fileName)
file, err := client.Files.Get(ctx, fileName, nil)
if err != nil {
	log.Fatal(err)
}
fmt.Println(file)

Almeja

name=$(jq ".file.name" file_info.json)
# Get the file of interest to check state
curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json
# Print some information about the file you got
name=$(jq ".file.name" file_info.json)
echo name=$name
file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

Cuerpo de la respuesta

Si se ejecuta de forma correcta, el cuerpo de la respuesta incluye una instancia de File.

Método: files.list

Enumera los metadatos de los File que pertenecen al proyecto solicitante.

Extremo

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

Parámetros de consulta

pageSize integer

Opcional. Es la cantidad máxima de Files que se devolverán por página. Si no se especifica, el valor predeterminado es 10. El valor máximo de pageSize es 100.

pageToken string

Opcional. Es un token de página de una llamada a files.list anterior.

Cuerpo de la solicitud

El cuerpo de la solicitud debe estar vacío.

Ejemplo de solicitud

Python

from google import genai

client = genai.Client()
print("My files:")
for f in client.files.list():
    print("  ", f.name)

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
console.log("My files:");
// Using the pager style to list files
const pager = await ai.files.list({ config: { pageSize: 10 } });
let page = pager.page;
const names = [];
while (true) {
  for (const f of page) {
    console.log("  ", f.name);
    names.push(f.name);
  }
  if (!pager.hasNextPage()) break;
  page = await pager.nextPage();
}

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
fmt.Println("My files:")
page, err := client.Files.List(ctx, nil)
if err != nil {
	log.Fatal(err)
}
for _, f := range page.Items {
	fmt.Println("  ", f.Name)
}

Almeja

echo "My files: "

curl "https://generativelanguage.googleapis.com/v1beta/files?key=$GEMINI_API_KEY"

Cuerpo de la respuesta

La respuesta para files.list.

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

Campos
files[] object (File)

Es la lista de Files.

nextPageToken string

Es un token que se puede enviar como pageToken en una llamada files.list posterior.

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

Método: files.delete

Borra el File.

Extremo

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

Parámetros de ruta

name string

Obligatorio. El nombre de la File que se borrará. Ejemplo: files/abc-123 Toma la forma files/{file}.

Cuerpo de la solicitud

El cuerpo de la solicitud debe estar vacío.

Ejemplo de solicitud

Python

from google import genai

client = genai.Client()
myfile = client.files.upload(file=media / "poem.txt")

client.files.delete(name=myfile.name)

try:
    result = client.models.generate_content(
        model="gemini-2.0-flash", contents=[myfile, "Describe this file."]
    )
    print(result)
except genai.errors.ClientError:
    pass

Node.js

// The Gen AI SDK for TypeScript and JavaScript is in preview.
// Some features have not been implemented.

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
myfile, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "poem.txt"), 
	&genai.UploadFileConfig{
		MIMEType: "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
// Delete the file.
_, err = client.Files.Delete(ctx, myfile.Name, nil)
if err != nil {
	log.Fatal(err)
}
// Attempt to use the deleted file.
parts := []*genai.Part{
	genai.NewPartFromURI(myfile.URI, myfile.MIMEType,),
	genai.NewPartFromText("Describe this file."),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

_, err = client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
// Expect an error when using a deleted file.
if err != nil {
	return nil
}
return fmt.Errorf("expected an error when using deleted file")

Almeja

curl --request "DELETE" https://generativelanguage.googleapis.com/v1beta/files/$name?key=$GEMINI_API_KEY

Cuerpo de la respuesta

Si se ejecuta correctamente, el cuerpo de la respuesta es un objeto JSON vacío.

Recurso de REST: files

Recurso: File

Es un archivo que se subió a la API. ID siguiente: 15

Campos
name string

Inmutable. Es el identificador. Nombre del recurso de File. El ID (nombre sin el prefijo "files/") puede contener hasta 40 caracteres alfanuméricos en minúscula o guiones (-). El ID no puede comenzar ni terminar con un guion. Si el nombre está vacío en la creación, se generará un nombre único. Ejemplo: files/123-456

displayName string

Opcional. Es el nombre visible legible por humanos para File. El nombre visible no debe tener más de 512 caracteres, incluidos los espacios. Ejemplo: "Imagen de bienvenida"

mimeType string

Solo salida. Tipo MIME del archivo.

sizeBytes string (int64 format)

Solo salida. Tamaño del archivo en bytes.

createTime string (Timestamp format)

Solo salida. Es la marca de tiempo de cuándo se creó el objeto File.

Usa el formato RFC 3339, en el que el resultado generado siempre estará normalizada a Z y usa 0, 3, 6 o 9 dígitos fraccionarios. También se aceptan otras compensaciones que no sean “Z”. Ejemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" o "2014-10-02T15:01:23+05:30".

updateTime string (Timestamp format)

Solo salida. Es la marca de tiempo de la última actualización de File.

Usa el formato RFC 3339, en el que el resultado generado siempre estará normalizada a Z y usa 0, 3, 6 o 9 dígitos fraccionarios. También se aceptan otras compensaciones que no sean “Z”. Ejemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" o "2014-10-02T15:01:23+05:30".

expirationTime string (Timestamp format)

Solo salida. Es la marca de tiempo del momento en que se borrará el File. Solo se establece si se programó el vencimiento de File.

Usa el formato RFC 3339, en el que el resultado generado siempre estará normalizada a Z y usa 0, 3, 6 o 9 dígitos fraccionarios. También se aceptan otras compensaciones que no sean “Z”. Ejemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" o "2014-10-02T15:01:23+05:30".

sha256Hash string (bytes format)

Solo salida. Es el hash SHA-256 de los bytes subidos.

String codificada en base64.

uri string

Solo salida. Es el URI del File.

downloadUri string

Solo salida. Es el URI de descarga del File.

state enum (State)

Solo salida. Es el estado de procesamiento del archivo.

source enum (Source)

Es la fuente del archivo.

error object (Status)

Solo salida. Es el estado de error si falló el procesamiento del archivo.

metadata Union type
Son los metadatos del archivo. metadata puede ser una de las siguientes opciones:
videoMetadata object (VideoFileMetadata)

Solo salida. Son los metadatos de un video.

Representación JSON
{
  "name": string,
  "displayName": string,
  "mimeType": string,
  "sizeBytes": string,
  "createTime": string,
  "updateTime": string,
  "expirationTime": string,
  "sha256Hash": string,
  "uri": string,
  "downloadUri": string,
  "state": enum (State),
  "source": enum (Source),
  "error": {
    object (Status)
  },

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

VideoFileMetadata

Son los metadatos de un video File.

Campos
videoDuration string (Duration format)

Es la duración del video.

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

Representación JSON
{
  "videoDuration": string
}

Estado

Estados del ciclo de vida de un archivo.

Enums
STATE_UNSPECIFIED Es el valor predeterminado. Este valor se usa si se omite el estado.
PROCESSING El archivo se está procesando y aún no se puede usar para la inferencia.
ACTIVE El archivo se procesó y está disponible para la inferencia.
FAILED Se produjo un error durante el procesamiento del archivo.

Fuente

Enums
SOURCE_UNSPECIFIED Se usa si no se especifica la fuente.
UPLOADED Indica que el usuario subió el archivo.
GENERATED Indica que Google generó el archivo.
REGISTERED Indica que el archivo está registrado, es decir, que es un archivo de Google Cloud Storage.

Estado

El tipo de Status define un modelo de error lógico que es adecuado para entornos de programación diferentes, incluidas las API de REST y las API de RPC. Lo usa gRPC. Cada mensaje Status contiene tres datos: código de error, mensaje de error y detalles del error.

Puedes obtener más información sobre este modelo de error y cómo trabajar con él en la guía de diseño de API.

Campos
code integer

El código de estado, que debe ser un valor enum de google.rpc.Code.

message string

Un mensaje de error dirigido al desarrollador, que debe estar en inglés. Cualquier mensaje de error dirigido al usuario debe localizarse y enviarse al campo google.rpc.Status.details; o el cliente debe localizarlo.

details[] object

Una lista de mensajes que contienen los detalles del error. Hay un conjunto común de tipos de mensajes para que usen las API.

Un objeto que contiene campos de un tipo arbitrario. Un campo adicional "@type" contiene una URI que identifica el tipo. Ejemplo: { "id": 1234, "@type": "types.example.com/standard/id" }.

Representación JSON
{
  "code": integer,
  "message": string,
  "details": [
    {
      "@type": string,
      field1: ...,
      ...
    }
  ]
}