Update app.py

app.py

@@ -1,12 +1,12 @@
 import gradio as gr
 import requests
-from typing import List, Dict, Optional
+from typing import List, Dict
 from huggingface_hub import HfApi
 import os
 from dotenv import load_dotenv
-import csv
 from pinecone import Pinecone
 from openai import OpenAI
+import re
 
 # Load environment variables
 load_dotenv()
@@ -27,8 +27,6 @@ def keyword_search_hf_spaces(query: str = "", limit: int = 3) -> Dict:
         Dictionary containing search results with MCP information
     """
     try:
-        print(f"Debug - Search query: '{query}'")  # Debug log
-        
         # Use list_spaces API with mcp-server filter and sort by likes
         spaces = list(api.list_spaces(
             search=query,
@@ -40,15 +38,35 @@ def keyword_search_hf_spaces(query: str = "", limit: int = 3) -> Dict:
         results = []
         for space in spaces[:limit]:  # Process up to limit matches
             try:
+                # Convert space ID to URL format - replace all special chars with hyphens
+                space_id_lower = re.sub(r'[^a-z0-9]', '-', space.id.lower())
+                # Remove consecutive hyphens
+                space_id_lower = re.sub(r'-+', '-', space_id_lower)
+                # Remove leading and trailing hyphens
+                space_id_lower = space_id_lower.strip('-')
+                sse_url = f"https://{space_id_lower}.hf.space/gradio_api/mcp/sse"
+                
                 space_info = {
                     "id": space.id,
                     "likes": space.likes,
                     "trending_score": space.trending_score,
-                    "source": "huggingface"
-                }
+                    "source": "huggingface",
+                    "configuration": {
+                            "mcpServers": {
+                                "gradio": {
+                                    "command": "npx",  # Use npx to run MCP-Remote
+                                    "args": [
+                                        "mcp-remote",
+                                        sse_url,
+                                        "--transport",
+                                        "sse-only"
+                                    ]
+                                }
+                            }
+                        }
+                    }
                 results.append(space_info)
             except Exception as e:
-                print(f"Error processing space {space.id}: {str(e)}")
                 continue
         
         return {
@@ -56,20 +74,20 @@ def keyword_search_hf_spaces(query: str = "", limit: int = 3) -> Dict:
             "total": len(results)
         }
     except Exception as e:
-        print(f"Debug - Critical error in keyword_search_hf_spaces: {str(e)}")
         return {
             "error": str(e),
             "results": [],
             "total": 0
         }
 
-def keyword_search_smithery(query: str = "", limit: int = 3) -> Dict:
+def keyword_search_smithery(query: str = "", limit: int = 3, os_type: str = "Mac/Linux") -> Dict:
     """
     Search for MCPs in Smithery Registry.
     
     Args:
         query: Search query string
         limit: Maximum number of results to return (default: 3)
+        os_type: Operating system type ("Mac/Linux", "Windows", "WSL")
         
     Returns:
         Dictionary containing search results with MCP information
@@ -120,13 +138,72 @@ def keyword_search_smithery(query: str = "", limit: int = 3) -> Dict:
         servers = sorted(data.get('servers', []), key=lambda x: x.get('useCount', 0), reverse=True)[:limit]
         
         for server in servers:
+            server_id = server.get('qualifiedName')
+            # Extract server ID without @author/ prefix for configuration
+            config_server_id = server_id.split('/')[-1] if '/' in server_id else server_id
+            
+            # Create configuration based on OS type
+            if os_type == "Mac/Linux":
+                configuration = {
+                    "mcpServers": {
+                        f"{config_server_id}": {
+                            "command": "npx",
+                            "args": [
+                                "-y",
+                                "@smithery/cli@latest",
+                                "run",
+                                f"{server_id}",
+                                "--key",
+                                "YOUR_SMITHERY_KEY"
+                            ]
+                        }
+                    }
+                }
+            elif os_type == "Windows":
+                configuration = {
+                    "mcpServers": {
+                        f"{config_server_id}": {
+                            "command": "cmd",
+                            "args": [
+                                "/c",
+                                "npx",
+                                "-y",
+                                "@smithery/cli@latest",
+                                "run",
+                                f"{server_id}",
+                                "--key",
+                                "YOUR_SMITHERY_KEY"
+                            ]
+                        }
+                    }
+                }
+            elif os_type == "WSL":
+                configuration = {
+                    "mcpServers": {
+                        f"{config_server_id}": {
+                            "command": "wsl",
+                            "args": [
+                                "npx",
+                                "-y",
+                                "@smithery/cli@latest",
+                                "run",
+                                f"{server_id}",
+                                "--key",
+                                "YOUR_SMITHERY_KEY"
+                            ]
+                        }
+                    }
+                }
+            
             server_info = {
-                "id": server.get('qualifiedName'),
+                "id": server_id,
                 "name": server.get('displayName'),
                 "description": server.get('description'),
                 "likes": server.get('useCount', 0),
-                "source": "smithery"
+                "source": "smithery",
+                "configuration": configuration
             }
+            
             results.append(server_info)
         
         return {
@@ -141,7 +218,7 @@ def keyword_search_smithery(query: str = "", limit: int = 3) -> Dict:
             "total": 0
         }
 
-def keyword_search(query: str, sources: List[str], limit: int = 3) -> Dict:
+def keyword_search(query: str, sources: List[str], limit: int = 3, os_type: str = "Mac/Linux") -> Dict:
     """
     Search for MCPs using keyword matching.
     
@@ -149,6 +226,7 @@ def keyword_search(query: str, sources: List[str], limit: int = 3) -> Dict:
         query: Keyword search query
         sources: List of sources to search from ('huggingface', 'smithery')
         limit: Maximum number of results to return (default: 3)
+        os_type: Operating system type ("Mac/Linux", "Windows", "WSL")
         
     Returns:
         Dictionary containing combined search results
@@ -160,7 +238,7 @@ def keyword_search(query: str, sources: List[str], limit: int = 3) -> Dict:
         all_results.extend(hf_results.get("results", []))
     
     if "smithery" in sources:
-        smithery_results = keyword_search_smithery(query, limit)
+        smithery_results = keyword_search_smithery(query, limit, os_type)
         all_results.extend(smithery_results.get("results", []))
     
     return {
@@ -169,7 +247,7 @@ def keyword_search(query: str, sources: List[str], limit: int = 3) -> Dict:
         "search_type": "keyword"
     }
 
-def embedding_search_hf_spaces(query: str = "", limit: int = 3) -> Dict:
+def semantic_search_hf_spaces(query: str = "", limit: int = 3) -> Dict:
     """
     Search for MCPs in Hugging Face Spaces using semantic embedding matching.
     
@@ -181,84 +259,100 @@ def embedding_search_hf_spaces(query: str = "", limit: int = 3) -> Dict:
         Dictionary containing search results with MCP information
     """
     try:
-        print("[DEBUG] embedding_search_hf_spaces called")
         pinecone_api_key = os.getenv('PINECONE_API_KEY')
         openai_api_key = os.getenv('OPENAI_API_KEY')
-        print(f"[DEBUG] pinecone_api_key exists: {pinecone_api_key is not None}, openai_api_key exists: {openai_api_key is not None}")
         if not pinecone_api_key or not openai_api_key:
-            print("[ERROR] API keys not found")
             return {
                 "error": "API keys not found",
                 "results": [],
                 "total": 0
             }
-        print("[DEBUG] Initializing Pinecone and OpenAI clients")
+        
         pc = Pinecone(api_key=pinecone_api_key)
         index = pc.Index("hf-mcp")
         client = OpenAI(api_key=openai_api_key)
-        print("[DEBUG] Generating embedding with OpenAI")
+        
         response = client.embeddings.create(
             input=query,
             model="text-embedding-3-large"
         )
         query_embedding = response.data[0].embedding
-        print(f"[DEBUG] Embedding generated: {type(query_embedding)}, len={len(query_embedding)}")
-        print("[DEBUG] Querying Pinecone index")
+        
         results = index.query(
             namespace="",
             vector=query_embedding,
             top_k=limit
         )
-        print(f"[DEBUG] Pinecone query results: {results}")
+        
         space_results = []
         if not results.matches:
-            print("[DEBUG] No matches found in Pinecone results")
             return {
                 "results": [],
                 "total": 0
             }
+            
         for match in results.matches:
             space_id = match.id
             try:
                 repo_id = space_id.replace('spaces/', '')
-                print(f"[DEBUG] Fetching space info for repo_id: {repo_id}")
                 space = api.space_info(repo_id)
+                
+                # Convert space ID to URL format - replace all special chars with hyphens
+                space_id_lower = re.sub(r'[^a-z0-9]', '-', space.id.lower())
+                # Remove consecutive hyphens
+                space_id_lower = re.sub(r'-+', '-', space_id_lower)
+                # Remove leading and trailing hyphens
+                space_id_lower = space_id_lower.strip('-')
+                sse_url = f"https://{space_id_lower}.hf.space/gradio_api/mcp/sse"
+                
                 space_info = {
                     "id": space.id,
                     "likes": space.likes,
                     "trending_score": space.trending_score,
                     "source": "huggingface",
-                    "score": match.score
+                    "score": match.score,
+                    "configuration": {
+                        "mcpServers": {
+                            "gradio": {
+                                "command": "npx",
+                                "args": [
+                                    "mcp-remote",
+                                    sse_url,
+                                    "--transport",
+                                    "sse-only"
+                                ]
+                            }
+                        }
+                    }
                 }
                 space_results.append(space_info)
             except Exception as e:
-                print(f"[ERROR] Error fetching space info for {space_id}: {str(e)}")
                 continue
+                
         return {
             "results": space_results,
             "total": len(space_results)
         }
     except Exception as e:
-        print(f"[CRITICAL ERROR] in embedding_search_hf_spaces: {str(e)}")
         return {
             "error": str(e),
             "results": [],
             "total": 0
         }
 
-def embedding_search_smithery(query: str = "", limit: int = 3) -> Dict:
+def semantic_search_smithery(query: str = "", limit: int = 3, os_type: str = "Mac/Linux") -> Dict:
     """
     Search for MCPs in Smithery Registry using semantic embedding matching.
     
     Args:
         query: Natural language search query
         limit: Maximum number of results to return (default: 3)
+        os_type: Operating system type ("Mac/Linux", "Windows", "WSL")
         
     Returns:
         Dictionary containing search results with MCP information
     """
     try:
-        print("[DEBUG] embedding_search_smithery called")
         from pinecone import Pinecone
         from openai import OpenAI
         import os
@@ -266,39 +360,37 @@ def embedding_search_smithery(query: str = "", limit: int = 3) -> Dict:
         pinecone_api_key = os.getenv('PINECONE_API_KEY')
         openai_api_key = os.getenv('OPENAI_API_KEY')
         smithery_token = os.getenv('SMITHERY_TOKEN')
-        print(f"[DEBUG] pinecone_api_key exists: {pinecone_api_key is not None}, openai_api_key exists: {openai_api_key is not None}, smithery_token exists: {smithery_token is not None}")
+        
         if not pinecone_api_key or not openai_api_key or not smithery_token:
-            print("[ERROR] API keys not found")
             return {
                 "error": "API keys not found",
                 "results": [],
                 "total": 0
             }
-        print("[DEBUG] Initializing Pinecone and OpenAI clients")
+            
         pc = Pinecone(api_key=pinecone_api_key)
         index = pc.Index("smithery-mcp")
         client = OpenAI(api_key=openai_api_key)
-        print("[DEBUG] Generating embedding with OpenAI")
+        
         response = client.embeddings.create(
             input=query,
             model="text-embedding-3-large"
         )
         query_embedding = response.data[0].embedding
-        print(f"[DEBUG] Embedding generated: {type(query_embedding)}, len={len(query_embedding)}")
-        print("[DEBUG] Querying Pinecone index")
+        
         results = index.query(
             namespace="",
             vector=query_embedding,
             top_k=limit
         )
-        print(f"[DEBUG] Pinecone query results: {results}")
+        
         server_results = []
         if not results.matches:
-            print("[DEBUG] No matches found in Pinecone results")
             return {
                 "results": [],
                 "total": 0
             }
+            
         headers = {
             'Authorization': f'Bearer {smithery_token}'
         }
@@ -306,40 +398,96 @@ def embedding_search_smithery(query: str = "", limit: int = 3) -> Dict:
         for match in results.matches:
             server_id = match.id
             try:
-                print(f"[DEBUG] Fetching server info for server_id: {server_id}")
                 response = requests.get(
                     f'https://registry.smithery.ai/servers/{server_id}',
                     headers=headers
                 )
                 if response.status_code != 200:
-                    print(f"[ERROR] Smithery API error for {server_id}: {response.status_code}")
                     continue
+                    
                 server = response.json()
+                
+                # Extract server ID without @author/ prefix for configuration
+                config_server_id = server_id.split('/')[-1] if '/' in server_id else server_id
+                
+                # Create configuration based on OS type
+                if os_type == "Mac/Linux":
+                    configuration = {
+                        "mcpServers": {
+                            f"{config_server_id}": {
+                                "command": "npx",
+                                "args": [
+                                    "-y",
+                                    "@smithery/cli@latest",
+                                    "run",
+                                    f"{server_id}",
+                                    "--key",
+                                    "YOUR_SMITHERY_KEY"
+                                ]
+                            }
+                        }
+                    }
+                elif os_type == "Windows":
+                    configuration = {
+                        "mcpServers": {
+                            f"{config_server_id}": {
+                                "command": "cmd",
+                                "args": [
+                                    "/c",
+                                    "npx",
+                                    "-y",
+                                    "@smithery/cli@latest",
+                                    "run",
+                                    f"{server_id}",
+                                    "--key",
+                                    "YOUR_SMITHERY_KEY"
+                                ]
+                            }
+                        }
+                    }
+                elif os_type == "WSL":
+                    configuration = {
+                        "mcpServers": {
+                            f"{config_server_id}": {
+                                "command": "wsl",
+                                "args": [
+                                    "npx",
+                                    "-y",
+                                    "@smithery/cli@latest",
+                                    "run",
+                                    f"{server_id}",
+                                    "--key",
+                                    "YOUR_SMITHERY_KEY"
+                                ]
+                            }
+                        }
+                    }
+                
                 server_info = {
-                    "id": server.get('qualifiedName'),
+                    "id": server_id,
                     "name": server.get('displayName'),
                     "description": server.get('description'),
                     "likes": server.get('useCount', 0),
                     "source": "smithery",
-                    "score": match.score
+                    "score": match.score,
+                    "configuration": configuration
                 }
                 server_results.append(server_info)
             except Exception as e:
-                print(f"[ERROR] Error fetching server info for {server_id}: {str(e)}")
                 continue
+                
         return {
             "results": server_results,
             "total": len(server_results)
         }
     except Exception as e:
-        print(f"[CRITICAL ERROR] in embedding_search_smithery: {str(e)}")
         return {
             "error": str(e),
             "results": [],
             "total": 0
         }
 
-def embedding_search(query: str, sources: List[str], limit: int = 3) -> Dict:
+def semantic_search(query: str, sources: List[str], limit: int = 3, os_type: str = "Mac/Linux") -> Dict:
     """
     Search for MCPs using semantic embedding matching.
     
@@ -347,6 +495,7 @@ def embedding_search(query: str, sources: List[str], limit: int = 3) -> Dict:
         query: Natural language search query
         sources: List of sources to search from ('huggingface', 'smithery')
         limit: Maximum number of results to return (default: 3)
+        os_type: Operating system type ("Mac/Linux", "Windows", "WSL")
         
     Returns:
         Dictionary containing combined search results
@@ -355,7 +504,7 @@ def embedding_search(query: str, sources: List[str], limit: int = 3) -> Dict:
     
     if "huggingface" in sources:
         try:
-            hf_results = embedding_search_hf_spaces(query, limit)
+            hf_results = semantic_search_hf_spaces(query, limit)
             all_results.extend(hf_results.get("results", []))
         except Exception as e:
             # Fallback to keyword search if vector search fails
@@ -364,34 +513,105 @@ def embedding_search(query: str, sources: List[str], limit: int = 3) -> Dict:
     
     if "smithery" in sources:
         try:
-            smithery_results = embedding_search_smithery(query, limit)
+            smithery_results = semantic_search_smithery(query, limit, os_type)
             all_results.extend(smithery_results.get("results", []))
         except Exception as e:
             # Fallback to keyword search if vector search fails
-            smithery_results = keyword_search_smithery(query, limit)
+            smithery_results = keyword_search_smithery(query, limit, os_type)
             all_results.extend(smithery_results.get("results", []))
     
     return {
         "results": all_results,
         "total": len(all_results),
-        "search_type": "embedding"
+        "search_type": "semantic"
     }
 
 # Create the Gradio interface
 with gr.Blocks(title="🚦 Router MCP", css="""
-    #client_radio {
-        margin-top: 0 !important;
-        padding-top: 0 !important;
+    /* Make JSON output expanded by default */
+    .json-viewer-container {
+        display: block !important;
+    }
+    .json-viewer-container > .json-viewer-header {
+        display: none !important;
+    }
+    .json-viewer-container > .json-viewer-content {
+        display: block !important;
+        max-height: none !important;
+    }
+    .json-viewer-container .json-viewer-item {
+        display: block !important;
+    }
+    .json-viewer-container .json-viewer-item > .json-viewer-header {
+        display: none !important;
     }
-    #client_radio .radio-group {
-        gap: 0.5rem !important;
+    .json-viewer-container .json-viewer-item > .json-viewer-content {
+        display: block !important;
+        max-height: none !important;
+    }
+    /* Additional selectors for nested items */
+    .json-viewer-container .json-viewer-item .json-viewer-item {
+        display: block !important;
+    }
+    .json-viewer-container .json-viewer-item .json-viewer-item > .json-viewer-header {
+        display: none !important;
+    }
+    .json-viewer-container .json-viewer-item .json-viewer-item > .json-viewer-content {
+        display: block !important;
+        max-height: none !important;
+    }
+    /* Title styling */
+    .title-container {
+        text-align: center;
+        margin: 0.5rem 0;
+        position: relative;
+        padding: 0.5rem 0;
+        overflow: hidden;
+    }
+    .title-container h1 {
+        display: inline-block;
+        position: relative;
+        z-index: 1;
+        font-size: 1.8rem;
+        margin: 0;
+        line-height: 1.2;
+        mix-blend-mode: multiply;
+    }
+    .title-container p {
+        position: relative;
+        z-index: 1;
+        font-size: 1rem;
+        margin: 0.5rem 0 0 0;
+        color: #666;
+        mix-blend-mode: multiply;
+    }
+    .traffic-light {
+        position: absolute;
+        top: 50%;
+        left: 50%;
+        transform: translate(-50%, -50%);
+        width: 300px;
+        height: 40px;
+        background: linear-gradient(90deg, 
+            rgba(255, 0, 0, 0.3) 0%,
+            rgba(255, 165, 0, 0.3) 50%,
+            rgba(0, 255, 0, 0.3) 100%
+        );
+        border-radius: 20px;
+        z-index: 0;
+        filter: blur(20px);
     }
 """) as demo:
-    gr.Markdown("# 🚦 Router MCP")
-    gr.Markdown("### Search MCP compatible spaces using natural language")
+    with gr.Column(elem_classes=["title-container"]):
+        gr.HTML('''
+            <div class="traffic-light"></div>
+            <h1>🚦 Router MCP</h1>
+            <p>Your Gateway to Optimal MCP Servers in Seconds</p>
+        ''')
     
     with gr.Row():
         with gr.Column():
+            gr.Markdown("### Search MCP servers using natural language query")
             query_input = gr.Textbox(
                 label="Describe the MCP Server you're looking for",
                 placeholder="e.g., 'I need an MCP Server that can generate images'"
@@ -410,79 +630,88 @@ with gr.Blocks(title="🚦 Router MCP", css="""
                 step=1
             )
             
-            gr.Markdown("### Select your MCP Client")
+            gr.Markdown("### Select your OS")
             client_radio = gr.Radio(
-                choices=["Cursor", "Windsurf", "Claude Desktop", "VS Code", "Gradio"],
-                label="",
-                value="Cursor",
+                choices=["Mac/Linux", "Windows", "WSL"],
+                label="Choose your operating system to get the appropriate command format",
+                value="Mac/Linux",  # Default back to Mac/Linux
                 interactive=True,
                 elem_id="client_radio"
             )
             
             with gr.Row():
                 keyword_search_button = gr.Button("Keyword Search")
-                embedding_search_button = gr.Button("Semantic Search")
+                semantic_search_button = gr.Button("Semantic Search")
         
         with gr.Column():
-            results_output = gr.JSON(label="Search Results")
+            results_output = gr.JSON(
+                label="Search Results",
+                elem_id="results_output"
+            )
     
     # Set up event handlers
     def get_sources():
         return ["huggingface" if hf_checkbox.value else "", "smithery" if smithery_checkbox.value else ""]
     
-    def handle_keyword_mcp_search(query: str, hf: bool, sm: bool, limit: int) -> Dict:
+    def handle_keyword_mcp_search(query: str, hf: bool, sm: bool, limit: int, os_type: str) -> Dict:
         """
         Handle keyword-based search for MCP servers across selected sources. If the client (such as Cursor or Claude) encounters a task it cannot handle, it can use MCP to search for other tools that can.
+        Use this search when you know the specific name or keywords of the MCP Server you're looking for.
 
         Args:
             query (str): The search query string to find matching MCP servers
-            hf (bool): Whether to include Hugging Face Spaces in the search (converted to "huggingface" string if True)
-            sm (bool): Whether to include Smithery in the search (converted to "smithery" string if True)
-            limit (int): Maximum number of results to return per source (default: 3)
+            hf (bool): Whether to include Hugging Face Spaces in the search
+            sm (bool): Whether to include Smithery in the search
+            limit (int): Maximum number of results to return per source
+            os_type (str): Operating system type ("Mac/Linux", "Windows", "WSL")
 
         Returns:
             Dict: A dictionary containing the search results with the following keys:
-                - results: List of found MCP servers
+                - results: List of found MCP servers with their configurations. Each configuration can be added to the MCP Client's config file to register the server.
                 - total: Total number of results
                 - search_type: Type of search performed ("keyword")
         """
         return keyword_search(
             query,
             ["huggingface" if hf else "", "smithery" if sm else ""],
-            int(limit)
+            int(limit),
+            os_type
         )
     
-    def handle_embedding_mcp_search(query: str, hf: bool, sm: bool, limit: int) -> Dict:
+    def handle_semantic_mcp_search(query: str, hf: bool, sm: bool, limit: int, os_type: str) -> Dict:
         """
         Handle semantic embedding-based search for MCP servers across selected sources. If the client (such as Cursor or Claude) encounters a task it cannot handle, it can use MCP to search for other tools that can.
+        Use this search when your query is more abstract or conceptual, as it can understand the meaning and context of your request.
 
         Args:
             query (str): The natural language search query to find semantically similar MCP servers
-            hf (bool): Whether to include Hugging Face Spaces in the search (converted to "huggingface" string if True)
-            sm (bool): Whether to include Smithery in the search (converted to "smithery" string if True)
-            limit (int): Maximum number of results to return per source (default: 3)
+            hf (bool): Whether to include Hugging Face Spaces in the search
+            sm (bool): Whether to include Smithery in the search
+            limit (int): Maximum number of results to return per source
+            os_type (str): Operating system type ("Mac/Linux", "Windows", "WSL")
 
         Returns:
             Dict: A dictionary containing the search results with the following keys:
-                - results: List of found MCP servers with similarity scores
+                - results: List of found MCP servers with their configurations and similarity scores. Each configuration can be added to the MCP Client's config file to register the server.
                 - total: Total number of results
-                - search_type: Type of search performed ("embedding")
+                - search_type: Type of search performed ("semantic")
         """
-        return embedding_search(
+        return semantic_search(
             query,
             ["huggingface" if hf else "", "smithery" if sm else ""],
-            int(limit)
+            int(limit),
+            os_type
         )
     
     keyword_search_button.click(
         fn=handle_keyword_mcp_search,
-        inputs=[query_input, hf_checkbox, smithery_checkbox, result_limit],
+        inputs=[query_input, hf_checkbox, smithery_checkbox, result_limit, client_radio],
         outputs=results_output
     )
     
-    embedding_search_button.click(
-        fn=handle_embedding_mcp_search,
-        inputs=[query_input, hf_checkbox, smithery_checkbox, result_limit],
+    semantic_search_button.click(
+        fn=handle_semantic_mcp_search,
+        inputs=[query_input, hf_checkbox, smithery_checkbox, result_limit, client_radio],
         outputs=results_output
     )