UI refactor

.env.example

@@ -18,4 +18,8 @@ MEMGRAPH_USERNAME=dummy-username
 MEMGRAPH_PASSWORD=dummy-password
 
 # Add other environment variables for authentication as needed
-API_KEY=test_12345
+API_KEY=test_12345
+
+# MCP Server Tokens
+MCP_GITHUB_TOKEN=github_token
+MCP_ATLASSIAN_TOKEN=atlassian_token

build.js

@@ -0,0 +1,57 @@
+const esbuild = require('esbuild');
+const path = require('path');
+
+const buildOptions = {
+  entryPoints: ['src/ui/main.ts'],
+  bundle: true,
+  outfile: 'src/ui/dist/bundle.js',
+  format: 'iife',
+  target: 'es2020',
+  minify: process.env.NODE_ENV === 'production',
+  sourcemap: process.env.NODE_ENV !== 'production',
+  globalName: 'ChatApp',
+  define: {
+    'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'development')
+  },
+  loader: {
+    '.ts': 'ts',
+  },
+  tsconfig: 'tsconfig.json'
+};
+
+// Build function
+async function build() {
+  try {
+    await esbuild.build(buildOptions);
+    console.log('✅ Build completed successfully');
+  } catch (error) {
+    console.error('❌ Build failed:', error);
+    process.exit(1);
+  }
+}
+
+// Watch function
+async function watch() {
+  try {
+    const ctx = await esbuild.context(buildOptions);
+    await ctx.watch();
+    console.log('👀 Watching for changes...');
+  } catch (error) {
+    console.error('❌ Watch failed:', error);
+    process.exit(1);
+  }
+}
+
+// Export for programmatic use
+module.exports = { build, watch, buildOptions };
+
+// CLI usage
+if (require.main === module) {
+  const command = process.argv[2];
+
+  if (command === 'watch') {
+    watch();
+  } else {
+    build();
+  }
+}

config/mcp.template.json

@@ -6,6 +6,8 @@
                 "<Arguments to pass to the server>"
             ],
             "env": {
+                // Environment variable values preceeded by a dollar sign ($) will be replaced with the value from the .env file.
+                // For example, "$MCP_GITHUB_TOKEN" will be replaced with the value of MCP_GITHUB_TOKEN from the .env file.
                 "<Environment Variable Name>": "<Environment Variable Value>"
             }
         }

docs/ideas/agent-behavior.md

@@ -0,0 +1,290 @@
+# Agent Behavior Optimization Strategy
+
+This document outlines a comprehensive strategy for enhancing agent behavior through architectural improvements, evaluation of proposed ideas, and introduction of new high-impact optimization techniques.
+
+## Executive Summary
+
+Current agent architecture shows solid fundamentals with session management, dynamic tool loading, and adaptive system prompts. However, several critical areas require optimization to achieve production-ready performance and user satisfaction.
+
+**High-Impact Recommendations:**
+- Implement context-aware prompt adaptation (not just tool-based updates)
+- Add agent specialization hierarchy for complex task delegation
+- Introduce proactive tool orchestration and intelligent error recovery
+- Deploy conversation state management with semantic memory integration
+
+## Critical Evaluation of Proposed Ideas
+
+### 1. Flexible System Prompts ✅ **STRONG - PRIORITIZE**
+
+**Current State:** System prompts update only when tools change, missing contextual adaptation opportunities.
+
+**Strengths:**
+- Builds on existing `_update_system_prompt()` infrastructure
+- Low implementation complexity with high user experience impact
+- Addresses real limitation in current architecture
+
+**Enhanced Implementation Strategy:**
+```python
+class ContextAwarePromptManager:
+    def __init__(self):
+        self.base_prompt = self._load_base_prompt()
+        self.context_adapters = {
+            'task_type': TaskTypeAdapter(),
+            'user_expertise': ExpertiseAdapter(), 
+            'conversation_stage': StageAdapter(),
+            'domain_focus': DomainAdapter()
+        }
+
+    def generate_prompt(self, context: Dict[str, Any]) -> str:
+        # Dynamic prompt composition based on conversation context
+        adapted_sections = []
+        for adapter_name, adapter in self.context_adapters.items():
+            if context.get(adapter_name):
+                adapted_sections.append(
+                    adapter.adapt(self.base_prompt, context[adapter_name])
+                )
+        return self._merge_prompt_sections(adapted_sections)
+```
+
+**Implementation Priority:** Phase 1 (4-6 weeks)
+
+### 2. Multiple Specialized Agents ⚠️ **MODERATE - REFINE APPROACH**
+
+**Original Idea Analysis:**
+- **Weakness:** Generic "multiple agents" without clear specialization strategy
+- **Risk:** Communication overhead, coordination complexity, debugging difficulties
+
+**Refined Strategy - Agent Specialization Hierarchy:**
+Instead of multiple independent agents, implement specialized capabilities within a single orchestrating agent:
+
+```python
+class SpecializedCapabilityManager:
+    def __init__(self):
+        self.capabilities = {
+            'research': ResearchCapability(),
+            'analysis': AnalysisCapability(), 
+            'coding': CodingCapability(),
+            'creative': CreativeCapability()
+        }
+
+    async def route_task(self, task: Task) -> CapabilityResult:
+        capability = self._select_capability(task)
+        return await capability.execute(task, context=self.shared_context)
+```
+
+**Benefits:**
+- Single session context maintained
+- Specialized processing without coordination overhead
+- Clear capability boundaries with shared memory
+
+**Implementation Priority:** Phase 2 (6-8 weeks)
+
+### 3. Improved Tool Use 🔄 **PARTIAL - NEEDS EXPANSION**
+
+**Current Limitation Analysis:**
+- Tools are enabled/disabled but lack intelligent orchestration
+- No proactive tool suggestion or error recovery
+- Missing tool performance optimization and caching
+
+**Enhanced Tool Orchestration Strategy:**
+
+```python
+class IntelligentToolOrchestrator:
+    def __init__(self):
+        self.tool_performance_tracker = ToolPerformanceTracker()
+        self.tool_recommender = ToolRecommendationEngine()
+        self.error_recovery = ToolErrorRecovery()
+
+    async def execute_with_optimization(self, task: Task) -> Result:
+        # Pre-execution optimization
+        optimal_tools = await self.tool_recommender.suggest_tools(task)
+
+        # Execution with monitoring
+        result = await self._execute_with_fallbacks(task, optimal_tools)
+
+        # Post-execution learning
+        self.tool_performance_tracker.record_usage(task, result)
+
+        return result
+```
+
+**Implementation Priority:** Phase 1 (concurrent with flexible prompts)
+
+## New High-Impact Ideas
+
+### 4. Conversation State Management 🆕 **HIGH IMPACT**
+
+**Problem:** Current agent lacks semantic understanding of conversation progression and context shifts.
+
+**Solution:** Implement conversation state tracking with semantic transitions:
+
+```python
+class ConversationStateManager:
+    def __init__(self):
+        self.states = ['exploration', 'focused_research', 'problem_solving', 'synthesis']
+        self.transition_detector = StateTransitionDetector()
+        self.memory_prioritizer = ContextualMemoryPrioritizer()
+
+    def update_state(self, new_message: str) -> ConversationState:
+        predicted_state = self.transition_detector.predict_transition(
+            current_state=self.current_state,
+            message=new_message,
+            history=self.recent_history
+        )
+
+        if predicted_state != self.current_state:
+            self._handle_state_transition(predicted_state)
+
+        return self.current_state
+```
+
+**Benefits:**
+- Adaptive response strategies based on conversation flow
+- Improved context retention and retrieval
+- Better user experience through contextual awareness
+
+### 5. Proactive Error Prevention 🆕 **HIGH IMPACT**
+
+**Problem:** Current agent is reactive - only handles errors after they occur.
+
+**Solution:** Implement predictive error prevention and graceful degradation:
+
+```python
+class ProactiveErrorManager:
+    def __init__(self):
+        self.error_predictor = ErrorPredictionModel()
+        self.fallback_strategies = FallbackStrategyRepository()
+
+    async def execute_with_prediction(self, action: Action) -> Result:
+        risk_assessment = self.error_predictor.assess_risk(action)
+
+        if risk_assessment.high_risk:
+            return await self._execute_with_enhanced_monitoring(action)
+
+        return await self._standard_execution(action)
+```
+
+### 6. Semantic Memory Integration 🆕 **MEDIUM-HIGH IMPACT**
+
+**Problem:** Current RAG system lacks integration with conversation memory for personalized responses.
+
+**Solution:** Bridge RAG knowledge base with conversational context:
+
+```python
+class SemanticMemoryBridge:
+    def __init__(self, rag_system, conversation_memory):
+        self.rag = rag_system
+        self.memory = conversation_memory
+        self.integration_engine = MemoryIntegrationEngine()
+
+    async def enhanced_retrieval(self, query: str) -> EnrichedContext:
+        # Combine RAG retrieval with conversation memory
+        rag_results = await self.rag.retrieve(query)
+        memory_context = await self.memory.get_relevant_context(query)
+
+        return self.integration_engine.merge_contexts(rag_results, memory_context)
+```
+
+## Implementation Roadmap
+
+### Phase 1: Foundation (4-6 weeks)
+**Priority:** Context-aware prompts + Tool orchestration
+- Implement `ContextAwarePromptManager`
+- Deploy `IntelligentToolOrchestrator`
+- Add basic conversation state detection
+
+**Success Metrics:**
+- 40% improvement in task completion accuracy
+- 60% reduction in tool selection errors
+- User satisfaction score >4.2/5
+
+### Phase 2: Intelligence (6-8 weeks)  
+**Priority:** Specialized capabilities + Semantic memory
+- Deploy `SpecializedCapabilityManager`
+- Integrate `SemanticMemoryBridge` with existing RAG
+- Implement `ProactiveErrorManager`
+
+**Success Metrics:**
+- 25% reduction in multi-step task failures
+- 50% improvement in context retention across sessions
+- 35% decrease in error recovery time
+
+### Phase 3: Optimization (4-6 weeks)
+**Priority:** Performance tuning + Advanced features
+- Fine-tune all systems based on real usage data
+- Add advanced conversation state management
+- Implement user behavior learning
+
+**Success Metrics:**
+- Sub-2 second response times for 90% of queries
+- 80% user task completion without clarification
+- Production-ready stability metrics
+
+## Discarded Ideas & Rationale
+
+### ❌ Generic Multi-Agent Architecture
+**Why Discarded:** Adds complexity without clear benefits for single-user sessions. Coordination overhead outweighs performance gains.
+
+**Better Alternative:** Specialized capability routing within single agent context.
+
+### ❌ Static Prompt Templates
+**Why Discarded:** Too rigid for dynamic conversations. Context-aware adaptation provides better user experience.
+
+**Better Alternative:** Dynamic prompt composition based on conversation state.
+
+### ❌ Tool Auto-Discovery 
+**Why Discarded:** Security risks and unpredictable behavior. Current explicit tool management is more reliable.
+
+**Better Alternative:** Intelligent tool recommendation within curated tool set.
+
+## Integration with Existing Architecture
+
+### Minimal Disruption Strategy
+- Extend current `Agent` class rather than replacing
+- Leverage existing `Chat` and tool infrastructure  
+- Build on current session management system
+
+### Key Integration Points
+1. **System Prompt Enhancement:** Replace `_update_system_prompt()` with context-aware version
+2. **Tool Management:** Extend current enable/disable with orchestration layer
+3. **Memory Integration:** Connect with existing RAG components in `src/core/rag/`
+4. **Session Continuity:** Build on current session management in `_agent_sessions`
+
+## Success Measurement Framework
+
+### Technical Metrics
+- **Response Accuracy:** Task completion without user clarification
+- **Context Retention:** Relevant information persistence across conversation turns
+- **Error Recovery:** Successful fallback execution rate
+- **Performance:** Response latency and system resource usage
+
+### User Experience Metrics  
+- **Task Success Rate:** Percentage of user goals achieved
+- **Conversation Flow:** Natural interaction progression
+- **User Satisfaction:** Direct feedback and retention metrics
+- **Learning Effectiveness:** Improvement in personalized responses over time
+
+## Risk Mitigation
+
+### Implementation Risks
+1. **Complexity Creep:** Maintain clear component boundaries and interfaces
+2. **Performance Degradation:** Implement performance monitoring from day one
+3. **Backward Compatibility:** Ensure existing functionality remains stable
+
+### Mitigation Strategies
+- Incremental deployment with feature flags
+- Comprehensive testing at each phase
+- Performance benchmarking against current baseline
+- User feedback integration throughout development
+
+## Conclusion
+
+This optimization strategy transforms the current reactive agent into a proactive, context-aware system while maintaining architectural stability. The phased approach ensures manageable implementation with measurable improvements at each stage.
+
+**Key Success Factors:**
+1. Focus on user experience improvements over technical complexity
+2. Leverage existing architecture strengths rather than rebuilding
+3. Measure and validate improvements at each implementation phase
+4. Maintain production stability throughout optimization process
+
+The recommended approach prioritizes proven high-impact changes while introducing innovative features that advance the state of AI agent capabilities.