Enhance chat configuration management and UI integration

- Updated `services.py` to allow service restart with an option to recreate containers, addressing WSL2 bind mount issues.
- Added new chat configuration management functions in `system_controller.py` for loading, saving, and validating chat prompts.
- Introduced `ChatSettings` component in the web UI for admin users to manage chat configurations easily.
- Updated API service methods in `api.ts` to support chat configuration endpoints.
- Integrated chat settings into the system management page for better accessibility.

Author: AnkushMalaker

backends/advanced/src/advanced_omi_backend/chat_service.py

@@ -22,6 +22,7 @@
 
 from advanced_omi_backend.database import get_database
 from advanced_omi_backend.llm_client import get_llm_client
+from advanced_omi_backend.model_registry import get_models_registry
 from advanced_omi_backend.services.memory import get_memory_service
 from advanced_omi_backend.services.memory.base import MemoryEntry
 from advanced_omi_backend.services.obsidian_service import (
@@ -133,7 +134,7 @@ def from_dict(cls, data: Dict) -> "ChatSession":
 
 class ChatService:
     """Service for managing chat sessions and memory-enhanced conversations."""
-    
+
     def __init__(self):
         self.db = None
         self.sessions_collection: Optional[AsyncIOMotorCollection] = None
@@ -142,6 +143,32 @@ def __init__(self):
         self.memory_service = None
         self._initialized = False
 
+    def _get_system_prompt(self) -> str:
+        """
+        Get system prompt from config with fallback to default.
+
+        Returns:
+            str: System prompt for chat interactions
+        """
+        try:
+            reg = get_models_registry()
+            if reg and hasattr(reg, 'config'):
+                chat_config = reg.config.get('chat', {})
+                prompt = chat_config.get('system_prompt')
+                if prompt:
+                    logger.debug("Loaded chat system prompt from config")
+                    return prompt
+        except Exception as e:
+            logger.warning(f"Failed to load chat system prompt from config: {e}")
+
+        # Fallback to default
+        logger.debug("Using default chat system prompt")
+        return """You are a helpful AI assistant with access to the user's personal memories and conversation history.
+
+Use the provided memories and conversation context to give personalized, contextual responses. If memories are relevant, reference them naturally in your response. Be conversational and helpful.
+
+If no relevant memories are available, respond normally based on the conversation context."""
+
     async def initialize(self):
         """Initialize the chat service with database connections."""
         if self._initialized:
@@ -392,12 +419,8 @@ async def generate_response_stream(
                 "timestamp": time.time()
             }
 
-            # Create system prompt
-            system_prompt = """You are a helpful AI assistant with access to the user's personal memories and conversation history. 
-
-Use the provided memories and conversation context to give personalized, contextual responses. If memories are relevant, reference them naturally in your response. Be conversational and helpful.
-
-If no relevant memories are available, respond normally based on the conversation context."""
+            # Get system prompt from config
+            system_prompt = self._get_system_prompt()
 
             # Prepare full prompt
             full_prompt = f"{system_prompt}\n\n{context}"

backends/advanced/src/advanced_omi_backend/controllers/system_controller.py

@@ -455,3 +455,103 @@ async def set_memory_provider(provider: str):
     except Exception as e:
         logger.exception("Error setting memory provider")
         raise e
+
+
+# Chat Configuration Management Functions
+
+async def get_chat_config_yaml() -> str:
+    """Get chat system prompt as plain text."""
+    try:
+        config_path = _find_config_path()
+
+        default_prompt = """You are a helpful AI assistant with access to the user's personal memories and conversation history.
+
+Use the provided memories and conversation context to give personalized, contextual responses. If memories are relevant, reference them naturally in your response. Be conversational and helpful.
+
+If no relevant memories are available, respond normally based on the conversation context."""
+
+        if not os.path.exists(config_path):
+            return default_prompt
+
+        with open(config_path, 'r') as f:
+            full_config = yaml.safe_load(f) or {}
+
+        chat_config = full_config.get('chat', {})
+        system_prompt = chat_config.get('system_prompt', default_prompt)
+
+        # Return just the prompt text, not the YAML structure
+        return system_prompt
+
+    except Exception as e:
+        logger.error(f"Error loading chat config: {e}")
+        raise
+
+
+async def save_chat_config_yaml(prompt_text: str) -> dict:
+    """Save chat system prompt from plain text."""
+    try:
+        config_path = _find_config_path()
+
+        # Validate plain text prompt
+        if not prompt_text or not isinstance(prompt_text, str):
+            raise ValueError("Prompt must be a non-empty string")
+
+        prompt_text = prompt_text.strip()
+        if len(prompt_text) < 10:
+            raise ValueError("Prompt too short (minimum 10 characters)")
+        if len(prompt_text) > 10000:
+            raise ValueError("Prompt too long (maximum 10000 characters)")
+
+        # Create chat config dict
+        chat_config = {'system_prompt': prompt_text}
+
+        # Load full config
+        if os.path.exists(config_path):
+            with open(config_path, 'r') as f:
+                full_config = yaml.safe_load(f) or {}
+        else:
+            full_config = {}
+
+        # Backup existing config
+        if os.path.exists(config_path):
+            backup_path = str(config_path) + '.backup'
+            shutil.copy2(config_path, backup_path)
+            logger.info(f"Created config backup at {backup_path}")
+
+        # Update chat section
+        full_config['chat'] = chat_config
+
+        # Save
+        with open(config_path, 'w') as f:
+            yaml.dump(full_config, f, default_flow_style=False, allow_unicode=True)
+
+        # Reload config in memory (hot-reload)
+        load_models_config(force_reload=True)
+
+        logger.info("Chat configuration updated successfully")
+
+        return {"success": True, "message": "Chat configuration updated successfully"}
+
+    except Exception as e:
+        logger.error(f"Error saving chat config: {e}")
+        raise
+
+
+async def validate_chat_config_yaml(prompt_text: str) -> dict:
+    """Validate chat system prompt plain text."""
+    try:
+        # Validate plain text prompt
+        if not isinstance(prompt_text, str):
+            return {"valid": False, "error": "Prompt must be a string"}
+
+        prompt_text = prompt_text.strip()
+        if len(prompt_text) < 10:
+            return {"valid": False, "error": "Prompt too short (minimum 10 characters)"}
+        if len(prompt_text) > 10000:
+            return {"valid": False, "error": "Prompt too long (maximum 10000 characters)"}
+
+        return {"valid": True, "message": "Configuration is valid"}
+
+    except Exception as e:
+        logger.error(f"Error validating chat config: {e}")
+        return {"valid": False, "error": f"Validation error: {str(e)}"}

backends/advanced/src/advanced_omi_backend/routers/modules/system_routes.py

@@ -7,7 +7,8 @@
 import logging
 from typing import Optional
 
-from fastapi import APIRouter, Body, Depends, Request
+from fastapi import APIRouter, Body, Depends, HTTPException, Request
+from fastapi.responses import Response
 from pydantic import BaseModel
 
 from advanced_omi_backend.auth import current_active_user, current_superuser
@@ -128,6 +129,53 @@ async def delete_all_user_memories(current_user: User = Depends(current_active_u
     return await system_controller.delete_all_user_memories(current_user)
 
 
+# Chat Configuration Management Endpoints
+
+@router.get("/admin/chat/config", response_class=Response)
+async def get_chat_config(current_user: User = Depends(current_superuser)):
+    """Get chat configuration as YAML. Admin only."""
+    try:
+        yaml_content = await system_controller.get_chat_config_yaml()
+        return Response(content=yaml_content, media_type="text/plain")
+    except Exception as e:
+        logger.error(f"Failed to get chat config: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/admin/chat/config")
+async def save_chat_config(
+    request: Request,
+    current_user: User = Depends(current_superuser)
+):
+    """Save chat configuration from YAML. Admin only."""
+    try:
+        yaml_content = await request.body()
+        yaml_str = yaml_content.decode('utf-8')
+        result = await system_controller.save_chat_config_yaml(yaml_str)
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Failed to save chat config: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/admin/chat/config/validate")
+async def validate_chat_config(
+    request: Request,
+    current_user: User = Depends(current_superuser)
+):
+    """Validate chat configuration YAML. Admin only."""
+    try:
+        yaml_content = await request.body()
+        yaml_str = yaml_content.decode('utf-8')
+        result = await system_controller.validate_chat_config_yaml(yaml_str)
+        return result
+    except Exception as e:
+        logger.error(f"Failed to validate chat config: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @router.get("/streaming/status")
 async def get_streaming_status(request: Request, current_user: User = Depends(current_superuser)):
     """Get status of active streaming sessions and Redis Streams health. Admin only."""