Getting Started with Flux

wss://api.deepgram.com/v2/listen?model=flux-general-en

wss://api.deepgram.com/v2/listen?model=flux-general-multi&language_hint=en&language_hint=es

from deepgram import AsyncDeepgramClient

client = AsyncDeepgramClient()

# SDK automatically uses /v2/listen endpoint
async with client.listen.v2.connect(
    model="flux-general-multi",
    encoding="linear16",
    sample_rate=16000,
    request_options={
        "additional_query_parameters": {
            "language_hint": ["en", "es"],
        }
    },
) as connection:
    # Your code here
    pass

 # Install the Deepgram Python SDK
 # https://github.com/deepgram/deepgram-python-sdk
 pip install deepgram-sdk

# Install python-dotenv to protect your API key
pip install python-dotenv

touch .env

DEEPGRAM_API_KEY="your_deepgram_api_key"

import asyncio
import subprocess
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

from deepgram import AsyncDeepgramClient
from deepgram.core.events import EventType
from deepgram.listen.v2.types import ListenV2TurnInfo

# URL for the realtime streaming audio to transcribe
STREAM_URL = "http://stream.live.vc.bbcmedia.co.uk/bbc_world_service"

# Terminal color codes
class Colors:
    GREEN = '\033[92m'    # 0.90-1.00
    YELLOW = '\033[93m'   # 0.80-0.90
    ORANGE = '\033[91m'   # 0.70-0.80 (using red as orange isn't standard)
    RED = '\033[31m'      # <=0.69
    RESET = '\033[0m'     # Reset to default

def get_confidence_color(confidence: float) -> str:
    """Return the appropriate color code based on confidence score"""
    if confidence >= 0.90:
        return Colors.GREEN
    elif confidence >= 0.80:
        return Colors.YELLOW
    elif confidence >= 0.70:
        return Colors.ORANGE
    else:
        return Colors.RED

async def main():
    """Main async function to handle URL streaming to Deepgram Flux"""

    # Create the Deepgram async client
    client = AsyncDeepgramClient() # The API key retrieval happens automatically in the constructor

    try:
        # Connect to Flux with auto-detection for streaming audio
        # SDK automatically connects to: wss://api.deepgram.com/v2/listen?model=flux-general-en&encoding=linear16&sample_rate=16000
        async with client.listen.v2.connect(
            model="flux-general-en",
            encoding="linear16",
            sample_rate="16000"
        ) as connection:

            # Define message handler function
            def on_message(message) -> None:
                msg_type = getattr(message, "type", "Unknown")

                # Show transcription results
                if hasattr(message, 'transcript') and message.transcript:
                    print(f"🎤 {message.transcript}")

                    # Show word-level confidence with color coding
                    if hasattr(message, 'words') and message.words:
                        colored_words = []
                        for word in message.words:
                            color = get_confidence_color(word.confidence)
                            colored_words.append(f"{color}{word.word}({word.confidence:.2f}){Colors.RESET}")
                        words_info = " | ".join(colored_words)
                        print(f"   📝 {words_info}")
                elif msg_type == "Connected":
                    print(f"✅ Connected to Deepgram Flux - Ready for audio!")

            # Set up event handlers
            connection.on(EventType.OPEN, lambda _: print("Connection opened"))
            connection.on(EventType.MESSAGE, on_message)
            connection.on(EventType.CLOSE, lambda _: print("Connection closed"))
            connection.on(EventType.ERROR, lambda error: print(f"Caught: {error}"))

            # Start the connection listening in background (it's already async)
            deepgram_task = asyncio.create_task(connection.start_listening())

            # Convert BBC stream to linear16 PCM using ffmpeg
            print(f"Starting to stream and convert audio from: {STREAM_URL}")

            # Use ffmpeg to convert the compressed BBC stream to linear16 PCM at 16kHz
            ffmpeg_cmd = [
                'ffmpeg',
                '-i', STREAM_URL,           # Input: BBC World Service stream
                '-f', 's16le',              # Output format: 16-bit little-endian PCM (linear16)
                '-ar', '16000',             # Sample rate: 16kHz
                '-ac', '1',                 # Channels: mono
                '-'                         # Output to stdout
            ]

            try:
                # Start ffmpeg process
                process = await asyncio.create_subprocess_exec(
                    *ffmpeg_cmd,
                    stdout=asyncio.subprocess.PIPE,
                    stderr=asyncio.subprocess.PIPE
                )

                print(f"✅ Audio conversion started (BBC → linear16 PCM)")

                # Read converted PCM data and send to Deepgram
                # Note: 1024 bytes = ~32ms of audio at 16kHz linear16
                # For optimal performance, consider using ~2560 bytes (~80ms at 16kHz)
                while True:
                    chunk = await process.stdout.read(1024)
                    if not chunk:
                        break

                    # Send converted linear16 PCM data to Flux
                    await connection._send(chunk)

                await process.wait()

            except Exception as e:
                print(f"Error during audio conversion: {e}")
                if 'process' in locals():
                    stderr = await process.stderr.read()
                    print(f"FFmpeg error: {stderr.decode()}")

            # Wait for Deepgram task to complete (or cancel after timeout)
            try:
                await asyncio.wait_for(deepgram_task, timeout=60)
            except asyncio.TimeoutError:
                print("Stream timeout after 60 seconds")
                deepgram_task.cancel()

    except Exception as e:
        print(f"Caught: {e}")

if __name__ == "__main__":
    asyncio.run(main())

import com.deepgram.DeepgramClient;
import com.deepgram.resources.listen.v2.websocket.V2WebSocketClient;
import com.deepgram.resources.listen.v2.websocket.V2ConnectOptions;
import java.io.*;

public class FluxStreaming {
    static final String STREAM_URL = "http://stream.live.vc.bbcmedia.co.uk/bbc_world_service";
    static final String GREEN  = "\033[92m";
    static final String YELLOW = "\033[93m";
    static final String ORANGE = "\033[91m";
    static final String RED    = "\033[31m";
    static final String RESET  = "\033[0m";

    static String getConfidenceColor(double confidence) {
        if (confidence >= 0.90) return GREEN;
        if (confidence >= 0.80) return YELLOW;
        if (confidence >= 0.70) return ORANGE;
        return RED;
    }

    public static void main(String[] args) throws Exception {
        DeepgramClient deepgram = DeepgramClient.builder().build();

        V2ConnectOptions options = V2ConnectOptions.builder()
            .model("flux-general-en")
            .encoding("linear16")
            .sampleRate(16000)
            .build();

        V2WebSocketClient wsClient = deepgram.listen().v2().v2WebSocket();
        wsClient.connect(options).get(10, java.util.concurrent.TimeUnit.SECONDS);

        wsClient.onConnected(() -> System.out.println("Connected to Deepgram Flux - Ready for audio!"));
        wsClient.onTurnInfo(message -> {
            if (message.getTranscript() != null && !message.getTranscript().isEmpty()) {
                System.out.println("Transcript: " + message.getTranscript());

                if (message.getWords() != null) {
                    StringBuilder sb = new StringBuilder();
                    for (var word : message.getWords()) {
                        String color = getConfidenceColor(word.getConfidence());
                        sb.append(color).append(word.getWord())
                          .append("(").append(String.format("%.2f", word.getConfidence())).append(")")
                          .append(RESET).append(" | ");
                    }
                    System.out.println("  " + sb);
                }
            }
        });
        wsClient.onDisconnected(() -> System.out.println("Connection closed"));
        wsClient.onError(err -> System.err.println("Error: " + err));

        System.out.println("Starting audio stream from: " + STREAM_URL);
        ProcessBuilder pb = new ProcessBuilder(
            "ffmpeg", "-i", STREAM_URL,
            "-f", "s16le", "-ar", "16000", "-ac", "1", "-"
        );
        Process ffmpeg = pb.start();

        // Read FFmpeg output and send to Deepgram (~80ms chunks at 16kHz)
        byte[] buffer = new byte[2560];
        int bytesRead;
        try (InputStream pcm = ffmpeg.getInputStream()) {
            while ((bytesRead = pcm.read(buffer)) != -1) {
                wsClient.sendMedia(okio.ByteString.of(buffer, 0, bytesRead));
            }
        }

        ffmpeg.waitFor();
    }
}