deepgram-rust-conversational-stt

name	deepgram-rust-conversational-stt
description	Use when implementing Deepgram Flux conversational STT from the Rust SDK, including flux_request APIs, turn events, FluxResponse handling, and turn-detection tuning for voice-agent-style pipelines.
metadata	{"author":"deepgram"}

Using Deepgram Conversational STT (Rust SDK)

Use this skill for Deepgram Flux, the crate's supported turn-based conversational streaming path.

When to use this product

• Building turn-based STT for voice-agent pipelines.
• Handling TurnEvent::{StartOfTurn, EndOfTurn, EagerEndOfTurn, TurnResumed, Update}.
• Tuning end-of-turn behavior with eot_threshold, eager_eot_threshold, and eot_timeout_ms.

Authentication

Flux is under the listen feature.

[dependencies]
deepgram = { version = "0.10.0", default-features = false, features = ["listen"] }
tokio = { version = "1", features = ["full"] }
futures = "0.3"

let dg = deepgram::Deepgram::new(std::env::var("DEEPGRAM_API_KEY")?)?;

Quick start

use std::{io::Write, time::Duration};

use deepgram::{
    common::{
        flux_response::{FluxResponse, TurnEvent},
        options::{Encoding, Model, Options},
    },
    Deepgram,
};
use futures::stream::StreamExt;

static PATH_TO_FILE: &str = "examples/audio/sample-mono.wav";
static AUDIO_CHUNK_SIZE: usize = 18_063;
static FRAME_DELAY: Duration = Duration::from_millis(100);

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DEEPGRAM_API_KEY")?;
    let dg = Deepgram::new(&api_key)?;

    let options = Options::builder()
        .model(Model::FluxGeneralEn)
        .eot_threshold(0.75)
        .eot_timeout_ms(5000)
        .keyterms(["activate", "cancel"])
        .build();

    let mut results = dg
        .transcription()
        .flux_request_with_options(options)
        .encoding(Encoding::Linear32)
        .()
        .(PATH_TO_FILE, AUDIO_CHUNK_SIZE, FRAME_DELAY)
        .?;

    (, results.());
      (result) = results.(). {
         result? {
            FluxResponse::Connected { request_id, sequence_id } => {
                ();
            }
            FluxResponse::TurnInfo { event, turn_index, transcript, end_of_turn_confidence, .. } => {
                 event {
                    TurnEvent::StartOfTurn => (),
                    TurnEvent::EndOfTurn => (),
                    TurnEvent::Update => {
                         !transcript.() {
                            ();
                            std::io::().().();
                        }
                    }
                    _ => {}
                }
            }
            FluxResponse::FatalError { code, description, .. } => {
                ();
                ;
            }
            FluxResponse::(value) => (),
        }
    }

    (())
}

Key parameters

• Entrypoints: flux_request(), flux_request_with_options(options).
• Flux transport builder fields: encoding, sample_rate, then .file(...), .stream(...), or .handle().await?.
• Flux-specific tuning in shared OptionsBuilder: model(Model::FluxGeneralEn), eot_threshold, eager_eot_threshold, eot_timeout_ms, keyterms.
• Main response type: common::flux_response::FluxResponse.

API reference (layered)

1. In-repo
   • src/listen/flux.rs
   • src/common/flux_response.rs
   • src/common/options.rs
   • examples/transcription/flux/simple_flux.rs
   • tests/flux_unknown_messages.rs
   • tests/flux_e2e.rs
2. OpenAPI
   • Raw spec: https://developers.deepgram.com/openapi.yaml
   • Endpoint reference: https://developers.deepgram.com/reference/speech-to-text/listen-flux
3. AsyncAPI
   • Raw spec: https://developers.deepgram.com/asyncapi.yaml
   • Flux channel docs are surfaced from the same product reference page above
4. Context7
   • /llmstxt/developers_deepgram_llms_txt
5. Product docs
   • https://developers.deepgram.com/docs/stt/getting-started

Gotchas

1. Flux is English-only in this crate's model surface. The default supported model is Model::FluxGeneralEn.
2. Real-time pacing matters even more than standard streaming. The example warns that bad chunk size / delay values can break turn detection.
3. Unknown events are intentional. FluxResponse::Unknown and TurnEvent::Unknown are there for forward compatibility; handle them instead of assuming exhaustiveness.
4. Use Flux for turn-taking, not full agent control. If you need TTS replies, prompts, or tool calls, that is Voice Agent territory and not a typed Rust SDK surface yet.

Example files in this repo

• examples/transcription/flux/simple_flux.rs
• examples/transcription/flux/simple_flux_token.rs
• examples/transcription/flux/microphone_flux.rs
• tests/flux_unknown_messages.rs
• tests/flux_e2e.rs

Central product skills

For cross-language Deepgram product knowledge — the consolidated API reference, documentation finder, focused runnable recipes, third-party integration examples, and MCP setup — install the central skills:

npx skills add deepgram/skills

This SDK ships language-idiomatic code skills; deepgram/skills ships cross-language product knowledge (see api, docs, recipes, examples, starters, setup-mcp).

---

Source: deepgram/deepgram-rust-sdk — distributed by TomeVault.