Update app.py

app.py

@@ -6,21 +6,35 @@ import base64
 from PIL import Image
 import io
 import requests
-from mcp.client.sse import SSEServerParameters
-from mcp.jsonrpc.client import JsonRpcClient
-from mcp.client.base import ServerCapabilities
+from typing import Dict, List, Optional, Any, Union
+import time
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
 ACCESS_TOKEN = os.getenv("HF_TOKEN")
-print("Access token loaded.")
+logger.info("Access token loaded.")
+
+# MCP Client Configuration
+MCP_SERVERS = {}
+try:
+    mcp_config = os.getenv("MCP_CONFIG")
+    if mcp_config:
+        MCP_SERVERS = json.loads(mcp_config)
+        logger.info(f"Loaded MCP configuration: {len(MCP_SERVERS)} servers defined")
+except Exception as e:
+    logger.error(f"Error loading MCP configuration: {e}")
 
 # Function to encode image to base64
 def encode_image(image_path):
     if not image_path:
-        print("No image path provided")
+        logger.warning("No image path provided")
         return None
     
     try:
-        print(f"Encoding image from path: {image_path}")
+        logger.info(f"Encoding image from path: {image_path}")
         
         # If it's already a PIL Image
         if isinstance(image_path, Image.Image):
@@ -37,117 +51,134 @@ def encode_image(image_path):
         buffered = io.BytesIO()
         image.save(buffered, format="JPEG")
         img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
-        print("Image encoded successfully")
+        logger.info("Image encoded successfully")
         return img_str
     except Exception as e:
-        print(f"Error encoding image: {e}")
+        logger.error(f"Error encoding image: {e}")
         return None
 
-# MCP Client class for handling MCP server connections
+# MCP Client implementation
 class MCPClient:
-    def __init__(self, url):
-        self.url = url
-        self.client = None
-        self.capabilities = None
-        self.tools = None
+    def __init__(self, server_url: str):
+        self.server_url = server_url
+        self.session_id = None
+        logger.info(f"Initialized MCP Client for server: {server_url}")
     
-    def connect(self):
+    def connect(self) -> bool:
+        """Establish connection with the MCP server"""
         try:
-            # Connect to the MCP server using SSE
-            server_params = SSEServerParameters(url=self.url)
-            self.client = JsonRpcClient(server_params)
-            self.client.connect()
-            
-            # Get server capabilities
-            self.capabilities = ServerCapabilities(self.client)
-            
-            # List available tools
-            self.tools = self.capabilities.list_tools()
-            print(f"Connected to MCP Server. Available tools: {[tool.name for tool in self.tools]}")
-            return True
+            response = requests.post(
+                f"{self.server_url}/connect",
+                json={"client": "Serverless-TextGen-Hub", "version": "1.0.0"}
+            )
+            if response.status_code == 200:
+                result = response.json()
+                self.session_id = result.get("session_id")
+                logger.info(f"Connected to MCP server with session ID: {self.session_id}")
+                return True
+            else:
+                logger.error(f"Failed to connect to MCP server: {response.status_code} - {response.text}")
+                return False
         except Exception as e:
-            print(f"Error connecting to MCP server: {e}")
+            logger.error(f"Error connecting to MCP server: {e}")
             return False
     
-    def call_tool(self, tool_name, **kwargs):
-        if not self.client or not self.tools:
-            print("MCP client not initialized or no tools available")
-            return None
-        
-        # Find the tool with the given name
-        tool = next((t for t in self.tools if t.name == tool_name), None)
-        if not tool:
-            print(f"Tool '{tool_name}' not found")
-            return None
+    def list_tools(self) -> List[Dict]:
+        """List available tools from the MCP server"""
+        if not self.session_id:
+            if not self.connect():
+                return []
         
         try:
-            # Call the tool with the given arguments
-            result = self.client.call_method("tools/call", {"name": tool_name, "arguments": kwargs})
-            return result
+            response = requests.get(
+                f"{self.server_url}/tools/list",
+                headers={"X-MCP-Session": self.session_id}
+            )
+            if response.status_code == 200:
+                result = response.json()
+                tools = result.get("tools", [])
+                logger.info(f"Retrieved {len(tools)} tools from MCP server")
+                return tools
+            else:
+                logger.error(f"Failed to list tools: {response.status_code} - {response.text}")
+                return []
         except Exception as e:
-            print(f"Error calling tool '{tool_name}': {e}")
-            return None
+            logger.error(f"Error listing tools: {e}")
+            return []
     
-    def close(self):
-        if self.client:
-            try:
-                self.client.close()
-                print("MCP client connection closed")
-            except Exception as e:
-                print(f"Error closing MCP client connection: {e}")
-
-# Function to convert text to audio using Kokoro MCP server
-def text_to_audio(text, speed=1.0, mcp_url=None):
-    """Convert text to audio using Kokoro MCP server if available.
-    
-    Args:
-        text (str): Text to convert to speech
-        speed (float): Speed multiplier for speech
-        mcp_url (str): URL of the Kokoro MCP server
+    def call_tool(self, tool_name: str, args: Dict) -> Dict:
+        """Call a tool on the MCP server"""
+        if not self.session_id:
+            if not self.connect():
+                return {"error": "Not connected to MCP server"}
         
-    Returns:
-        tuple: (sample_rate, audio_array) or None if conversion fails
+        try:
+            response = requests.post(
+                f"{self.server_url}/tools/call",
+                headers={"X-MCP-Session": self.session_id},
+                json={"name": tool_name, "arguments": args}
+            )
+            if response.status_code == 200:
+                result = response.json()
+                logger.info(f"Successfully called tool {tool_name}")
+                return result
+            else:
+                error_msg = f"Failed to call tool {tool_name}: {response.status_code} - {response.text}"
+                logger.error(error_msg)
+                return {"error": error_msg}
+        except Exception as e:
+            error_msg = f"Error calling tool {tool_name}: {e}"
+            logger.error(error_msg)
+            return {"error": error_msg}
+
+# Text-to-speech client function
+def text_to_speech(text: str, server_name: str = None) -> Optional[str]:
     """
-    if not text or not mcp_url:
+    Convert text to speech using an MCP TTS server
+    Returns an audio URL that can be embedded in the chat
+    """
+    if not server_name or server_name not in MCP_SERVERS:
+        logger.warning(f"TTS server {server_name} not configured")
         return None
     
-    try:
-        # Connect to MCP server
-        mcp_client = MCPClient(mcp_url)
-        if not mcp_client.connect():
-            return None
-        
-        # Call the text_to_audio tool
-        result = mcp_client.call_tool("text_to_audio", text=text, speed=speed)
-        mcp_client.close()
-        
-        if not result:
-            return None
-        
-        # Process the result - convert base64 audio to numpy array
-        import numpy as np
-        import base64
-        
-        # Assuming the result contains base64-encoded WAV data
-        audio_b64 = result
-        audio_data = base64.b64decode(audio_b64)
-        
-        # Convert to numpy array - this is simplified and may need adjustment
-        # based on the actual output format from the Kokoro MCP server
-        import io
-        import soundfile as sf
-        
-        audio_io = io.BytesIO(audio_data)
-        audio_array, sample_rate = sf.read(audio_io)
-        
-        return (sample_rate, audio_array)
-    except Exception as e:
-        print(f"Error converting text to audio: {e}")
+    server_url = MCP_SERVERS[server_name].get("url")
+    if not server_url:
+        logger.warning(f"No URL found for TTS server {server_name}")
+        return None
+    
+    client = MCPClient(server_url)
+    
+    # List available tools to find the TTS tool
+    tools = client.list_tools()
+    tts_tool = next((t for t in tools if "text_to_audio" in t["name"] or "tts" in t["name"]), None)
+    
+    if not tts_tool:
+        logger.warning(f"No TTS tool found on server {server_name}")
+        return None
+    
+    # Call the TTS tool
+    result = client.call_tool(tts_tool["name"], {"text": text, "speed": 1.0})
+    
+    if "error" in result:
+        logger.error(f"TTS error: {result['error']}")
+        return None
+    
+    # Process the result - usually a base64 encoded WAV
+    audio_data = result.get("audio") or result.get("content") or result.get("result")
+    
+    if isinstance(audio_data, str) and audio_data.startswith("data:audio"):
+        # Already a data URL
+        return audio_data
+    elif isinstance(audio_data, str):
+        # Assume it's base64 encoded
+        return f"data:audio/wav;base64,{audio_data}"
+    else:
+        logger.error(f"Unexpected TTS result format: {type(audio_data)}")
         return None
 
 def respond(
     message,
-    image_files,
+    image_files,  # Changed parameter name and structure
     history: list[tuple[str, str]],
     system_message,
     max_tokens,
@@ -160,35 +191,33 @@ def respond(
     custom_model,    
     model_search_term,
     selected_model,
-    mcp_server_url=None,
     tts_enabled=False,
-    tts_speed=1.0
+    tts_server=None
 ):
-    print(f"Received message: {message}")
-    print(f"Received {len(image_files) if image_files else 0} images")
-    print(f"History: {history}")
-    print(f"System message: {system_message}")
-    print(f"Max tokens: {max_tokens}, Temperature: {temperature}, Top-P: {top_p}")
-    print(f"Frequency Penalty: {frequency_penalty}, Seed: {seed}")
-    print(f"Selected provider: {provider}")         
-    print(f"Custom API Key provided: {bool(custom_api_key.strip())}")
-    print(f"Selected model (custom_model): {custom_model}")  
-    print(f"Model search term: {model_search_term}")
-    print(f"Selected model from radio: {selected_model}")
-    print(f"MCP Server URL: {mcp_server_url}")
-    print(f"TTS Enabled: {tts_enabled}")
+    logger.info(f"Received message: {message}")
+    logger.info(f"Received {len(image_files) if image_files else 0} images")
+    logger.info(f"History: {history}")
+    logger.info(f"System message: {system_message}")
+    logger.info(f"Max tokens: {max_tokens}, Temperature: {temperature}, Top-P: {top_p}")
+    logger.info(f"Frequency Penalty: {frequency_penalty}, Seed: {seed}")
+    logger.info(f"Selected provider: {provider}")         
+    logger.info(f"Custom API Key provided: {bool(custom_api_key.strip())}")
+    logger.info(f"Selected model (custom_model): {custom_model}")  
+    logger.info(f"Model search term: {model_search_term}")
+    logger.info(f"Selected model from radio: {selected_model}")
+    logger.info(f"TTS enabled: {tts_enabled}, TTS server: {tts_server}")
 
     # Determine which token to use
     token_to_use = custom_api_key if custom_api_key.strip() != "" else ACCESS_TOKEN
     
     if custom_api_key.strip() != "":
-        print("USING CUSTOM API KEY: BYOK token provided by user is being used for authentication")
+        logger.info("USING CUSTOM API KEY: BYOK token provided by user is being used for authentication")
     else:
-        print("USING DEFAULT API KEY: Environment variable HF_TOKEN is being used for authentication")
+        logger.info("USING DEFAULT API KEY: Environment variable HF_TOKEN is being used for authentication")
     
     # Initialize the Inference Client with the provider and appropriate token
     client = InferenceClient(token=token_to_use, provider=provider)
-    print(f"Hugging Face Inference Client initialized with {provider} provider.")
+    logger.info(f"Hugging Face Inference Client initialized with {provider} provider.")
 
     # Convert seed to None if -1 (meaning random)
     if seed == -1:
@@ -220,14 +249,14 @@ def respond(
                             }
                         })
                 except Exception as e:
-                    print(f"Error encoding image: {e}")
+                    logger.error(f"Error encoding image: {e}")
     else:
         # Text-only message
         user_content = message
 
     # Prepare messages in the format expected by the API
     messages = [{"role": "system", "content": system_message}]
-    print("Initial messages array constructed.")
+    logger.info("Initial messages array constructed.")
 
     # Add conversation history to the context
     for val in history:
@@ -256,29 +285,29 @@ def respond(
                                     }
                                 })
                         except Exception as e:
-                            print(f"Error encoding history image: {e}")
+                            logger.error(f"Error encoding history image: {e}")
                 
                 messages.append({"role": "user", "content": history_content})
             else:
                 # Regular text message
                 messages.append({"role": "user", "content": user_part})
-            print(f"Added user message to context (type: {type(user_part)})")
+            logger.info(f"Added user message to context (type: {type(user_part)})")
         
         if assistant_part:
             messages.append({"role": "assistant", "content": assistant_part})
-            print(f"Added assistant message to context: {assistant_part}")
+            logger.info(f"Added assistant message to context: {assistant_part}")
 
     # Append the latest user message
     messages.append({"role": "user", "content": user_content})
-    print(f"Latest user message appended (content type: {type(user_content)})")
+    logger.info(f"Latest user message appended (content type: {type(user_content)})")
 
     # Determine which model to use, prioritizing custom_model if provided
     model_to_use = custom_model.strip() if custom_model.strip() != "" else selected_model
-    print(f"Model selected for inference: {model_to_use}")
+    logger.info(f"Model selected for inference: {model_to_use}")
 
     # Start with an empty string to build the response as tokens stream in
     response = ""
-    print(f"Sending request to {provider} provider.")
+    logger.info(f"Sending request to {provider} provider.")
 
     # Prepare parameters for the chat completion request
     parameters = {
@@ -301,7 +330,7 @@ def respond(
             **parameters
         )
         
-        print("Received tokens: ", end="", flush=True)
+        logger.info("Received tokens: ")
         
         # Process the streaming response
         for chunk in stream:
@@ -314,26 +343,28 @@ def respond(
                         response += token_text
                         yield response
         
+        # If TTS is enabled and we have a response, convert it to speech
+        if tts_enabled and tts_server and response:
+            logger.info(f"Converting response to speech using TTS server: {tts_server}")
+            try:
+                audio_url = text_to_speech(response, tts_server)
+                if audio_url:
+                    # Add audio tag to the end of the response
+                    response += f"\n\n<audio src='{audio_url}' controls></audio>"
+                    yield response
+                else:
+                    logger.warning("TTS conversion failed, continuing without audio")
+            except Exception as e:
+                logger.error(f"Error in TTS conversion: {e}")
+                # Continue without TTS if there's an error
+        
         print()
     except Exception as e:
-        print(f"Error during inference: {e}")
+        logger.error(f"Error during inference: {e}")
         response += f"\nError: {str(e)}"
         yield response
 
-    print("Completed response generation.")
-    
-    # If TTS is enabled and we have a valid MCP server URL, convert response to audio
-    if tts_enabled and mcp_server_url and response:
-        try:
-            print(f"Converting response to audio using MCP server: {mcp_server_url}")
-            audio_data = text_to_audio(response, tts_speed, mcp_server_url)
-            if audio_data:
-                # Here we would need to handle returning both text and audio
-                # This would require modifying the Gradio interface to support this
-                print("Successfully converted text to audio")
-                # For now, we'll just return the text response
-        except Exception as e:
-            print(f"Error converting text to audio: {e}")
+    logger.info("Completed response generation.")
 
 # Function to validate provider selection based on BYOK
 def validate_provider(api_key, provider):
@@ -341,21 +372,10 @@ def validate_provider(api_key, provider):
         return gr.update(value="hf-inference")
     return gr.update(value=provider)
 
-# Function to test MCP server connection
-def test_mcp_connection(mcp_url):
-    if not mcp_url or not mcp_url.strip():
-        return "Please enter an MCP server URL"
-    
-    try:
-        mcp_client = MCPClient(mcp_url)
-        if mcp_client.connect():
-            tools = [tool.name for tool in mcp_client.tools]
-            mcp_client.close()
-            return f"Successfully connected to MCP server. Available tools: {', '.join(tools)}"
-        else:
-            return "Failed to connect to MCP server"
-    except Exception as e:
-        return f"Error connecting to MCP server: {str(e)}"
+# Function to list available MCP servers
+def list_mcp_servers():
+    """List all configured MCP servers"""
+    return list(MCP_SERVERS.keys())
 
 # GRADIO UI
 with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
@@ -363,10 +383,10 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
     chatbot = gr.Chatbot(
         height=600, 
         show_copy_button=True, 
-        placeholder="Select a model and begin chatting. Now supports multiple inference providers and multimodal inputs",
+        placeholder="Select a model and begin chatting. Now supports multiple inference providers, multimodal inputs, and MCP servers",
         layout="panel"
     )
-    print("Chatbot interface created.")
+    logger.info("Chatbot interface created.")
     
     # Multimodal textbox for messages (combines text and file uploads)
     msg = gr.MultimodalTextbox(
@@ -511,94 +531,76 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
         )
         
         gr.Markdown("[View all Text-to-Text models](https://huggingface.co/models?inference_provider=all&pipeline_tag=text-generation&sort=trending) | [View all multimodal models](https://huggingface.co/models?inference_provider=all&pipeline_tag=image-text-to-text&sort=trending)")
-    
-    # New Accordion for MCP Settings
-    with gr.Accordion("MCP Server Settings", open=False):
-        mcp_server_url = gr.Textbox(
-            value="",
-            label="MCP Server URL",
-            info="Enter the URL of an MCP server to connect to (e.g., https://example-kokoro-mcp.hf.space/gradio_api/mcp/sse)",
-            placeholder="https://fdaudens-kokoro-mcp.hf.space/gradio_api/mcp/sse"
-        )
         
-        test_connection_btn = gr.Button("Test Connection")
-        connection_status = gr.Textbox(
-            label="Connection Status",
-            interactive=False
-        )
-        
-        tts_enabled = gr.Checkbox(
-            label="Enable Text-to-Speech",
-            value=False,
-            info="Convert AI responses to speech using the Kokoro TTS service"
-        )
-        
-        tts_speed = gr.Slider(
-            minimum=0.5,
-            maximum=2.0,
-            value=1.0,
-            step=0.1,
-            label="Speech Speed"
-        )
-        
-        gr.Markdown("""
-        ### About MCP Support
-        
-        This app can connect to Model Context Protocol (MCP) servers to extend its capabilities. 
-        
-        For example, connecting to a Kokoro MCP server allows for text-to-speech conversion. 
-        
-        To use this feature:
-        1. Enter the MCP server URL
-        2. Test the connection
-        3. Enable the desired features (e.g., TTS)
-        4. Chat normally with the AI
-        
-        Note: TTS functionality requires an active connection to a Kokoro MCP server.
-        """)
+        # MCP TTS integration
+        with gr.Accordion("MCP Integration", open=False):
+            gr.Markdown("## Model Context Protocol (MCP) Integration")
+            gr.Markdown("Connect to MCP servers to extend functionality.")
+            
+            tts_enabled = gr.Checkbox(
+                label="Enable Text-to-Speech",
+                value=False,
+                info="When enabled, responses will be converted to speech using the selected MCP TTS server"
+            )
+            
+            # Create dropdown for available MCP servers
+            available_servers = list_mcp_servers()
+            tts_server = gr.Dropdown(
+                label="TTS Server",
+                choices=available_servers,
+                value=available_servers[0] if available_servers else None,
+                interactive=True,
+                visible=len(available_servers) > 0
+            )
+            
+            # If no servers configured, show a message
+            if not available_servers:
+                gr.Markdown("""
+                No MCP servers configured. Add them using the MCP_CONFIG environment variable:
+                ```json
+                {
+                  "kokoroTTS": {
+                    "url": "https://your-kokoro-tts-server/gradio_api/mcp/sse"
+                  }
+                }
+                ```
+                """)
 
     # Chat history state
     chat_history = gr.State([])
     
-    # Connect the test connection button
-    test_connection_btn.click(
-        fn=test_mcp_connection,
-        inputs=[mcp_server_url],
-        outputs=[connection_status]
-    )
-    
     # Function to filter models
     def filter_models(search_term):
-        print(f"Filtering models with search term: {search_term}")
+        logger.info(f"Filtering models with search term: {search_term}")
         filtered = [m for m in models_list if search_term.lower() in m.lower()]
-        print(f"Filtered models: {filtered}")
+        logger.info(f"Filtered models: {filtered}")
         return gr.update(choices=filtered)
 
     # Function to set custom model from radio
     def set_custom_model_from_radio(selected):
-        print(f"Featured model selected: {selected}")
+        logger.info(f"Featured model selected: {selected}")
         return selected
 
     # Function for the chat interface
     def user(user_message, history):
         # Debug logging for troubleshooting
-        print(f"User message received: {user_message}")
+        logger.info(f"User message received: {user_message}")
         
         # Skip if message is empty (no text and no files)
         if not user_message or (not user_message.get("text") and not user_message.get("files")):
-            print("Empty message, skipping")
+            logger.info("Empty message, skipping")
             return history
         
         # Prepare multimodal message format
         text_content = user_message.get("text", "").strip()
         files = user_message.get("files", [])
         
-        print(f"Text content: {text_content}")
-        print(f"Files: {files}")
+        logger.info(f"Text content: {text_content}")
+        logger.info(f"Files: {files}")
         
         # If both text and files are empty, skip
         if not text_content and not files:
-            print("No content to display")
+            logger.info("No content to display")
             return history
         
         # Add message with images to history
@@ -606,33 +608,33 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
             # Add text message first if it exists
             if text_content:
                 # Add a separate text message
-                print(f"Adding text message: {text_content}")
+                logger.info(f"Adding text message: {text_content}")
                 history.append([text_content, None])
             
             # Then add each image file separately
             for file_path in files:
                 if file_path and isinstance(file_path, str):
-                    print(f"Adding image: {file_path}")
+                    logger.info(f"Adding image: {file_path}")
                     # Add image as a separate message with no text
                     history.append([f"![Image]({file_path})", None])
             
             return history
         else:
             # For text-only messages
-            print(f"Adding text-only message: {text_content}")
+            logger.info(f"Adding text-only message: {text_content}")
             history.append([text_content, None])
             return history
     
     # Define bot response function
-    def bot(history, system_msg, max_tokens, temperature, top_p, freq_penalty, seed, provider, api_key, custom_model, search_term, selected_model, mcp_url, tts_on, tts_spd):
+    def bot(history, system_msg, max_tokens, temperature, top_p, freq_penalty, seed, provider, api_key, custom_model, search_term, selected_model, tts_enabled, tts_server):
         # Check if history is valid
         if not history or len(history) == 0:
-            print("No history to process")
+            logger.info("No history to process")
             return history
         
         # Get the most recent message and detect if it's an image
         user_message = history[-1][0]
-        print(f"Processing user message: {user_message}")
+        logger.info(f"Processing user message: {user_message}")
         
         is_image = False
         image_path = None
@@ -643,7 +645,7 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
             is_image = True
             # Extract image path from markdown format ![Image](path)
             image_path = user_message.replace("![Image](", "").replace(")", "")
-            print(f"Image detected: {image_path}")
+            logger.info(f"Image detected: {image_path}")
             text_content = ""  # No text for image-only messages
         
         # Look back for text context if this is an image
@@ -653,7 +655,7 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
             prev_message = history[-2][0]
             if isinstance(prev_message, str) and not prev_message.startswith("![Image]("):
                 text_context = prev_message
-                print(f"Using text context from previous message: {text_context}")
+                logger.info(f"Using text context from previous message: {text_context}")
         
         # Process message through respond function
         history[-1][1] = ""
@@ -676,9 +678,8 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
                 custom_model,
                 search_term,
                 selected_model,
-                mcp_url,
-                tts_on,
-                tts_spd
+                tts_enabled,
+                tts_server
             ):
                 history[-1][1] = response
                 yield history
@@ -699,9 +700,8 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
                 custom_model,
                 search_term,
                 selected_model,
-                mcp_url,
-                tts_on,
-                tts_spd
+                tts_enabled,
+                tts_server
             ):
                 history[-1][1] = response
                 yield history
@@ -716,7 +716,7 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
         bot,
         [chatbot, system_message_box, max_tokens_slider, temperature_slider, top_p_slider, 
          frequency_penalty_slider, seed_slider, provider_radio, byok_textbox, custom_model_box, 
-         model_search_box, featured_model_radio, mcp_server_url, tts_enabled, tts_speed],
+         model_search_box, featured_model_radio, tts_enabled, tts_server],
         [chatbot]
     ).then(
         lambda: {"text": "", "files": []},  # Clear inputs after submission
@@ -730,7 +730,7 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
         inputs=model_search_box,
         outputs=featured_model_radio
     )
-    print("Model search box change event linked.")
+    logger.info("Model search box change event linked.")
 
     # Connect the featured model radio to update the custom model box
     featured_model_radio.change(
@@ -738,7 +738,7 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
         inputs=featured_model_radio,
         outputs=custom_model_box
     )
-    print("Featured model radio button change event linked.")
+    logger.info("Featured model radio button change event linked.")
     
     # Connect the BYOK textbox to validate provider selection
     byok_textbox.change(
@@ -746,7 +746,7 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
         inputs=[byok_textbox, provider_radio],
         outputs=provider_radio
     )
-    print("BYOK textbox change event linked.")
+    logger.info("BYOK textbox change event linked.")
 
     # Also validate provider when the radio changes to ensure consistency
     provider_radio.change(
@@ -754,10 +754,17 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
         inputs=[byok_textbox, provider_radio],
         outputs=provider_radio
     )
-    print("Provider radio button change event linked.")
+    logger.info("Provider radio button change event linked.")
+    
+    # Update TTS server dropdown visibility based on the TTS toggle
+    tts_enabled.change(
+        lambda enabled: gr.update(visible=enabled and len(list_mcp_servers()) > 0),
+        inputs=tts_enabled,
+        outputs=tts_server
+    )
 
-print("Gradio interface initialized.")
+logger.info("Gradio interface initialized.")
 
 if __name__ == "__main__":
-    print("Launching the demo application.")
+    logger.info("Launching the demo application.")
     demo.launch(show_api=True)