Codeausführung

Vorschau :Die Verwendung der Firebase AI Logic-SDKs mit dem Tool zur Codeausführung ist eine Funktion in der Vorschauphase. Das bedeutet, dass sie weder einem SLA noch einer Richtlinie zur Einstellung von Produkten und Diensten unterliegt und sich so ändern kann, dass eine Abwärtskompatibilität nicht mehr gegeben ist.

Die Codeausführung ist ein Tool, mit dem das Modell Python-Code generieren und ausführen kann. Das Modell kann iterativ aus den Ergebnissen der Codeausführung lernen, bis es eine endgültige Ausgabe erstellt hat.

Sie können die Codeausführung verwenden, um Funktionen zu erstellen, die die Vorteile codebasierter Schlussfolgerungen nutzen und Textausgaben erzeugen. Die Codeausführung können Sie beispielsweise verwenden, um Gleichungen zu lösen oder Text zu verarbeiten. Sie können auch die in der Code-Ausführungsumgebung enthaltenen Bibliotheken verwenden, um speziellere Aufgaben auszuführen.

Hinweis :Gemini-Modelle können nur Code ausführen, der in Python geschrieben wurde. Sie können weiterhin anfordern, dass das Modell Code in einer anderen Sprache generiert, aber das Modell kann das Codeausführungstool nicht verwenden, um diesen Code auszuführen.

Bei der Codeausführung spielt es keine Rolle, in welcher Programmiersprache Ihre eigentliche App geschrieben ist.

Wie bei allen Tools, die Sie dem Modell zur Verfügung stellen, entscheidet das Modell, wann die Codeausführung verwendet wird.

Zur Code-Implementierung springen

Vergleich von Codeausführung und Funktionsaufrufen

Die Codeausführung und Funktionsaufrufe sind ähnliche Funktionen. Im Allgemeinen sollten Sie die Codeausführung bevorzugen, wenn das Modell Ihren Anwendungsfall abdecken kann. Die Codeausführung ist auch einfacher zu verwenden, da Sie sie nur aktivieren müssen.

Hier sind einige zusätzliche Unterschiede zwischen der Codeausführung und dem Funktionsaufruf:

Codeausführung	Funktionsaufrufe
Verwenden Sie die Codeausführung, wenn das Modell Python-Code für Sie schreiben und ausführen und das Ergebnis zurückgeben soll.	Verwenden Sie Funktionsaufrufe, wenn Sie bereits eigene Funktionen haben, die Sie lokal ausführen möchten.
Bei der Codeausführung kann das Modell Code im API-Backend in einer festen, isolierten Umgebung ausführen.	Mit Funktionsaufrufen können Sie die Funktionen, die das Modell anfordert, in einer beliebigen Umgebung ausführen.
Die Codeausführung wird in einer einzelnen Anfrage aufgelöst. Sie können die Codeausführung optional mit der Chatfunktion verwenden, müssen es aber nicht.	Für das Aufrufen von Funktionen ist eine zusätzliche Anfrage erforderlich, um die Ausgabe jedes Funktionsaufrufs zurückzusenden. Sie müssen also die Chatfunktion verwenden.

Unterstützte Modelle

• gemini-2.5-pro
• gemini-2.5-flash
• gemini-2.5-flash-lite
• gemini-2.0-flash-001 (und der automatisch aktualisierte Alias gemini-2.0-flash)
• gemini-2.0-flash-live-preview-04-09

Codeausführung verwenden

Sie können die Codeausführung sowohl mit reiner Texteingabe als auch mit multimodaler Eingabe verwenden. Die Antwort besteht jedoch immer nur aus Text oder Code.

Hinweis

Klicken Sie auf Ihren Gemini API-Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen. Gemini Developer API Vertex AI Gemini API

Falls noch nicht geschehen, folgen Sie dem Startleitfaden. Darin wird beschrieben, wie Sie Ihr Firebase-Projekt einrichten, Ihre App mit Firebase verbinden, das SDK hinzufügen, den Backend-Dienst für den ausgewählten Gemini API-Anbieter initialisieren und eine GenerativeModel-Instanz erstellen.

In dieser Anleitung wird davon ausgegangen, dass Sie die neuesten Firebase AI Logic-SDKs verwenden. Wenn Sie noch die SDKs „Vertex AI in Firebase“ verwenden, lesen Sie die Migrationsanleitung.

Zum Testen und Iterieren von Prompts und zum Generieren von Code-Snippets empfehlen wir die Verwendung von Google AI Studio.

Codeausführung aktivieren

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durcharbeiten, um Ihr Projekt und Ihre App einzurichten. In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den von Ihnen ausgewählten Gemini API-Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden.

Geben Sie beim Erstellen der GenerativeModel-Instanz CodeExecution als Tool an, das das Modell zum Generieren seiner Antwort verwenden kann. Dadurch kann das Modell Python-Code generieren und ausführen.

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

Die Unterstützung für Flutter wird in der nächsten Version verfügbar sein.

Einheit

Die Unterstützung für Unity wird in der nächsten Version verfügbar sein.

Hier erfahren Sie, wie Sie ein Modell auswählen, der für Ihren Anwendungsfall und Ihre App geeignet ist.

Beispielausgabe ansehen

Die Ausgabe könnte in etwa so aussehen (zur besseren Lesbarkeit formatiert):

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.

Diese Ausgabe kombiniert mehrere Inhaltsteile, die das Modell bei der Codeausführung zurückgibt:

• text: Inline-Text, der vom Modell generiert wurde
• executableCode: Vom Modell generierter Code, der ausgeführt werden soll
• codeExecutionResult: Ergebnis des ausgeführten Codes

Die Namenskonventionen für diese Teile variieren je nach Programmiersprache.

Codeausführung in Chats verwenden

Sie können die Codeausführung auch im Rahmen eines Chats verwenden:

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

Die Unterstützung für Flutter wird in der nächsten Version verfügbar sein.

Einheit

Die Unterstützung für Unity wird in der nächsten Version verfügbar sein.

Hier erfahren Sie, wie Sie ein Modell auswählen, der für Ihren Anwendungsfall und Ihre App geeignet ist.

Preise

Für die Aktivierung der Codeausführung und die Bereitstellung als Tool für das Modell fallen keine zusätzlichen Kosten an. Wenn das Modell sich für die Codeausführung entscheidet, werden Ihnen die aktuellen Kosten für Eingabe- und Ausgabetokens basierend auf dem verwendeten Gemini-Modell in Rechnung gestellt.

Das folgende Diagramm zeigt das Abrechnungsmodell für die Codeausführung:

 

Hier finden Sie eine Zusammenfassung der Abrechnung von Tokens, wenn ein Modell die Codeausführung verwendet:

• Der ursprüngliche Prompt wird einmal in Rechnung gestellt. Die entsprechenden Tokens werden als Zwischentokens gekennzeichnet und als Eingabetokens abgerechnet.

• Der generierte Code und das Ergebnis des ausgeführten Codes werden so abgerechnet:

  • Wenn sie während der Codeausführung verwendet werden, werden sie als Zwischen-Tokens gekennzeichnet und als Eingabe-Tokens abgerechnet.

  • Wenn sie in die endgültige Antwort aufgenommen werden, werden sie als Ausgabe-Tokens abgerechnet.

• Die endgültige Zusammenfassung in der endgültigen Antwort wird als Ausgabetokens abgerechnet.

Die Gemini API enthält eine Zwischenanzahl von Tokens in der API-Antwort, damit Sie wissen, warum Ihnen Eingabetokens über Ihren ursprünglichen Prompt hinaus in Rechnung gestellt werden.

Der generierte Code kann sowohl Text als auch multimodale Ausgaben wie Bilder enthalten.

Beschränkungen und Best Practices

• Das Modell kann nur Python-Code generieren und ausführen. Andere Artefakte wie Mediendateien können nicht zurückgegeben werden.

• Die Codeausführung kann maximal 30 Sekunden dauern, bevor eine Zeitüberschreitung auftritt.

• In einigen Fällen kann die Aktivierung der Codeausführung zu Regressionen in anderen Bereichen der Modellausgabe führen, z. B. beim Schreiben einer Geschichte.

• Das Tool zur Codeausführung unterstützt keine Datei-URIs als Eingabe/Ausgabe. Das Tool zur Codeausführung unterstützt jedoch Dateieingaben und Grafikausgaben als Inline-Bytes. Mit diesen Ein- und Ausgabefunktionen können Sie CSV- und Textdateien hochladen, Fragen zu den Dateien stellen und Matplotlib-Diagramme als Teil des Codeausführungsergebnisses generieren lassen. Die unterstützten MIME-Typen für Inline-Bytes sind .cpp, .csv, .java, .jpeg, .js, .png, .py, .ts und .xml.

Unterstützte Bibliotheken

Die Codeausführungsumgebung umfasst die folgenden Bibliotheken. Sie können keine eigenen Bibliotheken installieren.

Unterstützte Bibliotheken für die Gemini Developer API ansehen

• attrs
• Schach
• contourpy
• fpdf
• geopandas
• imageio
• jinja2
• joblib
• jsonschema
• jsonschema-specifications
• lxml
• matplotlib
• mpmath
• numpy
• opencv-python
• openpyxl
• Paketerstellung
• pandas
• Kissen
• protobuf
• pylatex
• pyparsing
• PyPDF2
• python-dateutil
• python-docx
• python-pptx
• reportlab
• scikit-learn
• scipy
• seaborn
• six
• striprtf
• sympy
• tabellarisch darstellen
• tensorflow
• toolz
• xlrd

Hinweis: Nur matplotlib wird für das Rendern von Diagrammen mithilfe der Codeausführung unterstützt.

Unterstützte Bibliotheken für die Vertex AI Gemini API ansehen

• Altair
• Schach
• Cv2
• Matplotlib
• Mpmath
• NumPy
• Pandas
• Pdfminer
• Reportlab
• Seaborn
• Sklearn
• Statsmodels
• Striprtf
• SymPy
• Tabulate

Feedback zu Firebase AI Logic geben