Add centralized agent configuration and environment variable support

- Introduced a new `agent_config.py` file to manage agent settings, including refresh intervals, language preferences, port settings, and debug options.
- Implemented environment variable support for overriding configuration values, enhancing flexibility for deployment.
- Updated the main application logic to utilize the new configuration system, allowing for easier management of settings.
- Added a new documentation file detailing the agent configuration structure and usage, providing guidance for users.
- Enhanced UI components to integrate with the new configuration, ensuring real-time updates and improved user experience.

.env.example

@@ -20,5 +20,9 @@ GIGACHAT_TIMEOUT=30
 AGENT_PROVIDER=mistral
 ENABLE_VECTOR_SIMILARITY=false
 CMW_DEFAULT_LANGUAGE=ru
+CMW_DEFAULT_LANGUAGE=ru
+CMW_DEFAULT_PORT=7860
+CMW_DEBUG_MODE=false
+CMW_VERBOSE_LOGGING=false
 # Unused
 # DEBUG_MODE=True

agent_ng/agent_config.py

@@ -0,0 +1,164 @@
+"""
+Agent Configuration
+==================
+
+Central configuration file for the CMW Platform Agent.
+Contains all configurable settings including refresh intervals, timeouts, and other parameters.
+"""
+
+from dataclasses import dataclass
+from typing import Dict, Any
+import os
+
+@dataclass
+class RefreshIntervals:
+    """Auto-refresh intervals for different UI components"""
+    status: float = 2.0      # Status pane refresh interval (seconds)
+    logs: float = 3.0        # Logs pane refresh interval (seconds)
+    stats: float = 4.0       # Stats pane refresh interval (seconds)
+    progress: float = 2.0    # Progress pane refresh interval (seconds)
+
+@dataclass
+class AgentSettings:
+    """Main agent configuration settings"""
+    # Language settings
+    default_language: str = "ru"
+    supported_languages: list = None
+    
+    # Port settings
+    default_port: int = 7860
+    auto_port_range: int = 10  # Number of ports to try when auto-finding
+    
+    # UI settings
+    refresh_intervals: RefreshIntervals = None
+    
+    # Agent settings
+    max_conversation_history: int = 50
+    max_tokens_per_request: int = 4000
+    request_timeout: float = 30.0
+    
+    # Debug settings
+    debug_mode: bool = False
+    verbose_logging: bool = False
+    
+    def __post_init__(self):
+        """Initialize default values after dataclass creation"""
+        if self.supported_languages is None:
+            self.supported_languages = ["en", "ru"]
+        
+        if self.refresh_intervals is None:
+            self.refresh_intervals = RefreshIntervals()
+
+class AgentConfig:
+    """Central configuration manager for the CMW Platform Agent"""
+    
+    def __init__(self):
+        self.settings = AgentSettings()
+        self._load_from_environment()
+    
+    def _load_from_environment(self):
+        """Load configuration from environment variables"""
+        # Language settings
+        if os.getenv('CMW_DEFAULT_LANGUAGE'):
+            self.settings.default_language = os.getenv('CMW_DEFAULT_LANGUAGE')
+        
+        # Port settings
+        if os.getenv('CMW_DEFAULT_PORT'):
+            try:
+                self.settings.default_port = int(os.getenv('CMW_DEFAULT_PORT'))
+            except ValueError:
+                pass
+        
+        # Debug settings
+        if os.getenv('CMW_DEBUG_MODE', '').lower() in ['true', '1', 'yes']:
+            self.settings.debug_mode = True
+        
+        if os.getenv('CMW_VERBOSE_LOGGING', '').lower() in ['true', '1', 'yes']:
+            self.settings.verbose_logging = True
+        
+        # Refresh intervals from environment
+        self._load_refresh_intervals_from_env()
+    
+    def _load_refresh_intervals_from_env(self):
+        """Load refresh intervals from environment variables"""
+        # Note: All refresh intervals are internal application parameters
+        # They should be modified in the code, not via environment variables
+        # This method is kept for future extensibility but currently does nothing
+        pass
+    
+    def get_refresh_intervals(self) -> RefreshIntervals:
+        """Get the current refresh intervals configuration"""
+        return self.settings.refresh_intervals
+    
+    def get_language_settings(self) -> Dict[str, Any]:
+        """Get language-related settings"""
+        return {
+            'default_language': self.settings.default_language,
+            'supported_languages': self.settings.supported_languages
+        }
+    
+    def get_port_settings(self) -> Dict[str, Any]:
+        """Get port-related settings"""
+        return {
+            'default_port': self.settings.default_port,
+            'auto_port_range': self.settings.auto_port_range
+        }
+    
+    def get_agent_settings(self) -> Dict[str, Any]:
+        """Get agent-related settings"""
+        return {
+            'max_conversation_history': self.settings.max_conversation_history,
+            'max_tokens_per_request': self.settings.max_tokens_per_request,
+            'request_timeout': self.settings.request_timeout
+        }
+    
+    def get_debug_settings(self) -> Dict[str, Any]:
+        """Get debug-related settings"""
+        return {
+            'debug_mode': self.settings.debug_mode,
+            'verbose_logging': self.settings.verbose_logging
+        }
+    
+    def update_setting(self, category: str, key: str, value: Any):
+        """Update a specific setting"""
+        if category == 'refresh_intervals':
+            if hasattr(self.settings.refresh_intervals, key):
+                setattr(self.settings.refresh_intervals, key, value)
+        elif hasattr(self.settings, key):
+            setattr(self.settings, key, value)
+    
+    def print_config(self):
+        """Print current configuration"""
+        print("🔧 Agent Configuration:")
+        print(f"  Language: {self.settings.default_language}")
+        print(f"  Port: {self.settings.default_port}")
+        print(f"  Debug Mode: {self.settings.debug_mode}")
+        print(f"  Refresh Intervals:")
+        print(f"    Status: {self.settings.refresh_intervals.status}s")
+        print(f"    Logs: {self.settings.refresh_intervals.logs}s")
+        print(f"    Stats: {self.settings.refresh_intervals.stats}s")
+        print(f"    Progress: {self.settings.refresh_intervals.progress}s")
+
+# Global configuration instance
+config = AgentConfig()
+
+# Convenience functions for easy access
+def get_refresh_intervals() -> RefreshIntervals:
+    """Get refresh intervals configuration"""
+    return config.get_refresh_intervals()
+
+def get_language_settings() -> Dict[str, Any]:
+    """Get language settings"""
+    return config.get_language_settings()
+
+def get_port_settings() -> Dict[str, Any]:
+    """Get port settings"""
+    return config.get_port_settings()
+
+def get_agent_settings() -> Dict[str, Any]:
+    """Get agent settings"""
+    return config.get_agent_settings()
+
+def get_debug_settings() -> Dict[str, Any]:
+    """Get debug settings"""
+    return config.get_debug_settings()

agent_ng/app_ng_modular.py

@@ -26,6 +26,15 @@ from typing import List, Dict, Any, Optional, Tuple, AsyncGenerator
 import json
 import time
 from dataclasses import asdict
+# Import configuration with fallback for direct execution
+try:
+    from agent_ng.agent_config import config, get_language_settings, get_port_settings
+except ImportError:
+    # Fallback for direct execution
+    import sys
+    from pathlib import Path
+    sys.path.append(str(Path(__file__).parent))
+    from agent_config import config, get_language_settings, get_port_settings
 
 # LangChain imports
 from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
@@ -914,13 +923,23 @@ def main():
     parser = argparse.ArgumentParser(description='CMW Platform Agent')
     parser.add_argument('-en', '--english', action='store_true', help='Start in English')
     parser.add_argument('-ru', '--russian', action='store_true', help='Start in Russian')
-    parser.add_argument('-p', '--port', type=int, default=7860, help='Port to run on (default: 7860)')
+    parser.add_argument('-p', '--port', type=int, default=None, help='Port to run on (overrides config)')
     parser.add_argument('--auto-port', action='store_true', help='Automatically find an available port')
+    parser.add_argument('--config', action='store_true', help='Show current configuration')
     args = parser.parse_args()
     
-    # Determine language from environment variable, command line, or default
-    # Priority: Command line > Environment variable > Default (Russian)
-    language = os.getenv('CMW_DEFAULT_LANGUAGE', 'ru')  # Default to Russian
+    # Show configuration if requested
+    if args.config:
+        config.print_config()
+        return
+    
+    # Get language settings from central config
+    language_settings = get_language_settings()
+    port_settings = get_port_settings()
+    
+    # Determine language from command line, environment variable, or config default
+    # Priority: Command line > Environment variable > Config default
+    language = language_settings['default_language']
     
     if args.russian:
         language = "ru"
@@ -928,13 +947,15 @@ def main():
         language = "en"
     
     # Determine port
+    default_port = args.port if args.port is not None else port_settings['default_port']
+    
     if args.auto_port:
-        port = find_available_port(args.port)
+        port = find_available_port(default_port, port_settings['auto_port_range'])
         if port is None:
-            print(f"❌ Could not find an available port starting from {args.port}")
+            print(f"❌ Could not find an available port starting from {default_port}")
             sys.exit(1)
     else:
-        port = args.port
+        port = default_port
     
     print(f"🚀 Starting LangChain-Native LLM Agent App with language detection...")
     print(f"🌐 Language: {language.upper()}")

agent_ng/tabs/chat_tab.py

@@ -143,6 +143,9 @@ class ChatTab:
             outputs=[self.components["chatbot"], self.components["msg"]]
         )
         
+        # Trigger UI updates after chat events
+        self._setup_chat_event_triggers()
+        
         # Quick action events (using local methods)
         self.components["quick_math_btn"].click(
             fn=self._quick_math,
@@ -176,6 +179,32 @@ class ChatTab:
         
         print("✅ ChatTab: All event handlers connected successfully")
     
+    def _setup_chat_event_triggers(self):
+        """Setup event triggers to update other UI components when chat events occur"""
+        # Get UI update handlers
+        trigger_ui_update = self.event_handlers.get("trigger_ui_update")
+        
+        if trigger_ui_update:
+            # Trigger UI update after send button click
+            self.components["send_btn"].click(
+                fn=trigger_ui_update,
+                outputs=[]  # No specific outputs, just triggers the update
+            )
+            
+            # Trigger UI update after message submit
+            self.components["msg"].submit(
+                fn=trigger_ui_update,
+                outputs=[]
+            )
+            
+            # Trigger UI update after clear button click
+            self.components["clear_btn"].click(
+                fn=trigger_ui_update,
+                outputs=[]
+            )
+            
+            print("✅ ChatTab: UI update triggers connected")
+    
     def get_components(self) -> Dict[str, Any]:
         """Get all components created by this tab"""
         return self.components

agent_ng/ui_manager.py

@@ -11,6 +11,15 @@ import gradio as gr
 from pathlib import Path
 from typing import Dict, Any, Callable, List, Tuple, Optional
 import os
+# Import configuration with fallback for direct execution
+try:
+    from agent_ng.agent_config import get_refresh_intervals
+except ImportError:
+    # Fallback for direct execution
+    import sys
+    from pathlib import Path
+    sys.path.append(str(Path(__file__).parent))
+    from agent_config import get_refresh_intervals
 
 class UIManager:
     """Manages Gradio UI creation and configuration with i18n support"""
@@ -90,7 +99,7 @@ class UIManager:
         update_progress_handler = event_handlers.get("update_progress_display")
         
         
-        # Load initial UI state once on startup - no timers to avoid queue issues
+        # Load initial UI state once on startup
         if "status_display" in self.components and update_status_handler:
             demo.load(
                 fn=update_status_handler,
@@ -115,7 +124,55 @@ class UIManager:
                 fn=refresh_stats_handler,
                 outputs=[self.components["stats_display"]]
             )
+        
+        # Setup auto-refresh timers for real-time updates
+        self._setup_auto_refresh_timers(demo, event_handlers)
     
+    def _setup_auto_refresh_timers(self, demo: gr.Blocks, event_handlers: Dict[str, Callable]):
+        """Setup auto-refresh timers for real-time updates"""
+        print("🔄 Setting up auto-refresh timers...")
+        
+        # Get refresh intervals from central configuration
+        intervals = get_refresh_intervals()
+        
+        # Status updates
+        if "status_display" in self.components and event_handlers.get("update_status"):
+            status_timer = gr.Timer(intervals.status, active=True)
+            status_timer.tick(
+                fn=event_handlers["update_status"],
+                outputs=[self.components["status_display"]]
+            )
+            print(f"✅ Status auto-refresh timer set ({intervals.status}s)")
+        
+        # Logs updates
+        if "logs_display" in self.components and event_handlers.get("refresh_logs"):
+            logs_timer = gr.Timer(intervals.logs, active=True)
+            logs_timer.tick(
+                fn=event_handlers["refresh_logs"],
+                outputs=[self.components["logs_display"]]
+            )
+            print(f"✅ Logs auto-refresh timer set ({intervals.logs}s)")
+        
+        # Stats updates
+        if "stats_display" in self.components and event_handlers.get("refresh_stats"):
+            stats_timer = gr.Timer(intervals.stats, active=True)
+            stats_timer.tick(
+                fn=event_handlers["refresh_stats"],
+                outputs=[self.components["stats_display"]]
+            )
+            print(f"✅ Stats auto-refresh timer set ({intervals.stats}s)")
+        
+        # Progress updates (for visual feedback)
+        if "progress_display" in self.components and event_handlers.get("update_progress_display"):
+            progress_timer = gr.Timer(intervals.progress, active=True)
+            progress_timer.tick(
+                fn=event_handlers["update_progress_display"],
+                outputs=[self.components["progress_display"]]
+            )
+            print(f"✅ Progress auto-refresh timer set ({intervals.progress}s)")
+        
+        print("🔄 Auto-refresh timers configured successfully")
+
     def get_components(self) -> Dict[str, Any]:
         """Get all components created by the UI manager"""
         return self.components

docs/AGENT_CONFIGURATION.md

@@ -0,0 +1,186 @@
+# Agent Configuration
+
+## Overview
+
+The CMW Platform Agent uses a central configuration system that allows you to customize various settings including refresh intervals, language preferences, port settings, and debug options.
+
+## Configuration File
+
+The main configuration is located in `agent_ng/agent_config.py` and provides:
+
+- **Centralized Settings**: All configurable parameters in one place
+- **Environment Variable Support**: Override settings via environment variables
+- **Type Safety**: Uses dataclasses for type-safe configuration
+- **Easy Access**: Simple functions to get configuration values
+
+## Configuration Categories
+
+### 1. Refresh Intervals
+
+Controls how often different UI components are updated:
+
+```python
+@dataclass
+class RefreshIntervals:
+    status: float = 2.0      # Status pane refresh interval (seconds)
+    logs: float = 3.0        # Logs pane refresh interval (seconds)
+    stats: float = 4.0       # Stats pane refresh interval (seconds)
+    progress: float = 2.0    # Progress pane refresh interval (seconds)
+```
+
+### 2. Language Settings
+
+```python
+default_language: str = "ru"  # Default language (ru/en)
+supported_languages: list = ["en", "ru"]  # Supported languages
+```
+
+### 3. Port Settings
+
+```python
+default_port: int = 7860      # Default port
+auto_port_range: int = 10     # Number of ports to try when auto-finding
+```
+
+### 4. Agent Settings
+
+```python
+max_conversation_history: int = 50    # Max conversation history
+max_tokens_per_request: int = 4000   # Max tokens per request
+request_timeout: float = 30.0        # Request timeout in seconds
+```
+
+### 5. Debug Settings
+
+```python
+debug_mode: bool = False      # Enable debug mode
+verbose_logging: bool = False # Enable verbose logging
+```
+
+## Environment Variables
+
+You can override any configuration using environment variables:
+
+### Language Settings
+```bash
+# Set default language
+export CMW_DEFAULT_LANGUAGE="en"  # or "ru"
+```
+
+### Port Settings
+```bash
+# Set default port
+export CMW_DEFAULT_PORT="7861"
+```
+
+### Refresh Intervals
+```bash
+# Note: All refresh intervals are internal application parameters
+# and should be modified in the code, not via environment variables
+# 
+# To modify refresh intervals, edit agent_ng/agent_config.py:
+# - Status: 2.0s (internal)
+# - Logs: 3.0s (internal)  
+# - Stats: 4.0s (internal)
+# - Progress: 2.0s (internal)
+```
+
+### Debug Settings
+```bash
+# Enable debug mode
+export CMW_DEBUG_MODE="true"
+export CMW_VERBOSE_LOGGING="true"
+```
+
+## Command Line Usage
+
+### View Current Configuration
+```bash
+python agent_ng/app_ng_modular.py --config
+```
+
+### Override Settings
+```bash
+# Override port
+python agent_ng/app_ng_modular.py --en -p 7861
+
+# Use auto port finding
+python agent_ng/app_ng_modular.py --ru --auto-port
+```
+
+## Programmatic Usage
+
+### Get Configuration Values
+```python
+from agent_ng.agent_config import get_refresh_intervals, get_language_settings
+
+# Get refresh intervals
+intervals = get_refresh_intervals()
+print(f"Status updates every {intervals.status} seconds")
+
+# Get language settings
+lang_settings = get_language_settings()
+print(f"Default language: {lang_settings['default_language']}")
+```
+
+### Update Configuration
+```python
+from agent_ng.agent_config import config
+
+# Update refresh intervals
+config.update_setting('refresh_intervals', 'status', 1.0)  # 1 second
+config.update_setting('refresh_intervals', 'logs', 2.0)    # 2 seconds
+
+# Update other settings
+config.update_setting('agent_settings', 'max_tokens_per_request', 8000)
+```
+
+## Default Values
+
+| Setting | Default Value | Description | Environment Configurable |
+|---------|---------------|-------------|-------------------------|
+| `status` | 2.0s | Status pane refresh interval | ❌ Internal only |
+| `logs` | 3.0s | Logs pane refresh interval | ❌ Internal only |
+| `stats` | 4.0s | Stats pane refresh interval | ❌ Internal only |
+| `progress` | 2.0s | Progress pane refresh interval | ❌ Internal only |
+| `default_language` | "ru" | Default language | ✅ `CMW_DEFAULT_LANGUAGE` |
+| `default_port` | 7860 | Default port | ✅ `CMW_DEFAULT_PORT` |
+| `auto_port_range` | 10 | Port range for auto-finding | ❌ Internal only |
+| `max_conversation_history` | 50 | Max conversation history | ❌ Internal only |
+| `max_tokens_per_request` | 4000 | Max tokens per request | ❌ Internal only |
+| `request_timeout` | 30.0s | Request timeout | ❌ Internal only |
+| `debug_mode` | False | Debug mode | ✅ `CMW_DEBUG_MODE` |
+| `verbose_logging` | False | Verbose logging | ✅ `CMW_VERBOSE_LOGGING` |
+
+## Best Practices
+
+1. **Use Environment Variables**: For deployment and different environments
+2. **Keep Defaults Sensible**: Default values should work for most use cases
+3. **Document Changes**: When modifying defaults, update documentation
+4. **Test Configuration**: Always test configuration changes
+5. **Use Type Hints**: Configuration uses type hints for better IDE support
+
+## Troubleshooting
+
+### Configuration Not Loading
+- Check that `agent_ng/agent_config.py` is properly imported
+- Verify environment variable names are correct
+- Check for typos in configuration keys
+
+### Refresh Intervals Not Working
+- Ensure the UI Manager is using `get_refresh_intervals()`
+- Check that timer components are properly created
+- Verify event handlers are connected
+
+### Port Issues
+- Check if port is already in use
+- Use `--auto-port` flag for automatic port finding
+- Verify port range settings
+
+## Future Enhancements
+
+- **Configuration File**: Support for YAML/JSON configuration files
+- **Hot Reload**: Reload configuration without restarting
+- **Validation**: Configuration validation and error reporting
+- **Profiles**: Different configuration profiles for different environments
+- **UI Configuration**: Web-based configuration interface