Gemini 2.0 Flash: Schritt-für-Schritt-Anleitung mit Demo-Projekt

Schritt 1: Den API-Schlüssel für Google AI Studio einrichten

Um den API-Schlüssel einzurichten, navigieren Sie zu Google AI Studio und klicke auf die Schaltfläche "API-Schlüssel erstellen". Denke daran, den Schlüssel zu kopieren und ihn dann in eine Datei mit dem Namen .env einzufügen, die folgendes Format hat:

GOOGLE_API_KEY=replace_this_with_api_key

Wenn du bereits mit demselben Google-Konto mit der Google Cloud Platform gearbeitet hast, wird Google AI Studio dich auffordern, eines deiner Projekte für die Aktivierung der API auszuwählen.

Um diesem Lernprogramm folgen zu können, muss sich der Python-Code im selben Ordner wie die Datei .env befinden.

Schritt 2: Python-Abhängigkeiten installieren

Für dieses Projekt werden wir die folgenden Pakete verwenden:

• google-genai: Eine Python-Bibliothek zur Integration der generativen KI-Modelle von Google in unsere Anwendungen.
• pyautogui: Eine plattformübergreifende Bibliothek zur programmatischen Steuerung von Maus und Tastatur, um Aufgaben zu automatisieren. In unserem Fall verwenden wir es, um dem KI-Modell den Bildschirminhalt zur Verfügung zu stellen.
• python-dotenv: Eine Bibliothek zur Verwaltung von Umgebungsvariablen indem wir sie aus .env-Dateien in unsere Python-Anwendung laden.
• sounddevice: Eine Python-Bibliothek zum Aufnehmen und Abspielen von Ton mit einfachen APIs für die Audioeingabe und -ausgabe.
• numpy: Eine grundlegende Bibliothek für numerische Berechnungen in Python, die Arrays, Matrizen und eine Vielzahl von mathematischen Operationen unterstützt.

Um die Abhängigkeiten zu installieren, können wir pip verwenden:

pip install google-genai pyautogui python-dotenv sounddevice numpy

Alternativ dazu laden wir die anforderungen.txt Datei von dem GitHub-Repository herunter und verwenden sie, um eine Conda-Umgebung zu erstellen:

conda create --name gemini python=3.11
conda activate gemini
pip install -r requirements.txt

Schritt 3: Einen Text-Chatbot mit Google GenAI API erstellen

Beginnen wir damit, ein einfaches KI-Chat-Interface für die Kommandozeile zu erstellen, indem wir das Gemini 2 Flash-Modell von Google mit der google.genai Bibliothek verwenden. Ich empfehle einen Blick in die offiziellen Dokumentation von Gemini 2.0 für den Fall, dass es auf dem Weg dorthin zu Problemen kommt.

Der vollständige Code für dieses Beispiel ist in der Datei text.py auf meinem GitHub-Repository.

Erstellen und Verbinden mit dem Google GenAI Client

Der erste Schritt besteht darin, den API-Schlüssel sicher zu laden und den Google GenAI-Client zu initialisieren. Das Skript verwendet dotenv, um Umgebungsvariablen aus der Datei .env zu laden.

Hier erfährst du, wie du den Client mit den nötigen Anmeldedaten einrichtest:

from google import genai
from dotenv import load_dotenv
import os

# Load environment variables from a .env file
load_dotenv()
client = genai.Client(
    api_key=os.getenv("GOOGLE_API_KEY"),
    http_options={"api_version": "v1alpha"},
)

print("Connected to the AI model!")

Asynchrone API-Aufrufe tätigen

Wenn wir mit APIs wie Google GenAI arbeiten, müssen wir oft asynchrone Vorgänge verwalten. Bei der asynchronen Programmierung können andere Vorgänge fortgesetzt werden, während du auf Netzwerkanfragen wartest, wodurch deine Anwendung schneller reagiert. Das ist besonders wichtig, wenn es um Vorgänge mit hoher Latenz geht, z. B. bei Netzwerkanfragen.

In Python wird die asynchrone Programmierung durch die Bibliothek asyncio und die Syntax async/await ermöglicht.

So können wir eine asynchrone Anfrage an Google GenAI stellen:

from google import genai
from dotenv import load_dotenv
import os
import asyncio

# Load environment variables from a .env file
load_dotenv()
async def main():
    client = genai.Client(
        api_key=os.getenv("GOOGLE_API_KEY"),
        http_options={"api_version": "v1alpha"},
    )    
    # Define the AI model and configuration
    model_id = "gemini-2.0-flash-exp"
    config = {"response_modalities": ["TEXT"]}
    async with client.aio.live.connect(model=model_id, config=config) as session:
        await session.send("Hello", end_of_turn=True)
        # Process responses from the AI
        async for response in session.receive():
            if not response.server_content.turn_complete:
                for part in response.server_content.model_turn.parts:
                    print(part.text, end="", flush=True)

# Run the main function
asyncio.run(main())

Diese Version verbindet sich mit dem KI-Modell und sendet eine einzelne "Hallo"-Nachricht. Die Antwort wird Wort für Wort auf der Konsole ausgegeben.

Interaktiv machen

Um die Anwendung interaktiv zu gestalten und es dem Nutzer zu ermöglichen, mit dem KI-Modell hin und her zu chatten, fügen wir eine Schleife hinzu, in der der Nutzer mehrere Nachrichten senden kann. Die Schleife läuft weiter, bis der Benutzer "exit" eingibt.

from google import genai
from dotenv import load_dotenv
import os
import asyncio

# Load environment variables from a .env file
load_dotenv()
async def main():
    client = genai.Client(
        api_key=os.getenv("GOOGLE_API_KEY"),
        http_options={"api_version": "v1alpha"},
    )
    # Define the AI model and configuration
    model_id = "gemini-2.0-flash-exp"
    config = {"response_modalities": ["TEXT"]}
    async with client.aio.live.connect(model=model_id, config=config) as session:
        while True:
            message = input("> ")
            print()
            # Exit the loop if the user types "exit"
            if message == "exit":
                print("Exiting...")
                break
            # Send the user's message to the AI model, marking the end of the turn
            await session.send(message, end_of_turn=True)
            # Receive responses asynchronously and process each response
            async for response in session.receive():
                if not response.server_content.turn_complete:
                    for part in response.server_content.model_turn.parts:
                        print(part.text, end="", flush=True)
            print()

# Run the main function
asyncio.run(main())

Und das war's! Mit dem obigen Skript haben wir einen KI-Chatbot für die Kommandozeile erstellt, der die Google GenAI API nutzt. So sieht es aus:

Schritt 4: Audiomodus hinzufügen

Der Audiomodus ermöglicht es dem Modell, mit der Stimme statt mit dem Text zu antworten. Um das vorherige Beispiel für die Bearbeitung von Audioantworten anzupassen, müssen wir:

1. Importiere sounddevice für die Audiowiedergabe und numpy, um Audiodaten zu verarbeiten.
2. Ändere die Antwortmodalität von TEXT auf AUDIO:

	config = {"response_modalities": ["AUDIO"]} 

3. Initialisiere einen Audiostream, bevor du dich mit dem Client verbindest:

	with sd.OutputStream(
	samplerate=24000, 
	channels=1, 
	dtype="int16",
) as audio_stream:

4. Greife auf die Audiodaten aus dem Antwortteil zu und füge sie dem Audiostrom aus der Wiedergabe hinzu:

for part in response.server_content.model_turn.parts:
    # Get the audio data from the response part and add it to the steam
    inline_data = part.inline_data
    audio_data = np.frombuffer(inline_data.data, dtype="int16")
    audio_stream.write(audio_data)

Die Datei audio.py im dem Repository enthält das vollständige Skript mit diesen Änderungen. Das Skript enthält Kommentare zu den Zeilen, die sich geändert haben.

Schritt 5: Code-Ausführung mit Tools hinzufügen

Eine der großartigen Eigenschaften moderner KI-Modelle ist ihre Fähigkeit, selbstständig benutzerdefinierte Funktionen in unserem Code aufzurufen, und Gemini 2 ist da keine Ausnahme.

Die Funktionsweise besteht darin, dass wir dem Modell mitteilen, welche Funktionen aufgerufen werden können, indem wir sie als Werkzeuge registrieren. Anhand der Eingabeaufforderung, der Funktionsnamen und der Beschreibungen entscheidet das Modell dann, ob es einen Funktionsaufruf machen will. Wenn er sich dafür entscheidet, sendet er eine spezielle Antwort mit dem Namen der Funktion, die er aufrufen will, und den Argumenten.

Um ein Werkzeug zu definieren, müssen wir:

1. Schreibe eine Python-Funktion mit demselben Namen und denselben Argumenten, wie sie im Schema definiert sind.
2. Erstelle das Funktionsschema, d.h. ein Wörterbuch mit Metadaten über die Funktion, wie z.B. ihren Namen, eine textliche Beschreibung und eine Angabe der Argumente.
3. Stelle das Funktionsschema für das KI-Modell zur Verfügung.
4. Führe die Funktion aus, wenn das Modell sie anfordert.

Um das zu veranschaulichen, definieren wir ein Tool, das eine Datei lesen kann, so dass das Modell Fragen zu Dateien auf unserem lokalen Rechner beantworten kann.

Definieren der Funktion

Dieser Teil ist ganz normaler Python-Code. Das Modell erwartet, dass die Antwort ein Wörterbuch mit einem ”result” Schlüssel ist, wenn die Funktion erfolgreich war, und andernfalls ”error”.

def load_file_content(filename):
    try:
      with open(filename, "rt") as f:
          return {
              "result": f.read()
          }
    except Exception as e:
      return {
          "error": "Could not load file content",
      }

Festlegen des Schemas

So können wir ein Schema für diese Funktion definieren:

load_file_content_schema = {
    "name": "load_file_content",
    "description": "Load the content of a file",
    "parameters": {
        "type": "object",
        "properties": {
            "filename": {
                "type": "string",
                "description": "The name of the file",
            },
        },
        "required": ["filename"],
    },
    "output": {
        "type": "string",
        "description": "The text content of the file",
    },
}

Wir bieten vier Felder an:

• ”name”: Der Name der Funktion.
• ”description”: Eine textliche Beschreibung. Diese wird vom Modell verwendet, um zu entscheiden, ob die Funktion aufgerufen werden soll.
• ”properties”: Beschreibung der Funktionsargumente.
• ”output”: Beschreibung der Funktionsausgabe.

Siehe die offizielle Dokumentation für weitere Informationen über Funktionsschemata.

Bereitstellen der Funktion für das Modell

Damit das Modell über unsere Funktion Bescheid weiß, stellen wir das Funktionsschema in der Modellkonfiguration bereit:

config = {
       "tools": [{"function_declarations": [load_file_content_schema]}], 
       "response_modalities": ["TEXT"]
}

Bearbeitung der Funktionsaufrufanforderung aus dem Modell

Wenn das Modell beschließt, einen Funktionsaufruf durchzuführen, fügt es der response eine tool_call hinzu. Dieser enthält den Namen der Funktion und die Argumente. Sie könnte mehrere Aufrufanforderungen enthalten, also müssen wir sie alle durchgehen, die entsprechenden Funktionen aufrufen und das Ergebnis an das Modell zurückschicken:

# A dictionary mapping the function names to the actual functions
FUNCTIONS = {"load_file_content": load_file_content}
if response.tool_call is not None:
    for fc in tool_call.function_calls:
        f = FUNCTIONS.get(fc.name)
        tool_response = types.LiveClientToolResponse(
            function_responses=[
                types.FunctionResponse(
                    name=fc.name,
                    id=fc.id,
                    response=f(**fc.args),
                )
            ]
        )
    await session.send(tool_response)

Die vollständige Implementierung dieses Beispiels findest du in der Datei tool.py im dem Repository die das vollständige Skript mit diesen Änderungen enthält. Die Funktions- und Schemadefinitionen sind in der der Datei tool_spec.py .

Web-Zugang

Mit Hilfe von Tools können wir dem Modell auch die Möglichkeit geben, auf das Internet zuzugreifen, indem wir das Google-Suchwerkzeug hinzufügen:

search_tool = {"google_search": {}}
config = {
    "tools": [search_tool],
    "response_modalities": ["TEXT"],
}

Dieses Werkzeug ist eingebaut, und deshalb müssen wir keine Funktion bereitstellen.

Code-Ausführung

Eine weitere eingebaute Funktion ist die Codeausführung. Die Code-Ausführung ermöglicht es dem Modell, Python-Code zu schreiben und auszuführen, um komplexe Fragen zu beantworten, die meist mit Mathematik zu tun haben. Wenn wir dieses Tool zum Beispiel bitten, die Summe der ersten 10 Primzahlen zu berechnen, schreibt es zunächst Python-Code, um diese zu berechnen, führt ihn aus und gibt dann die Antwort.

Um das Tool zu aktivieren, tun wir das:

code_execution_tool = {"code_execution": {}}
config = {
    "tools": [code_execution_tool],
    "response_modalities": ["TEXT"],
}

Hier ist ein Beispiel für das Verhalten des Modells bei der Codeausführung:

​​> add the first 10 prime numbers
Okay, I understand. You want me to add the first 10 prime numbers.
Here's my plan:
1. **Identify the first 10 prime numbers:** I will use a python code to find prime numbers.
2. **Sum the prime numbers:** I will also sum them using python.
3. **Report the result**
The first 10 prime numbers are 2, 3, 5, 7, 11, 13, 17, 19, 23, and 29.  Their sum is 129.

Schritt 6: Baue einen visuellen Assistenten

In diesem letzten Abschnitt erkunden wir die visuellen Fähigkeiten von Gemini 2. Das Ziel ist es, einen KI-Assistenten zu schaffen, der die Inhalte auf unserem Bildschirm versteht und Fragen dazu beantworten kann. Das kann zum Beispiel nützlich sein, wenn wir ihn bitten, einen Fehler zu erklären, den wir in unserem Terminal sehen, oder Informationen zu etwas zu liefern, das gerade auf dem Bildschirm angezeigt wird.

In den vorherigen Beispielen haben wir asynchrone Programmierung verwendet, um uns mit dem KI-Modell zu verbinden und Daten hin und her zu senden, während wir die Antworten in Echtzeit verarbeiten. Leider unterstützt die aktuelle Version des SDKs noch keine Echtzeitkommunikation mit Bildern. Stattdessen stellen wir die Bilddaten über einen Anfrage-Antwort-Workflow bereit. Beachte, dass dies keine Einschränkung von Gemini 2.0 selbst ist - es ist nur so, dass die aktuelle Beta-API dies noch nicht unterstützt.

Eine synchrone Anfrage an Google GenAI senden

Beginnen wir damit, zu lernen, wie man eine Anfrage mit Bilddaten an die Google GenAI API sendet. So können wir eine synchrone Anfrage senden:

from google import genai
from dotenv import load_dotenv
import os

load_dotenv()

client = genai.Client(
    api_key=os.getenv("GOOGLE_API_KEY"),
    http_options={"api_version": "v1alpha"},
)

response = client.models.generate_content(
    model="gemini-2.0-flash-exp",
    contents=["Hello"],
)

print(response.text)

Der Hauptunterschied in diesem Beispiel ist, dass wir client.models.generate_content verwenden, um eine Anfrage an die API zu senden. Dies ist eine synchrone Anfrage, d.h. sie bietet keine Konversationsmöglichkeit in Echtzeit.

Ein Bild senden

Wir können ein Bild senden, indem wir es laden und der Inhaltsliste hinzufügen. Wir verwenden das PIL-Paket, um eine Funktion namens load_and_resize_image() zu erstellen, die das Bild lädt und seine Größe ändert.

from PIL import Image

def load_and_resize_image(image_path):
    with Image.open(image_path) as img:
        aspect_ratio = img.height / img.width
        new_height = int(img.width * aspect_ratio)
        return img.resize((img.width, new_height), Image.Resampling.LANCZOS)    

image = load_and_resize_image("example_image.jpeg")

response = client.models.generate_content(
    model="gemini-2.0-flash-exp",
    contents=["Describe the image", image],
)

print(response.text)

Den visuellen KI-Assistenten schaffen

Der visuelle KI-Assistent verarbeitet eine Texteingabe zusammen mit einem Screenshot, um uns bei der Beantwortung von Fragen zu dem, was auf dem Bildschirm zu sehen ist, zu helfen. Ich habe damit ausgiebig experimentiert, und das Modell kann den Bildschirminhalt auch dann verstehen, wenn mehrere Fenster geöffnet sind.

Die einfachste Art, das Modell mit dem Bildschirminhalt zu versorgen, ist, einen Screenshot zu machen. Dazu verwenden wir das Paket pyautogui, eine plattformübergreifende Bibliothek zur programmatischen Steuerung von Maus und Tastatur, um Aufgaben zu automatisieren. In unserem Fall werden wir es nur zum Erstellen von Screenshots verwenden, aber wir könnten die Funktionalität erweitern, damit die KI Aufgaben auf unserem Computer selbstständig ausführen kann.

Hier ist eine Funktion, um einen Screenshot zu machen:

def capture_screen():
    timestamp = time.strftime("%Y%m%d-%H%M%S")
    filename = f"screenshot_{timestamp}.jpeg"
    screenshot = pyautogui.screenshot()
    screenshot = screenshot.convert("RGB")
    screenshot.save(filename, format="JPEG")
    return filename

Um die Anwendung interaktiv zu gestalten, wiederholen wir die folgenden Schritte, bis der/die Nutzer/in sich entscheidet, die Anwendung zu beenden:

1. Fordere den Benutzer auf, eine Eingabeaufforderung einzugeben.
2. Mache einen Screenshot und sende ihn zusammen mit der Aufforderung an das KI-Modell.
3. Zeige dem Benutzer das Ergebnis an.

Bei diesem Ansatz müssen wir eine Sache beachten. Die Anwendung wird im Terminal ausgeführt, das auch auf dem Bildschirm angezeigt wird. Deshalb ist es besser, das Modell anzuweisen, das Terminalfenster zu ignorieren. Das kannst du tun, indem du eine system_instruction zur Konfiguration hinzufügst:

client.models.generate_content(
        model="gemini-2.0-flash-exp",
        contents=[prompt, screen],
        config=types.GenerateContentConfig(
            system_instruction="Ignore the terminal window in the image when analyzing the image",
        ),
)

Das alles zusammengenommen ist unser visueller KI-Assistent. Die Datei mit dem vollständigen Code ist auch als vision.py Datei im dem Repository.

from google import genai
from google.genai import types
from PIL import Image
import pyautogui
import time
import os
from dotenv import load_dotenv
load_dotenv()

# Initialize the GenAI client
client = genai.Client(
    api_key=os.getenv("GOOGLE_API_KEY"),
    http_options={"api_version": "v1alpha"},
)
def capture_screen():
    timestamp = time.strftime("%Y%m%d-%H%M%S")
    filename = f"screenshot_{timestamp}.jpeg"
    screenshot = pyautogui.screenshot()
    screenshot = screenshot.convert("RGB")
    screenshot.save(filename, format="JPEG")
    return filename

def load_and_resize_image(image_path):
    with Image.open(image_path) as img:
        aspect_ratio = img.height / img.width
        new_height = int(img.width * aspect_ratio)
        return img.resize((img.width, new_height), Image.Resampling.LANCZOS)    

def get_genai_response(prompt):
    print("Analyzing screen...")
    screen = load_and_resize_image(capture_screen())
    response = client.models.generate_content(
        model="gemini-2.0-flash-exp",
        contents=[prompt, screen],
        config=types.GenerateContentConfig(
            system_instruction="Ignore the terminal window in the image when analyzing the image",
        ),
    )
    return response.text

def main():
    while True:
        prompt = input("> ")
        print()
        if prompt == "exit":
            break
        answer = get_genai_response(prompt)
        print(answer)
        print()

if __name__ == "__main__":
    main()

Die aktuelle Version ist etwas klobig und erfordert, dass das Terminal über der aktuellen Ansicht geöffnet ist, damit wir es auslösen können. Ein natürlicher nächster Schritt wäre, es im Hintergrund laufen zu lassen und die Spracheingabe und -ausgabe anstelle von Text zu verwenden.

Fazit

Wir haben gelernt, wie wir das Gemini 2.0 Flash-Modell für verschiedene Anwendungen nutzen können, z. B. für die Entwicklung von Chatbots, die in Echtzeit Gespräche mit Text und Stimme führen können, für die Ausführung von Aktionen durch Funktionsaufrufe durch das KI-Modell und für einen visuellen Assistenten, der in der Lage ist, unsere Bildschirminhalte zu analysieren.

Wenn du mehr erfahren möchtest, stellt Google zwei Beispiele zur Verfügung, die die Fähigkeit des Modells zeigen, Objekte in einem Bild zu erkennen, indem ihre Begrenzungsrahmen mit Beschriftungen versehen werden. Dieses Beispiel konzentriert sich auf das räumliche Verständnis in 2D, indem das Modell aufgefordert wird, Törtchen auf einem Bild zu identifizieren und zu beschriften. Gemini kann auch den 3D-Kontext eines Bildes verstehen, wie hier zu sehen ist. hier.

Insgesamt ist Gemini 2.0 sehr vielversprechend, auch wenn die aktuelle Version der API noch nicht ihr volles Potenzial ausschöpfen kann. Ich freue mich darauf, die multimodalen Echtzeitfunktionen in naher Zukunft vollständig zu nutzen.