Ti presentiamo Gemini 2.5 Flash, Veo 2 e gli aggiornamenti all'API Live Scopri di più

Questa pagina è stata tradotta dall'API Cloud Translation.

Esecuzione di codice

L'API Gemini fornisce uno strumento di esecuzione del codice che consente al modello di generare ed eseguire codice Python. Il modello può quindi apprendere in modo iterativo dai risultati dell'esecuzione del codice fino a ottenere un output finale. Puoi utilizzare l'esecuzione di codice per creare applicazioni che traggono vantaggio dal ragionamento basato sul codice. Ad esempio, puoi utilizzare l'esecuzione del codice per risolvere equazioni o elaborare il testo. Puoi anche utilizzare le librerie incluse nell'ambiente di esecuzione del codice per svolgere attività più specializzate.

Gemini è in grado di eseguire codice solo in Python. Puoi comunque chiedere a Gemini di generare codice in un altro linguaggio, ma il modello non può utilizzare lo strumento di esecuzione del codice per eseguirlo.

Attivare l'esecuzione del codice

Per attivare l'esecuzione del codice, configura lo strumento di esecuzione del codice nel modello. In questo modo il modello può generare ed eseguire il codice.

Python

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)

JavaScript

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

Vai

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

REST

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."
        }
    },
}'

L'output potrebbe avere il seguente aspetto, che è stato formattato per la lettura:

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.

Questo output combina diverse parti di contenuti restituite dal modello quando viene utilizzata l'esecuzione di codice:

text: testo in linea generato dal modello
executableCode: codice generato dal modello da eseguire
codeExecutionResult: risultato del codice eseguibile

Le convenzioni di denominazione per queste parti variano in base al linguaggio di programmazione.

Utilizzare l'esecuzione di codice in chat

Puoi anche utilizzare l'esecuzione di codice all'interno di una chat.

Python

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)

JavaScript

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

Vai

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

REST

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."
            }]
        }
    ]
}'

Input/output (I/O)

A partire da Gemini 2.0 Flash, l'esecuzione del codice supporta l'input di file e l'output di grafici. Utilizzando queste funzionalità di input e output, puoi caricare file CSV e di testo, porre domande sui file e generare grafici Matplotlib nell'ambito della risposta. I file di output vengono restituiti come immagini in linea nella risposta.

Prezzi di I/O

Quando utilizzi l'I/O di esecuzione del codice, ti vengono addebitati i token di input e di output:

Token di input:

Prompt dell'utente

Token di output:

Codice generato dal modello
Output dell'esecuzione del codice nell'ambiente di codice
Riepilogo generato dal modello

Dettagli I/O

Quando lavori con l'I/O di esecuzione del codice, tieni presente i seguenti dettagli tecnici:

Il tempo di esecuzione massimo dell'ambiente di codice è di 30 secondi.
Se l'ambiente di codice genera un errore, il modello potrebbe decidere di rigenerare l'output del codice. Ciò può accadere fino a 5 volte.
La dimensione massima del file di input è limitata dalla finestra del token del modello. In AI Studio, con Gemini Flash 2.0, la dimensione massima del file di input è di 1 milione di token (circa 2 MB per i file di testo dei tipi di input supportati). Se caricate un file troppo grande, AI Studio non vi consente di inviarlo.
L'esecuzione del codice funziona meglio con file di testo e CSV.
Il file di input può essere passato in part.inlineData o part.fileData (caricato tramite l'API Files) e il file di output viene sempre restituito come part.inlineData.

	A turno singolo	Bidirezionale (API Multimodal Live)
Modelli supportati	Tutti i modelli Gemini 2.0	Solo modelli sperimentali Flash
Tipi di input file supportati	.png, .jpeg, .csv, .xml, .cpp, .java, .py, .js, .ts	.png, .jpeg, .csv, .xml, .cpp, .java, .py, .js, .ts
Librerie di rappresentazione supportate	Matplotlib	Matplotlib
Utilizzo di più strumenti	No	Sì

Fatturazione

Non sono previsti costi aggiuntivi per l'abilitazione dell'esecuzione di codice dall'API Gemini. Ti verrà addebitato l'attuale tasso di token di input e output in base al modello Gemini in uso.

Ecco alcune altre informazioni da conoscere sulla fatturazione per l'esecuzione di codice:

Ti viene addebitato un solo token di input per i token di input che passi al modello e ti vengono addebitati i token di output finali che ti vengono restituiti dal modello.
I token che rappresentano il codice generato vengono conteggiati come token di output. Il codice generato può includere testo e output multimodali come le immagini.
Anche i risultati dell'esecuzione del codice vengono conteggiati come token di output.

Il modello di fatturazione è mostrato nel seguente diagramma:

modello di fatturazione per l'esecuzione del codice

La fatturazione avviene in base alla tariffa corrente dei token di input e di output in base al modello Gemini in uso.
Se Gemini utilizza l'esecuzione di codice per generare la risposta, il prompt originale, il codice generato e il risultato del codice eseguito sono etichettati come token intermedi e vengono fatturati come token di input.
Gemini genera quindi un riepilogo e restituisce il codice generato, il risultato del codice eseguito e il riepilogo finale. Questi vengono fatturati come token di output.
L'API Gemini include un conteggio intermedio dei token nella risposta dell'API, in modo da sapere perché ricevi token di input aggiuntivi oltre alla richiesta iniziale.

Limitazioni

Il modello può solo generare ed eseguire codice. Non può restituire altri elementi come i file multimediali.
In alcuni casi, l'attivazione dell'esecuzione di codice può portare a regressioni in altre aree dell'output del modello (ad esempio, la scrittura di una storia).
Esistono alcune differenze nella capacità dei diversi modelli di utilizzare l'esecuzione del codice.

Librerie supportate

L'ambiente di esecuzione del codice include le seguenti librerie:

attrs
scacchi
contourpy
fpdf
geopandas
imageio
jinja2
joblib
jsonschema
jsonschema-specifications
lxml
matplotlib
mpmath
NumPy
opencv-python
openpyxl
pacchettizzazione
panda
cuscino
protobuf
pylatex
pyparsing
PyPDF2
python-dateutil
python-docx
python-pptx
reportlab
scikit-learn
SciPy
Seaborn
sei
striprtf
sympy
tabula
tensorflow
toolz
xlrd

Non puoi installare le tue librerie.

Passaggi successivi

Prova il codelab di esecuzione del codice.
Scopri altri strumenti dell'API Gemini:
- Chiamata di funzione
- Grounding con la Ricerca Google