Update app.py

app.py

@@ -5,8 +5,6 @@ import json
 import base64
 from PIL import Image
 import io
-import requests
-from smolagents.mcp_client import MCPClient
 
 ACCESS_TOKEN = os.getenv("HF_TOKEN")
 print("Access token loaded.")
@@ -41,154 +39,9 @@ def encode_image(image_path):
         print(f"Error encoding image: {e}")
         return None
 
-# Dictionary to store active MCP connections
-mcp_connections = {}
-
-def connect_to_mcp_server(server_url, server_name=None):
-    """Connect to an MCP server and return available tools"""
-    if not server_url:
-        return None, "No server URL provided"
-    
-    try:
-        # Create an MCP client and connect to the server
-        client = MCPClient({"url": server_url})
-        # Get available tools
-        tools = client.get_tools()
-        
-        # Store the connection for later use
-        name = server_name or f"Server_{len(mcp_connections)}"
-        mcp_connections[name] = {"client": client, "tools": tools, "url": server_url}
-        
-        return name, f"Successfully connected to {name} with {len(tools)} available tools"
-    except Exception as e:
-        print(f"Error connecting to MCP server: {e}")
-        return None, f"Error connecting to MCP server: {str(e)}"
-
-def list_mcp_tools(server_name):
-    """List available tools for a connected MCP server"""
-    if server_name not in mcp_connections:
-        return "Server not connected"
-    
-    tools = mcp_connections[server_name]["tools"]
-    tool_info = []
-    for tool in tools:
-        tool_info.append(f"- {tool.name}: {tool.description}")
-    
-    if not tool_info:
-        return "No tools available for this server"
-    
-    return "\n".join(tool_info)
-
-def call_mcp_tool(server_name, tool_name, **kwargs):
-    """Call a specific tool from an MCP server"""
-    if server_name not in mcp_connections:
-        return f"Server '{server_name}' not connected"
-    
-    client = mcp_connections[server_name]["client"]
-    tools = mcp_connections[server_name]["tools"]
-    
-    # Find the requested tool
-    tool = next((t for t in tools if t.name == tool_name), None)
-    if not tool:
-        return f"Tool '{tool_name}' not found on server '{server_name}'"
-    
-    try:
-        # Call the tool with provided arguments
-        result = client.call_tool(tool_name, kwargs)
-        return result
-    except Exception as e:
-        print(f"Error calling MCP tool: {e}")
-        return f"Error calling MCP tool: {str(e)}"
-
-def analyze_message_for_tool_call(message, active_mcp_servers, client, model_to_use, system_message):
-    """Analyze a message to determine if an MCP tool should be called"""
-    # Skip analysis if message is empty
-    if not message or not message.strip():
-        return None, None
-    
-    # Get information about available tools
-    tool_info = []
-    for server_name in active_mcp_servers:
-        if server_name in mcp_connections:
-            server_tools = mcp_connections[server_name]["tools"]
-            for tool in server_tools:
-                tool_info.append({
-                    "server_name": server_name,
-                    "tool_name": tool.name,
-                    "description": tool.description
-                })
-    
-    if not tool_info:
-        return None, None
-    
-    # Create a structured query for the LLM to analyze if a tool call is needed
-    tools_desc = []
-    for info in tool_info:
-        tools_desc.append(f"{info['server_name']}.{info['tool_name']}: {info['description']}")
-    
-    tools_string = "\n".join(tools_desc)
-    
-    analysis_system_prompt = f"""You are an assistant that helps determine if a user message requires using an external tool.
-Available tools:
-{tools_string}
-
-Your job is to:
-1. Analyze the user's message
-2. Determine if they're asking to use one of the tools
-3. If yes, respond with a JSON object with the server_name, tool_name, and parameters
-4. If no, respond with "NO_TOOL_NEEDED"
-
-Example 1:
-User: "Please turn this text into speech: Hello world"
-Response: {{"server_name": "kokoroTTS", "tool_name": "text_to_audio", "parameters": {{"text": "Hello world", "speed": 1.0}}}}
-
-Example 2:
-User: "What is the capital of France?"
-Response: NO_TOOL_NEEDED"""
-    
-    try:
-        # Call the LLM to analyze the message
-        response = client.chat_completion(
-            model=model_to_use,
-            messages=[
-                {"role": "system", "content": analysis_system_prompt},
-                {"role": "user", "content": message}
-            ],
-            temperature=0.2,  # Low temperature for more deterministic responses
-            max_tokens=300
-        )
-        
-        analysis = response.choices[0].message.content
-        print(f"Tool analysis: {analysis}")
-        
-        if "NO_TOOL_NEEDED" in analysis:
-            return None, None
-        
-        # Try to extract JSON from the response
-        json_start = analysis.find("{")
-        json_end = analysis.rfind("}") + 1
-        
-        if json_start < 0 or json_end <= 0:
-            return None, None
-            
-        json_str = analysis[json_start:json_end]
-        try:
-            tool_call = json.loads(json_str)
-            return tool_call.get("server_name"), {
-                "tool_name": tool_call.get("tool_name"),
-                "parameters": tool_call.get("parameters", {})
-            }
-        except json.JSONDecodeError:
-            print(f"Failed to parse tool call JSON: {json_str}")
-            return None, None
-            
-    except Exception as e:
-        print(f"Error analyzing message for tool calls: {str(e)}")
-        return None, None
-
 def respond(
     message,
-    image_files,
+    image_files,  # Changed parameter name and structure
     history: list[tuple[str, str]],
     system_message,
     max_tokens,
@@ -200,10 +53,7 @@ def respond(
     custom_api_key,
     custom_model,    
     model_search_term,
-    selected_model,
-    mcp_enabled=False,
-    active_mcp_servers=None,
-    mcp_interaction_mode="Natural Language"
+    selected_model
 ):
     print(f"Received message: {message}")
     print(f"Received {len(image_files) if image_files else 0} images")
@@ -216,9 +66,6 @@ def respond(
     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 enabled: {mcp_enabled}")
-    print(f"Active MCP servers: {active_mcp_servers}")
-    print(f"MCP interaction mode: {mcp_interaction_mode}")
 
     # Determine which token to use
     token_to_use = custom_api_key if custom_api_key.strip() != "" else ACCESS_TOKEN
@@ -235,58 +82,6 @@ def respond(
     # Convert seed to None if -1 (meaning random)
     if seed == -1:
         seed = None
-        
-    # Determine which model to use
-    model_to_use = custom_model.strip() if custom_model.strip() != "" else selected_model
-    print(f"Model selected for inference: {model_to_use}")
-
-    # Process MCP commands in command mode
-    if mcp_enabled and message:
-        if message.startswith("/mcp"):  # Always handle explicit commands
-            # Handle MCP command
-            command_parts = message.split(" ", 3)
-            if len(command_parts) < 3:
-                return "Invalid MCP command. Format: /mcp <server_name> <tool_name> [arguments]"
-            
-            _, server_name, tool_name = command_parts[:3]
-            args_json = "{}" if len(command_parts) < 4 else command_parts[3]
-            
-            try:
-                args_dict = json.loads(args_json)
-                result = call_mcp_tool(server_name, tool_name, **args_dict)
-                if isinstance(result, dict):
-                    return json.dumps(result, indent=2)
-                return str(result)
-            except json.JSONDecodeError:
-                return f"Invalid JSON arguments: {args_json}"
-            except Exception as e:
-                return f"Error executing MCP command: {str(e)}"
-        elif mcp_interaction_mode == "Natural Language" and active_mcp_servers:
-            # Use natural language processing to detect tool calls
-            server_name, tool_info = analyze_message_for_tool_call(
-                message, 
-                active_mcp_servers, 
-                client, 
-                model_to_use, 
-                system_message
-            )
-            
-            if server_name and tool_info:
-                try:
-                    # Call the detected tool
-                    print(f"Calling tool via natural language: {server_name}.{tool_info['tool_name']} with parameters: {tool_info['parameters']}")
-                    result = call_mcp_tool(server_name, tool_info['tool_name'], **tool_info['parameters'])
-                    
-                    # Format the response to include what was done
-                    if isinstance(result, dict):
-                        result_str = json.dumps(result, indent=2)
-                    else:
-                        result_str = str(result)
-                    
-                    return f"I used the {tool_info['tool_name']} tool from {server_name} with your request.\n\nResult:\n{result_str}"
-                except Exception as e:
-                    print(f"Error executing MCP tool via natural language: {str(e)}")
-                    # Continue with normal response if tool call fails
 
     # Create multimodal content if images are present
     if image_files and len(image_files) > 0:
@@ -319,25 +114,8 @@ def respond(
         # Text-only message
         user_content = message
 
-    # Add information about available MCP tools to the system message if MCP is enabled
-    augmented_system_message = system_message
-    if mcp_enabled and active_mcp_servers:
-        tool_info = []
-        for server_name in active_mcp_servers:
-            if server_name in mcp_connections:
-                server_tools = list_mcp_tools(server_name).split("\n")
-                tool_info.extend([f"{server_name}: {tool}" for tool in server_tools])
-        
-        if tool_info:
-            mcp_tools_description = "\n".join(tool_info)
-            
-            if mcp_interaction_mode == "Command Mode":
-                augmented_system_message += f"\n\nYou have access to the following MCP tools:\n{mcp_tools_description}\n\nTo use these tools, the user can type a command in the format: /mcp <server_name> <tool_name> <arguments_json>"
-            else:
-                augmented_system_message += f"\n\nYou have access to the following MCP tools:\n{mcp_tools_description}\n\nThe user can use these tools by describing what they want in natural language, and the system will automatically detect when to use a tool based on their request."
-    
     # Prepare messages in the format expected by the API
-    messages = [{"role": "system", "content": augmented_system_message}]
+    messages = [{"role": "system", "content": system_message}]
     print("Initial messages array constructed.")
 
     # Add conversation history to the context
@@ -433,13 +211,19 @@ def respond(
 
     print("Completed response generation.")
 
+# 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") 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, multimodal inputs, and MCP tools",
+        placeholder="Select a model and begin chatting. Now supports multiple inference providers and multimodal inputs",
         layout="panel"
     )
     print("Chatbot interface created.")
@@ -455,6 +239,8 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
         sources=["upload"]
     )
     
+    # Note: We're removing the separate submit button since MultimodalTextbox has its own
+
     # Create accordion for settings
     with gr.Accordion("Settings", open=False):
         # System message
@@ -588,69 +374,6 @@ 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)")
 
-    # Create accordion for MCP settings
-    with gr.Accordion("MCP Settings", open=False):
-        mcp_enabled_checkbox = gr.Checkbox(
-            label="Enable MCP Support",
-            value=False,
-            info="Enable Model Context Protocol support to connect to external tools and services"
-        )
-        
-        with gr.Row():
-            mcp_server_url = gr.Textbox(
-                label="MCP Server URL",
-                placeholder="https://example-mcp-server.hf.space/gradio_api/mcp/sse",
-                info="URL of the MCP server to connect to"
-            )
-            
-            mcp_server_name = gr.Textbox(
-                label="Server Name",
-                placeholder="Optional name for this server",
-                info="A friendly name to identify this server"
-            )
-            
-            mcp_connect_button = gr.Button("Connect to MCP Server")
-        
-        mcp_status = gr.Textbox(
-            label="MCP Connection Status",
-            placeholder="No MCP servers connected",
-            interactive=False
-        )
-        
-        active_mcp_servers = gr.Dropdown(
-            label="Active MCP Servers",
-            choices=[],
-            multiselect=True,
-            info="Select which MCP servers to use in chat"
-        )
-        
-        mcp_mode = gr.Radio(
-            label="MCP Interaction Mode",
-            choices=["Natural Language", "Command Mode"],
-            value="Natural Language",
-            info="Choose how to interact with MCP tools"
-        )
-        
-        gr.Markdown("""
-        ### MCP Interaction Modes
-        
-        **Natural Language Mode**: Simply describe what you want in plain English. Examples:
-        ```
-        Please convert the text "Hello world" to speech
-        Can you read this text aloud: "Welcome to MCP integration"
-        ```
-        
-        **Command Mode**: Use structured commands (for advanced users)
-        ```
-        /mcp <server_name> <tool_name> {"param1": "value1", "param2": "value2"}
-        ```
-        
-        Example:
-        ```
-        /mcp kokoroTTS text_to_audio {"text": "Hello world", "speed": 1.0}
-        ```
-        """)
-
     # Chat history state
     chat_history = gr.State([])
     
@@ -666,16 +389,6 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
         print(f"Featured model selected: {selected}")
         return selected
 
-    # Function to connect to MCP server
-    def connect_mcp_server(url, name):
-        server_name, status = connect_to_mcp_server(url, name)
-        
-        # Update the active servers dropdown
-        servers = list(mcp_connections.keys())
-        
-        # Return the status message and updated server list
-        return status, gr.update(choices=servers)
-
     # Function for the chat interface
     def user(user_message, history):
         # Debug logging for troubleshooting
@@ -721,7 +434,7 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
             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_enabled, selected_servers, mcp_interaction_mode):
+    def bot(history, system_msg, max_tokens, temperature, top_p, freq_penalty, seed, provider, api_key, custom_model, search_term, selected_model):
         # Check if history is valid
         if not history or len(history) == 0:
             print("No history to process")
@@ -772,10 +485,7 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
                 api_key,
                 custom_model,
                 search_term,
-                selected_model,
-                mcp_enabled,
-                selected_servers,
-                mcp_interaction_mode
+                selected_model
             ):
                 history[-1][1] = response
                 yield history
@@ -795,21 +505,12 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
                 api_key,
                 custom_model,
                 search_term,
-                selected_model,
-                mcp_enabled,
-                selected_servers,
-                mcp_interaction_mode
+                selected_model
             ):
                 history[-1][1] = response
                 yield history
 
-    # Update function for provider validation 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)
-
-    # Event handlers
+    # Event handlers - only using the MultimodalTextbox's built-in submit functionality
     msg.submit(
         user,
         [msg, chatbot],
@@ -819,7 +520,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_enabled_checkbox, active_mcp_servers, mcp_mode],
+         model_search_box, featured_model_radio],
         [chatbot]
     ).then(
         lambda: {"text": "", "files": []},  # Clear inputs after submission
@@ -827,13 +528,6 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
         [msg]
     )
     
-    # Connect MCP connect button
-    mcp_connect_button.click(
-        connect_mcp_server,
-        [mcp_server_url, mcp_server_name],
-        [mcp_status, active_mcp_servers]
-    )
-    
     # Connect the model filter to update the radio choices
     model_search_box.change(
         fn=filter_models,
@@ -870,4 +564,4 @@ print("Gradio interface initialized.")
 
 if __name__ == "__main__":
     print("Launching the demo application.")
-    demo.launch(show_api=True, mcp_server=False)  # Not launching as MCP server as we're the client
+    demo.launch(show_api=True)