Multimodale Apps und benutzerdefinierte verwaltete Agents mit dem Gemini Interactions Java SDK erstellen

1. Willkommen, Gemini-Entwickler!

Sketchnote für Entwickler

In diesem Codelab erfahren Sie, wie Sie mit dem benutzerdefinierten Gemini Interactions SDK KI-Anwendungen der nächsten Generation in Java erstellen.

Was ist die Gemini Interactions API?

Herkömmliche LLM-APIs sind zustandslos und anfrage-/antwortgesteuert. Um einen Multi-Turn-Chat-Assistenten oder eine komplexe Agentenschleife zu erstellen, mussten Entwickler bisher den Unterhaltungsstatus, die Kürzung des Verlaufs, die Orchestrierung von Toolaufrufen und die Ausführungsschleifen vollständig im clientseitigen Anwendungscode verwalten.

Die Gemini Interactions API verlagert diese Komplexität auf den Server. Es handelt sich um eine zustandsorientierte, sitzungsbasierte API, bei der die Infrastruktur von Google den Konversationsgraphen hostet und verwaltet. Eine einzelne Interaktion stellt eine zustandsorientierte Sitzung dar. Wenn Sie mit der API interagieren, gibt sie eine umfangreiche, strukturierte Zeitachse zurück, die aus polymorphen Schritten besteht, z. B.:

  • ThoughtStep: Der interne Prozess der Problemlösung des Modells.
  • ModelOutputStep: Vom Modell generierte Text-, Audio- oder Bildinhalte.
  • ToolCallStep und ToolResultStep: Vom System oder Modell initiierte Toolaufrufe.
  • UserInteractionStep: Punkte, an denen das System pausiert, um menschliche Eingaben oder Genehmigungen anzufordern.

Was sind verwaltete KI-Agenten?

Die Orchestrierung autonomer Agenten – die Handhabung von Schleifen, Wiederholungslogik, Tool-Ausführungsumgebungen und Zustandsverwaltung – ist bekanntermaßen schwierig.

Verwaltete KI-Agenten sind eine Plattformlösung, die von der Gemini Interactions API bereitgestellt wird. Anstatt Agentenschleifen lokal auszuführen, können Sie spezialisierte Agenten direkt in der Infrastruktur von Google bereitstellen:

  • Integrierte Agenten: Sofort einsatzbereite spezialisierte Agenten wie der Deep Research-Agent, der mehrstufige Web-Recherchen durchführt, Ergebnisse zusammenfasst und umfassende Berichte erstellt.
  • Benutzerdefinierte verwaltete Agenten: Autonome Entitäten, die Sie definieren. Sie stellen Systemanweisungen bereit, hängen Tools an (z. B. die Google Suche oder eine Bash-Ausführungsumgebung) und konfigurieren eine Cloud Sandbox – eine sichere, isolierte und containerisierte Laufzeitumgebung mit anpassbaren Regeln für ausgehenden Traffic (z. B. um den Zugriff nur auf bestimmte Domains wie GitHub zu erlauben).

Mit dem Gemini Interactions Java SDK können Sie diese verwalteten Agenten in Standard-Java-Anwendungen ganz einfach initialisieren, koordinieren und mit ihnen zusammenarbeiten.

Lerninhalte

  • Informationen zur neuen polymorphen Step-basierten Architektur
  • Ausdrucksstarke TTS-Audioinhalte direkt an Lautsprecher streamen
  • So generieren Sie Musik (MP3 + Text) mit Lyria.
  • Visuelle Sketchnotes mit Gemini 3 Pro Image erstellen
  • Deep Research-Agenten mithilfe der kollaborativen Planung steuern
  • Benutzerdefinierten KI-Agenten mit Regeln für ausgehenden Netzwerktraffic und Tools bereitstellen

Voraussetzungen

  • Java 21 oder höher.
  • Apache Maven.
  • Einen Texteditor oder eine IDE (IntelliJ IDEA, VS Code usw.)
  • Einen Gemini API-Schlüssel (aus Google AI Studio).

2. Einrichtung: Projekt und API-Schlüssel

Maven-Projekt erstellen

Erstellen Sie mit dem folgenden Befehl ein neues Maven-Projekt über Ihr Terminal:

mvn archetype:generate \
    -DgroupId=com.example \
    -DartifactId=gemini-interactions-demo \
    -DarchetypeGroupId=org.apache.maven.archetypes \
    -DarchetypeArtifactId=maven-archetype-quickstart \
    -DarchetypeVersion=1.5 \
    -DinteractiveMode=false

Wechseln Sie in das neu erstellte Projektverzeichnis:

cd gemini-interactions-demo

Öffnen Sie die Datei pom.xml und konfigurieren Sie sie:

  1. Aktualisieren Sie die Java-Versionsattribute, um Java 21 als Ziel festzulegen:
    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
    </properties>
    
  2. Fügen Sie die SDK-Abhängigkeit im -Block hinzu:
    <dependency>
        <groupId>io.github.glaforge</groupId>
        <artifactId>gemini-interactions-api-sdk</artifactId>
        <version>0.10.1</version>
    </dependency>
    

API-Schlüssel konfigurieren

Rufen Sie einen Gemini API-Schlüssel aus Google AI Studio ab.

Legen Sie den Schlüssel als Umgebungsvariable in Ihrem Terminal fest:

macOS / Linux:

export GEMINI_API_KEY="your_actual_api_key"

Windows (Eingabeaufforderung):

set GEMINI_API_KEY="your_actual_api_key"

3. Hello World: Navigating the Step Architecture

Mit der Interactions API wurde eine polymorphe, schrittbasierte Zeitachsenarchitektur eingeführt. Anstatt eine flache Liste von Ausgaben zurückzugeben, gibt die API eine Sequenz von typisierten Step-Objekten zurück (z.B. ModelOutputStep, ThoughtStep, FunctionCallStep).

In diesem Schritt schreiben Sie eine einfache Interaktion, um zu verstehen, wie Sie die endgültige Modellausgabe aus dieser Struktur extrahieren.

HelloInteractions.java erstellen

Erstellen Sie die Datei src/main/java/com/example/HelloInteractions.java mit folgendem Inhalt:

package com.example;

import io.github.glaforge.gemini.interactions.GeminiInteractionsClient;
import io.github.glaforge.gemini.interactions.model.*;
import io.github.glaforge.gemini.interactions.model.InteractionParams.ModelInteractionParams;

public class HelloInteractions {
    public static void main(String[] args) {
        // 1. Initialize the client
        GeminiInteractionsClient client = GeminiInteractionsClient.builder()
            .apiKey(System.getenv("GEMINI_API_KEY"))
            .build();

        // 2. Build the request
        ModelInteractionParams request = ModelInteractionParams.builder()
            .model("gemini-3.5-flash")
            .input("Explain the difference between a library and a framework in one sentence.")
            .build();

        // 3. Send request
        Interaction response = client.create(request);
        
        // 4. Navigate the step-based architecture to get the output
        response.steps().stream()
            .filter(step -> step instanceof Step.ModelOutputStep)
            .map(step -> (Step.ModelOutputStep) step)
            .findFirst()
            .ifPresent(step -> System.out.println(step.content().get(0)));
    }
}

Code ausführen

Kompilieren Sie die Klasse und führen Sie sie aus:

mvn compile exec:java -Dexec.mainClass=com.example.HelloInteractions

4. Steuerbares Audio: Streaming Expressive TTS

Gemini 3.1 Flash bietet steuerbare Text-zu-Sprache-Funktionen (TTS). Sie können das Tempo, den Ton und die Umgebung der Stimme mithilfe von Prompts steuern und mitten im Satz emotionale Tags (wie [excitedly] oder [whispers]) verwenden.

In diesem Schritt generieren Sie ausdrucksstarke Audioinhalte und streamen sie direkt an Ihre Lautsprecher.

StreamingDJ.java erstellen

Erstellen Sie die Datei src/main/java/com/example/StreamingDJ.java mit folgendem Inhalt:

package com.example;

import io.github.glaforge.gemini.interactions.GeminiInteractionsClient;
import io.github.glaforge.gemini.interactions.model.*;
import io.github.glaforge.gemini.interactions.model.Config.SpeechConfig;
import io.github.glaforge.gemini.interactions.model.InteractionParams.ModelInteractionParams;
import javax.sound.sampled.*;
import java.util.Base64;
import java.util.stream.Stream;

public class StreamingDJ {
    public static void main(String[] args) throws Exception {
        GeminiInteractionsClient client = GeminiInteractionsClient.builder()
            .apiKey(System.getenv("GEMINI_API_KEY"))
            .build();

        // Prompt defining the voice profile and emotional tags
        String prompt = """
            # AUDIO PROFILE: Jaz R.
            ## THE SCENE: London Studio
            ### DIRECTOR'S NOTES
            Accent: Jaz is a DJ from Brixton, London.
            Style: Bouncy, energetic, high-speed delivery.
            
            #### TRANSCRIPT
            [excitedly] Yes, massive vibes in the studio! 
            [whispers] But keep it down, the boss is coming... 
            [shouting] Turn this up! Let's go!
            """;

        ModelInteractionParams request = ModelInteractionParams.builder()
            .model("gemini-3.1-flash-tts-preview")
            .input(prompt)
            .responseModalities(Interaction.Modality.AUDIO)
            .speechConfig(new SpeechConfig("Algenib", "en-GB"))
            .stream(true) // Enable streaming
            .build();

        System.out.println("Streaming audio from Gemini...");

        try (Stream<Events> eventStream = client.stream(request)) {
            // Configure the Java Audio System for 24kHz Mono 16-bit PCM
            AudioFormat format = new AudioFormat(24000, 16, 1, true, false);
            DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);

            try (SourceDataLine line = (SourceDataLine) AudioSystem.getLine(info)) {
                line.open(format);
                line.start();

                // Process the stream and play audio chunks as they arrive
                eventStream.forEach(event -> {
                    if (event instanceof Events.StepDelta cd && cd.delta() instanceof Events.AudioDelta audioDelta) {
                        byte[] audioData = Base64.getDecoder().decode(audioDelta.data());
                        line.write(audioData, 0, audioData.length);
                    }
                });
                line.drain();
            }
        }
    }
}

Code ausführen

mvn compile exec:java -Dexec.mainClass=com.example.StreamingDJ

Ausgabe anhören

Hier ist ein Audiobeispiel dafür, was Sie hören, wenn Sie den Code ausführen (mit der Stimme Algenib und emotionalen Tags):

Generierte TTS-Ausgabe (tts_output.wav) anhören

5. Musikgenerierung mit Lyria 3

Mit dem DeepMind Lyria 3-Modell können Sie Musik und Jingles generieren. Wenn Sie duale Antwortmodalitäten (AUDIO und TEXT) anfordern, können Sie sowohl die generierte Audiodatei (MP3) als auch den Songtext abrufen.

MusicGenerator.java erstellen

Erstellen Sie die Datei src/main/java/com/example/MusicGenerator.java mit folgendem Inhalt:

package com.example;

import io.github.glaforge.gemini.interactions.GeminiInteractionsClient;
import io.github.glaforge.gemini.interactions.model.*;
import io.github.glaforge.gemini.interactions.model.InteractionParams.ModelInteractionParams;
import io.github.glaforge.gemini.interactions.model.Content.AudioContent;
import java.nio.file.Files;
import java.nio.file.Paths;

public class MusicGenerator {
    public static void main(String[] args) throws Exception {
        GeminiInteractionsClient client = GeminiInteractionsClient.builder()
            .apiKey(System.getenv("GEMINI_API_KEY"))
            .build();

        ModelInteractionParams request = ModelInteractionParams.builder()
            .model("models/lyria-3-clip-preview") // 30-second clip
            .input("An uplifting rock song with acoustic guitars about coding in Java.")
            .responseModalities(
                Interaction.Modality.AUDIO,
                Interaction.Modality.TEXT) // Request both MP3 and Lyrics
            .build();

        System.out.println("Generating music (this might take a moment)...");
        Interaction response = client.create(request);

        // 1. Print the lyrics (TEXT output)
        System.out.println("\n--- Generated Lyrics ---");
        response.steps().stream()
            .filter(step -> step instanceof Step.ModelOutputStep)
            .flatMap(step -> ((Step.ModelOutputStep) step).content().stream())
            .filter(content -> content instanceof Content.TextContent)
            .forEach(content -> System.out.println(((Content.TextContent) content).text()));

        // 2. Save the MP3 (AUDIO output)
        response.steps().stream()
            .filter(step -> step instanceof Step.ModelOutputStep)
            .flatMap(step -> ((Step.ModelOutputStep) step).content().stream())
            .filter(content -> content instanceof AudioContent)
            .map(content -> (AudioContent) content)
            .findFirst()
            .ifPresent(audio -> {
                try {
                    Files.write(Paths.get("coding_song.mp3"), audio.data());
                    System.out.println("\nSuccess: Song saved to coding_song.mp3");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
    }
}

Code ausführen

mvn compile exec:java -Dexec.mainClass=com.example.MusicGenerator

Generierten Song anhören

Hier ist die generierte MP3-Datei (coding_song.mp3) mit der Musik und dem Songtext:

Generierten Song anhören (coding_song.mp3)

6. Visualisieren mit Sketchnotes (Nano Banana Pro)

Gemini 3 Pro Image (auch als Nano Banana Pro bezeichnet) kann Bilder generieren. Wenn Sie die Modalität IMAGE anfordern, können Sie Infografiken, Diagramme oder Sketchnotes basierend auf Texteingaben generieren.

In diesem Schritt erstellen Sie eine Sketchnote-Zusammenfassung eines Artikels über verwaltete Agenten und speichern sie als PNG-Datei.

ImageGenerator.java erstellen

Erstellen Sie die Datei src/main/java/com/example/ImageGenerator.java mit folgendem Inhalt:

package com.example;

import io.github.glaforge.gemini.interactions.GeminiInteractionsClient;
import io.github.glaforge.gemini.interactions.model.*;
import io.github.glaforge.gemini.interactions.model.InteractionParams.ModelInteractionParams;
import io.github.glaforge.gemini.interactions.model.Content.ImageContent;
import java.nio.file.Files;
import java.nio.file.Paths;

public class ImageGenerator {
    public static void main(String[] args) throws Exception {
        GeminiInteractionsClient client = GeminiInteractionsClient.builder()
            .apiKey(System.getenv("GEMINI_API_KEY"))
            .build();

        String articleSummary = """
            Managed Agents in the Gemini API allow developers to run autonomous agents
            that reason, plan, use tools, and execute code inside isolated cloud sandboxes.
            The Gemini API handles the infrastructure (containers, network, runtime).
            It is powered by the Antigravity agent running on Gemini 3.5 Flash.
            The Java Interactions SDK supports these capabilities, utilizing a Step-based
            architecture to model the execution timeline.
            """;

        ModelInteractionParams request = ModelInteractionParams.builder()
            .model("gemini-3-pro-image-preview")
            .input(String.format("""
                Create a hand-drawn and hand-written sketchnote
                style summary infographic, with a pure white background,
                about the following information:
                
                %s
                """, articleSummary))
            .responseModalities(Interaction.Modality.IMAGE) // Request IMAGE modality
            .build();

        System.out.println("Generating sketchnote (this might take a moment)...");
        Interaction response = client.create(request);

        // Save the generated image
        response.steps().stream()
            .filter(step -> step instanceof Step.ModelOutputStep)
            .flatMap(step -> ((Step.ModelOutputStep) step).content().stream())
            .filter(content -> content instanceof ImageContent)
            .map(content -> (ImageContent) content)
            .findFirst()
            .ifPresent(image -> {
                try {
                    Files.write(Paths.get("sketchnote.png"), image.data());
                    System.out.println("Success: Sketchnote saved to sketchnote.png");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
    }
}

Code ausführen

mvn compile exec:java -Dexec.mainClass=com.example.ImageGenerator

Generierte Sketchnote

Hier ist die vom Modell generierte Sketchnote (sketchnote.png):

Generierte Sketchnote

7. KI-Agenten steuern: Kollaborative Deep Research

Deep Research ist ein leistungsstarker KI-Agent, der mehrstufige Rechercheaufgaben ausführen kann. Anstatt die Recherche sofort zu starten, können Sie die gemeinsame Planung nutzen, um den Rechercheplan zu prüfen, zu ändern und zu steuern, bevor der Agent mit der Datenerhebung beginnt.

Sie implementieren eine Unterhaltung mit mehreren Runden, in der derselbe serverseitige Zustand (previousInteractionId) verwendet wird, um einen Plan zu verfeinern.

CollaborativeResearch.java erstellen

Erstellen Sie die Datei src/main/java/com/example/CollaborativeResearch.java mit folgendem Inhalt:

package com.example;

import io.github.glaforge.gemini.interactions.GeminiInteractionsClient;
import io.github.glaforge.gemini.interactions.model.*;
import io.github.glaforge.gemini.interactions.model.InteractionParams.AgentInteractionParams;
import io.github.glaforge.gemini.interactions.model.Config.DeepResearchAgentConfig;
import io.github.glaforge.gemini.interactions.model.Config.ThinkingSummaries;
import io.github.glaforge.gemini.interactions.model.Config.Visualization;

public class CollaborativeResearch {
    public static void main(String[] args) throws Exception {
        GeminiInteractionsClient client = GeminiInteractionsClient.builder()
            .apiKey(System.getenv("GEMINI_API_KEY"))
            .build();

        String agentModel = "deep-research-preview-04-2026";

        // --- Phase 1: Request a Plan ---
        System.out.println("Phase 1: Requesting research plan...");
        AgentInteractionParams planParams = AgentInteractionParams.builder()
            .agent(agentModel)
            .input("Research the latest generations of Google Cloud TPUs (TPU7x and the 8th generation TPU 8t and TPU 8i).")
            .agentConfig(new DeepResearchAgentConfig(
                "deep-research", 
                ThinkingSummaries.AUTO, 
                Visualization.AUTO, 
                true // TRUE enables collaborative planning
            ))
            .background(true)
            .store(true)
            .build();

        Interaction planInteraction = client.create(planParams);
        planInteraction = waitForCompletion(client, planInteraction.id());
        
        System.out.println("\n--- Proposed Plan ---");
        printOutputText(planInteraction);

        // --- Phase 2: Refine the Plan ---
        System.out.println("\nPhase 2: Refining research plan...");
        AgentInteractionParams refineParams = AgentInteractionParams.builder()
            .agent(agentModel)
            .input("Focus on comparing the architectural, performance, and scaling differences between the TPU7x generation and the two flavors of the eighth generation: TPU 8t (optimized for training at scale) and TPU 8i (optimized for low-latency reasoning and inference).")
            .agentConfig(new DeepResearchAgentConfig(
                "deep-research", 
                ThinkingSummaries.AUTO, 
                Visualization.AUTO, 
                true // Keep collaborative planning TRUE to iterate
            ))
            .previousInteractionId(planInteraction.id()) // Resume session
            .background(true)
            .store(true)
            .build();

        Interaction refinedInteraction = client.create(refineParams);
        refinedInteraction = waitForCompletion(client, refinedInteraction.id());

        System.out.println("\n--- Refined Plan ---");
        printOutputText(refinedInteraction);

        // --- Phase 3: Approve and Execute ---
        System.out.println("\nPhase 3: Approving plan and starting deep research (this will take a few minutes)...");
        AgentInteractionParams executeParams = AgentInteractionParams.builder()
            .agent(agentModel)
            .input("Plan looks good, execute!")
            .agentConfig(new DeepResearchAgentConfig(
                "deep-research", 
                ThinkingSummaries.AUTO, 
                Visualization.AUTO, 
                false // FALSE approves the plan and executes the research
            ))
            .previousInteractionId(refinedInteraction.id()) // Resume session
            .background(true)
            .store(true)
            .build();

        Interaction finalReport = client.create(executeParams);
        finalReport = waitForCompletion(client, finalReport.id());

        System.out.println("\n--- Final Research Report ---");
        printOutputText(finalReport);
    }

    private static Interaction waitForCompletion(GeminiInteractionsClient client, String id) throws Exception {
        Interaction interaction = client.get(id);
        while (interaction.status() != Interaction.Status.COMPLETED && interaction.status() != Interaction.Status.FAILED) {
            Thread.sleep(5000);
            interaction = client.get(id);
        }
        if (interaction.status() == Interaction.Status.FAILED) {
            throw new RuntimeException("Interaction failed. Status: " + interaction.status());
        }
        return interaction;
    }

    private static void printOutputText(Interaction interaction) {
        interaction.steps().stream()
            .filter(step -> step instanceof Step.ModelOutputStep)
            .flatMap(step -> ((Step.ModelOutputStep) step).content().stream())
            .filter(content -> content instanceof Content.TextContent)
            .forEach(content -> System.out.println(((Content.TextContent) content).text()));
    }
}

Code ausführen

mvn compile exec:java -Dexec.mainClass=com.example.CollaborativeResearch

Generierte Berichtsausgabe

Der Deep Research-Agent erstellt einen umfassenden, strukturierten Bericht. Den vollständigen Bericht, der durch die Beispielausführung generiert wurde, können Sie hier aufrufen:

Generierten Deep Research-Bericht (tpu_history_report.md) ansehen

8. Benutzerdefinierte KI-Agenten und Cloud-Sandboxes

Für komplexe Entwickleraufgaben können Sie benutzerdefinierte KI-Agenten bereitstellen. Sie definieren die Systemanweisungen, statten sie mit Tools (z. B. Code-Ausführung/Bash) aus und konfigurieren ihre Remote-Umgebung (z. B. Regeln für ausgehenden Traffic).

In diesem Schritt stellen Sie einen KI-Agenten mit sicherem Internetzugriff auf github.com bereit und weisen ihn an, ein Repository zu klonen und die Konfigurationsdateien in seiner Cloud-Sandbox zu analysieren.

GitHubAnalyzer.java erstellen

Erstellen Sie die Datei src/main/java/com/example/GitHubAnalyzer.java mit folgendem Inhalt:

package com.example;

import io.github.glaforge.gemini.interactions.GeminiInteractionsClient;
import io.github.glaforge.gemini.interactions.model.*;
import io.github.glaforge.gemini.interactions.model.InteractionParams.AgentInteractionParams;
import java.util.List;

public class GitHubAnalyzer {
    public static void main(String[] args) throws Exception {
        GeminiInteractionsClient client = GeminiInteractionsClient.builder()
            .apiKey(System.getenv("GEMINI_API_KEY"))
            .build();

        String agentId = "github-analyzer-codelab";

        // 1. Define the Custom Agent with Network Egress and Tools
        Agent customAgent = Agent.builder()
            .id(agentId)
            .description("Clones and analyzes GitHub repos.")
            .baseAgent("antigravity-preview-09-2026")
            .baseEnvironment(new EnvironmentConfig(
                new EnvironmentNetworkEgressAllowlist(List.of(
                    new AllowlistEntry("github.com") // Allow git clone over HTTPS
                )),
                List.of()
            ))
            .systemInstruction("You are an architect. Clone the repo, inspect files, and write a summary.")
            .tools(List.of(
                new AgentTool.CodeExecution(), // Enables terminal bash execution in sandbox
                new AgentTool.GoogleSearch()
            ))
            .build();

        // 2. Provision the Agent
        System.out.println("Provisioning custom agent in the cloud...");
        client.createAgent(customAgent);

        try {
            // 3. Start the Interaction
            AgentInteractionParams params = AgentInteractionParams.builder()
                .agent(agentId)
                .input("Clone https://github.com/glaforge/gemini-interactions-api-sdk and explain its pom.xml structure.")
                .environment("remote") // Crucial: Run in cloud sandbox
                .build();

            System.out.println("Starting clone and analysis (polling status)...");
            Interaction interaction = client.create(params);

            // 4. Poll for completion
            while (interaction.status() != Interaction.Status.COMPLETED) {
                System.out.println("Agent working... Status: " + interaction.status());
                Thread.sleep(5000);
                interaction = client.get(interaction.id());
            }

            // 5. Output the results
            System.out.println("\n--- Architectural Analysis ---");
            interaction.steps().stream()
                .filter(step -> step instanceof Step.ModelOutputStep)
                .flatMap(step -> ((Step.ModelOutputStep) step).content().stream())
                .filter(content -> content instanceof Content.TextContent)
                .forEach(content -> System.out.println(((Content.TextContent) content).text()));

        } finally {
            // 6. Clean up resources
            client.deleteAgent(agentId);
            System.out.println("\nCustom agent resource deleted from cloud.");
        }
    }
}

Code ausführen

mvn compile exec:java -Dexec.mainClass=com.example.GitHubAnalyzer

Generierte Analyseausgabe

Nachdem Sie das Repository geklont haben, können Sie sich den vollständigen Architekturbericht, der vom benutzerdefinierten Agenten erstellt wurde, hier ansehen:

GitHub Analyzer-Ausgabe ansehen (github_analysis_report.md)

9. Glückwunsch!

Sie haben das Codelab abgeschlossen und gelernt, wie Sie mit dem Gemini Interactions SDK komplexe, multimodale und agentische Workflows in Java erstellen.

Was Sie erreicht haben:

  1. Schrittarchitektur verwendet: Die neue polymorphe Schrittarchitektur wurde verwendet, um Standardmodelle abzufragen.
  2. Gestreamte ausdrucksstarke Sprachausgabe: Verwendet Regieanweisungen und Inline-Stimmungs-Tags, um Audio in Echtzeit zu streamen.
  3. Generierte Musik: Mit Lyria 3 generierte MP3-Tracks und Songtexte.
  4. Generierte Sketchnotes: Visuelle Zusammenfassungen, die mit Gemini 3 Pro Image (Nano Banana Pro) erstellt wurden.
  5. Gesteuerte Deep Research: Mit der Funktion „Collaborative Planning“ können Sie Recherchepläne verfeinern.
  6. Bereitgestellte benutzerdefinierte Agenten: Erstellen Sie Sandbox-Umgebungen mit benutzerdefinierter Steuerung des ausgehenden Traffics, um Code sicher auszuführen.

Weitere Informationen: