Gemini 2.5 Flash, Veo 2 und Updates für die Live API Weitere Informationen

Diese Seite wurde von der Cloud Translation API übersetzt.

Codeausführung

Die Gemini API bietet ein Codeausführungstool, mit dem das Modell Python-Code generieren und ausführen kann. Das Modell kann dann iterativ aus den Ergebnissen der Codeausführung lernen, bis es eine endgültige Ausgabe erzeugt. Sie können die Codeausführung verwenden, um Anwendungen zu erstellen, die von codebasierter Logik profitieren. Die Codeausführung kann beispielsweise zum Lösen von Gleichungen oder zum Verarbeiten von Text verwendet werden. Sie können auch die Bibliotheken verwenden, die in der Codeausführungsumgebung enthalten sind, um speziellere Aufgaben auszuführen.

Gemini kann nur Code in Python ausführen. Sie können Gemini weiterhin bitten, Code in einer anderen Sprache zu generieren. Das Modell kann ihn jedoch nicht mit dem Tool zur Codeausführung ausführen.

Codeausführung aktivieren

Wenn Sie die Codeausführung aktivieren möchten, konfigurieren Sie das Tool für die Codeausführung im Modell. So kann das Modell Code generieren und ausführen.

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

Ok

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

Die Ausgabe könnte in etwa so aussehen, wie hier 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 Verwendung der Codeausführung zurückgibt:

text: Inline-Text, der vom Modell generiert wird
executableCode: Vom Modell generierter Code, der ausgeführt werden soll
codeExecutionResult: Ergebnis des ausführbaren Codes

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

Codeausführung in Google Chat verwenden

Sie können die Codeausführung auch in einem Chat verwenden.

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

Ok

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

Eingabe/Ausgabe (I/O)

Ab Gemini 2.0 Flash unterstützt die Codeausführung die Dateieingabe und die Grafikausgabe. Mit diesen Eingabe- und Ausgabefunktionen können Sie CSV- und Textdateien hochladen, Fragen zu den Dateien stellen und Matplotlib-Diagramme als Teil der Antwort generieren lassen. Die Ausgabedateien werden in der Antwort als Inline-Bilder zurückgegeben.

I/O-Preise

Bei der Verwendung der Codeausführungs-E/A werden Ihnen Eingabe- und Ausgabetokens in Rechnung gestellt:

Eingabetokens:

Nutzer-Prompt

Ausgabetokens:

Vom Modell generierter Code
Codeausführungsausgabe in der Codeumgebung
Vom Modell generierte Zusammenfassung

E/A-Details

Beachten Sie bei der Arbeit mit der E/A der Codeausführung die folgenden technischen Details:

Die maximale Laufzeit der Codeumgebung beträgt 30 Sekunden.
Wenn die Codeumgebung einen Fehler generiert, kann das Modell entscheiden, die Codeausgabe neu zu generieren. Das kann bis zu fünfmal passieren.
Die maximale Dateieingabegröße wird durch das Modelltokenfenster begrenzt. In AI Studio mit Gemini Flash 2.0 beträgt die maximale Größe der Eingabedatei 1 Million Token (ungefähr 2 MB für Textdateien der unterstützten Eingabetypen). Wenn Sie eine zu große Datei hochladen, können Sie sie in AI Studio nicht senden.
Die Codeausführung funktioniert am besten mit Text- und CSV-Dateien.
Die Eingabedatei kann in part.inlineData oder part.fileData übergeben werden (über die Files API hochgeladen). Die Ausgabedatei wird immer als part.inlineData zurückgegeben.

	Single-Turn	Bidirektional (Multimodal Live API)
Unterstützte Modelle	Alle Gemini 2.0-Modelle	Nur experimentelle Flash-Modelle
Unterstützte Dateieingabetypen	PNG, JPEG, CSV, XML, CPP, JAVA, PY, JS, TS	PNG, JPEG, CSV, XML, CPP, JAVA, PY, JS, TS
Unterstützte Plot-Bibliotheken	Matplotlib	Matplotlib
Mehrere Tools verwenden	Nein	Ja

Abrechnung

Für die Aktivierung der Codeausführung über die Gemini API fallen keine zusätzlichen Kosten an. Die Abrechnung erfolgt zum aktuellen Preis für Eingabe- und Ausgabetokens basierend auf dem von Ihnen verwendeten Gemini-Modell.

Weitere Informationen zur Abrechnung der Codeausführung:

Die Eingabe-Tokens, die Sie an das Modell übergeben, werden Ihnen nur einmal in Rechnung gestellt. Außerdem werden Ihnen die endgültigen Ausgabe-Tokens in Rechnung gestellt, die vom Modell zurückgegeben werden.
Tokens, die generierten Code darstellen, werden als Ausgabetokens gezählt. Der generierte Code kann Text und multimodale Ausgabe wie Bilder enthalten.
Ergebnisse der Codeausführung werden ebenfalls als Ausgabetokens gezählt.

Das Abrechnungsmodell ist im folgenden Diagramm dargestellt:

Abrechnungsmodell für die Codeausführung

Die Abrechnung erfolgt nach dem aktuellen Preis für Eingabe- und Ausgabetokens, der auf dem von Ihnen verwendeten Gemini-Modell basiert.
Wenn Gemini beim Generieren Ihrer Antwort die Codeausführung verwendet, werden der ursprüngliche Prompt, der generierte Code und das Ergebnis des ausgeführten Codes als Zwischen-Tokens gekennzeichnet und als Eingabe-Tokens abgerechnet.
Gemini generiert dann eine Zusammenfassung und gibt den generierten Code, das Ergebnis des ausgeführten Codes und die endgültige Zusammenfassung zurück. Diese werden als Ausgabetokens abgerechnet.
Die Gemini API enthält in der API-Antwort eine Zwischentokenanzahl, damit Sie wissen, warum Sie zusätzlich zu Ihrem ursprünglichen Prompt zusätzliche Eingabetokens erhalten.

Beschränkungen

Das Modell kann nur Code generieren und ausführen. Andere Artefakte wie Mediendateien können nicht zurückgegeben werden.
In einigen Fällen kann die Aktivierung der Codeausführung zu Rückschritten in anderen Bereichen der Modellausgabe führen, z. B. beim Schreiben einer Geschichte.
Die verschiedenen Modelle unterscheiden sich in der Fähigkeit, Codeausführungen erfolgreich zu verwenden.

Unterstützte Bibliotheken

Die Codeausführungsumgebung umfasst die folgenden Bibliotheken:

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
tensorflow
toolz
xlrd

Sie können keine eigenen Bibliotheken installieren.

Nächste Schritte

Probieren Sie das Colab zur Codeausführung aus.
Weitere Informationen zu anderen Gemini API-Tools:
- Funktionsaufrufe
- Fundierung mit der Google Suche