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 de código hasta llegar a un resultado final. Puedes usar la ejecución de código para compilar 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 del código para realizar tareas más especializadas.

Gemini solo puede ejecutar código en Python. Puedes pedirle a Gemini que genere código en otro lenguaje, pero el modelo no puede usar la herramienta de ejecución de código para ejecutarlo.

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

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.0-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)

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

let response = await ai.models.generateContent({
  model: "gemini-2.0-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);
  }
});

package main

import (
    "context"
    "fmt"
    "os"
    "google.golang.org/genai"
)

func main() {

    ctx := context.Background()
    client, _ := genai.NewClient(ctx, &genai.ClientConfig{
        APIKey:  os.Getenv("GOOGLE_API_KEY"),
        Backend: genai.BackendGeminiAPI,
    })

    config := &genai.GenerateContentConfig{
        Tools: []*genai.Tool{
            {CodeExecution: &genai.ToolCodeExecution{}},
        },
    }

    result, _ := client.Models.GenerateContent(
        ctx,
        "gemini-2.0-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())
}

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_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 tiene formato 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 muestra el modelo cuando se usa la ejecución de código:

• text: Es el texto intercalado que genera el modelo.
• executableCode: Es el código que genera el modelo y que se debe ejecutar.
• codeExecutionResult: Es el resultado del código ejecutable.

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

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.

from google import genai
from google.genai import types

client = genai.Client()

chat = client.chats.create(
    model="gemini-2.0-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)

import {GoogleGenAI} from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

const chat = ai.chats.create({
  model: "gemini-2.0-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);

package main

import (
    "context"
    "fmt"
    "os"
    "google.golang.org/genai"
)

func main() {

    ctx := context.Background()
    client, _ := genai.NewClient(ctx, &genai.ClientConfig{
        APIKey:  os.Getenv("GOOGLE_API_KEY"),
        Backend: genai.BackendGeminiAPI,
    })

    config := &genai.GenerateContentConfig{
        Tools: []*genai.Tool{
            {CodeExecution: &genai.ToolCodeExecution{}},
        },
    }

    chat, _ := client.Chats.Create(
        ctx,
        "gemini-2.0-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())
}

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_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 E/S de ejecución de código, se te cobra por los tokens de entrada y salida:

Tokens de entrada:

• Instrucción del usuario

Tokens de salida:

• Código generado por el modelo
• Resultado de la ejecución de código en el entorno de código
• 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, el modelo puede decidir 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 (alrededor de 2 MB para los 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 (subir a través de la API de Files) y el archivo de salida siempre se muestra como part.inlineData.

Facturación

No se aplican cargos adicionales por habilitar la ejecución de código desde la API de Gemini. Se te facturará a la tarifa actual de tokens de entrada y salida según el 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 por los tokens de salida finales que te muestra el modelo.
• Los tokens que representan el código generado se cuentan como tokens de salida. El código generado puede incluir texto y salidas multimodales, como imágenes.
• Los resultados de la ejecución de código también se cuentan como tokens de salida.

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

• Se te factura a la tarifa actual de 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 muestra 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 debes saber 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 mostrar otros artefactos, como archivos multimedia.
• 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).
• Hay cierta variación en la capacidad de los diferentes modelos para usar la ejecución de código con éxito.

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
• tabula
• tensorflow
• toolz
• xlrd

No puedes instalar tus propias bibliotecas.

¿Qué sigue?

• Prueba la ejecución de código de Colab.
• Obtén información sobre otras herramientas de la API de Gemini:
  • Llamada a función
  • Grounding with Google Search