Update mcp_spaces_finder.py

mcp_spaces_finder.py

@@ -1,339 +1,108 @@
 """
-HuggingFace MCP Spaces Finder Module
-
-A reusable module to discover and list Model Context Protocol (MCP) servers
-available on HuggingFace Spaces.
-
+Simple HuggingFace MCP Spaces Finder Module
+A minimal module to discover MCP servers on HuggingFace Spaces.
+Just a dropdown that displays the selected value in a textbox.
 Usage:
-    from mcp_spaces_finder import MCPSpacesFinder, create_mcp_dropdown
+    from mcp_spaces_finder import create_simple_mcp_selector
     
-    # In your Gradio app
-    mcp_dropdown = create_mcp_dropdown()
+    # One-liner in your Gradio app
+    dropdown, textbox = create_simple_mcp_selector()
 """
 
 import gradio as gr
-from huggingface_hub import HfApi, list_spaces
+from huggingface_hub import list_spaces
 import time
-from typing import List, Dict, Optional, Tuple
-from dataclasses import dataclass
+from typing import List, Tuple
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
-@dataclass
-class MCPSpace:
-    id: str
-    title: str
-    author: str
-    likes: int
-    status: str
-    url: str
-    description: str
-    sdk: str
-    last_modified: str
-    created_at: str
-
-class MCPSpacesFinder:
-    """
-    A class to find and manage MCP-enabled spaces on HuggingFace Hub.
-    """
+class SimpleMCPFinder:
+    """Simple MCP spaces finder with caching."""
     
     def __init__(self, cache_duration: int = 300):
-        """
-        Initialize the MCP Spaces Finder.
-        
-        Args:
-            cache_duration (int): Cache duration in seconds (default: 5 minutes)
-        """
-        self.api = HfApi()
-        self.mcp_spaces_cache = None
-        self.cache_timestamp = None
+        self.cache = None
+        self.cache_time = None
         self.cache_duration = cache_duration
-        
-    def get_space_status(self, space_id: str) -> str:
-        """Get the current runtime status of a space."""
-        try:
-            runtime = self.api.get_space_runtime(space_id)
-            if hasattr(runtime, 'stage'):
-                return runtime.stage
-            return "unknown"
-        except Exception:
-            return "error"
     
-    def process_space_batch(self, spaces_batch) -> List[MCPSpace]:
-        """Process a batch of spaces to get their runtime status."""
-        processed_spaces = []
+    def get_mcp_spaces(self) -> List[str]:
+        """Get list of running MCP space IDs."""
         
-        for space in spaces_batch:
-            try:
-                space_id = space.id
-                status = self.get_space_status(space_id)
-                
-                processed_space = MCPSpace(
-                    id=space_id,
-                    title=getattr(space, 'title', space_id.split('/')[-1]) or space_id.split('/')[-1],
-                    author=space.author,
-                    likes=getattr(space, 'likes', 0),
-                    status=status,
-                    url=f"https://huggingface.co/spaces/{space_id}",
-                    description=getattr(space, 'description', 'No description available') or 'No description available',
-                    sdk=getattr(space, 'sdk', 'unknown'),
-                    last_modified=str(getattr(space, 'last_modified', 'unknown')),
-                    created_at=str(getattr(space, 'created_at', 'unknown'))
-                )
-                processed_spaces.append(processed_space)
-                
-            except Exception as e:
-                print(f"Error processing space {getattr(space, 'id', 'unknown')}: {e}")
-                continue
-                
-        return processed_spaces
-    
-    def find_mcp_spaces(self, limit: int = 2000, running_only: bool = True) -> List[MCPSpace]:
-        """
-        Find MCP-enabled spaces using the official mcp-server filter.
-        
-        Args:
-            limit (int): Maximum number of spaces to fetch
-            running_only (bool): If True, only return running/building spaces
-            
-        Returns:
-            List[MCPSpace]: List of MCP spaces sorted by likes
-        """
+        # Check cache
+        if (self.cache is not None and 
+            self.cache_time is not None and 
+            time.time() - self.cache_time < self.cache_duration):
+            return self.cache
         
-        # Check cache first
-        if (self.mcp_spaces_cache is not None and 
-            self.cache_timestamp is not None and 
-            time.time() - self.cache_timestamp < self.cache_duration):
-            return self.mcp_spaces_cache
+        print("Fetching MCP spaces...")
         
-        print("Fetching MCP spaces from HuggingFace Hub...")
-        
-        # Get all spaces with the official mcp-server tag, sorted by likes
+        # Get MCP spaces sorted by likes
         spaces = list(list_spaces(
             filter="mcp-server",
-            sort="likes", 
+            sort="likes",
             direction=-1,
-            limit=limit,
+            limit=1000,
             full=True
         ))
         
-        print(f"Found {len(spaces)} spaces with mcp-server tag")
-        
-        # Process spaces in batches using ThreadPoolExecutor for status checking
-        batch_size = 50
-        space_batches = [spaces[i:i + batch_size] for i in range(0, len(spaces), batch_size)]
-        
-        all_processed_spaces = []
-        
-        with ThreadPoolExecutor(max_workers=5) as executor:
-            future_to_batch = {
-                executor.submit(self.process_space_batch, batch): batch 
-                for batch in space_batches
-            }
-            
-            for future in as_completed(future_to_batch):
-                try:
-                    batch_results = future.result()
-                    all_processed_spaces.extend(batch_results)
-                except Exception as e:
-                    print(f"Error processing batch: {e}")
-        
-        if running_only:
-            # Filter to only include running or building spaces
-            filtered_spaces = [
-                space for space in all_processed_spaces 
-                if space.status in ["RUNNING", "RUNNING_BUILDING", "BUILDING"]
-            ]
-        else:
-            filtered_spaces = all_processed_spaces
+        # Extract just the space IDs 
+        space_ids = [space.id for space in spaces]
         
-        # Sort by likes descending
-        filtered_spaces.sort(key=lambda x: x.likes, reverse=True)
+        # Cache results
+        self.cache = space_ids
+        self.cache_time = time.time()
         
-        # Cache the results
-        self.mcp_spaces_cache = filtered_spaces
-        self.cache_timestamp = time.time()
-        
-        print(f"Found {len(filtered_spaces)} {'running/building' if running_only else 'total'} MCP spaces")
-        return filtered_spaces
-    
-    def get_dropdown_choices(self, running_only: bool = True) -> Tuple[List[Tuple[str, str]], int]:
-        """
-        Get dropdown choices for Gradio dropdown component.
-        
-        Args:
-            running_only (bool): If True, only return running/building spaces
-            
-        Returns:
-            Tuple[List[Tuple[str, str]], int]: (choices, total_count)
-        """
-        spaces = self.find_mcp_spaces(running_only=running_only)
-        
-        choices = [(space.id, space.id) for space in spaces]
-        return choices, len(spaces)
-    
-    def get_space_info(self, space_id: str) -> Optional[MCPSpace]:
-        """
-        Get detailed information about a specific space.
-        
-        Args:
-            space_id (str): The space ID (username/spacename)
-            
-        Returns:
-            Optional[MCPSpace]: Space information or None if not found
-        """
-        spaces = self.mcp_spaces_cache or self.find_mcp_spaces()
-        return next((space for space in spaces if space.id == space_id), None)
-    
-    def clear_cache(self):
-        """Clear the cache to force refresh on next request."""
-        self.mcp_spaces_cache = None
-        self.cache_timestamp = None
+        print(f"Found {len(space_ids)} MCP spaces")
+        return space_ids
 
-# Global instance for easy usage
-_default_finder = MCPSpacesFinder()
+# Global instance
+_finder = SimpleMCPFinder()
 
-def create_mcp_dropdown(
-    label: str = "🤖 Select MCP Server",
-    info: str = "Choose a running MCP server",
-    running_only: bool = True,
-    **kwargs
-) -> gr.Dropdown:
+def create_simple_mcp_selector(
+    dropdown_label: str = "🤖 Select MCP Server",
+    textbox_label: str = "Selected MCP Server",
+    placeholder: str = "No server selected"
+) -> Tuple[gr.Dropdown, gr.Textbox]:
     """
-    Create a Gradio dropdown populated with MCP spaces.
+    Create a simple MCP selector with dropdown and textbox.
     
     Args:
-        label (str): Label for the dropdown
-        info (str): Info text for the dropdown
-        running_only (bool): If True, only show running/building spaces
-        **kwargs: Additional arguments passed to gr.Dropdown
+        dropdown_label (str): Label for the dropdown
+        textbox_label (str): Label for the textbox  
+        placeholder (str): Placeholder text when nothing selected
         
     Returns:
-        gr.Dropdown: Configured dropdown component
+        Tuple[gr.Dropdown, gr.Textbox]: The dropdown and textbox components
     """
-    choices, count = _default_finder.get_dropdown_choices(running_only=running_only)
     
-    status_text = "running/building" if running_only else "total"
-    final_label = f"{label} ({count} {status_text})"
+    # Get MCP spaces
+    spaces = _finder.get_mcp_spaces()
     
-    return gr.Dropdown(
-        choices=choices,
-        label=final_label,
-        info=info,
-        value=None,
-        **kwargs
+    # Create dropdown with space choices
+    dropdown = gr.Dropdown(
+        choices=spaces,
+        label=f"{dropdown_label} ({len(spaces)} available)",
+        value=None
     )
-
-def get_mcp_space_info(space_id: str) -> Optional[MCPSpace]:
-    """
-    Get information about a specific MCP space.
-    
-    Args:
-        space_id (str): The space ID (username/spacename)
-        
-    Returns:
-        Optional[MCPSpace]: Space information or None if not found
-    """
-    return _default_finder.get_space_info(space_id)
-
-def refresh_mcp_spaces() -> Tuple[List[Tuple[str, str]], int]:
-    """
-    Refresh the MCP spaces cache and return updated choices.
-    
-    Returns:
-        Tuple[List[Tuple[str, str]], int]: (choices, total_count)
-    """
-    _default_finder.clear_cache()
-    return _default_finder.get_dropdown_choices()
-
-def get_mcp_config_text(space_id: str) -> str:
-    """
-    Generate MCP configuration text for a given space.
     
-    Args:
-        space_id (str): The space ID (username/spacename)
-        
-    Returns:
-        str: Formatted MCP configuration instructions
-    """
-    space_info = get_mcp_space_info(space_id)
+    # Create textbox to display selection
+    textbox = gr.Textbox(
+        label=textbox_label,
+        value=placeholder,
+        interactive=False
+    )
     
-    if not space_info:
-        return f"Space {space_id} not found or not available."
+    # Connect dropdown to textbox
+    def update_textbox(selected_value):
+        return selected_value if selected_value else placeholder
     
-    config_text = f"""
-# {space_info.title}
-
-**Space ID:** {space_info.id}  
-**Author:** {space_info.author}  
-**Likes:** ❤️ {space_info.likes}  
-**Status:** {space_info.status}  
-**URL:** [{space_info.url}]({space_info.url})
-
-## 🔧 MCP Configuration
-
-### For VSCode/Cursor/Claude Code (Recommended)
-```json
-{{
-  "servers": {{
-    "{space_info.id.replace('/', '-')}": {{
-      "url": "{space_info.url}/gradio_api/mcp/sse"
-    }}
-  }}
-}}
-```
-
-### For Claude Desktop
-```json
-{{
-  "mcpServers": {{
-    "{space_info.id.replace('/', '-')}": {{
-      "command": "npx",
-      "args": [
-        "mcp-remote", 
-        "{space_info.url}/gradio_api/mcp/sse"
-      ]
-    }}
-  }}
-}}
-```
-
-### Alternative: Use HF MCP Space Server
-```json
-{{
-  "mcpServers": {{
-    "hf-spaces": {{
-      "command": "npx",
-      "args": [
-        "-y", 
-        "@llmindset/mcp-hfspace",
-        "{space_info.id}"
-      ]
-    }}
-  }}
-}}
-```
-
-**Description:** {space_info.description}
-    """.strip()
+    dropdown.change(
+        fn=update_textbox,
+        inputs=[dropdown], 
+        outputs=[textbox]
+    )
     
-    return config_text
+    return dropdown, textbox
 
-# Utility functions for easy integration
-def create_mcp_interface_simple() -> Tuple[gr.Dropdown, gr.Markdown]:
-    """
-    Create a simple MCP interface with dropdown and output.
-    
-    Returns:
-        Tuple[gr.Dropdown, gr.Markdown]: (dropdown, output_component)
-    """
-    dropdown = create_mcp_dropdown()
-    output = gr.Markdown("Select an MCP server above to view configuration details.")
-    
-    def update_output(space_id):
-        if space_id:
-            return get_mcp_config_text(space_id)
-        return "Select an MCP server above to view configuration details."
-    
-    dropdown.change(fn=update_output, inputs=[dropdown], outputs=[output])
-    
-    return dropdown, output
+def refresh_mcp_spaces():
+    """Clear cache to force refresh."""
+    _finder.cache = None
+    _finder.cache_time = None