Ejecución de código

La API de Gemini proporciona una herramienta de ejecución de código que permite que el modelo genere y ejecute código de Python. Luego, el modelo puede aprender de forma iterativa a partir de los resultados de la ejecución del código hasta llegar a un resultado final. Puedes usar la ejecución de código para crear aplicaciones que se beneficien del razonamiento basado en código. Por ejemplo, puedes usar la ejecución de código para resolver ecuaciones o procesar texto. También puedes usar las bibliotecas incluidas en el entorno de ejecución de código para realizar tareas más especializadas.

Gemini solo puede ejecutar código en Python. Aun así, puedes pedirle a Gemini que genere código en otro idioma, pero el modelo no podrá usar la herramienta de ejecución de código para ejecutarlo.

Habilitar la ejecución de código

Para habilitar la ejecución de código, configura la herramienta de ejecución de código en el modelo. Esto permite que el modelo genere y ejecute código.

Python

from google import genai from google.genai import types  client = genai.Client()  response = client.models.generate_content(     model="gemini-2.5-flash",     contents="What is the sum of the first 50 prime numbers? "     "Generate and run code for the calculation, and make sure you get all 50.",     config=types.GenerateContentConfig(         tools=[types.Tool(code_execution=types.ToolCodeExecution)]     ), )  for part in response.candidates[0].content.parts:     if part.text is not None:         print(part.text)     if part.executable_code is not None:         print(part.executable_code.code)     if part.code_execution_result is not None:         print(part.code_execution_result.output)

JavaScript

import { GoogleGenAI } from "@google/genai";  const ai = new GoogleGenAI({});  let response = await ai.models.generateContent({   model: "gemini-2.5-flash",   contents: [     "What is the sum of the first 50 prime numbers? " +       "Generate and run code for the calculation, and make sure you get all 50.",   ],   config: {     tools: [{ codeExecution: {} }],   }, });  const parts = response?.candidates?.[0]?.content?.parts || []; parts.forEach((part) => {   if (part.text) {     console.log(part.text);   }    if (part.executableCode && part.executableCode.code) {     console.log(part.executableCode.code);   }    if (part.codeExecutionResult && part.codeExecutionResult.output) {     console.log(part.codeExecutionResult.output);   } });

Go

package main  import (     "context"     "fmt"     "os"     "google.golang.org/genai" )  func main() {      ctx := context.Background()     client, err := genai.NewClient(ctx, nil)     if err != nil {         log.Fatal(err)     }      config := &genai.GenerateContentConfig{         Tools: []*genai.Tool{             {CodeExecution: &genai.ToolCodeExecution{}},         },     }      result, _ := client.Models.GenerateContent(         ctx,         "gemini-2.5-flash",         genai.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."),         config,     )      fmt.Println(result.Text())     fmt.Println(result.ExecutableCode())     fmt.Println(result.CodeExecutionResult()) }

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent" \ -H "x-goog-api-key: $GEMINI_API_KEY" \ -H 'Content-Type: application/json' \ -d ' {"tools": [{"code_execution": {}}],     "contents": {       "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."         }     }, }'

El resultado podría ser similar al siguiente, que se formateó para facilitar la lectura:

Okay, I need to calculate the sum of the first 50 prime numbers. Here's how I'll approach this:  1.  **Generate Prime Numbers:** I'll use an iterative method to find prime     numbers. I'll start with 2 and check if each subsequent number is divisible     by any number between 2 and its square root. If not, it's a prime. 2.  **Store Primes:** I'll store the prime numbers in a list until I have 50 of     them. 3.  **Calculate the Sum:**  Finally, I'll sum the prime numbers in the list.  Here's the Python code to do this:  def is_prime(n):   """Efficiently checks if a number is prime."""   if n <= 1:     return False   if n <= 3:     return True   if n % 2 == 0 or n % 3 == 0:     return False   i = 5   while i * i <= n:     if n % i == 0 or n % (i + 2) == 0:       return False     i += 6   return True  primes = [] num = 2 while len(primes) < 50:   if is_prime(num):     primes.append(num)   num += 1  sum_of_primes = sum(primes) print(f'{primes=}') print(f'{sum_of_primes=}')  primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229] sum_of_primes=5117  The sum of the first 50 prime numbers is 5117.

Este resultado combina varias partes de contenido que el modelo devuelve cuando se usa la ejecución de código:

  • text: Texto intercalado generado por el modelo
  • executableCode: Código generado por el modelo que se debe ejecutar
  • codeExecutionResult: Resultado del código ejecutable

Las convenciones de nomenclatura para estas partes varían según el lenguaje de programación.

Cómo usar la ejecución de código en el chat

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

Python

from google import genai from google.genai import types  client = genai.Client()  chat = client.chats.create(     model="gemini-2.5-flash",     config=types.GenerateContentConfig(         tools=[types.Tool(code_execution=types.ToolCodeExecution)]     ), )  response = chat.send_message("I have a math question for you.") print(response.text)  response = chat.send_message(     "What is the sum of the first 50 prime numbers? "     "Generate and run code for the calculation, and make sure you get all 50." )  for part in response.candidates[0].content.parts:     if part.text is not None:         print(part.text)     if part.executable_code is not None:         print(part.executable_code.code)     if part.code_execution_result is not None:         print(part.code_execution_result.output)

JavaScript

import {GoogleGenAI} from "@google/genai";  const ai = new GoogleGenAI({});  const chat = ai.chats.create({   model: "gemini-2.5-flash",   history: [     {       role: "user",       parts: [{ text: "I have a math question for you:" }],     },     {       role: "model",       parts: [{ text: "Great! I'm ready for your math question. Please ask away." }],     },   ],   config: {     tools: [{codeExecution:{}}],   } });  const response = await chat.sendMessage({   message: "What is the sum of the first 50 prime numbers? " +             "Generate and run code for the calculation, and make sure you get all 50." }); console.log("Chat response:", response.text);

Go

package main  import (     "context"     "fmt"     "os"     "google.golang.org/genai" )  func main() {      ctx := context.Background()     client, err := genai.NewClient(ctx, nil)     if err != nil {         log.Fatal(err)     }      config := &genai.GenerateContentConfig{         Tools: []*genai.Tool{             {CodeExecution: &genai.ToolCodeExecution{}},         },     }      chat, _ := client.Chats.Create(         ctx,         "gemini-2.5-flash",         config,         nil,     )      result, _ := chat.SendMessage(                     ctx,                     genai.Part{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.",                               },                 )      fmt.Println(result.Text())     fmt.Println(result.ExecutableCode())     fmt.Println(result.CodeExecutionResult()) }

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent" \ -H "x-goog-api-key: $GEMINI_API_KEY" \ -H 'Content-Type: application/json' \ -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."             }]         }     ] }'

Entrada/salida (E/S)

A partir de Gemini 2.0 Flash, la ejecución de código admite la entrada de archivos y la salida de gráficos. Con estas capacidades de entrada y salida, puedes subir archivos CSV y de texto, hacer preguntas sobre los archivos y generar gráficos de Matplotlib como parte de la respuesta. Los archivos de salida se muestran como imágenes intercaladas en la respuesta.

Precios de E/S

Cuando usas la E/S de ejecución de código, se te cobran los tokens de entrada y los tokens de salida:

Tokens de entrada:

  • Instrucción del usuario

Tokens de salida:

  • Código generado por el modelo
  • Resultado de la ejecución del código en el entorno de código
  • Tokens de pensamiento
  • Resumen generado por el modelo

Detalles de E/S

Cuando trabajes con E/S de ejecución de código, ten en cuenta los siguientes detalles técnicos:

  • El tiempo de ejecución máximo del entorno de código es de 30 segundos.
  • Si el entorno de código genera un error, es posible que el modelo decida volver a generar el resultado del código. Esto puede suceder hasta 5 veces.
  • El tamaño máximo de entrada de archivos está limitado por la ventana de tokens del modelo. En AI Studio, con Gemini Flash 2.0, el tamaño máximo del archivo de entrada es de 1 millón de tokens (aproximadamente 2 MB para archivos de texto de los tipos de entrada admitidos). Si subes un archivo demasiado grande, AI Studio no te permitirá enviarlo.
  • La ejecución de código funciona mejor con archivos de texto y CSV.
  • El archivo de entrada se puede pasar en part.inlineData o part.fileData (se sube a través de la API de Files), y el archivo de salida siempre se devuelve como part.inlineData.
Un solo turno Bidireccional (API de Multimodal Live)
Modelos compatibles Todos los modelos de Gemini 2.0 y 2.5 Solo modelos experimentales de Flash
Tipos de entrada de archivos admitidos .png, .jpeg, .csv, .xml, .cpp, .java, .py, .js, .ts .png, .jpeg, .csv, .xml, .cpp, .java, .py, .js, .ts
Bibliotecas de trazado compatibles Matplotlib y Seaborn Matplotlib y Seaborn
Uso de varias herramientas Sí (solo ejecución de código y fundamentación) Sí

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 en función del modelo de Gemini que uses.

A continuación, se incluyen otros aspectos que debes tener en cuenta sobre la facturación de la ejecución de código:

  • Solo se te factura una vez por los tokens de entrada que pasas al modelo y se te factura por los tokens de salida finales que te devuelve el modelo.
  • Los tokens que representan el código generado se cuentan como tokens de salida. El código generado puede incluir texto y resultados multimodales, como imágenes.
  • Los resultados de la ejecución de código también se contabilizan como tokens de salida.

El modelo de facturación se muestra en el siguiente diagrama:

Modelo de facturación de ejecución de código

  • Se te facturará según la tarifa actual de los tokens de entrada y salida en función del 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 intermedio en la respuesta de la API, por lo que sabrás por qué recibes tokens de entrada adicionales más allá de tu instrucción inicial.

Limitaciones

  • El modelo solo puede generar y ejecutar código. No puede devolver otros artefactos, como archivos multimedia.
  • En algunos casos, habilitar la ejecución de código puede provocar regresiones en otras áreas del resultado del modelo (por ejemplo, escribir un cuento).
  • La capacidad de los diferentes modelos para usar la ejecución de código con éxito varía.

Bibliotecas compatibles

El entorno de ejecución de código incluye las siguientes bibliotecas:

  • attrs
  • ajedrez
  • contourpy
  • fpdf
  • geopandas
  • imageio
  • jinja2
  • joblib
  • jsonschema
  • jsonschema-specifications
  • lxml
  • matplotlib
  • mpmath
  • numpy
  • opencv-python
  • openpyxl
  • empaquetado
  • pandas
  • almohada
  • protobuf
  • pylatex
  • pyparsing
  • PyPDF2
  • python-dateutil
  • python-docx
  • python-pptx
  • reportlab
  • scikit-learn
  • scipy
  • seaborn
  • six
  • striprtf
  • sympy
  • tabulación
  • tensorflow
  • toolz
  • xlrd

No puedes instalar tus propias bibliotecas.

¿Qué sigue?