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?
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.ToolCallStepundToolResultStep: 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:
- 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> - 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):
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:
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):

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:
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:
- Schrittarchitektur verwendet: Die neue polymorphe Schrittarchitektur wurde verwendet, um Standardmodelle abzufragen.
- Gestreamte ausdrucksstarke Sprachausgabe: Verwendet Regieanweisungen und Inline-Stimmungs-Tags, um Audio in Echtzeit zu streamen.
- Generierte Musik: Mit Lyria 3 generierte MP3-Tracks und Songtexte.
- Generierte Sketchnotes: Visuelle Zusammenfassungen, die mit Gemini 3 Pro Image (Nano Banana Pro) erstellt wurden.
- Gesteuerte Deep Research: Mit der Funktion „Collaborative Planning“ können Sie Recherchepläne verfeinern.
- Bereitgestellte benutzerdefinierte Agenten: Erstellen Sie Sandbox-Umgebungen mit benutzerdefinierter Steuerung des ausgehenden Traffics, um Code sicher auszuführen.
Weitere Informationen:
- Den SDK-Quellcode und weitere Testfälle finden Sie auf GitHub: glaforge/gemini-interactions-api-sdk.
- Weitere Informationen zu agentischen Designmustern finden Sie im Blog von Guillaume: glaforge.dev.