AI-agenter · leksjon

Agentarbeidsflyter for lyd + tekst

Arbeidsflyter fra ende til ende: transkripsjon → resonnering → lydsvar.

Leksjon 2 av 413 trinn

Agentarbeidsflyter for lyd + tekst er en gratis leksjon i AI-agenter på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI-agenter, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI-agenter inneholder totalt 4 leksjoner.

Oversikt over lyd-tekst-agentpipeline

En lyd-tekst-agentpipeline konverterer mellom den talte og den skrevne verdenen. Den grunnleggende arbeidsflyten er: lyd inn → Whisper-transkripsjon → tekstagent → TTS-lyd ut. Dette muliggjør taleassistenter, samtaleanalyse, møtesammendrag og håndfrie grensesnitt.

Støttede lydformater

OpenAI Whisper støtter: mp3, mp4, mpeg, mpga, m4a, wav, webm. Maksimal filstørrelse er 25 MB. For større filer må De dele opp eller komprimere lyden før De sender den.

For best mulig transkripsjonskvalitet og minst mulig filstørrelse bør De alltid ta opp eller konvertere til 16 kHz mono.

import os

SUPPORTED_FORMATS = {'.mp3', '.mp4', '.mpeg', '.mpga', '.m4a', '.wav', '.webm'}
MAX_FILE_SIZE_BYTES = 25 * 1024 * 1024  # 25 MB

def validate_audio_file(path: str) -> dict:
    ext = os.path.splitext(path)[1].lower()
    size = os.path.getsize(path) if os.path.exists(path) else 0
    return {
        'path': path,
        'format_ok': ext in SUPPORTED_FORMATS,
        'size_ok': size <= MAX_FILE_SIZE_BYTES,
        'size_mb': round(size / 1024 / 1024, 2),
        'extension': ext
    }

# Usage:
info = validate_audio_file('meeting.wav')
print(info)

Transkribere lyd med Whisper

OpenAIs audio.transcriptions.create-endepunkt fungerer som et grensesnitt mot Whisper. Send inn filobjektet, modellnavnet og eventuelt et språkhint (det går raskere og unngår feildeteksjon) samt en ledetekst (forhåndsinnstiller ordforrådet for domenespesifikke termer).

from openai import OpenAI

client = OpenAI(api_key='YOUR_OPENAI_API_KEY')

def transcribe_audio(
    audio_path: str,
    language: str = 'en',
    prompt: str = ''
) -> str:
    with open(audio_path, 'rb') as audio_file:
        transcript = client.audio.transcriptions.create(
            model='whisper-1',
            file=audio_file,
            language=language,
            prompt=prompt,  # e.g. 'Python, NestJS, TypeScript, API'
            response_format='text'
        )
    return transcript

text = transcribe_audio('user_query.mp3', language='en',
                        prompt='Kubernetes, microservices, Docker')
print('Transcription:', text)

Transkripsjon med tidsstempler

For møteanalyse eller talerdiarisering ber De om formatet verbose_json. Dette returnerer tidsstempler på ord- eller segmentnivå, slik at De kan finne nøyaktige tidspunkter i lyden for referanse eller klipping.

def transcribe_with_timestamps(audio_path: str) -> dict:
    from openai import OpenAI
    client = OpenAI(api_key='YOUR_OPENAI_API_KEY')
    with open(audio_path, 'rb') as f:
        result = client.audio.transcriptions.create(
            model='whisper-1',
            file=f,
            response_format='verbose_json',
            timestamp_granularities=['segment']
        )
    # result.segments: list of {start, end, text}
    segments = [
        {'start': s.start, 'end': s.end, 'text': s.text}
        for s in result.segments
    ]
    return {'full_text': result.text, 'segments': segments}

# Example output structure:
# {'full_text': 'Hello team...', 'segments': [{'start': 0.0, 'end': 2.3, 'text': 'Hello team'}]}

Tekstbehandling med agenten

Etter transkripsjonen sendes teksten gjennom LLM-agenten som en vanlig tekstmelding. Inkluder en systeminstruksjon som angir konteksten: teksten kommer fra en muntlig ytring, så forvent fyllord og ufullstendige setninger.

import anthropic

VOICE_AGENT_SYSTEM = (
    'You are a helpful voice assistant. The user\'s message was transcribed from speech '
    'and may contain filler words ("um", "uh"), false starts, or incomplete sentences. '
    'Interpret the intent charitably and respond concisely in 1-3 sentences. '
    'Your response will be converted to speech, so avoid markdown, lists, or code blocks.'
)

def voice_agent_respond(transcription: str) -> str:
    client = anthropic.Anthropic(api_key='YOUR_ANTHROPIC_API_KEY')
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=256,
        system=VOICE_AGENT_SYSTEM,
        messages=[{'role': 'user', 'content': transcription}]
    )
    return response.content[0].text

Tekst-til-tale med OpenAI TTS

Konverter agentens tekstsvar tilbake til tale ved hjelp av OpenAIs TTS-API. Velg en stemme (alloy, echo, fable, onyx, nova, shimmer) og en modell (tts-1 for hastighet, tts-1-hd for kvalitet). Lagre resultatet som en mp3-fil eller strøm det direkte.

from openai import OpenAI
from pathlib import Path

client = OpenAI(api_key='YOUR_OPENAI_API_KEY')

def text_to_speech(
    text: str,
    output_path: str = 'response.mp3',
    voice: str = 'nova',
    model: str = 'tts-1'
) -> str:
    response = client.audio.speech.create(
        model=model,
        voice=voice,
        input=text,
        response_format='mp3'
    )
    Path(output_path).write_bytes(response.content)
    print(f'TTS audio saved to {output_path}')
    return output_path

# Full pipeline:
tts_file = text_to_speech(
    'The weather in London is currently 15 degrees and partly cloudy.',
    voice='nova'
)

Strømming av lydutdata

For sanntidsstemmesvar kan De strømme TTS-lyden i biter i stedet for å vente på hele filen. OpenAIs stream_to_file-hjelpefunksjon eller manuell iterasjon over biter lar Dem begynne å spille av lyd mens resten fortsatt genereres.

from openai import OpenAI

client = OpenAI(api_key='YOUR_OPENAI_API_KEY')

def stream_tts_to_file(text: str, output_path: str):
    # OpenAI SDK streams the audio response
    with client.audio.speech.with_streaming_response.create(
        model='tts-1',
        voice='nova',
        input=text,
        response_format='mp3'
    ) as response:
        response.stream_to_file(output_path)
    print(f'Streamed to {output_path}')

def stream_tts_chunks(text: str):
    """Yield raw audio bytes for piping to an audio player."""
    with client.audio.speech.with_streaming_response.create(
        model='tts-1',
        voice='nova',
        input=text
    ) as response:
        for chunk in response.iter_bytes(chunk_size=4096):
            yield chunk  # pipe to audio player or WebSocket

Dele opp lange lydfiler

Lydfiler som er større enn 25 MB, må deles opp før de sendes til Whisper. Bruk biblioteket pydub til å dele opp filen etter tidsintervaller og behandle hver del uavhengig, før De slår sammen transkripsjonene.

from pydub import AudioSegment
import os

def split_audio(
    path: str,
    chunk_minutes: int = 10
) -> list:
    audio = AudioSegment.from_file(path)
    chunk_ms = chunk_minutes * 60 * 1000
    chunks = []
    os.makedirs('audio_chunks', exist_ok=True)
    for i, start in enumerate(range(0, len(audio), chunk_ms)):
        chunk = audio[start:start + chunk_ms]
        chunk_path = f'audio_chunks/chunk_{i:03d}.mp3'
        chunk.export(chunk_path, format='mp3')
        chunks.append(chunk_path)
    return chunks

def transcribe_long_audio(path: str) -> str:
    chunks = split_audio(path, chunk_minutes=10)
    transcripts = []
    for chunk_path in chunks:
        text = transcribe_audio(chunk_path)
        transcripts.append(text)
    # Clean up chunks
    for chunk_path in chunks:
        os.remove(chunk_path)
    return ' '.join(transcripts)

Sanntidslydpipeline

En sanntidspipeline tar opp mikrofoninndata i biter, sender hver bit til Whisper etter hvert som den kommer inn, og strømmer TTS-utdata tilbake — noe som skaper en tilnærmet sanntids talesamtale. Den største utfordringen er å håndtere forsinkelsen i hvert trinn.

import asyncio
import time

async def realtime_voice_loop(mic_stream, speaker_stream, client):
    """
    mic_stream: async generator yielding audio bytes
    speaker_stream: async callable accepting audio bytes
    """
    buffer = b''
    BUFFER_THRESHOLD = 50 * 1024  # ~3 seconds at 16kHz mono mp3

    async for audio_chunk in mic_stream:
        buffer += audio_chunk

        if len(buffer) >= BUFFER_THRESHOLD:
            t0 = time.time()
            # Save buffer to temp file
            with open('/tmp/voice_chunk.mp3', 'wb') as f:
                f.write(buffer)
            buffer = b''

            # Transcribe
            text = transcribe_audio('/tmp/voice_chunk.mp3')
            print(f'Transcribed ({time.time()-t0:.1f}s): {text}')

            # Agent response
            reply = voice_agent_respond(text)

            # TTS and stream to speaker
            for audio_bytes in stream_tts_chunks(reply):
                await speaker_stream(audio_bytes)

Språkdeteksjon og automatisk ruting

Whisper oppdager automatisk talespråket. Bruk det identifiserte språket til å rute samtalen til riktig agentpersona eller til å angi TTS-språket for svaret.

def transcribe_and_detect_language(audio_path: str) -> dict:
    from openai import OpenAI
    client = OpenAI(api_key='YOUR_OPENAI_API_KEY')
    with open(audio_path, 'rb') as f:
        result = client.audio.transcriptions.create(
            model='whisper-1',
            file=f,
            response_format='verbose_json'
        )
    return {
        'text': result.text,
        'language': result.language,  # e.g. 'english', 'spanish'
        'duration': result.duration
    }

LANGUAGE_VOICE_MAP = {
    'english': 'nova',
    'spanish': 'alloy',
    'french': 'echo',
    'german': 'fable'
}

def respond_in_detected_language(audio_path: str) -> str:
    info = transcribe_and_detect_language(audio_path)
    voice = LANGUAGE_VOICE_MAP.get(info['language'], 'nova')
    reply = voice_agent_respond(info['text'])
    return text_to_speech(reply, voice=voice)

Håndtering av bakgrunnsstøy og dårlig lyd

Lyd av lav kvalitet reduserer transkripsjonsnøyaktigheten. Praktiske tiltak er å forbehandle lyden med støyreduksjon (biblioteket noisereduce), legge til domenets ordforråd i Whisper-parameteren prompt, validere tilliten til transkripsjonen og be om en presisering når tilliten er lav.

def transcribe_with_quality_check(
    audio_path: str,
    min_confidence_words: int = 3
) -> dict:
    from openai import OpenAI
    import string
    client = OpenAI(api_key='YOUR_OPENAI_API_KEY')
    with open(audio_path, 'rb') as f:
        result = client.audio.transcriptions.create(
            model='whisper-1',
            file=f,
            response_format='verbose_json',
            timestamp_granularities=['word']
        )
    # Word count as a basic quality proxy
    words = result.text.translate(
        str.maketrans('', '', string.punctuation)
    ).split()
    quality_ok = len(words) >= min_confidence_words
    return {
        'text': result.text,
        'word_count': len(words),
        'quality_ok': quality_ok,
        'fallback_message': None if quality_ok else 'I could not hear you clearly. Please repeat.'
    }

Kunnskapssjekk

Hva gjør Whisper-parameteren prompt?

Besvar den i den interaktive leksjonen

Oppsummering: arbeidsflyter for lyd-tekst-agenter

Utmerket! Viktigste punkter:

Whisper: støtter mp3/wav/m4a og flere formater, maks. 25 MB; del opp store filer med pydub
Tidsstempler: bruk verbose_json med timestamp_granularities for segmenttidspunkter
TTS: OpenAI TTS med flere stemmealternativer; strøm biter for lav forsinkelse
Språkdeteksjon: Whisper oppdager språket automatisk; rute til riktig stemme eller agent basert på det identifiserte språket
Sanntidspipeline: buffre lydbiter → transkribere → agent → strømme TTS

Neste tema: videoforståelse i agenter — uthenting av bilderuter og temporal resonnering.

Gratis å komme i gang

Lær deg AI-agenter med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 60
Leksjoner: 239

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Agentarbeidsflyter for lyd + tekst» gratis?

Ja – hele teksten i «Agentarbeidsflyter for lyd + tekst» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av AI-agenter-kurset, kan du oppgradere til CoddyKit PRO. Kurset i AI-agenter inneholder totalt 4 leksjoner.

Hva lærer jeg i «Agentarbeidsflyter for lyd + tekst»?

Arbeidsflyter fra ende til ende: transkripsjon → resonnering → lydsvar. Du øver på AI-agenter med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med AI-agenter?

Ingen tidligere erfaring er nødvendig. AI-agenter på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Agentarbeidsflyter for lyd + tekst»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne AI-agenter-leksjonen?

Ja. Alle AI-agenter-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Agenter for bilder + tekst med Claude Vision og GPT-4V
Agentarbeidsflyter for lyd + tekst
Videoforståelse i agenter
Mønstre for resonnering på tvers av modaliteter

← Tilbake til AI-agenter