Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Ejecución de código

La función de ejecución de código de la API de Gemini permite que el modelo genere y ejecute código de Python y aprenda de forma iterativa a partir de los resultados hasta llegar a un resultado final. Puedes usar esta función de ejecución de código para crear aplicaciones que se beneficien del razonamiento basado en código y que produzcan resultados de texto. Por ejemplo, puedes usar la ejecución de código en una aplicación que resuelve ecuaciones o procesa texto.

La API de Gemini proporciona la ejecución de código como una herramienta, de forma similar a las llamadas a funciones. Después de que agregas la ejecución de código como herramienta, el modelo decide cuándo usarla.

El entorno de ejecución de código incluye las siguientes bibliotecas. No puedes instalar tus propias bibliotecas.

Modelos compatibles

Los siguientes modelos proporcionan compatibilidad para la ejecución de código:

Haz clic para expandir los modelos compatibles

Comienza a usar la ejecución de código

En esta sección, se supone que completaste los pasos de configuración que se muestran en Comienza a usar Gemini Enterprise Agent Platform.

Habilita la ejecución de código

Puedes habilitar el modelo para que use la ejecución de código agregándolo a la lista tools cuando configures el modelo:

Python

Instalar

pip install --upgrade google-genai

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

from google import genai
from google.genai.types import (
    GenerateContentConfig,
    HttpOptions,
    Tool,
    ToolCodeExecution,
)

client = genai.Client(http_options=HttpOptions(api_version="v1"))
model_id = "gemini-3.5-flash"

code_execution_tool = Tool(code_execution=ToolCodeExecution())
response = client.models.generate_content(
    model=model_id,
    contents="Calculate 20th fibonacci number. Then find the nearest palindrome to it.",
    config=GenerateContentConfig(
        tools=[code_execution_tool],
        temperature=0,
    ),
)
print("# Code:")
print(response.executable_code)
print("# Outcome:")
print(response.code_execution_result)

# Example response:
# # Code:
# def fibonacci(n):
#     if n <= 0:
#         return 0
#     elif n == 1:
#         return 1
#     else:
#         a, b = 0, 1
#         for _ in range(2, n + 1):
#             a, b = b, a + b
#         return b
#
# fib_20 = fibonacci(20)
# print(f'{fib_20=}')
#
# # Outcome:
# fib_20=6765

Go

Obtén información para instalar o actualizar el Go.

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

import (
	"context"
	"fmt"
	"io"

	genai "google.golang.org/genai"
)

// generateWithCodeExec shows how to generate text using the code execution tool.
func generateWithCodeExec(w io.Writer) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	prompt := "Calculate 20th fibonacci number. Then find the nearest palindrome to it."
	contents := []*genai.Content{
		{Parts: []*genai.Part{
			{Text: prompt},
		},
			Role: genai.RoleUser},
	}
	config := &genai.GenerateContentConfig{
		Tools: []*genai.Tool{
			{CodeExecution: &genai.ToolCodeExecution{}},
		},
		Temperature: genai.Ptr(float32(0.0)),
	}
	modelName := "gemini-2.5-flash"

	resp, err := client.Models.GenerateContent(ctx, modelName, contents, config)
	if err != nil {
		return fmt.Errorf("failed to generate content: %w", err)
	}

	for _, p := range resp.Candidates[0].Content.Parts {
		if p.Text != "" {
			fmt.Fprintf(w, "Gemini: %s", p.Text)
		}
		if p.ExecutableCode != nil {
			fmt.Fprintf(w, "Language: %s\n%s\n", p.ExecutableCode.Language, p.ExecutableCode.Code)
		}
		if p.CodeExecutionResult != nil {
			fmt.Fprintf(w, "Outcome: %s\n%s\n", p.CodeExecutionResult.Outcome, p.CodeExecutionResult.Output)
		}
	}

	// Example response:
	// Gemini: Okay, I can do that. First, I'll calculate the 20th Fibonacci number. Then, I need ...
	//
	// Language: PYTHON
	//
	// def fibonacci(n):
	//    ...
	//
	// fib_20 = fibonacci(20)
	// print(f'{fib_20=}')
	//
	// Outcome: OUTCOME_OK
	// fib_20=6765
	//
	// Now that I have the 20th Fibonacci number (6765), I need to find the nearest palindrome. ...
	// ...

	return nil
}

Node.js

Instalar

npm install @google/genai

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

const {GoogleGenAI} = require('@google/genai');

const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
const GOOGLE_CLOUD_LOCATION = process.env.GOOGLE_CLOUD_LOCATION || 'global';

async function generateAndExecuteCode(
  projectId = GOOGLE_CLOUD_PROJECT,
  location = GOOGLE_CLOUD_LOCATION
) {
  const client = new GoogleGenAI({
    vertexai: true,
    project: projectId,
    location: location,
  });

  const response = await client.models.generateContent({
    model: 'gemini-2.5-flash',
    contents:
      'Calculate 20th fibonacci number. Then find the nearest palindrome to it.',
    config: {
      tools: [{codeExecution: {}}],
      temperature: 0,
    },
  });

  console.debug(response.executableCode);

  // Example response:
  // Code:
  // function fibonacci(n) {
  //   if (n <= 0) {
  //     return 0;
  //   } else if (n === 1) {
  //     return 1;
  //   } else {
  //     let a = 0, b = 1;
  //     for (let i = 2; i <= n; i++) {
  //       [a, b] = [b, a + b];
  //     }
  //     return b;
  //   }
  // }
  //
  // const fib20 = fibonacci(20);
  // console.log(`fib20=${fib20}`);

  console.debug(response.codeExecutionResult);

  // Outcome:
  // fib20=6765

  return response.codeExecutionResult;
}

Java

Obtén información para instalar o actualizar el Java.

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True


import com.google.genai.Client;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.HttpOptions;
import com.google.genai.types.Tool;
import com.google.genai.types.ToolCodeExecution;

public class ToolsCodeExecWithText {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash";
    generateContent(modelId);
  }

  // Generates text using the Code Execution tool
  public static String generateContent(String modelId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("global")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1").build())
            .build()) {

      // Create a GenerateContentConfig and set codeExecution tool
      GenerateContentConfig contentConfig =
          GenerateContentConfig.builder()
              .tools(Tool.builder().codeExecution(ToolCodeExecution.builder().build()).build())
              .temperature(0.0F)
              .build();

      GenerateContentResponse response =
          client.models.generateContent(
              modelId,
              "Calculate 20th fibonacci number. Then find the nearest palindrome to it.",
              contentConfig);

      System.out.println("Code: \n" + response.executableCode());
      System.out.println("Outcome: \n" + response.codeExecutionResult());
      // Example response
      // Code:
      // def fibonacci(n):
      //    if n <= 0:
      //        return 0
      //    elif n == 1:
      //        return 1
      //    else:
      //        a, b = 1, 1
      //        for _ in range(2, n):
      //            a, b = b, a + b
      //        return b
      //
      // fib_20 = fibonacci(20)
      // print(f'{fib_20=}')
      //
      // Outcome:
      // fib_20=6765
      return response.executableCode();
    }
  }
}

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

GENERATE_RESPONSE_METHOD: El tipo de respuesta que quieres que genere el modelo. Elige un método que genere cómo quieres que se muestre la respuesta del modelo:
- streamGenerateContent: La respuesta se transmite a medida que se genera para reducir la percepción de latencia para un público humano.
- generateContent: La respuesta se muestra después de que se genera por completo.
LOCATION: La región para procesar la solicitud.
PROJECT_ID: Es el ID del proyecto. .
MODEL_ID: Es el ID del modelo que deseas usar.
ROLE: el rol en una conversación asociada con el contenido. Especificar un rol es obligatorio incluso en casos de uso de un solo turno. Los valores aceptables son los siguientes:
- USER: especifica el contenido que envías.
- MODEL: especifica la respuesta del modelo.
```
TEXT
```
Las instrucciones de texto que se incluirán en el mensaje.

Para enviar tu solicitud, elige una de estas opciones:

curl

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual:

cat > request.json << 'EOF'
{
  "tools": [{'codeExecution': {}}],
  "contents": {
    "role": "ROLE",
    "parts": { "text": "TEXT" }
  },
}
EOF

Luego, ejecuta el siguiente comando para enviar tu solicitud de REST:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD"

PowerShell

Nota: En el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual:

@'
{
  "tools": [{'codeExecution': {}}],
  "contents": {
    "role": "ROLE",
    "parts": { "text": "TEXT" }
  },
}
'@  | Out-File -FilePath request.json -Encoding utf8

Luego, ejecuta el siguiente comando para enviar tu solicitud de REST:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

Respuesta

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": "Okay, I understand. You want me to calculate the sum of the first 10 positive integers and to use code to do so. Here's my plan: I will use a loop to add the numbers from 1 to 10 and then return the final sum.\n\n"
          },
          {
            "executableCode": {
              "language": "PYTHON",
              "code": "\ntotal = 0\nfor i in range(1, 11):\n    total += i\nprint(f'{total=}')\n"
            }
          },
          {
            "codeExecutionResult": {
              "outcome": "OUTCOME_OK",
              "output": "total=55\n"
            }
          },
          {
            "text": "The sum of the first 10 positive numbers is 55.\n"
          }
        ]
      },
      "finishReason": "STOP",
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.19436789,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.17441037
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.0685376,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.14903527
        },
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.23231025,
          "severity": "HARM_SEVERITY_LOW",
          "severityScore": 0.2436427
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.08269742,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.10818888
        }
      ],
      "score": -0.50845032930374146,
      "avgLogprobs": -0.0046222757209431042
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 34,
    "candidatesTokenCount": 110,
    "totalTokenCount": 144,
    "billablePromptUsage": {
      "textCount": 119
    },
    "trafficType": "ON_DEMAND"
  },
  "modelVersion": "gemini-2.0-flash-001",
  "createTime": "2024-12-09T23:33:47.842964Z",
  "responseId": "W35XZ9S5M6acmecP3vDFkQU"
}

Usa la ejecución de código en el chat

También puedes usar la ejecución de código como parte de un chat.

REST

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://aiplatform.googleapis.com/v1/projects/test-project/locations/global/publishers/google/models/gemini-3.5-flash:generateContent -d \
$'{
    "tools": [{'code_execution': {}}],
    "contents": [
      {
        "role": "user",
        "parts": {
          "text": "Can you print \"Hello world!\"?"
        }
      },
      {
        "role": "model",
        "parts": [
          {
            "text": ""
          },
          {
            "executable_code": {
              "language": "PYTHON",
              "code": "\nprint(\"hello world!\")\n"
            }
          },
          {
            "code_execution_result": {
              "outcome": "OUTCOME_OK",
              "output": "hello world!\n"
            }
          },
          {
            "text": "I have printed \"hello world!\" using the provided python code block. \n"
          }
        ],
      },
      {
        "role": "user",
        "parts": {
          "text": "What is the sum of the first 50 prime numbers? Generate and run code for the calculation, and make sure you get all 50."
        }
      }
    ]
  }'

(Solo para Gemini 3 Flash) Usa la ejecución de código con imágenes

Gemini 3 Flash puede escribir y ejecutar código de Python para manipular e inspeccionar imágenes de forma activa. Puedes usar la ejecución de código con imágenes para lo siguiente:

Acerca e inspecciona imágenes: Detecta cuando los detalles son demasiado pequeños (como leer un medidor que está lejos de la cámara) y escribe código para recortar y volver a examinar el área con una resolución más alta.

Nota: El modelo escribe automáticamente código para acercar los detalles pequeños. Sin embargo, para otras tareas, debes indicarle de forma explícita al modelo que escriba código. Por ejemplo, usa instrucciones como "escribe código para contar la cantidad de engranajes" o "rota esta imagen para que quede en posición vertical".
Matemáticas visuales: Ejecuta cálculos de varios pasos con código (como sumar conceptos en un recibo).
Anotación de imágenes: Anota imágenes para responder preguntas, como dibujar flechas entre objetos para mostrar relaciones.

Para usar la ejecución de código con imágenes, habilita la ejecución de código cuando configures el modelo y envía una instrucción con una imagen para que el modelo la inspeccione:

Python

# Example input image
image_path = "https://storage.googleapis.com/cloud-samples-data/generative-ai/image/chips.jpeg"
image_bytes = requests.get(image_path).content
image = types.Part.from_bytes(
  data=image_bytes, mime_type="image/jpeg"
)

response = client.models.generate_content(
    model=MODEL_ID,
    contents=[image, "Locate the ESMT chip. What are the numbers on the chip?"],
    config=types.GenerateContentConfig(
        tools=[types.Tool(code_execution=types.ToolCodeExecution)]
    ),
)

Ejecución de código frente a llamada a funciones

La ejecución de código y la llamada a funciones son funciones similares:

La ejecución de código permite que el modelo ejecute código en el backend de la API en un entorno fijo y aislado.
La llamada a funciones te permite ejecutar las funciones que solicita el modelo en cualquier entorno que desees.

En general, deberías preferir usar la ejecución de código si puede controlar tu caso de uso. La ejecución de código es más sencilla de usar (solo tienes que habilitarla) y se resuelve en una sola solicitud GenerateContent. La llamada a funciones requiere una solicitud GenerateContent adicional para devolver el resultado de cada llamada a función.

En la mayoría de los casos, debes usar la llamada a funciones si tienes tus propias funciones que quieres ejecutar de forma local, y debes usar la ejecución de código si quieres que la API escriba y ejecute código de Python por ti y devuelva el resultado.

Facturación

No se aplican cargos adicionales por habilitar la ejecución de código desde la API de Gemini. Se te facturará según la tarifa actual de los tokens de entrada y salida, según el modelo de Gemini que uses.

Aquí tienes algunos datos más sobre la facturación de la ejecución de código:

Solo se te facturará una vez por los tokens de entrada que pases al modelo y los tokens de entrada intermedios que genere el uso de la herramienta de ejecución de código.
Se te facturan los tokens de salida finales que se te devuelven en la respuesta de la API.

Diagrama del flujo de facturación para el uso de la herramienta de ejecución de código, como se describe en el
texto que aparece a continuación.

Se te facturará según la tarifa actual de los tokens de entrada y salida según el modelo de Gemini que uses.
Si Gemini usa la ejecución de código cuando genera tu respuesta, la instrucción original, el código generado y el resultado del código ejecutado se etiquetan como tokens intermedios y se facturan como tokens de entrada.
Luego, Gemini genera un resumen y devuelve el código generado, el resultado del código ejecutado y el resumen final. Estos se facturan como tokens de salida.
La API de Gemini incluye un recuento de tokens intermedios en la respuesta de la API, por lo que puedes hacer un seguimiento de los tokens de entrada adicionales más allá de los que se pasaron en tu instrucción inicial.

El código generado puede incluir salidas de texto y multimodales, como imágenes.

Limitaciones

El modelo solo puede generar y ejecutar código. No puede devolver otros artefactos, como archivos multimedia.
La herramienta de ejecución de código no admite URIs de archivos como entrada o salida. Sin embargo, la herramienta de ejecución de código admite la entrada de archivos y la salida de gráficos como bytes intercalados. Con estas funciones de entrada y salida, puedes subir archivos CSV y de texto, hacer preguntas sobre los archivos y generar gráficos de Matplotlib como parte del resultado de la ejecución de código. Los tipos de MIME admitidos para los bytes intercalados son .cpp, .csv, .java, .jpeg, .js, .png, .py, .ts y .xml.
La ejecución de código puede durar un máximo de 30 segundos antes de que se agote el tiempo de espera.
En algunos casos, habilitar la ejecución de código puede generar regresiones en otras áreas del resultado del modelo (por ejemplo, escribir una historia).

Prácticas recomendadas y advertencias

Sigue estas prácticas recomendadas y lineamientos cuando uses la ejecución de código:

Directivas de ejecución explícitas: Los modelos de lenguaje grandes pueden usar el razonamiento lingüístico de forma predeterminada, a menos que indiques lo contrario. Cuando proporciones instrucciones de ejecución de código, usa directivas explícitas (por ejemplo, "SIEMPRE ejecuta la secuencia de comandos" o "NO calcules directamente").
Aislamiento de red: La zona de pruebas de ejecución de código no tiene acceso público a Internet. Las secuencias de comandos no pueden realizar solicitudes HTTP externas ni descargar recursos externos.
Ejecución sin estado: Cada ejecución se realiza en un contenedor efímero. Los archivos creados o modificados durante un turno no persisten en los turnos o las sesiones posteriores.
Dependencias: Solo están disponibles las bibliotecas estándar de Python y los paquetes de manipulación de datos preinstalados (como numpy o pandas). El entorno no admite instalaciones dinámicas de paquetes de entorno de ejecución (como pip install).
E/S estándar: Escribe secuencias de comandos que acepten entradas de argumentos de línea de comandos (sys.argv) o de entrada estándar (sys.stdin), y que impriman el resultado directamente en la salida estándar (sys.stdout).

Ejecución de código Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Modelos compatibles

Haz clic para expandir los modelos compatibles

Comienza a usar la ejecución de código

Habilita la ejecución de código

Python

Instalar

Go

Node.js

Instalar

Java

REST

curl

PowerShell

Respuesta

Usa la ejecución de código en el chat

REST

(Solo para Gemini 3 Flash) Usa la ejecución de código con imágenes

Python

Ejecución de código frente a llamada a funciones

Facturación

Limitaciones

Prácticas recomendadas y advertencias

Ejecución de código