All Gemini 1.5 models will be retired on September 24, 2025. To avoid service disruption, update to a newer model (for example, gemini-2.5-flash-lite). Learn more.

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

Exécution du code

L'exécution de code est un outil qui permet au modèle de générer et d'exécuter du code Python. Le modèle peut apprendre de manière itérative à partir des résultats de l'exécution du code jusqu'à ce qu'il parvienne à un résultat final.

Vous pouvez utiliser l'exécution de code pour créer des fonctionnalités qui bénéficient d'un raisonnement basé sur du code et qui génèrent des sorties textuelles. 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.

Comme pour tous les outils que vous fournissez au modèle, celui-ci décide quand utiliser l'exécution de code.

Accéder à l'implémentation du code

Comparaison entre l'exécution de code et l'appel de fonction

L'exécution de code et l'appel de fonction sont des fonctionnalités similaires. En général, il est préférable d'utiliser l'exécution de code si le modèle peut gérer votre cas d'utilisation. L'exécution de code est également plus simple à utiliser, car il suffit de l'activer.

Voici d'autres différences entre l'exécution de code et l'appel de fonction :

Exécution du code	Appel de fonction
Utilisez l'exécution de code si vous souhaitez que le modèle écrive et exécute du code Python pour vous, puis renvoie le résultat.	Utilisez l'appel de fonction si vous avez déjà vos propres fonctions que vous souhaitez exécuter en local.
L'exécution de code permet au modèle d'exécuter du code dans le backend de l'API au sein d'un environnement fixe et isolé.	L'appel de fonction permet d'exécuter les fonctions demandées par le modèle, dans l'environnement de votre choix.
L'exécution de code se résout en une seule requête. Bien que vous puissiez éventuellement utiliser l'exécution de code avec la fonctionnalité de chat, cela n'est pas obligatoire.	L'appel de fonction nécessite une requête supplémentaire pour renvoyer la sortie de chaque appel de fonction. Vous devez donc utiliser la fonctionnalité de chat.

Modèles compatibles

gemini-2.5-pro
gemini-2.5-flash
gemini-2.5-flash-lite
gemini-2.0-flash-001 (et son alias mis à jour automatiquement gemini-2.0-flash)
gemini-2.0-flash-live-preview-04-09

Utiliser l'exécution de code

Vous pouvez utiliser l'exécution de code avec des entrées textuelles uniquement ou multimodales, mais la réponse sera toujours du texte ou du code uniquement.

Avant de commencer

Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques à ce fournisseur sur cette page.

Si ce n'est pas déjà fait, suivez le guide de démarrage, qui décrit comment configurer votre projet Firebase, associer votre application à Firebase, ajouter le SDK, initialiser le service de backend pour le fournisseur Gemini API de votre choix et créer une instance GenerativeModel.

Pour tester et effectuer des itérations de vos requêtes, et même obtenir un extrait de code généré, nous vous recommandons d'utiliser Google AI Studio.

Activer l'exécution de code

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous devez également cliquer sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page.

Lorsque vous créez l'instance GenerativeModel, fournissez CodeExecution comme outil que le modèle peut utiliser pour générer sa réponse. Cela permet au modèle de générer et d'exécuter du code Python.

Swift


import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  // Provide code execution as a tool that the model can use to generate its response.
  tools: [.codeExecution()]
)

let prompt = """
What is the sum of the first 50 prime numbers?
Generate and run code for the calculation, and make sure you get all 50.
"""

let response = try await model.generateContent(prompt)

guard let candidate = response.candidates.first else {
  print("No candidates in response.")
  return
}
for part in candidate.content.parts {
  if let textPart = part as? TextPart {
    print("Text = \(textPart.text)")
  } else if let executableCode = part as? ExecutableCodePart {
    print("Code = \(executableCode.code), Language = \(executableCode.language)")
  } else if let executionResult = part as? CodeExecutionResultPart {
    print("Outcome = \(executionResult.outcome), Result = \(executionResult.output ?? "no output")")
  }
}

Kotlin


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
    modelName = "GEMINI_MODEL_NAME",
    // Provide code execution as a tool that the model can use to generate its response.
    tools = listOf(Tool.codeExecution())
)

val prompt =  "What is the sum of the first 50 prime numbers? " +
        "Generate and run code for the calculation, and make sure you get all 50."

val response = model.generateContent(prompt)

response.candidates.first().content.parts.forEach {
    if(it is TextPart) {
        println("Text = ${it.text}")
    }
    if(it is ExecutableCodePart) {
        println("Code = ${it.code}, Language = ${it.language}")
    }
    if(it is CodeExecutionResultPart) {
       println("Outcome = ${it.outcome}, Result = ${it.output}")
    }
}

Java


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel("GEMINI_MODEL_NAME",
                        null,
                        null,
                        // Provide code execution as a tool that the model can use to generate its response.
                        List.of(Tool.codeExecution()));

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

String 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.";

Content prompt = new Content.Builder()
    .addText(text)
    .build();

ListenableFuture response = model.generateContent(prompt);

Futures.addCallback(response, new FutureCallback() {
   @Override
public void onSuccess(GenerateContentResponse response)   {
    // Access the first candidate's content parts
    List parts = response.getCandidates().get(0).getContent().getParts();
    for (Part part : parts) {
        if (part instanceof TextPart) {
            TextPart textPart = (TextPart) part;
            System.out.println("Text = " + textPart.getText());
        } else if (part instanceof ExecutableCodePart) {
            ExecutableCodePart codePart = (ExecutableCodePart) part;
            System.out.println("Code = " + codePart.getCode() + ", Language = " + codePart.getLanguage());
        } else if (part instanceof CodeExecutionResultPart) {
            CodeExecutionResultPart resultPart = (CodeExecutionResultPart) part;
            System.out.println("Outcome = " + resultPart.getOutcome() + ", Result = " + resultPart.getOutput());
        }
    }
}

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(
  ai,
  {
    model: "GEMINI_MODEL_NAME",
    // Provide code execution as a tool that the model can use to generate its response.
    tools: [{ codeExecution: {} }]
  }
);

const prompt =  "What is the sum of the first 50 prime numbers? " +
        "Generate and run code for the calculation, and make sure you get all 50."

const result = await model.generateContent(prompt);
const response = await result.response;

const parts = response.candidates?.[0].content.parts;

if (parts) {
  parts.forEach((part) => {
    if (part.text) {
        console.log(`Text: ${part.text}`);
    } else if (part.executableCode) {
      console.log(
        `Code: ${part.executableCode.code}, Language: ${part.executableCode.language}`
      );
    } else if (part.codeExecutionResult) {
      console.log(
        `Outcome: ${part.codeExecutionResult.outcome}, Result: ${part.codeExecutionResult.output}`
      );
    }
  });
}

Dart

La compatibilité avec Flutter sera disponible dans la prochaine version.

Unity

La compatibilité avec Unity sera disponible dans la prochaine version.

Découvrez comment choisir un modèle adapté à votre cas d'utilisation et à votre application.

Voir un exemple de résultat

Le résultat peut ressembler à ce qui suit (mise en forme pour une meilleure lisibilité) :

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 de code :

text : texte intégré généré par le modèle
executableCode : code généré par le modèle et destiné à être exécuté
codeExecutionResult : résultat du code exécuté

Les conventions de nommage pour ces parties 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 un chat :

Swift


import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  // Provide code execution as a tool that the model can use to generate its response.
  tools: [.codeExecution()]
)

let prompt = """
What is the sum of the first 50 prime numbers?
Generate and run code for the calculation, and make sure you get all 50.
"""
let chat = model.startChat()

let response = try await chat.sendMessage(prompt)

guard let candidate = response.candidates.first else {
  print("No candidates in response.")
  return
}
for part in candidate.content.parts {
  if let textPart = part as? TextPart {
    print("Text = \(textPart.text)")
  } else if let executableCode = part as? ExecutableCodePart {
    print("Code = \(executableCode.code), Language = \(executableCode.language)")
  } else if let executionResult = part as? CodeExecutionResultPart {
    print("Outcome = \(executionResult.outcome), Result = \(executionResult.output ?? "no output")")
  }
}

Kotlin


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
    modelName = "GEMINI_MODEL_NAME",
    // Provide code execution as a tool that the model can use to generate its response.
    tools = listOf(Tool.codeExecution())
)

val prompt =  "What is the sum of the first 50 prime numbers? " +
        "Generate and run code for the calculation, and make sure you get all 50."
val chat = model.startChat()
val response = chat.sendMessage(prompt)

response.candidates.first().content.parts.forEach {
    if(it is TextPart) {
        println("Text = ${it.text}")
    }
    if(it is ExecutableCodePart) {
        println("Code = ${it.code}, Language = ${it.language}")
    }
    if(it is CodeExecutionResultPart) {
       println("Outcome = ${it.outcome}, Result = ${it.output}")
    }
}

Java


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel("GEMINI_MODEL_NAME",
                        null,
                        null,
                        // Provide code execution as a tool that the model can use to generate its response.
                        List.of(Tool.codeExecution()));

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);
String 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.";

Content prompt = new Content.Builder()
    .addText(text)
    .build();

ChatFutures chat = model.startChat();
ListenableFuture response = chat.sendMessage(prompt);

Futures.addCallback(response, new FutureCallback() {
   @Override
public void onSuccess(GenerateContentResponse response)   {
    // Access the first candidate's content parts
    List parts = response.getCandidates().get(0).getContent().getParts();
    for (Part part : parts) {
        if (part instanceof TextPart) {
            TextPart textPart = (TextPart) part;
            System.out.println("Text = " + textPart.getText());
        } else if (part instanceof ExecutableCodePart) {
            ExecutableCodePart codePart = (ExecutableCodePart) part;
            System.out.println("Code = " + codePart.getCode() + ", Language = " + codePart.getLanguage());
        } else if (part instanceof CodeExecutionResultPart) {
            CodeExecutionResultPart resultPart = (CodeExecutionResultPart) part;
            System.out.println("Outcome = " + resultPart.getOutcome() + ", Result = " + resultPart.getOutput());
        }
    }
}

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(
  ai,
  {
    model: "GEMINI_MODEL_NAME",
    // Provide code execution as a tool that the model can use to generate its response.
    tools: [{ codeExecution: {} }]
  }
);

const prompt =  "What is the sum of the first 50 prime numbers? " +
        "Generate and run code for the calculation, and make sure you get all 50."
const chat = model.startChat()
const result = await chat.sendMessage(prompt);
const response = await result.response;

const parts = response.candidates?.[0].content.parts;

if (parts) {
  parts.forEach((part) => {
    if (part.text) {
        console.log(`Text: ${part.text}`);
    } else if (part.executableCode) {
      console.log(
        `Code: ${part.executableCode.code}, Language: ${part.executableCode.language}`
      );
    } else if (part.codeExecutionResult) {
      console.log(
        `Outcome: ${part.codeExecutionResult.outcome}, Result: ${part.codeExecutionResult.output}`
      );
    }
  });
}

Dart

La compatibilité avec Flutter sera disponible dans la prochaine version.

Unity

La compatibilité avec Unity sera disponible dans la prochaine version.

Découvrez comment choisir un modèle adapté à votre cas d'utilisation et à votre application.

Tarifs

L'exécution de code et la fourniture de code en tant qu'outil pour le modèle n'entraînent aucuns frais supplémentaires. Si le modèle décide d'utiliser l'exécution de code, vous serez facturé au tarif actuel des jetons d'entrée et de sortie en fonction du modèle Gemini que vous utilisez.

Le schéma suivant illustre le modèle de facturation pour l'exécution de code :

Schéma montrant comment les jetons sont facturés lorsqu'un modèle utilise l'exécution de code.

Voici un récapitulatif de la facturation des jetons lorsqu'un modèle utilise l'exécution de code :

La requête d'origine est facturée une seule fois. Ses jetons sont étiquetés comme jetons intermédiaires, qui sont facturés en tant que jetons d'entrée.
Le code généré et le résultat du code exécuté sont facturés comme suit :
- Lorsqu'ils sont utilisés lors de l'exécution de code, ils sont désignés comme des jetons intermédiaires et sont facturés en tant que jetons d'entrée.
- Lorsqu'ils sont inclus dans la réponse finale, ils sont facturés en tant que jetons de sortie.
Le récapitulatif final de la réponse finale est facturé en tant que jetons de sortie.

Gemini API inclut un nombre de jetons intermédiaires dans la réponse de l'API. Vous savez ainsi pourquoi vous êtes facturé pour les jetons d'entrée au-delà de votre requête initiale.

Notez que le code généré peut inclure des sorties textuelles et multimodales, comme des images.

Limitations et bonnes pratiques

Le modèle ne peut que générer et exécuter du code Python. Il ne peut pas renvoyer d'autres artefacts tels que des fichiers multimédias.
L'exécution du code peut durer au maximum 30 secondes avant l'expiration du délai.
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).
L'outil d'exécution de code n'accepte pas les URI de fichier en tant qu'entrée/sortie. Toutefois, il accepte l'entrée de fichier et la sortie de graphique en tant qu'octets intégrés. Grâce à ces fonctionnalités d'entrée et de sortie, vous pouvez importer des fichiers CSV et des fichiers texte, poser des questions sur les fichiers et générer des graphiques Matplotlib dans le résultat de l'exécution du code. Les types MIME compatibles pour les octets intégrés sont .cpp, .csv, .java, .jpeg, .js, .png, .py, .ts et .xml.

Bibliothèques prises en charge

L'environnement d'exécution du code inclut les bibliothèques suivantes. Vous ne pouvez pas installer vos propres bibliothèques.

Afficher les bibliothèques compatibles avec Gemini Developer API

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
seaborn
six
striprtf
sympy
tabuler
tensorflow
toolz
xlrd

Afficher les bibliothèques compatibles avec Vertex AI Gemini API

Envoyer des commentaires sur votre expérience avec Firebase AI Logic

Exécution du code Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Comparaison entre l'exécution de code et l'appel de fonction

Modèles compatibles

Utiliser l'exécution de code

Avant de commencer

Activer l'exécution de code

Swift

Kotlin

Java

Web

Dart

Unity

Utiliser l'exécution de code dans le chat

Swift

Kotlin

Java

Web

Dart

Unity

Tarifs

Limitations et bonnes pratiques

Bibliothèques prises en charge

Exécution du code