Update app.py

app.py

@@ -5,13 +5,7 @@ import json
 import base64
 from PIL import Image
 import io
-from smolagents.mcp_client import MCPClient
 
-# Global variables for MCP Client and TTS tool
-mcp_client = None
-tts_tool = None
-
-# Access token from environment
 ACCESS_TOKEN = os.getenv("HF_TOKEN")
 print("Access token loaded.")
 
@@ -23,14 +17,19 @@ def encode_image(image_path):
     
     try:
         print(f"Encoding image from path: {image_path}")
+        
+        # If it's already a PIL Image
         if isinstance(image_path, Image.Image):
             image = image_path
         else:
+            # Try to open the image file
             image = Image.open(image_path)
         
+        # Convert to RGB if image has an alpha channel (RGBA)
         if image.mode == 'RGBA':
             image = image.convert('RGB')
         
+        # Encode to base64
         buffered = io.BytesIO()
         image.save(buffered, format="JPEG")
         img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
@@ -40,19 +39,69 @@ def encode_image(image_path):
         print(f"Error encoding image: {e}")
         return None
 
-# Initialize MCP Client at startup
-def init_mcp_client():
-    global mcp_client, tts_tool
+def text_generation(
+    message: str,
+    system_message: str = "You are a helpful AI assistant.",
+    max_tokens: int = 512,
+    temperature: float = 0.7,
+    top_p: float = 0.95,
+    frequency_penalty: float = 0.0,
+    provider: str = "hf-inference",
+    model: str = "meta-llama/Llama-3.2-11B-Vision-Instruct"
+) -> str:
+    """
+    Generate text based on the input message using the specified model and provider.
+
+    Args:
+        message (str): The input text prompt.
+        system_message (str): The system prompt to guide the AI's behavior.
+        max_tokens (int): Maximum number of tokens to generate.
+        temperature (float): Sampling temperature for randomness.
+        top_p (float): Top-p sampling parameter.
+        frequency_penalty (float): Penalty for frequent tokens.
+        provider (str): Inference provider (e.g., 'hf-inference').
+        model (str): Model identifier (e.g., 'meta-llama/Llama-3.2-11B-Vision-Instruct').
+
+    Returns:
+        str: The generated text response.
+    """
+    print(f"Text generation called with message: {message}")
+    
+    # Initialize the Inference Client
+    client = InferenceClient(token=ACCESS_TOKEN, provider=provider)
+    print(f"Inference Client initialized with {provider} provider.")
+
+    # Prepare messages
+    messages = [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": message}
+    ]
+    
+    # Prepare parameters
+    parameters = {
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "top_p": top_p,
+        "frequency_penalty": frequency_penalty,
+    }
+
     try:
-        mcp_client = MCPClient({"url": "https://fdaudens-kokoro-mcp.hf.space/gradio_api/mcp/sse"})
-        tools = mcp_client.get_tools()
-        tts_tool = next((tool for tool in tools if tool.name == "text_to_audio"), None)
-        if tts_tool:
-            print("Successfully connected to Kokoro TTS tool")
+        # Perform chat completion (non-streaming for MCP simplicity)
+        response = client.chat_completion(
+            model=model,
+            messages=messages,
+            stream=False,
+            **parameters
+        )
+        if hasattr(response, 'choices') and len(response.choices) > 0:
+            generated_text = response.choices[0].message.content
+            print(f"Generated text: {generated_text}")
+            return generated_text
         else:
-            print("TTS tool not found")
+            raise ValueError("No valid response received from the model.")
     except Exception as e:
-        print(f"Error initializing MCP Client: {e}")
+        print(f"Error during text generation: {e}")
+        return f"Error: {str(e)}"
 
 def respond(
     message,
@@ -82,6 +131,7 @@ def respond(
     print(f"Model search term: {model_search_term}")
     print(f"Selected model from radio: {selected_model}")
 
+    # Determine which token to use
     token_to_use = custom_api_key if custom_api_key.strip() != "" else ACCESS_TOKEN
     
     if custom_api_key.strip() != "":
@@ -89,57 +139,81 @@ def respond(
     else:
         print("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.")
 
+    # Convert seed to None if -1 (meaning random)
     if seed == -1:
         seed = None
 
+    # Create multimodal content if images are present
     if image_files and len(image_files) > 0:
+        # Process the user message to include images
         user_content = []
+        
+        # Add text part if there is any
         if message and message.strip():
-            user_content.append({"type": "text", "text": message})
+            user_content.append({
+                "type": "text",
+                "text": message
+            })
         
+        # Add image parts
         for img in image_files:
             if img is not None:
+                # Get raw image data from path
                 try:
                     encoded_image = encode_image(img)
                     if encoded_image:
                         user_content.append({
                             "type": "image_url",
-                            "image_url": {"url": f"data:image/jpeg;base64,{encoded_image}"}
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{encoded_image}"
+                            }
                         })
                 except Exception as e:
                     print(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.")
 
+    # Add conversation history to the context
     for val in history:
         user_part = val[0]
         assistant_part = val[1]
         if user_part:
+            # Handle both text-only and multimodal messages in history
             if isinstance(user_part, tuple) and len(user_part) == 2:
+                # This is a multimodal message with text and images
                 history_content = []
-                if user_part[0]:
-                    history_content.append({"type": "text", "text": user_part[0]})
+                if user_part[0]:  # Text
+                    history_content.append({
+                        "type": "text",
+                        "text": user_part[0]
+                    })
                 
-                for img in user_part[1]:
+                for img in user_part[1]:  # Images
                     if img:
                         try:
                             encoded_img = encode_image(img)
                             if encoded_img:
                                 history_content.append({
                                     "type": "image_url",
-                                    "image_url": {"url": f"data:image/jpeg;base64,{encoded_img}"}
+                                    "image_url": {
+                                        "url": f"data:image/jpeg;base64,{encoded_img}"
+                                    }
                                 })
                         except Exception as e:
                             print(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)})")
         
@@ -147,15 +221,19 @@ def respond(
             messages.append({"role": "assistant", "content": assistant_part})
             print(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)})")
 
+    # 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}")
 
+    # Start with an empty string to build the response as tokens stream in
     response = ""
     print(f"Sending request to {provider} provider.")
 
+    # Prepare parameters for the chat completion request
     parameters = {
         "max_tokens": max_tokens,
         "temperature": temperature,
@@ -166,7 +244,9 @@ def respond(
     if seed is not None:
         parameters["seed"] = seed
 
+    # Use the InferenceClient for making the request
     try:
+        # Create a generator for the streaming response
         stream = client.chat_completion(
             model=model_to_use,
             messages=messages,
@@ -176,8 +256,10 @@ def respond(
         
         print("Received tokens: ", end="", flush=True)
         
+        # Process the streaming response
         for chunk in stream:
             if hasattr(chunk, 'choices') and len(chunk.choices) > 0:
+                # Extract the content from the response
                 if hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'content'):
                     token_text = chunk.choices[0].delta.content
                     if token_text:
@@ -193,40 +275,16 @@ def respond(
 
     print("Completed response generation.")
 
-# Function to generate audio from the last bot response
-def generate_audio(history):
-    if not history or len(history) == 0:
-        print("No history available for audio generation")
-        return None
-    last_message = history[-1][1]  # Bot's response
-    if not last_message or not isinstance(last_message, str):
-        print("Last message is empty or not a string")
-        return None
-    if tts_tool:
-        try:
-            # Call the TTS tool directly, expecting (sample_rate, audio_array)
-            result = tts_tool(text=last_message, speed=1.0)
-            if result and len(result) == 2:
-                sample_rate, audio_data = result
-                print("Audio generated successfully")
-                return (sample_rate, audio_data)
-            else:
-                print("TTS tool returned invalid result")
-                return None
-        except Exception as e:
-            print(f"Error generating audio: {e}")
-            return None
-    else:
-        print("TTS tool not available")
-        return None
-
+# Function to validate provider selection based on BYOK
 def validate_provider(api_key, provider):
     if not api_key.strip() and provider != "hf-inference":
         return gr.update(value="hf-inference")
     return gr.update(value=provider)
 
-# Gradio UI
-with gr.Blocks(theme="Nymbo/Nymbo_Theme")    chatbot = gr.Chatbot(
+# GRADIO UI
+with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
+    # Create the chatbot component
+    chatbot = gr.Chatbot(
         height=600, 
         show_copy_button=True, 
         placeholder="Select a model and begin chatting. Now supports multiple inference providers and multimodal inputs",
@@ -234,6 +292,7 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme")    chatbot = gr.Chatbot(
     )
     print("Chatbot interface created.")
     
+    # Multimodal textbox for messages (combines text and file uploads)
     msg = gr.MultimodalTextbox(
         placeholder="Type a message or upload images...",
         show_label=False,
@@ -243,83 +302,207 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme")    chatbot = gr.Chatbot(
         file_count="multiple",
         sources=["upload"]
     )
+    
+    # Note: We're removing the separate submit button since MultimodalTextbox has its own
 
-    # Audio generation components
-    with gr.Row():
-        generate_audio_btn = gr.Button("Generate Audio from Last Response")
-        audio_output = gr.Audio(label="Generated Audio", type="numpy")
-
+    # Create accordion for settings
     with gr.Accordion("Settings", open=False):
+        # System message
         system_message_box = gr.Textbox(
             value="You are a helpful AI assistant that can understand images and text.", 
             placeholder="You are a helpful assistant.",
             label="System Prompt"
         )
         
+        # Generation parameters
         with gr.Row():
             with gr.Column():
-                max_tokens_slider = gr.Slider(minimum=1, maximum=4096, value=512, step=1, label="Max tokens")
-                temperature_slider = gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature")
-                top_p_slider = gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-P")
+                max_tokens_slider = gr.Slider(
+                    minimum=1,
+                    maximum=4096,
+                    value=512,
+                    step=1,
+                    label="Max tokens"
+                )
+                
+                temperature_slider = gr.Slider(
+                    minimum=0.1,
+                    maximum=4.0,
+                    value=0.7,
+                    step=0.1,
+                    label="Temperature"
+                )
+                
+                top_p_slider = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.95,
+                    step=0.05,
+                    label="Top-P"
+                )
+                
             with gr.Column():
-                frequency_penalty_slider = gr.Slider(minimum=-2.0, maximum=2.0, value=0.0, step=0.1, label="Frequency Penalty")
-                seed_slider = gr.Slider(minimum=-1, maximum=65535, value=-1, step=1, label="Seed (-1 for random)")
+                frequency_penalty_slider = gr.Slider(
+                    minimum=-2.0,
+                    maximum=2.0,
+                    value=0.0,
+                    step=0.1,
+                    label="Frequency Penalty"
+                )
+                
+                seed_slider = gr.Slider(
+                    minimum=-1,
+                    maximum=65535,
+                    value=-1,
+                    step=1,
+                    label="Seed (-1 for random)"
+                )
         
+        # Provider selection
         providers_list = [
-            "hf-inference", "cerebras", "together", "sambanova", "novita", "cohere", "fireworks-ai", "hyperbolic", "nebius"
+            "hf-inference",  # Default Hugging Face Inference
+            "cerebras",      # Cerebras provider
+            "together",      # Together AI
+            "sambanova",     # SambaNova
+            "novita",        # Novita AI
+            "cohere",        # Cohere
+            "fireworks-ai",  # Fireworks AI
+            "hyperbolic",    # Hyperbolic
+            "nebius",        # Nebius
         ]
         
-        provider_radio = gr.Radio(choices=providers_list, value="hf-inference", label="Inference Provider")
-        byok_textbox = gr.Textbox(value="", label="BYOK (Bring Your Own Key)", info="Enter a custom Hugging Face API key here.", placeholder="Enter your Hugging Face API token", type="password")
-        custom_model_box = gr.Textbox(value="", label="Custom Model", info="(Optional) Provide a custom Hugging Face model path.", placeholder="meta-llama/Llama-3.3-70B-Instruct")
-        model_search_box = gr.Textbox(label="Filter Models", placeholder="Search for a featured model...", lines=1)
+        provider_radio = gr.Radio(
+            choices=providers_list,
+            value="hf-inference",
+            label="Inference Provider",
+        )
+        
+        # New BYOK textbox
+        byok_textbox = gr.Textbox(
+            value="",
+            label="BYOK (Bring Your Own Key)",
+            info="Enter a custom Hugging Face API key here. When empty, only 'hf-inference' provider can be used.",
+            placeholder="Enter your Hugging Face API token",
+            type="password"  # Hide the API key for security
+        )
         
+        # Custom model box
+        custom_model_box = gr.Textbox(
+            value="",
+            label="Custom Model",
+            info="(Optional) Provide a custom Hugging Face model path. Overrides any selected featured model.",
+            placeholder="meta-llama/Llama-3.3-70B-Instruct"
+        )
+        
+        # Model search
+        model_search_box = gr.Textbox(
+            label="Filter Models",
+            placeholder="Search for a featured model...",
+            lines=1
+        )
+        
+        # Featured models list
         models_list = [
-            "meta-llama/Llama-3.2-11B-Vision-Instruct", "meta-llama/Llama-3.3-70B-Instruct", "meta-llama/Llama-3.1-70B-Instruct",
-            "meta-llama/Llama-3.0-70B-Instruct", "meta-llama/Llama-3.2-3B-Instruct", "meta-llama/Llama-3.2-1B-Instruct",
-            "meta-llama/Llama-3.1-8B-Instruct", "NousResearch/Hermes-3-Llama-3.1-8B", "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
-            "mistralai/Mistral-Nemo-Instruct-2407", "mistralai/Mixtral-8x7B-Instruct-v0.1", "mistralai/Mistral-7B-Instruct-v0.3",
-            "mistralai/Mistral-7B-Instruct-v0.2", "Qwen/Qwen3-235B-A22B", "Qwen/Qwen3-32B", "Qwen/Qwen2.5-72B-Instruct",
-            "Qwen/Qwen2.5-3B-Instruct", "Qwen/Qwen2.5-0.5B-Instruct", "Qwen/QwQ-32B", "Qwen/Qwen2.5-Coder-32B-Instruct",
-            "microsoft/Phi-3.5-mini-instruct", "microsoft/Phi-3-mini-128k-instruct", "microsoft/Phi-3-mini-4k-instruct"
+            "meta-llama/Llama-3.2-11B-Vision-Instruct",
+            "meta-llama/Llama-3.3-70B-Instruct",
+            "meta-llama/Llama-3.1-70B-Instruct",
+            "meta-llama/Llama-3.0-70B-Instruct",
+            "meta-llama/Llama-3.2-3B-Instruct",
+            "meta-llama/Llama-3.2-1B-Instruct",
+            "meta-llama/Llama-3.1-8B-Instruct",
+            "NousResearch/Hermes-3-Llama-3.1-8B",
+            "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
+            "mistralai/Mistral-Nemo-Instruct-2407",
+            "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "mistralai/Mistral-7B-Instruct-v0.3",
+            "mistralai/Mistral-7B-Instruct-v0.2",
+            "Qwen/Qwen3-235B-A22B",
+            "Qwen/Qwen3-32B",
+            "Qwen/Qwen2.5-72B-Instruct",
+            "Qwen/Qwen2.5-3B-Instruct",
+            "Qwen/Qwen2.5-0.5B-Instruct",
+            "Qwen/QwQ-32B",
+            "Qwen/Qwen2.5-Coder-32B-Instruct",
+            "microsoft/Phi-3.5-mini-instruct",
+            "microsoft/Phi-3-mini-128k-instruct",
+            "microsoft/Phi-3-mini-4k-instruct",
         ]
 
-        featured_model_radio = gr.Radio(label="Select a model below", choices=models_list, value="meta-llama/Llama-3.2-11B-Vision-Instruct", interactive=True)
+        featured_model_radio = gr.Radio(
+            label="Select a model below",
+            choices=models_list,
+            value="meta-llama/Llama-3.2-11B-Vision-Instruct",
+            interactive=True
+        )
+        
         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)")
 
+    # Add MCP Support Section
+    with gr.Accordion("MCP Support (for LLMs)", open=False):
+        gr.Markdown("""
+        ### MCP Support
+        
+        This app supports the Model Context Protocol (MCP), allowing Large Language Models like Claude Desktop to use it as a text generation tool.
+        
+        To use this app with an MCP client, add the following configuration:
+        
+        ```json
+        {
+          "mcpServers": {
+            "textGen": {
+              "url": "https://YOUR_USERNAME-serverless-textgen-hub.hf.space/gradio_api/mcp/sse"
+            }
+          }
+        }
+        ```
+        
+        Replace `YOUR_USERNAME` with your actual Hugging Face username.
+        """)
+
+    # Chat history state
     chat_history = gr.State([])
     
+    # Function to filter models
     def filter_models(search_term):
         print(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}")
         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}")
         return selected
 
+    # Function for the chat interface
     def user(user_message, history):
         print(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")
             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}")
         
+        # If both text and files are empty, skip
         if not text_content and not files:
             print("No content to display")
             return history
         
+        # Add message with images to history
         if files and len(files) > 0:
+            # Add text message first if it exists
             if text_content:
                 print(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}")
@@ -327,10 +510,12 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme")    chatbot = gr.Chatbot(
             
             return history
         else:
+            # For text-only messages
             print(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):
         if not history or len(history) == 0:
             print("No history to process")
@@ -360,50 +545,91 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme")    chatbot = gr.Chatbot(
         
         if is_image:
             for response in respond(
-                text_context, [image_path], history[:-1], system_msg, max_tokens, temperature, top_p,
-                freq_penalty, seed, provider, api_key, custom_model, search_term, selected_model
+                text_context,
+                [image_path],
+                history[:-1],
+                system_msg,
+                max_tokens,
+                temperature,
+                top_p,
+                freq_penalty,
+                seed,
+                provider,
+                api_key,
+                custom_model,
+                search_term,
+                selected_model
             ):
                 history[-1][1] = response
                 yield history
         else:
             for response in respond(
-                text_content, None, history[:-1], system_msg, max_tokens, temperature, top_p,
-                freq_penalty, seed, provider, api_key, custom_model, search_term, selected_model
+                text_content,
+                None,
+                history[:-1],
+                system_msg,
+                max_tokens,
+                temperature,
+                top_p,
+                freq_penalty,
+                seed,
+                provider,
+                api_key,
+                custom_model,
+                search_term,
+                selected_model
             ):
                 history[-1][1] = response
                 yield history
 
-    msg.submit(user, [msg, chatbot], [chatbot], queue=False).then(
-        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], [chatbot]
-    ).then(lambda: {"text": "", "files": []}, None, [msg])
+    # Event handlers
+    msg.submit(
+        user,
+        [msg, chatbot],
+        [chatbot],
+        queue=False
+    ).then(
+        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],
+        [chatbot]
+    ).then(
+        lambda: {"text": "", "files": []},
+        None,
+        [msg]
+    )
     
-    model_search_box.change(fn=filter_models, inputs=model_search_box, outputs=featured_model_radio)
+    model_search_box.change(
+        fn=filter_models,
+        inputs=model_search_box,
+        outputs=featured_model_radio
+    )
     print("Model search box change event linked.")
 
-    featured_model_radio.change(fn=set_custom_model_from_radio, inputs=featured_model_radio, outputs=custom_model_box)
+    featured_model_radio.change(
+        fn=set_custom_model_from_radio,
+        inputs=featured_model_radio,
+        outputs=custom_model_box
+    )
     print("Featured model radio button change event linked.")
-    
-    byok_textbox.change(fn=validate_provider, inputs=[byok_textbox, provider_radio], outputs=provider_radio)
+
+    byok_textbox.change(
+        fn=validate_provider,
+        inputs=[byok_textbox, provider_radio],
+        outputs=provider_radio
+    )
     print("BYOK textbox change event linked.")
 
-    provider_radio.change(fn=validate_provider, inputs=[byok_textbox, provider_radio], outputs=provider_radio)
+    provider_radio.change(
+        fn=validate_provider,
+        inputs=[byok_textbox, provider_radio],
+        outputs=provider_radio
+    )
     print("Provider radio button change event linked.")
 
-    # Event handler for audio generation
-    generate_audio_btn.click(fn=generate_audio, inputs=[chatbot], outputs=[audio_output])
-
-    # Initialize MCP Client on app load
-    demo.load(init_mcp_client)
-
 print("Gradio interface initialized.")
 
 if __name__ == "__main__":
     print("Launching the demo application.")
-    try:
-        demo.launch(server_api=True)
-    finally:
-        if mcp_client:
-            mcp_client.close()
-            print("MCP Client closed.")
+    demo.launch(show_api=True, mcp_server=True)