testing MCP support

app.py

@@ -5,6 +5,8 @@ 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.")
@@ -39,9 +41,154 @@ 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,  # Changed parameter name and structure
+    image_files,
     history: list[tuple[str, str]],
     system_message,
     max_tokens,
@@ -53,7 +200,10 @@ def respond(
     custom_api_key,
     custom_model,    
     model_search_term,
-    selected_model
+    selected_model,
+    mcp_enabled=False,
+    active_mcp_servers=None,
+    mcp_interaction_mode="Natural Language"
 ):
     print(f"Received message: {message}")
     print(f"Received {len(image_files) if image_files else 0} images")
@@ -66,6 +216,9 @@ 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
@@ -82,6 +235,58 @@ 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:
@@ -114,8 +319,25 @@ 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": system_message}]
+    messages = [{"role": "system", "content": augmented_system_message}]
     print("Initial messages array constructed.")
 
     # Add conversation history to the context
@@ -211,19 +433,13 @@ 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 and multimodal inputs",
+        placeholder="Select a model and begin chatting. Now supports multiple inference providers, multimodal inputs, and MCP tools",
         layout="panel"
     )
     print("Chatbot interface created.")
@@ -239,8 +455,6 @@ 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
@@ -374,6 +588,69 @@ 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([])
     
@@ -389,6 +666,16 @@ 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
@@ -434,7 +721,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):
+    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):
         # Check if history is valid
         if not history or len(history) == 0:
             print("No history to process")
@@ -485,7 +772,9 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
                 api_key,
                 custom_model,
                 search_term,
-                selected_model
+                selected_model,
+                mcp_enabled,
+                selected_servers
             ):
                 history[-1][1] = response
                 yield history
@@ -505,12 +794,20 @@ with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
                 api_key,
                 custom_model,
                 search_term,
-                selected_model
+                selected_model,
+                mcp_enabled,
+                selected_servers
             ):
                 history[-1][1] = response
                 yield history
 
-    # Event handlers - only using the MultimodalTextbox's built-in submit functionality
+    # 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
     msg.submit(
         user,
         [msg, chatbot],
@@ -520,7 +817,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],
+         model_search_box, featured_model_radio, mcp_enabled_checkbox, active_mcp_servers, mcp_mode],
         [chatbot]
     ).then(
         lambda: {"text": "", "files": []},  # Clear inputs after submission
@@ -528,6 +825,13 @@ 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,
@@ -564,4 +868,4 @@ print("Gradio interface initialized.")
 
 if __name__ == "__main__":
     print("Launching the demo application.")
-    demo.launch(show_api=True)
+    demo.launch(show_api=True, mcp_server=False)  # Not launching as MCP server as we're the client