Update app.py

app.py

@@ -465,17 +465,17 @@ class MultimodalRAG:
             logger.error(f"Error during cleanup: {e}")
 
 class TemplateManager:
-    """Manages Gradio interface templates"""
+    """Manages Gradio templates and their metadata"""
     
-    def __init__(self, template_dir: Path = TEMPLATE_DIR):
-        self.template_dir = template_dir
-        self.template_dir.mkdir(exist_ok=True)
-        self.templates: Dict[str, Template] = {}
+    def __init__(self):
+        self.templates = {}
+        self.component_index = {}
+        self.category_index = {}
         self.load_templates()
-    
-def _get_builtin_templates(self) -> Dict[str, Template]:
-    """Get built-in templates"""
-    templates = {
+        
+    def load_templates(self):
+        """Load built-in templates"""
+        self.templates = {
         "image_classifier": Template(
             code="""
             import gradio as gr
@@ -1482,7 +1482,106 @@ def _get_builtin_templates(self) -> Dict[str, Template]:
             components=["Slider", "Textbox", "Button", "JSON"],
             metadata={"category": "task_automation"}
         )
+        }
+                
+        # Build indexes
+        self._build_component_index()
+        self._build_category_index()
+        
+    def _build_component_index(self):
+        """Build index of templates by component"""
+        self.component_index = {}
+        for name, template in self.templates.items():
+            for component in template.components:
+                if component not in self.component_index:
+                    self.component_index[component] = []
+                self.component_index[component].append(name)
+                
+    def _build_category_index(self):
+        """Build index of templates by category"""
+        self.category_index = {}
+        for name, template in self.templates.items():
+            category = template.metadata.get("category", "other")
+            if category not in self.category_index:
+                self.category_index[category] = []
+            self.category_index[category].append(name)
+            
+    def get_template(self, name: str) -> Optional[Template]:
+        """Get template by name"""
+        return self.templates.get(name)
+    
+    def search(self, query: str, limit: int = 5) -> List[Dict]:
+        """Search templates by description or metadata"""
+        results = []
+        for name, template in self.templates.items():
+            score = self._calculate_search_score(query, template)
+            if score > 0:
+                results.append({
+                    "name": name,
+                    "template": template,
+                    "score": score
+                })
         
+        results.sort(key=lambda x: x["score"], reverse=True)
+        return results[:limit]
+    
+    def _calculate_search_score(self, query: str, template: Template) -> float:
+        """Calculate search relevance score"""
+        query = query.lower()
+        score = 0.0
+        
+        # Check description match
+        if query in template.description.lower():
+            score += 1.0
+            
+        # Check category match
+        category = template.metadata.get("category", "").lower()
+        if query in category:
+            score += 0.5
+            
+        # Check component match
+        for component in template.components:
+            if query in component.lower():
+                score += 0.2
+                
+        return score
+    
+    def get_categories(self) -> List[str]:
+        """Get list of available categories"""
+        return list(self.category_index.keys())
+    
+    def get_components(self) -> List[str]:
+        """Get list of available components"""
+        return list(self.component_index.keys())
+
+# Update the Template class if needed
+@dataclass
+class Template:
+    """Template data structure"""
+    code: str
+    description: str
+    components: List[str]
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    version: str = "1.0"
+
+# Main execution
+if __name__ == "__main__":
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    logger = logging.getLogger(__name__)
+
+    # Initialize GPU configuration
+    setup_gpu_memory()
+
+    try:
+        # Create and run the builder interface
+        demo = create_builder_interface()
+        demo.launch(share=True)
+    except Exception as e:
+        logger.error(f"Error running application: {e}")
         def load_templates(self):
         """Load all templates from directory"""
         try: