feat: add ElevenLabs TTS integration with on-demand audio buttons

Add text-to-speech narration for portfolio analysis, build, and debate features using ElevenLabs API.

- Create TTSService and DebateAudioGenerator in backend/audio module
- Add on-demand audio buttons to analyse portfolio, build portfolio, and compare strategies pages
- Implement multi-speaker debate audio with distinct voices (bull/bear/consensus)
- Add global state management for audio generation (LAST_BUILD_RESULT, LAST_DEBATE_DATA)
- Configure ElevenLabs API settings in backend/config.py
- Add elevenlabs>=1.0.0 dependency to pyproject.toml
- Update header to reflect 9 MCP servers

Audio generation is triggered on-demand via button clicks after results are available.

README.md

@@ -3,13 +3,15 @@ title: Portfolio Intelligence Platform
 emoji: 📊
 colorFrom: blue
 colorTo: purple
-sdk: docker
-app_port: 7860
+sdk: gradio
+sdk_version: 5.49.1
+app_file: app.py
 pinned: false
 license: mit
 short_description: AI portfolio analysis with multi-agent MCP orchestration
 tags:
-  - mcp-in-action-track-consumer
+  - building-mcp-track-enterprise
+  - building-mcp-track-customer
   - agents
   - mcp
   - portfolio-analysis
@@ -39,7 +41,7 @@ This architecture demonstrates that agentic systems can be both transparent and
 
 ## Hackathon Submission
 
-**Track**: MCP in Action - Consumer
+**Track**: MCP in Action - Consumer | MCP in Action - Enterprise
 
 **Social Media Post**: [TODO: Add link to X/LinkedIn post]
 

app.py

@@ -177,6 +177,11 @@ LAST_STRESS_TEST = None
 LAST_EXPORT_PDF_PATH = None  # Pre-generated PDF export path
 LAST_EXPORT_CSV_PATH = None  # Pre-generated CSV export path
 
+# Global state for audio generation
+LAST_ANALYSIS_TEXT = None  # Stores analysis text for audio generation
+LAST_BUILD_RESULT = None  # Stores build portfolio result for audio
+LAST_DEBATE_DATA = None  # Stores debate data for audio simulation
+
 # Loading screen rotating messages with MCP phases and disclaimers
 LOADING_MESSAGES = [
     "MCP Workflow: Initialising Model Context Protocol servers...",
@@ -964,7 +969,8 @@ async def run_analysis_with_ui_update(
             "results",
             analysis_text,
             performance_metrics,
-            *charts
+            *charts,
+            gr.update(visible=True)  # analysis_audio_btn (show audio button)
         )
 
     except Exception as e:
@@ -1798,7 +1804,7 @@ def create_interface() -> gr.Blocks:
                     <p>AI-powered portfolio analysis with transparent multi-agent MCP orchestration</p>
                     <div class="value-props">
                         <div class="value-prop">
-                            <span>6 MCP Servers</span>
+                            <span>9 MCP Servers</span>
                         </div>
                         <div class="value-prop">
                             <span>Quantitative Models</span>
@@ -2063,6 +2069,21 @@ def create_interface() -> gr.Blocks:
                     with gr.Group(elem_classes="preview-card", visible=False) as build_results_container:
                         build_status = gr.Markdown("", elem_classes="build-status")
 
+                        # Audio narration button and player
+                        with gr.Row():
+                            build_audio_btn = gr.Button(
+                                "🔊 Listen to Portfolio",
+                                variant="secondary",
+                                size="sm",
+                                visible=False
+                            )
+                        build_audio_player = gr.Audio(
+                            label="Portfolio Summary Audio",
+                            interactive=False,
+                            visible=False,
+                            show_download_button=True
+                        )
+
                         with gr.Row():
                             build_regenerate_btn = gr.Button("Regenerate", variant="secondary", size="sm")
 
@@ -2126,6 +2147,21 @@ def create_interface() -> gr.Blocks:
                         compare_consensus = gr.Markdown("")
                         compare_stance = gr.Textbox(label="Stance", interactive=False)
 
+                        # Audio debate button and player
+                        with gr.Row():
+                            compare_audio_btn = gr.Button(
+                                "🎭 Listen to Debate",
+                                variant="secondary",
+                                size="sm",
+                                visible=False
+                            )
+                        compare_audio_player = gr.Audio(
+                            label="Advisory Council Debate Audio",
+                            interactive=False,
+                            visible=False,
+                            show_download_button=True
+                        )
+
                         # Debate transcript
                         with gr.Accordion("View Full Debate", open=False):
                             compare_debate_transcript = gr.JSON(label="Debate Rounds")
@@ -2431,6 +2467,21 @@ def create_interface() -> gr.Blocks:
                     with gr.Column():
                         analysis_output = gr.Markdown("")
 
+                        # Audio narration button and player
+                        with gr.Row():
+                            analysis_audio_btn = gr.Button(
+                                "🔊 Listen to Analysis",
+                                variant="secondary",
+                                size="sm",
+                                visible=False
+                            )
+                        analysis_audio_player = gr.Audio(
+                            label="Audio Summary",
+                            interactive=False,
+                            visible=False,
+                            show_download_button=True
+                        )
+
                         # Performance Metrics Accordion (progressive disclosure)
                         with gr.Accordion("Performance Metrics & Reasoning", open=False):
                             performance_metrics_output = gr.Markdown("")
@@ -2732,6 +2783,183 @@ def create_interface() -> gr.Blocks:
                 test_page: gr.update(visible=True)
             }
 
+        # ============================================================
+        # AUDIO GENERATION HANDLERS
+        # ============================================================
+
+        async def generate_analysis_audio():
+            """Generate audio narration for portfolio analysis on-demand."""
+            global LAST_ANALYSIS_STATE
+
+            if not LAST_ANALYSIS_STATE:
+                logger.warning("No analysis state available for audio generation")
+                return (
+                    gr.update(visible=False),  # audio_player
+                    gr.update(visible=True),   # button
+                )
+
+            try:
+                from backend.audio.tts_service import TTSService
+
+                tts = TTSService()
+                if not tts.is_available():
+                    logger.warning("TTS service not available")
+                    return (
+                        gr.update(visible=False),
+                        gr.update(visible=True),
+                    )
+
+                # Extract analysis text
+                ai_synthesis = LAST_ANALYSIS_STATE.get("ai_synthesis", "")
+                recommendations = LAST_ANALYSIS_STATE.get("recommendations", [])
+
+                if not ai_synthesis and not recommendations:
+                    logger.warning("No analysis content available")
+                    return (
+                        gr.update(visible=False),
+                        gr.update(visible=True),
+                    )
+
+                logger.info("Generating audio for analysis...")
+
+                # Generate audio
+                audio_path = await tts.generate_analysis_narration(
+                    analysis_text=ai_synthesis[:1000],  # Limit to 1000 chars
+                    recommendations=recommendations
+                )
+
+                logger.info(f"Audio generated: {audio_path}")
+
+                return (
+                    gr.update(value=audio_path, visible=True),  # Show audio player
+                    gr.update(visible=True),  # Keep button visible
+                )
+
+            except Exception as e:
+                logger.error(f"Audio generation failed: {e}")
+                return (
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                )
+
+        async def generate_build_audio():
+            """Generate audio narration for built portfolio on-demand."""
+            global LAST_BUILD_RESULT
+
+            if not LAST_BUILD_RESULT:
+                logger.warning("No build result available for audio generation")
+                return (
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                )
+
+            try:
+                from backend.audio.tts_service import TTSService
+
+                tts = TTSService()
+                if not tts.is_available():
+                    logger.warning("TTS service not available")
+                    return (
+                        gr.update(visible=False),
+                        gr.update(visible=True),
+                    )
+
+                # Extract portfolio summary
+                portfolio_summary = LAST_BUILD_RESULT.get("summary", "")
+                holdings = LAST_BUILD_RESULT.get("holdings", [])
+
+                if not portfolio_summary:
+                    logger.warning("No portfolio summary available")
+                    return (
+                        gr.update(visible=False),
+                        gr.update(visible=True),
+                    )
+
+                logger.info("Generating audio for portfolio...")
+
+                # Generate audio
+                audio_path = await tts.generate_portfolio_narration(
+                    portfolio_summary=portfolio_summary[:1000],
+                    holdings=holdings
+                )
+
+                logger.info(f"Audio generated: {audio_path}")
+
+                return (
+                    gr.update(value=audio_path, visible=True),
+                    gr.update(visible=True),
+                )
+
+            except Exception as e:
+                logger.error(f"Audio generation failed: {e}")
+                return (
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                )
+
+        async def generate_debate_audio():
+            """Generate multi-speaker debate audio on-demand."""
+            global LAST_DEBATE_DATA
+
+            if not LAST_DEBATE_DATA:
+                logger.warning("No debate data available for audio generation")
+                return (
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                )
+
+            try:
+                from backend.audio.tts_service import DebateAudioGenerator
+
+                debate_gen = DebateAudioGenerator()
+                if not debate_gen.is_available():
+                    logger.warning("Debate audio generator not available")
+                    return (
+                        gr.update(visible=False),
+                        gr.update(visible=True),
+                    )
+
+                # Extract debate data
+                bull_case = LAST_DEBATE_DATA.get("bull_case", "")
+                bear_case = LAST_DEBATE_DATA.get("bear_case", "")
+                consensus = LAST_DEBATE_DATA.get("consensus", "")
+                bull_confidence = LAST_DEBATE_DATA.get("bull_confidence")
+                bear_confidence = LAST_DEBATE_DATA.get("bear_confidence")
+                stance = LAST_DEBATE_DATA.get("stance")
+
+                if not bull_case or not bear_case or not consensus:
+                    logger.warning("Incomplete debate data")
+                    return (
+                        gr.update(visible=False),
+                        gr.update(visible=True),
+                    )
+
+                logger.info("Generating debate audio...")
+
+                # Generate multi-speaker debate audio
+                audio_path = await debate_gen.generate_debate_audio(
+                    bull_case=bull_case[:1000],
+                    bear_case=bear_case[:1000],
+                    consensus=consensus[:1000],
+                    bull_confidence=bull_confidence,
+                    bear_confidence=bear_confidence,
+                    stance=stance
+                )
+
+                logger.info(f"Debate audio generated: {audio_path}")
+
+                return (
+                    gr.update(value=audio_path, visible=True),
+                    gr.update(visible=True),
+                )
+
+            except Exception as e:
+                logger.error(f"Debate audio generation failed: {e}")
+                return (
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                )
+
         async def handle_build_portfolio(goals, risk_tolerance, constraints, session_state):
             """Handle the Build Portfolio workflow with streaming updates.
 
@@ -2744,6 +2972,7 @@ def create_interface() -> gr.Blocks:
             Yields:
                 Tuple of UI updates: (agent_chat, results_container, status)
             """
+            global LAST_BUILD_RESULT
             logger.info(f"handle_build_portfolio called")
             logger.info(f"Input types - goals: {type(goals).__name__}, risk_tolerance: {type(risk_tolerance).__name__}, constraints: {type(constraints).__name__}")
             logger.info(f"Input values - goals: {goals!r}, risk_tolerance: {risk_tolerance!r}, constraints: {constraints!r}")
@@ -2818,12 +3047,25 @@ def create_interface() -> gr.Blocks:
                         logger.error(f"Full traceback:\n{traceback.format_exc()}")
                         raise
 
+                # Store build result for audio generation
+                if chat_messages:
+                    final_message = chat_messages[-1]
+                    if isinstance(final_message, dict) and "metadata" in final_message:
+                        portfolio_data = final_message.get("metadata", {}).get("portfolio", {})
+                        LAST_BUILD_RESULT = {
+                            "summary": final_message.get("content", ""),
+                            "holdings": portfolio_data.get("holdings", []),
+                            "reasoning": final_message.get("metadata", {}).get("reasoning_trace", [])
+                        }
+                        logger.info("Build result stored for audio generation")
+
                 # Final yield: Show results container
                 logger.info(f"Completed streaming. Yielding final result with {len(chat_messages)} messages")
                 yield (
                     gr.update(value=chat_messages, visible=True),  # build_agent_chat (final state, visible)
                     gr.update(visible=True),  # build_results_container (show results)
-                    "Portfolio built successfully!"  # build_status
+                    "Portfolio built successfully!",  # build_status
+                    gr.update(visible=True)  # build_audio_btn (show audio button)
                 )
 
             except Exception as e:
@@ -2906,6 +3148,7 @@ def create_interface() -> gr.Blocks:
                 Tuple of UI updates: (debate_chat, results_container, status, bull_case, bull_conf,
                                       bear_case, bear_conf, consensus, stance, debate_transcript)
             """
+            global LAST_DEBATE_DATA
             if not portfolio_text or not portfolio_text.strip():
                 yield (
                     gr.update(value=[], visible=False),  # compare_debate_chat (empty, hidden)
@@ -2988,6 +3231,18 @@ def create_interface() -> gr.Blocks:
                                     "confidence": 60  # Default, could parse from title
                                 }
 
+                # Store debate data for audio generation
+                if consensus_data and bull_case_data and bear_case_data:
+                    LAST_DEBATE_DATA = {
+                        "bull_case": bull_case_data.get("thesis", ""),
+                        "bear_case": bear_case_data.get("thesis", ""),
+                        "consensus": consensus_data.get("recommendation", ""),
+                        "bull_confidence": bull_case_data.get("confidence"),
+                        "bear_confidence": bear_case_data.get("confidence"),
+                        "stance": consensus_data.get("stance", "Mixed")
+                    }
+                    logger.info("Debate data stored for audio generation")
+
                 # Final yield: Show results container with analysis
                 yield (
                     gr.update(value=chat_messages, visible=True),  # compare_debate_chat (final state, visible)
@@ -2999,7 +3254,8 @@ def create_interface() -> gr.Blocks:
                     bear_case_data.get("confidence", 0),  # compare_bear_confidence
                     consensus_data.get("recommendation", ""),  # compare_consensus
                     consensus_data.get("stance", "Mixed"),  # compare_stance
-                    chat_messages  # compare_debate_transcript (use chat messages)
+                    chat_messages,  # compare_debate_transcript (use chat messages)
+                    gr.update(visible=True)  # compare_audio_btn (show audio button)
                 )
 
             except Exception as e:
@@ -3903,7 +4159,8 @@ Please try again with different parameters.
                 optimization_plot,
                 load_past_portfolio_dropdown,
                 export_pdf_btn,
-                export_csv_btn
+                export_csv_btn,
+                analysis_audio_btn  # Audio button
             ],
             show_progress="full"
         )
@@ -4440,7 +4697,8 @@ Please try again with different parameters.
             outputs=[
                 build_agent_chat,
                 build_results_container,
-                build_status
+                build_status,
+                build_audio_btn  # Audio button
             ]
         )
 
@@ -4473,7 +4731,8 @@ Please try again with different parameters.
                 compare_bear_confidence,
                 compare_consensus,
                 compare_stance,
-                compare_debate_transcript
+                compare_debate_transcript,
+                compare_audio_btn  # Audio button
             ]
         )
 
@@ -4532,6 +4791,40 @@ Please try again with different parameters.
             ]
         )
 
+        # ============================================================
+        # AUDIO BUTTON EVENT HANDLERS
+        # ============================================================
+
+        # Analysis audio button
+        analysis_audio_btn.click(
+            fn=generate_analysis_audio,
+            inputs=[],
+            outputs=[
+                analysis_audio_player,
+                analysis_audio_btn
+            ]
+        )
+
+        # Build portfolio audio button
+        build_audio_btn.click(
+            fn=generate_build_audio,
+            inputs=[],
+            outputs=[
+                build_audio_player,
+                build_audio_btn
+            ]
+        )
+
+        # Compare/debate audio button
+        compare_audio_btn.click(
+            fn=generate_debate_audio,
+            inputs=[],
+            outputs=[
+                compare_audio_player,
+                compare_audio_btn
+            ]
+        )
+
     return demo
 
 

backend/audio/__init__.py

@@ -0,0 +1,5 @@
+"""Audio generation services for Portfolio Intelligence Platform."""
+
+from backend.audio.tts_service import TTSService, DebateAudioGenerator
+
+__all__ = ["TTSService", "DebateAudioGenerator"]

backend/audio/tts_service.py

@@ -0,0 +1,306 @@
+"""Text-to-Speech service using ElevenLabs API for on-demand audio generation."""
+
+import os
+import logging
+import tempfile
+from typing import Optional, List, Dict, Any
+from elevenlabs.client import AsyncElevenLabs
+from elevenlabs import VoiceSettings
+
+logger = logging.getLogger(__name__)
+
+
+class TTSService:
+    """Text-to-Speech service for generating audio narration on-demand."""
+
+    def __init__(self, api_key: Optional[str] = None):
+        """Initialise TTS service with ElevenLabs API.
+
+        Args:
+            api_key: ElevenLabs API key (uses env var if not provided)
+        """
+        self.api_key = api_key or os.getenv("ELEVENLABS_API_KEY")
+        if not self.api_key:
+            logger.warning("ELEVENLABS_API_KEY not set - audio generation will fail")
+            self.client = None
+        else:
+            self.client = AsyncElevenLabs(api_key=self.api_key)
+
+        # Default voice: George - professional, neutral male voice
+        self.default_voice_id = "JBFqnCBsd6RMkjVDRZzb"
+
+    def is_available(self) -> bool:
+        """Check if TTS service is available."""
+        return self.client is not None
+
+    async def generate_audio(
+        self,
+        text: str,
+        voice_id: Optional[str] = None,
+        model: str = "eleven_multilingual_v2",
+        voice_settings: Optional[VoiceSettings] = None
+    ) -> bytes:
+        """Generate audio from text.
+
+        Args:
+            text: Text to convert to speech
+            voice_id: ElevenLabs voice ID (uses default if not provided)
+            model: ElevenLabs model ID
+            voice_settings: Optional voice customisation
+
+        Returns:
+            Audio data as bytes (MP3 format)
+
+        Raises:
+            RuntimeError: If TTS service not available
+        """
+        if not self.is_available():
+            raise RuntimeError("TTS service not available - check ELEVENLABS_API_KEY")
+
+        if not text or not text.strip():
+            raise ValueError("Text cannot be empty")
+
+        logger.info(f"Generating audio: {len(text)} characters")
+
+        try:
+            audio_generator = await self.client.text_to_speech.convert(
+                text=text,
+                voice_id=voice_id or self.default_voice_id,
+                model_id=model,
+                voice_settings=voice_settings,
+                output_format="mp3_44100_128"
+            )
+
+            # Collect audio chunks
+            audio_chunks = []
+            async for chunk in audio_generator:
+                audio_chunks.append(chunk)
+
+            audio_data = b"".join(audio_chunks)
+            logger.info(f"Audio generated: {len(audio_data)} bytes")
+            return audio_data
+
+        except Exception as e:
+            logger.error(f"Audio generation failed: {e}")
+            raise
+
+    async def generate_analysis_narration(
+        self,
+        analysis_text: str,
+        recommendations: Optional[List[str]] = None
+    ) -> str:
+        """Generate audio narration for portfolio analysis.
+
+        Args:
+            analysis_text: Main analysis text/summary
+            recommendations: Optional list of recommendations
+
+        Returns:
+            Path to generated MP3 file
+        """
+        if not self.is_available():
+            raise RuntimeError("TTS service not available")
+
+        # Build narrative script
+        script = "Portfolio Analysis Summary.\n\n"
+        script += analysis_text
+
+        if recommendations:
+            script += "\n\nRecommendations:\n"
+            for i, rec in enumerate(recommendations, 1):
+                script += f"\n{i}. {rec}\n"
+
+        script += "\n\nThis analysis is for informational purposes only and does not constitute financial advice."
+
+        # Generate audio
+        audio_data = await self.generate_audio(script)
+
+        # Save to temporary file
+        temp_file = tempfile.NamedTemporaryFile(
+            delete=False,
+            suffix=".mp3",
+            prefix="analysis_"
+        )
+        temp_file.write(audio_data)
+        temp_file.close()
+
+        logger.info(f"Analysis narration saved to: {temp_file.name}")
+        return temp_file.name
+
+    async def generate_portfolio_narration(
+        self,
+        portfolio_summary: str,
+        holdings: Optional[List[Dict[str, Any]]] = None
+    ) -> str:
+        """Generate audio narration for built portfolio.
+
+        Args:
+            portfolio_summary: Portfolio summary text
+            holdings: Optional list of holdings with ticker and allocation
+
+        Returns:
+            Path to generated MP3 file
+        """
+        if not self.is_available():
+            raise RuntimeError("TTS service not available")
+
+        script = "Portfolio Construction Complete.\n\n"
+        script += portfolio_summary
+
+        if holdings:
+            script += "\n\nPortfolio Holdings:\n"
+            for holding in holdings[:10]:  # Limit to top 10
+                ticker = holding.get("ticker", "Unknown")
+                weight = holding.get("weight", 0)
+                script += f"{ticker}: {weight:.1f}% allocation. "
+
+        script += "\n\nRemember to conduct your own research before making investment decisions."
+
+        # Generate audio
+        audio_data = await self.generate_audio(script)
+
+        # Save to temporary file
+        temp_file = tempfile.NamedTemporaryFile(
+            delete=False,
+            suffix=".mp3",
+            prefix="portfolio_"
+        )
+        temp_file.write(audio_data)
+        temp_file.close()
+
+        logger.info(f"Portfolio narration saved to: {temp_file.name}")
+        return temp_file.name
+
+
+class DebateAudioGenerator:
+    """Generate multi-speaker audio for debate simulation."""
+
+    def __init__(self, api_key: Optional[str] = None):
+        """Initialise debate audio generator.
+
+        Args:
+            api_key: ElevenLabs API key (uses env var if not provided)
+        """
+        self.api_key = api_key or os.getenv("ELEVENLABS_API_KEY")
+        if not self.api_key:
+            logger.warning("ELEVENLABS_API_KEY not set - audio generation will fail")
+            self.client = None
+        else:
+            self.client = AsyncElevenLabs(api_key=self.api_key)
+
+        # Voice assignments for debate roles
+        self.voices = {
+            "bull": "pNInz6obpgDQGcFmaJgB",     # Adam - optimistic, energetic
+            "bear": "XB0fDUnXU5powFXDhCwa",     # Charlotte - cautious, analytical
+            "consensus": "JBFqnCBsd6RMkjVDRZzb", # George - neutral, professional
+            "moderator": "EXAVITQu4vr4xnSDxMaL"  # Bella - clear, articulate
+        }
+
+    def is_available(self) -> bool:
+        """Check if debate audio generator is available."""
+        return self.client is not None
+
+    async def generate_debate_audio(
+        self,
+        bull_case: str,
+        bear_case: str,
+        consensus: str,
+        bull_confidence: Optional[float] = None,
+        bear_confidence: Optional[float] = None,
+        stance: Optional[str] = None
+    ) -> str:
+        """Generate multi-speaker debate simulation audio.
+
+        Args:
+            bull_case: Bull perspective text
+            bear_case: Bear perspective text
+            consensus: Consensus recommendation text
+            bull_confidence: Bull confidence percentage
+            bear_confidence: Bear confidence percentage
+            stance: Final stance (bullish/bearish/neutral)
+
+        Returns:
+            Path to generated MP3 file with complete debate
+        """
+        if not self.is_available():
+            raise RuntimeError("Debate audio generator not available")
+
+        logger.info("Generating debate simulation audio")
+
+        audio_segments = []
+
+        # Introduction
+        intro_text = "Advisory Council Debate. We will hear from the Bull researcher, followed by the Bear researcher, and conclude with a consensus recommendation."
+        intro_audio = await self._generate_segment(intro_text, self.voices["moderator"])
+        audio_segments.append(intro_audio)
+        audio_segments.append(self._generate_pause(1.0))
+
+        # Bull case
+        bull_intro = f"Bull Case. Confidence level: {bull_confidence:.0f} percent. " if bull_confidence else "Bull Case. "
+        bull_audio = await self._generate_segment(bull_intro + bull_case, self.voices["bull"])
+        audio_segments.append(bull_audio)
+        audio_segments.append(self._generate_pause(1.5))
+
+        # Bear case
+        bear_intro = f"Bear Case. Confidence level: {bear_confidence:.0f} percent. " if bear_confidence else "Bear Case. "
+        bear_audio = await self._generate_segment(bear_intro + bear_case, self.voices["bear"])
+        audio_segments.append(bear_audio)
+        audio_segments.append(self._generate_pause(1.5))
+
+        # Consensus
+        consensus_intro = f"Consensus Recommendation. Final stance: {stance}. " if stance else "Consensus Recommendation. "
+        consensus_audio = await self._generate_segment(consensus_intro + consensus, self.voices["consensus"])
+        audio_segments.append(consensus_audio)
+
+        # Combine all segments
+        final_audio = b"".join(audio_segments)
+
+        # Save to temporary file
+        temp_file = tempfile.NamedTemporaryFile(
+            delete=False,
+            suffix=".mp3",
+            prefix="debate_"
+        )
+        temp_file.write(final_audio)
+        temp_file.close()
+
+        logger.info(f"Debate audio saved to: {temp_file.name}")
+        return temp_file.name
+
+    async def _generate_segment(self, text: str, voice_id: str) -> bytes:
+        """Generate audio segment with specific voice.
+
+        Args:
+            text: Text to convert
+            voice_id: ElevenLabs voice ID
+
+        Returns:
+            Audio data as bytes
+        """
+        audio_generator = await self.client.text_to_speech.convert(
+            text=text,
+            voice_id=voice_id,
+            model_id="eleven_multilingual_v2",
+            output_format="mp3_44100_128"
+        )
+
+        chunks = []
+        async for chunk in audio_generator:
+            chunks.append(chunk)
+
+        return b"".join(chunks)
+
+    def _generate_pause(self, duration: float) -> bytes:
+        """Generate silence pause between segments.
+
+        Args:
+            duration: Pause duration in seconds
+
+        Returns:
+            Silence audio data
+        """
+        # Simple silence: MP3 frame with minimal data
+        # For production, use proper silent MP3 frames
+        sample_rate = 44100
+        silence_samples = int(sample_rate * duration * 0.1)  # Simplified
+        return b'\x00' * silence_samples

backend/config.py

@@ -73,6 +73,18 @@ class Settings(BaseSettings):
         validation_alias="ALPACA_SECRET_KEY"
     )
 
+    # ElevenLabs TTS Configuration
+    elevenlabs_api_key: Optional[str] = Field(
+        default=None,
+        validation_alias="ELEVENLABS_API_KEY",
+        description="ElevenLabs API key for text-to-speech generation"
+    )
+    elevenlabs_enabled: bool = Field(
+        default=True,
+        validation_alias="ELEVENLABS_ENABLED",
+        description="Enable/disable audio generation features"
+    )
+
     # Application Settings
     environment: str = Field(
         default="development",

pyproject.toml

@@ -63,6 +63,8 @@ dependencies = [
     "python-dateutil>=2.8.0",
     # Sentiment Analysis
     "vaderSentiment>=3.3.2",
+    # Text-to-Speech
+    "elevenlabs>=1.0.0",
     # Monitoring & Observability
     "sentry-sdk[fastapi]>=2.0.0",
     "fmp-data>=1.0.2",

uv.lock

@@ -1068,6 +1068,23 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/87/62/9773de14fe6c45c23649e98b83231fffd7b9892b6cf863251dc2afa73643/einops-0.8.1-py3-none-any.whl", hash = "sha256:919387eb55330f5757c6bea9165c5ff5cfe63a642682ea788a6d472576d81737", size = 64359, upload-time = "2025-02-09T03:17:01.998Z" },
 ]
 
+[[package]]
+name = "elevenlabs"
+version = "2.24.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pydantic" },
+    { name = "pydantic-core" },
+    { name = "requests" },
+    { name = "typing-extensions" },
+    { name = "websockets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/48/b8/7ef371670766a09169969531bd9cfb6c3bfebe55ae479d2f009cfff4b2f7/elevenlabs-2.24.0.tar.gz", hash = "sha256:bd5278ea8521aeb463ef4649192b5aa8cedf12be7f9b3ca19c79331a7d33d305", size = 418072, upload-time = "2025-11-21T09:15:34.916Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/52/a21ebfa6a2cadeb3b234a4bd92a59809fbbcbb6024ee2e48774f30daf8cf/elevenlabs-2.24.0-py3-none-any.whl", hash = "sha256:b8d0435f84a3bc0592dd086b4945bd79d9430c6892bf3f75752c03bb53ae3ad6", size = 1121523, upload-time = "2025-11-21T09:15:31.77Z" },
+]
+
 [[package]]
 name = "email-validator"
 version = "2.3.0"
@@ -3483,6 +3500,7 @@ dependencies = [
     { name = "anthropic" },
     { name = "arch" },
     { name = "chronos-forecasting" },
+    { name = "elevenlabs" },
     { name = "fastapi" },
     { name = "fastmcp" },
     { name = "fmp-data" },
@@ -3541,6 +3559,7 @@ requires-dist = [
     { name = "anthropic", specifier = ">=0.39.0" },
     { name = "arch", specifier = ">=8.0.0" },
     { name = "chronos-forecasting", specifier = ">=1.0.0" },
+    { name = "elevenlabs", specifier = ">=1.0.0" },
     { name = "fastapi", specifier = ">=0.104.0" },
     { name = "fastmcp", specifier = ">=2.12.5" },
     { name = "fmp-data", specifier = ">=1.0.2" },