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

1. Willkommen, Gemini-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?

Traditionelle LLM-APIs sind zustandslos und anfrage-/antwortorientiert. Um einen Chatassistenten mit mehreren Gesprächsrunden oder eine komplexe agentische Schleife zu erstellen, mussten Entwickler bisher den Unterhaltungsstatus, die Kürzung des Verlaufs, die Orchestrierung von Tool-Aufrufen und Ausführungsschleifen vollständig im anwendungsseitigen Code verwalten.

Die Gemini Interactions API verlagert diese Komplexität auf den Server. Es handelt sich um eine zustandsbehaftete, sitzungsbasierte API, bei der die Unterhaltungsgrafik von der Google-Infrastruktur gehostet und verwaltet wird. Eine einzelne Interaktion stellt eine zustandsbehaftete Sitzung dar. Wenn Sie damit interagieren, gibt die API eine umfassende, strukturierte Zeitachse zurück, die aus polymorphen Schritten besteht, z. B.:

• ThoughtStep: Der interne Denkprozess des Modells.
• ModelOutputStep: Text-, Audio- oder Bildinhalte, die vom Modell generiert wurden.
• ToolCallStep und ToolResultStep: Vom System oder Modell initiierte Tool-Aufrufe.
• UserInteractionStep: Punkte, an denen das System pausiert, um eine Eingabe oder Genehmigung durch den Nutzer anzufordern.

Was sind verwaltete KI-Agenten?

Die Orchestrierung autonomer KI-Agenten – die Verarbeitung von Schleifen, die Logik für Wiederholungsversuche, Tool-Ausführungsumgebungen und die Statusverwaltung – ist bekanntermaßen schwierig.

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

• Integrierte KI-Agenten: Nutzungsfertige spezialisierte KI-Agenten wie der Deep Research-Agent, der mehrstufige Web-Recherchen durchführt, Ergebnisse zusammenfasst und umfassende Berichte erstellt.
• Benutzerdefinierte verwaltete KI-Agenten: Autonome Entitäten, die Sie definieren. Sie geben Systemanweisungen, fügen Tools hinzu (z. B. Google Suche oder eine Bash-Ausführungsumgebung) und konfigurieren eine Cloud Sandbox – eine sichere, isolierte und containerisierte Laufzeitumgebung mit anpassbaren Regeln für den Netzwerkausgang (z. B. Zugriff nur auf bestimmte Domains wie GitHub).

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

Lerninhalte

• Die neue polymorphe Step-basierte Architektur.
• Ausdrucksstarkes TTS-Audio direkt an Lautsprecher streamen.
• Musik (MP3 + Songtexte) mit Lyria generieren.
• Visuelle Sketchnotes mit Gemini 3 Pro Image erstellen.
• Den Deep Research-Agenten mit Collaborative Planning steuern.
• Einen benutzerdefinierten KI-Agenten mit Regeln für den Netzwerkausgang 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 (von Google AI Studio).

2. Einrichtung: Projekt und API-Schlüssel

Maven-Projekt erstellen

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

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 Eigenschaften der Java-Version auf Java 21:

   <properties>
       <maven.compiler.source>21</maven.compiler.source>
       <maven.compiler.target>21</maven.compiler.target>
   </properties>
   

2. Fügen Sie die SDK-Abhängigkeit in den Block ein:

   <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 von Google AI Studio ab.

Legen Sie den Schlüssel als Umgebungsvariable im Terminal fest:

macOS / Linux :

export GEMINI_API_KEY="your_actual_api_key"

Windows (Eingabeaufforderung) :

set GEMINI_API_KEY="your_actual_api_key"

3. Hallo Welt: Die Step-Architektur

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 und führen Sie die Klasse aus:

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

Wichtiges Konzept: Die response.steps() Liste stellt die chronologische Zeitachse der Interaktion dar. Da Modelle Schlussfolgerungen ziehen können, wird möglicherweise zuerst ein ThoughtStep angezeigt. Es empfiehlt sich, die Schritte zu filtern, um den ModelOutputStep mit dem generierten TextContent zu finden.

4. Steuerbares Audio: Ausdrucksstarkes TTS-Streaming

Mit Gemini 3.1 Flash wird steuerbare Text-zu-Sprache (TTS) eingeführt. Sie können mit Prompts das Tempo, den Ton und die Umgebung der Stimme steuern und emotionale Tags (z. B. [excitedly] oder [whispers]) mitten im Satz verwenden.

In diesem Schritt generieren Sie ausdrucksstarkes Audio und streamen es 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 dessen, was Sie hören, wenn Sie den Code ausführen (mit der Stimme Algenib und emotionalen Tags):

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

Wichtiges Konzept: Wenn Sie .stream(true) festlegen, kann das SDK StepDelta Ereignisse mit AudioDelta Chunks erzeugen. Wir decodieren die Base64-Daten im laufenden Betrieb und leiten sie direkt an die SourceDataLine des Systems weiter, um eine Wiedergabe mit geringer Latenz zu erzielen.

5. Musikgenerierung mit Lyria 3

Mit dem DeepMind Lyria 3-Modell können Sie Musik und Jingles generieren. Wenn Sie zwei Antwortmodalitäten (AUDIO und TEXT) anfordern, können Sie sowohl das generierte Audio (MP3) als auch die Songtexte 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 Musik und Songtexten:

Generierten Song anhören (coding_song.mp3)

Wichtiges Konzept: Die Interactions API gibt native MP3-Bytes zurück, wenn die Modalität AUDIO für Lyria angefordert wird. Es ist keine komplexe Audiodecodierung erforderlich. Sie können die Rohbytes direkt in eine .mp3-Datei schreiben.

6. Visualisierung mit Sketchnotes (Nano Banana Pro)

Mit Gemini 3 Pro Image (auch bekannt als Nano Banana Pro) können Bilder generiert werden. Wenn Sie die Modalität IMAGE anfordern, können Sie Infografiken, Diagramme oder Sketchnotes auf Grundlage von Texteingaben erstellen.

In diesem Schritt generieren Sie eine Sketchnote-Zusammenfassung eines Artikels über verwaltete KI-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 generierte Sketchnote (sketchnote.png), die vom Modell erstellt wurde:

Wichtiges Konzept: Wie bei Audio extrahieren wir die Bildbytes aus dem polymorphen ModelOutputStep, indem wir nach Content.ImageContent filtern. Die Daten werden als Rohbytes zurückgegeben, die direkt als .png-Datei gespeichert werden können.

7. KI-Agenten steuern: Gemeinsame Deep Research

Deep Research ist ein leistungsstarker Agent, der mehrstufige Rechercheaufgaben ausführen kann. Anstatt die Recherche sofort auszuführen, können Sie mit Collaborative Planning den Rechercheplan überprüfen, ändern und steuern, bevor der Agent mit dem Erfassen von Daten beginnt.

Sie implementieren eine Unterhaltung mit mehreren Gesprächsrunden, bei der derselbe serverseitige Status (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 ansehen:

Generierten Deep Research-Bericht ansehen (tpu_history_report.md)

Wichtiges Konzept: Wenn Sie collaborative_planning=true in DeepResearchAgentConfig festlegen, wird der Ausführungsablauf pausiert und der vorgeschlagene Plan zurückgegeben. Anschließend setzen wir die Sitzung mit previousInteractionId fort, um den Agenten zu steuern, bevor wir die Ausführung durch Festlegen auf false starten.

8. Benutzerdefinierte KI-Agenten und Cloud Sandboxes

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

In diesem Schritt stellen Sie einen Agenten bereit, der sicheren Internetzugriff auf github.com hat, und weisen ihn an, ein Repository zu klonen und seine 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-05-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

Den vollständigen Bericht zur Architekturanalyse, der vom benutzerdefinierten Agenten nach dem Klonen des Repositorys erstellt wurde, können Sie hier ansehen:

Ausgabe des GitHub-Analysetools ansehen (github_analysis_report.md)

Wichtiger Hinweis: Benutzerdefinierte Agentenressourcen sollten mit deleteAgent bereinigt werden, wenn sie nicht mehr benötigt werden, um Remote-Sandbox-Ressourcen freizugeben.

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.

Ihr Lernerfolg:

1. Die Step-Architektur: Sie haben die neue polymorphe Step-Architektur verwendet, um Standardmodelle abzufragen.
2. Ausdrucksstarkes TTS-Streaming: Sie haben Regieanweisungen und Inline-Tags für Emotionen verwendet, um Audio in Echtzeit zu streamen.
3. Musik generiert: Sie haben mit Lyria 3 MP3-Tracks und Songtexte generiert.
4. Sketchnotes generiert: Sie haben mit Gemini 3 Pro Image (Nano Banana Pro) visuelle Zusammenfassungen erstellt.
5. Deep Research gesteuert: Sie haben Collaborative Planning verwendet, um Recherchepläne zu verfeinern.
6. Benutzerdefinierte KI-Agenten bereitgestellt: Sie haben Sandbox-Umgebungen mit benutzerdefinierter Steuerung des Netzwerkausgangs erstellt, um Code sicher auszuführen.

Weitere Informationen:

• Quellcode des SDK und weitere Testfälle auf GitHub: glaforge/gemini-interactions-api-sdk
• Weitere Informationen zu agentischen Designmustern im Blog von Guillaume: glaforge.dev