Skip to content
gemini-rs

gemini-rs

Build text agents and Live voice sessions in Rust. Declare tool policies and conversation flows, test them offline, and inspect live behavior.
Get startedBrowse the cookbookOpen the Flow Studio tour

v4.0 · Rust SDK

Choose the application you want to build

Section titled “Choose the application you want to build”
Goal Start here Check before expanding
A text agent Text agents One request, tool result and returned answer
A voice conversation Live sessions Connection, audio output and interruption handling
A constrained tool workflow Governed flows Allowed transitions and denied actions
A conversation test suite Conversation CI Scripted scenarios, independent of model calls
A custom transport Architecture Wire events and the layer you need to replace

The fluent crate supplies application builders. The runtime owns state, callbacks and tool dispatch. The wire crate owns protocol and transport. The independent memory crate adds session memory.

A declared flow can constrain tool dispatch. Its instruction text does not make every model utterance correct. Test control-plane behavior offline, then measure the live model and transport separately.

Connect a voice session

Section titled “Connect a voice session”
use gemini_adk_fluent_rs::prelude::*;


Live::builder()
    .instruction("You are a helpful concierge.")
    .greeting("Greet the caller.")
    .connect_from_env().await?     // Google AI or Vertex — resolved from env
    .talk().await?;                // microphone in, speakers out, barge-in handled

Or with explicit callbacks:

use gemini_adk_fluent_rs::prelude::*;


let handle = Live::builder()
    .voice(Voice::Kore)
    .instruction("You are a helpful voice assistant.")
    .on_audio(|pcm| { /* play audio */ })
    .on_text(|text| print!("{text}"))
    .connect_from_env()
    .await?;


handle.send_text("What's the weather like?").await?;
handle.disconnect().await?;

New here? Start with Setup and Running and Authentication & Connecting, then browse the cookbook (Crawl → Walk → Run → Governed).

Edit and test a session specification

Section titled “Edit and test a session specification”

A whole governed session can be one JSON document (SessionSpec): the conversation or flow, tools, extraction, phases, watchers, computed state, memory, runtime tuning, and its tests. It validates, simulates and generates Rust, Python or Go projects offline. It is stored as versioned bundles that a runtime serves by label. The Studio is the editor for that document:

The Studio: sections, the conversation graph, and a stage's inspector with its allowed tools and completion guard

See Flows as JSON for the format and the Studio tour for the editor.

Find your way around

Section titled “Find your way around”

Memory

The durable memory engine — async-prepare, sync-consume — and its declarative binding into governed state.