%pip install --upgrade pip

%pip install -r requirements.txt

import io
import os
import time
 
import anthropic
import elevenlabs
from dotenv import load_dotenv
from IPython.display import Audio

# Load environment variables from .env file
 
load_dotenv()
 
ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")

assert ELEVENLABS_API_KEY is not None, (
    "ERROR: ELEVENLABS_API_KEY not found. Please copy .env.example to .env and add your API keys."
)
assert ANTHROPIC_API_KEY is not None, (
    "ERROR: ANTHROPIC_API_KEY not found. Please copy .env.example to .env and add your API keys."
)
 
elevenlabs_client = elevenlabs.ElevenLabs(
    api_key=ELEVENLABS_API_KEY, base_url="https://api.elevenlabs.io"
)
 
anthropic_client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)

print("Available Models and Voices:\n")
for model in elevenlabs_client.models.list():
    print(f"{model.name}: {model.model_id}")
 
print()
 
voices = elevenlabs_client.voices.search().voices
for voice in voices:
    print(f"{voice.name}: {voice.voice_id}")
 
# Select the first voice for assistant responses
selected_voice = voices[0]
VOICE_ID = selected_voice.voice_id
 
print(f"\nSelected voice: {selected_voice.name} with ID: {VOICE_ID}")

audio = elevenlabs_client.text_to_speech.convert(
    voice_id=VOICE_ID,  # Use the dynamically selected voice
    output_format="mp3_44100_128",
    model_id="eleven_v3",
    text="Hello, Claude. ",
)
 
audio_data = io.BytesIO()
for chunk in audio:
    audio_data.write(chunk)
 
Audio(audio_data.getvalue())

audio_data.seek(0)
 
start_time = time.time()
 
transcription = elevenlabs_client.speech_to_text.convert(file=audio_data, model_id="scribe_v1")
 
end_time = time.time()
transcription_time = end_time - start_time
 
print(f"Transcribed text: {transcription.text}")
print(f"Transcription time: {transcription_time:.2f} seconds")

start_time = time.time()
 
message = anthropic_client.messages.create(
    model="claude-haiku-4-5",
    max_tokens=1000,
    temperature=0,
    messages=[{"role": "user", "content": transcription.text}],
)
 
end_time = time.time()
non_streaming_response_time = end_time - start_time
 
print(message.content[0].text)
print(f"\nResponse time: {non_streaming_response_time:.2f} seconds")

start_time = time.time()
first_token_time = None
 
claude_full_response = ""
 
with anthropic_client.messages.stream(
    model="claude-haiku-4-5",
    max_tokens=1000,
    temperature=0,
    messages=[{"role": "user", "content": transcription.text}],
) as stream:
    for text in stream.text_stream:
        claude_full_response += text
        print(text, end="", flush=True)
        if first_token_time is None:
            first_token_time = time.time()
 
streaming_time_to_first_token = first_token_time - start_time
print(
    f"\n\nStreaming time to first token: {streaming_time_to_first_token:.2f} seconds - reducing perceived latency by {(non_streaming_response_time - streaming_time_to_first_token) * 100 / non_streaming_response_time:.2f}%"
)

start_time = time.time()
first_audio_chunk_time = None
 
audio_buffer = io.BytesIO()
 
audio_generator = elevenlabs_client.text_to_speech.stream(
    voice_id=VOICE_ID,
    output_format="mp3_44100_128",
    text=claude_full_response,
    model_id="eleven_turbo_v2_5",
)
 
for chunk in audio_generator:
    if first_audio_chunk_time is None:
        first_audio_chunk_time = time.time()
    audio_buffer.write(chunk)
 
streaming_tts_time_to_first_chunk = first_audio_chunk_time - start_time
print(f"Streaming TTS time to first audio chunk: {streaming_tts_time_to_first_chunk:.2f} seconds")
 
Audio(audio_buffer.getvalue())

import re
 
sentence_pattern = re.compile(r"[.!?]+")
sentence_buffer = ""
audio_chunks = []
 
start_time = time.time()
first_audio_time = None
 
with anthropic_client.messages.stream(
    model="claude-haiku-4-5",
    max_tokens=1000,
    temperature=0,
    messages=[{"role": "user", "content": transcription.text}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
        sentence_buffer += text
 
        if sentence_pattern.search(sentence_buffer):
            sentences = sentence_pattern.split(sentence_buffer)
 
            # Process all complete sentences (all but the last element)
            for i in range(len(sentences) - 1):
                complete_sentence = sentences[i].strip()
                if complete_sentence:
                    audio_gen = elevenlabs_client.text_to_speech.stream(
                        voice_id=VOICE_ID,
                        output_format="mp3_44100_128",  # Free tier format
                        text=complete_sentence,
                        model_id="eleven_turbo_v2_5",
                    )
 
                    sentence_audio = io.BytesIO()
                    for chunk in audio_gen:
                        if first_audio_time is None:
                            first_audio_time = time.time()
                        sentence_audio.write(chunk)
 
                    audio_chunks.append(sentence_audio.getvalue())
 
            sentence_buffer = sentences[-1]
 
if sentence_buffer.strip():
    audio_gen = elevenlabs_client.text_to_speech.stream(
        voice_id=VOICE_ID,
        output_format="mp3_44100_128",
        text=sentence_buffer.strip(),
        model_id="eleven_turbo_v2_5",
    )
    sentence_audio = io.BytesIO()
    for chunk in audio_gen:
        sentence_audio.write(chunk)
    audio_chunks.append(sentence_audio.getvalue())
 
sentence_streaming_time_to_first_audio = first_audio_time - start_time
print(f"\n\nTime to first audio: {sentence_streaming_time_to_first_audio:.2f} seconds")
 
combined_pcm = b"".join(audio_chunks)
Audio(combined_pcm)