Présentation de Gemini 2.5 Flash, de Veo 2 et de modifications apportées à l'API Live En savoir plus

Cette page a été traduite par l'API Cloud Translation.

Exécution du code

L'API Gemini fournit un outil d'exécution de code qui permet au modèle de générer et d'exécuter du code Python. Le modèle peut ensuite apprendre de manière itérative à partir des résultats d'exécution du code jusqu'à ce qu'il parvienne à une sortie finale. Vous pouvez utiliser l'exécution de code pour créer des applications qui bénéficient d'un raisonnement basé sur du code. Par exemple, vous pouvez utiliser l'exécution de code pour résoudre des équations ou traiter du texte. Vous pouvez également utiliser les bibliothèques incluses dans l'environnement d'exécution du code pour effectuer des tâches plus spécialisées.

Gemini ne peut exécuter du code qu'en Python. Vous pouvez toujours demander à Gemini de générer du code dans une autre langue, mais le modèle ne peut pas utiliser l'outil d'exécution du code pour l'exécuter.

Activer l'exécution du code

Pour activer l'exécution du code, configurez l'outil d'exécution du code sur le modèle. Cela permet au modèle de générer et d'exécuter du code.

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

Go

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

Le résultat peut ressembler à ceci, qui a été mis en forme pour faciliter la lecture:

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.

Cette sortie combine plusieurs parties de contenu que le modèle renvoie lors de l'exécution du code:

text: texte intégré généré par le modèle
executableCode: code généré par le modèle à exécuter
codeExecutionResult: résultat du code exécutable

Les conventions de nommage de ces éléments varient selon le langage de programmation.

Utiliser l'exécution de code dans le chat

Vous pouvez également utiliser l'exécution de code dans le cadre d'un 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);

Go

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

Entrée/Sortie (E/S)

À partir de Gemini 2.0 Flash, l'exécution de code est compatible avec l'entrée de fichiers et la sortie de graphiques. Grâce à ces fonctionnalités d'entrée et de sortie, vous pouvez importer des fichiers CSV et texte, poser des questions sur les fichiers et générer des graphiques Matplotlib en réponse. Les fichiers de sortie sont renvoyés sous forme d'images intégrées dans la réponse.

Tarifs des E/S

Lorsque vous utilisez l'E/S d'exécution de code, les jetons d'entrée et de sortie vous sont facturés:

Jetons d'entrée:

Requête de l'utilisateur

Jetons de sortie:

Code généré par le modèle
Sortie de l'exécution du code dans l'environnement de code
Résumé généré par le modèle

Détails des E/S

Lorsque vous travaillez avec les entrées/sorties d'exécution de code, tenez compte des détails techniques suivants:

La durée d'exécution maximale de l'environnement de code est de 30 secondes.
Si l'environnement de code génère une erreur, le modèle peut décider de générer à nouveau la sortie du code. Cela peut se produire jusqu'à cinq fois.
La taille maximale d'entrée de fichier est limitée par la fenêtre de jeton du modèle. Dans AI Studio, avec Gemini Flash 2.0, la taille maximale du fichier d'entrée est de 1 million de jetons (environ 2 Mo pour les fichiers texte des types d'entrée compatibles). Si vous importez un fichier trop volumineux, AI Studio ne vous permettra pas de l'envoyer.
L'exécution du code fonctionne mieux avec les fichiers texte et CSV.
Le fichier d'entrée peut être transmis au format part.inlineData ou part.fileData (importé via l'API Files), et le fichier de sortie est toujours renvoyé au format part.inlineData.

	Un seul tour	Bidirectionnel (API Multimodal Live)
Modèles compatibles	Tous les modèles Gemini 2.0	Modèles expérimentaux Flash uniquement
Types de fichiers acceptés	.png, .jpeg, .csv, .xml, .cpp, .java, .py, .js et .ts	.png, .jpeg, .csv, .xml, .cpp, .java, .py, .js, .ts
Bibliothèques de tracé compatibles	Matplotlib	Matplotlib
Utilisation de plusieurs outils	Non	Oui

Facturation

L'activation de l'exécution du code à partir de l'API Gemini n'entraîne aucun coût supplémentaire. Vous serez facturé au tarif actuel des jetons d'entrée et de sortie en fonction du modèle Gemini que vous utilisez.

Voici quelques autres points à connaître concernant la facturation de l'exécution du code:

Vous ne serez facturé qu'une seule fois pour les jetons d'entrée que vous transmettez au modèle, et pour les jetons de sortie finaux qui vous sont renvoyés par le modèle.
Les jetons représentant le code généré sont comptabilisés comme des jetons de sortie. Le code généré peut inclure du texte et une sortie multimodale, comme des images.
Les résultats de l'exécution du code sont également comptabilisés comme des jetons de sortie.

Le modèle de facturation est illustré dans le schéma suivant:

modèle de facturation basé sur l'exécution de code

Vous êtes facturé au tarif actuel des jetons d'entrée et de sortie en fonction du modèle Gemini que vous utilisez.
Si Gemini utilise l'exécution de code pour générer votre réponse, la requête d'origine, le code généré et le résultat du code exécuté sont désignés comme jetons intermédiaires et sont facturés en tant que jetons d'entrée.
Gemini génère ensuite un récapitulatif et renvoie le code généré, le résultat du code exécuté et le récapitulatif final. Ils sont facturés en tant que jetons de sortie.
L'API Gemini inclut un nombre de jetons intermédiaires dans la réponse de l'API afin que vous sachiez pourquoi vous recevez des jetons d'entrée supplémentaires au-delà de votre invite initiale.

Limites

Le modèle ne peut générer et exécuter du code que. Il ne peut pas renvoyer d'autres artefacts tels que des fichiers multimédias.
Dans certains cas, l'activation de l'exécution du code peut entraîner des régressions dans d'autres domaines de la sortie du modèle (par exemple, l'écriture d'une histoire).
La capacité des différents modèles à utiliser l'exécution de code avec succès varie.

Bibliothèques prises en charge

L'environnement d'exécution du code comprend les bibliothèques suivantes:

attrs
échecs
contourpy
fpdf
geopandas
imageio
jinja2
joblib
jsonschema
jsonschema-specifications
lxml
matplotlib
mpmath
numpy
opencv-python
openpyxl
packaging
pandas
pillow
protobuf
pylatex
pyparsing
PyPDF2
python-dateutil
python-docx
python-pptx
reportlab
scikit-learn
scipy
naître
six
striprtf
sympy
tabulation
tensorflow
toolz
xlrd

Vous ne pouvez pas installer vos propres bibliothèques.

Étape suivante

Essayez le Colab d'exécution du code.
Découvrez d'autres outils de l'API Gemini :
- Appel de fonction
- Ancrage avec la recherche Google