Esecuzione di codice

Python Node.js Go REST

La funzionalità di esecuzione del codice dell'API Gemini consente al modello di generare ed eseguire codice Python e di apprendere in modo iterativo dai risultati fino a ottenere un output finale. Puoi utilizzare questa funzionalità di esecuzione di codice per creare applicazioni che beneficiano del ragionamento basato su codice e che producono output di testo. Ad esempio, puoi utilizzare l'esecuzione di codice in un'applicazione che risolve equazioni o elabora il testo.

L'esecuzione di codice è disponibile sia in AI Studio che nell'API Gemini. In AI Studio, puoi attivare l'esecuzione del codice nel riquadro a destra in Strumenti. L'API Gemini fornisce l'esecuzione di codice come strumento, in modo simile alla chiamata di funzioni. Dopo aver aggiunto l'esecuzione di codice come strumento, è il modello a decidere quando utilizzarlo.

L'ambiente di esecuzione del codice include le seguenti librerie: altair, chess, cv2, matplotlib, mpmath, numpy, pandas, pdfminer, reportlab, seaborn, sklearn, statsmodels, striprtf, sympy e tabulate. Non puoi installare le tue librerie.

Iniziare a utilizzare l'esecuzione di codice

È disponibile anche un notebook di esecuzione del codice:

Visualizza su ai.google.dev

Provare un notebook di Colab

Visualizzare il blocco note su GitHub

In questa sezione si presuppone che tu abbia completato i passaggi di installazione e configurazione illustrati nella guida rapida.

Attiva l'esecuzione del codice sul modello

Puoi attivare l'esecuzione di codice nel modello, come mostrato di seguito:

from google import genai
from google.genai import types

client = genai.Client(api_key="GEMINI_API_KEY")

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

In un notebook puoi visualizzare tutto in formato Markdown con questa funzione di assistenza:

def display_code_execution_result(response):
  for part in response.candidates[0].content.parts:
    if part.text is not None:
      display(Markdown(part.text))
    if part.executable_code is not None:
      code_html = f'<pre style="background-color: #BBBBEE;">{part.executable_code.code}</pre>' # Change code color
      display(HTML(code_html))
    if part.code_execution_result is not None:
      display(Markdown(part.code_execution_result.output))
    if part.inline_data is not None:
      display(Image(data=part.inline_data.data, format="png"))
    display(Markdown("---"))

display_code_execution_result(response)

L'output potrebbe avere il seguente aspetto:

Ok, devo calcolare la somma dei primi 50 numeri primi. Utilizzerò uno script Python per generare i primi 50 numeri primi e poi sommarli.

```python
def is_prime(n):
  """Checks if a number is prime."""
  if n <= 1:
    return False
  for i in range(2, int(n**0.5) + 1):
    if n % i == 0:
      return False
  return True

def sum_of_primes(n):
  """Calculates the sum of the first n prime numbers."""
  primes = []
  i = 2
  while len(primes) < n:
    if is_prime(i):
      primes.append(i)
    i += 1
  return sum(primes)

# Calculate the sum of the first 50 prime numbers
sum_of_first_50_primes = sum_of_primes(50)

print(f"The sum of the first 50 prime numbers is: {sum_of_first_50_primes}")
```

**Output:**

```
The sum of the first 50 prime numbers is: 5117
```

Utilizzare l'esecuzione di codice in chat

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

from google import genai
from google.genai import types

client = genai.Client(api_key="GEMINI_API_KEY")

chat = client.chats.create(
    model='gemini-2.0-flash',
    config=types.GenerateContentConfig(
      tools=[types.Tool(
        code_execution=types.ToolCodeExecution
      )]
    )
)

response = chat.send_message("Can you run some code to bogo-sort this list of numbers?: [2,34,1,65,4]")
display_code_execution_result(response)

La conversazione potrebbe continuare così:

Mi risulta che vuoi che ordini l'elenco [2, 34, 1, 65, 4] con la ricerca Bogo. Bogosort è un algoritmo di ordinamento notoriamente inefficiente. Funziona rimescolando ripetutamente l'elenco finché non viene ordinato. A causa del rendimento estremamente scadente, non è pratico per gli elenchi di dimensioni significative.

Tuttavia, a scopo dimostrativo, posso eseguire una versione semplificata per un numero molto limitato di iterazioni, solo per mostrare la procedura. Posso procedere?

response = chat.send_message("Yes, please create the code.")
display_code_execution_result(response)

Ok,procederò con una funzione che mescola l'elenco e controlla se è ordinato. Lo eseguirò per un massimo di 10 iterazioni. …

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. Grazie a queste nuove funzionalità di input e output, puoi caricare file CSV e di testo, porre domande sui file e generare grafici Matplotlib come parte della 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. Questo 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.

Fatturazione

Non sono previsti costi aggiuntivi per l'abilitazione dell'esecuzione di codice dall'API Gemini. Ti verrà addebitato il prezzo corrente dei token di input e di output in base al modello Gemini che utilizzi.

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:

• 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).
• Esiste una certa variabilità nella capacità dei diversi modelli di utilizzare l'esecuzione del codice.