LLM Kit AssemblyAI

AssemblyAI provider for LLM Kit - High-quality speech-to-text transcription with advanced features like speaker diarization, sentiment analysis, and PII redaction.

Note: This provider uses the standardized builder pattern. See the Quick Start section for the recommended usage.

Features

• Transcription: High-quality speech-to-text transcription with 100+ language support
• Speaker Diarization: Identify and label different speakers in audio
• Sentiment Analysis: Analyze sentiment of transcribed text
• Auto-Chapters and Highlights: Automatically generate chapters and key highlights
• PII Redaction: Redact personally identifiable information from transcripts
• Language Detection: Automatic language detection for audio files
• Two Models: best (highest accuracy) and nano (faster, lower cost)

Installation

Add this to your Cargo.toml:

[dependencies]
llm-kit-assemblyai = "0.1"
llm-kit-core = "0.1"
llm-kit-provider = "0.1"
tokio = { version = "1", features = ["full"] }

Quick Start

Using the Client Builder (Recommended)

use llm_kit_assemblyai::AssemblyAIClient;
use llm_kit_provider::TranscriptionModel;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create provider using the client builder
    let provider = AssemblyAIClient::new()
        .api_key("your-api-key")  // Or use ASSEMBLYAI_API_KEY env var
        .build();
    
    // Create a transcription model
    let model = provider.transcription_model("best");
    
    println!("Model: {}", model.model_id());
    println!("Provider: {}", model.provider());
    Ok(())
}

Using Settings Directly (Alternative)

use llm_kit_assemblyai::{AssemblyAIProvider, AssemblyAIProviderSettings};
use llm_kit_provider::TranscriptionModel;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create provider with settings
    let provider = AssemblyAIProvider::new(AssemblyAIProviderSettings::default());
    
    let model = provider.transcription_model("best");
    
    println!("Model: {}", model.model_id());
    Ok(())
}

Configuration

Environment Variables

Set your AssemblyAI API key as an environment variable:

export ASSEMBLYAI_API_KEY=your-api-key

Using the Client Builder

use llm_kit_assemblyai::AssemblyAIClient;

let provider = AssemblyAIClient::new()
    .api_key("your-api-key")
    .header("Custom-Header", "value")
    .polling_interval_ms(5000)  // Check transcription status every 5s
    .name("my-assemblyai-provider")
    .build();

Builder Methods

The AssemblyAIClient builder supports:

• .api_key(key) - Set the API key
• .name(name) - Set provider name
• .header(key, value) - Add a single custom header
• .headers(map) - Add multiple custom headers
• .polling_interval_ms(ms) - Set polling interval for transcription status (default: 3000ms)
• .build() - Build the provider

Supported Models

AssemblyAI provides two transcription models:

• best: Highest accuracy model (default)
• nano: Faster processing with lower cost

// Use the best model
let model = provider.transcription_model("best");

// Or use the nano model for faster processing
let model = provider.transcription_model("nano");

Provider-Specific Options

AssemblyAI supports advanced transcription features through provider options. These can be passed using the llm-kit-core API or through the provider's direct interface.

Using Provider Options

use llm_kit_core::Transcribe;
use llm_kit_provider::transcription_model::AudioInput;

// Enable speaker diarization
let result = Transcribe::new(model, AudioInput::Data(audio_data))
    .with_provider_options(serde_json::json!({
        "speakerLabels": true,
        "speakersExpected": 2
    }))
    .execute()
    .await?;

Advanced Features

Speaker Diarization

Identify different speakers in the audio:

let result = Transcribe::new(model, AudioInput::Data(audio_data))
    .with_provider_options(serde_json::json!({
        "speakerLabels": true,
        "speakersExpected": 2
    }))
    .execute()
    .await?;

Sentiment Analysis

Analyze the sentiment of transcribed text:

let result = Transcribe::new(model, AudioInput::Data(audio_data))
    .with_provider_options(serde_json::json!({
        "sentimentAnalysis": true
    }))
    .execute()
    .await?;

PII Redaction

Redact personally identifiable information:

let result = Transcribe::new(model, AudioInput::Data(audio_data))
    .with_provider_options(serde_json::json!({
        "redactPii": true,
        "redactPiiPolicies": ["person_name", "phone_number", "email_address"]
    }))
    .execute()
    .await?;

Auto-Chapters and Highlights

Generate chapters and highlights automatically:

let result = Transcribe::new(model, AudioInput::Data(audio_data))
    .with_provider_options(serde_json::json!({
        "autoChapters": true,
        "autoHighlights": true
    }))
    .execute()
    .await?;

Language Detection

Automatically detect the language:

let result = Transcribe::new(model, AudioInput::Data(audio_data))
    .with_provider_options(serde_json::json!({
        "languageDetection": true
    }))
    .execute()
    .await?;

Available Provider Options

All available provider options:

Examples

See the examples/ directory for complete examples:

• transcription.rs - Basic transcription using do_generate() directly

Run examples with:

cargo run --example transcription

Documentation

• API Documentation
• LLM Kit Documentation
• AssemblyAI API Reference

License

Apache-2.0

Contributing

Contributions are welcome! Please see the Contributing Guide for more details.