Initial commit: AI Assistant Multi-Agent System for HuggingFace Spaces

.gitignore

@@ -0,0 +1,33 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+.venv
+
+# macOS
+.DS_Store
+
+# Data files
+py/data/chat_history.db
+*.db
+
+# IDE
+.vscode/
+.idea/
+
+# Logs
+*.log
+
+# Temporary files
+*.tmp
+*.bak
+*~
+
+# Gradio
+flagged/
+gradio_cached_examples/

README.md

@@ -0,0 +1,277 @@
+# AI Assistant Multi-Agent System
+
+A modern multi-agent conversational AI system built with LangChain, featuring specialized agents for documentation, settings, and system management. The system uses RAG (Retrieval-Augmented Generation) for intelligent documentation search and provides a clean Gradio web interface.
+
+## 🚀 Quick Start
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd ai_assistant_python/v3
+
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Set OpenAI API key
+export OPENAI_API_KEY="your-api-key"
+
+# Run the application
+python py/app.py
+```
+
+Visit http://localhost:7860 to start chatting!
+
+## 🏗️ Architecture
+
+### System Overview
+
+```mermaid
+graph TB
+    subgraph "Frontend"
+        UI[Gradio Web UI]
+    end
+    
+    subgraph "Agent System"
+        AR[Agent Registry<br/>Singleton Manager]
+        DR[📚 Document Reader]
+        PS[⚙️ Profile Settings]
+        NC[🌐 Network Config]
+        SM[👥 Subscriber Mgmt]
+        SQ[📊 System Query]
+        PD[📋 Policy & DNN]
+    end
+    
+    subgraph "Storage"
+        CDB[(ChromaDB<br/>Vector Store)]
+        CHM[(Chat History<br/>SQLite)]
+    end
+    
+    UI <--> AR
+    AR --> DR & PS & NC & SM & SQ & PD
+    DR <--> CDB
+    DR & PS & NC & SM & SQ & PD <--> CHM
+    
+    classDef active fill:#4CAF50,color:#fff
+    classDef mock fill:#FFC107,color:#000
+    classDef future fill:#9E9E9E,color:#fff
+    
+    class DR,PS active
+    class NC,SM,SQ,PD future
+```
+
+### Agent Communication Flow
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Agent1 as Current Agent
+    participant Registry as Agent Registry
+    participant Agent2 as Target Agent
+    
+    User->>Agent1: "Set my profile name"
+    Agent1->>Agent1: Detect need to switch
+    Agent1->>Registry: switch_to_profile_settings()
+    Registry->>Agent2: run_agent(message, context)
+    Agent2->>Agent2: Process request
+    Agent2-->>Registry: Response
+    Registry-->>Agent1: __SWITCH_AGENT__|response
+    Agent1-->>User: Profile updated!
+```
+
+## 🤖 Available Agents
+
+### Active Agents
+
+#### 📚 Document Reader (Default)
+- **Purpose**: Search and retrieve technical documentation
+- **Features**:
+  - RAG-powered semantic search
+  - Version-specific documentation queries
+  - Multi-product support (Harmony/Chorus)
+  - Vector similarity awareness
+- **Example**: "How do I install Chorus 1.1?"
+
+#### ⚙️ Profile Settings
+- **Purpose**: Manage user preferences and settings
+- **Features**:
+  - View current profile
+  - Update preferences (mock implementation)
+  - Notification management
+- **Example**: "Set my profile name to John"
+
+### Future Agents (Stubs)
+
+#### 🌐 Network Configuration
+- Configure NAT, VLAN, IP addresses
+- Bulk network operations
+- Template application
+
+#### 👥 Subscriber Management
+- CRUD operations for subscribers
+- CSV import/export
+- IMSI range management
+
+#### 📊 System Query
+- Analytics and performance metrics
+- System health monitoring
+- Read-only insights
+
+#### 📋 Policy & DNN
+- DNN creation and management
+- QoS profile configuration
+- Policy rule management
+
+## 🔧 Technical Details
+
+### Core Components
+
+```
+v3/py/
+├── agents/                      # Agent implementations
+│   ├── base_agent.py           # Base class with common functionality
+│   ├── document_reader.py      # RAG-enabled documentation agent
+│   └── profile_settings.py     # User settings agent
+├── tools/
+│   ├── agent_tools.py          # Agent registry & switching
+│   └── document_tools.py       # Documentation search tools
+├── backend/
+│   ├── chromadb_manager.py     # Vector database management
+│   └── chat_history_manager.py # Conversation persistence
+├── frontend/
+│   └── gradio_app.py          # Web interface
+└── config.yaml                # Configuration
+```
+
+### Key Technologies
+
+- **LangChain**: Agent orchestration and tool management
+- **ChromaDB**: Vector database for semantic search
+- **OpenAI**: LLM provider (GPT-4o-mini by default)
+- **Gradio**: Modern web UI framework
+- **SQLite**: Chat history persistence
+
+### Agent Registry Pattern
+
+The system uses a singleton registry pattern for agent management:
+
+```python
+# Initialize agents once
+agent_tools.initialize_agents(llm, api_gateway)
+
+# Run any agent by ID
+result = agent_tools.run_agent('document_reader', message, context)
+```
+
+### Smart Agent Switching
+
+Agents can seamlessly transfer conversations:
+
+```python
+# Using StructuredTool for proper parameter handling
+@tool
+def switch_to_profile_settings(reason: str = "") -> str:
+    """Transfer to Profile Settings agent"""
+    return run_target_agent_with_context()
+```
+
+## 🎯 Usage Examples
+
+### Basic Interaction
+```
+You: Hello
+Assistant: Hello! How can I assist you today?
+
+You: How do I install Harmony 1.8?
+Assistant: [Searches documentation and provides installation steps...]
+
+You: Set my profile name to Alice
+Assistant: [Switches to Profile Settings] I've updated your profile name to 'Alice'!
+```
+
+### Version-Specific Queries
+```
+You: Show me Chorus 1.1 webhook documentation
+Assistant: [Retrieves Chorus 1.1 specific webhook docs...]
+```
+
+## 🔍 Advanced Features
+
+### RAG-Powered Search
+- Semantic similarity search using embeddings
+- Metadata filtering by product and version
+- Context-aware responses with source citations
+
+### Graceful Error Handling
+- Iteration limit handling with fallback responses
+- User-friendly error messages
+- Comprehensive logging for debugging
+
+### Chat History Management
+- Automatic history cleaning (removes transfer noise)
+- Persistent conversation storage
+- Context preservation across agent switches
+
+## 🛠️ Configuration
+
+### config.yaml
+```yaml
+# Model settings
+llm:
+  model: "gpt-4o-mini"
+  temperature: 0.0
+
+# RAG settings
+rag:
+  k: 6  # Number of documents to retrieve
+
+# Available products/versions
+products:
+  harmony: ["1.8", "1.6", "1.5", "1.2"]
+  chorus: ["1.1"]
+```
+
+### Environment Variables
+```bash
+OPENAI_API_KEY="sk-..."  # Required
+```
+
+## 🚧 Development
+
+### Adding a New Agent
+
+1. Create agent class inheriting from `BaseAgent`:
+```python
+class MyAgent(BaseAgent):
+    def _create_tools(self) -> List[Tool]:
+        # Define agent-specific tools
+        
+    def _get_system_prompt(self) -> str:
+        # Define agent behavior
+```
+
+2. Register in `agent_tools.py`:
+```python
+AGENT_INFO["my_agent"] = {
+    "display_name": "My Agent",
+    "description": "What it does",
+    "tools": {"read": [...], "write": [...]}
+}
+```
+
+3. Initialize in registry:
+```python
+_AGENT_INSTANCES["my_agent"] = MyAgent(llm)
+```
+
+### Testing
+```bash
+# Run tests (when implemented)
+pytest tests/
+
+# Run with debug logging
+python py/app.py --debug
+```

README_HF.md

@@ -0,0 +1,59 @@
+---
+title: AI Assistant Multi Agent System
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.0.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# AI Assistant Multi-Agent System
+
+A modern multi-agent conversational AI system built with LangChain, featuring specialized agents for documentation, settings, and system management.
+
+## 🌟 Features
+
+- **📚 Document Reader Agent**: RAG-powered semantic search across technical documentation
+- **⚙️ Profile Settings Agent**: Manage user preferences and settings
+- **🔄 Smart Agent Switching**: Seamless handoff between specialized agents
+- **🚀 Fast In-Memory Search**: Optimized vector similarity search without external databases
+
+## 🔧 Configuration
+
+Set your OpenAI API key in the Space settings:
+
+```
+OPENAI_API_KEY=your-api-key-here
+```
+
+## 💬 Usage Examples
+
+Simply start chatting! The Document Reader agent handles documentation queries by default, and will automatically transfer you to the appropriate agent when needed.
+
+### Example Queries:
+- "How do I install Harmony 1.8?"
+- "Show me webhook documentation for Chorus"
+- "Set my profile name to Alice"
+- "What are the system requirements for Harmony?"
+
+## 🏗️ Architecture
+
+This system uses:
+- **LangChain** for agent orchestration
+- **OpenAI** embeddings and LLMs
+- **In-memory vector search** for fast document retrieval
+- **Gradio** for the web interface
+
+## 📊 Available Documentation
+
+- **Harmony**: Versions 1.2, 1.5, 1.6, 1.8
+- **Chorus**: Version 1.1
+
+The system searches through pre-embedded technical documentation to provide accurate, version-specific answers.
+
+## 🤝 Contributing
+
+This is an open-source project. Feel free to contribute or report issues on our GitHub repository.

app.py

@@ -0,0 +1,20 @@
+"""
+Hugging Face Spaces entry point for the AI Assistant Multi-Agent System
+"""
+
+import sys
+import os
+
+# Add the py directory to the Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'py'))
+
+# Import and run the actual app
+from frontend.gradio_app import demo
+
+if __name__ == "__main__":
+    # Launch with HuggingFace Spaces settings
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

py/agents/__init__.py

@@ -0,0 +1,8 @@
+"""
+LangChain-based agent implementations
+"""
+
+from .document_reader import DocumentReaderAgent
+from .profile_settings import ProfileSettingsAgent
+
+__all__ = ['DocumentReaderAgent', 'ProfileSettingsAgent']

py/agents/base_agent.py

@@ -0,0 +1,317 @@
+"""
+Base Agent class with common functionality for all agents
+"""
+
+import logging
+import traceback
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Any
+
+import tiktoken
+from langchain.agents import Tool, AgentExecutor
+from langchain.schema import OutputParserException
+from langchain.agents.format_scratchpad import format_to_openai_function_messages
+from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain.schema import SystemMessage
+from langchain_openai import ChatOpenAI
+from langchain.memory import ConversationBufferMemory
+
+from tools import agent_tools
+from tools.agent_tools import convert_tool_to_openai_function
+
+logger = logging.getLogger(__name__)
+
+
+class BaseAgent(ABC):
+    """Base class for all agents with common functionality."""
+    
+    def __init__(self, agent_id: str, llm: Optional[ChatOpenAI] = None, **kwargs):
+        """
+        Initialize base agent.
+        
+        Args:
+            agent_id: Unique identifier for the agent
+            llm: Optional LangChain LLM instance
+            **kwargs: Additional arguments for specific agents
+        """
+        self.agent_id = agent_id
+        
+        # Get agent info from central registry
+        if agent_id not in agent_tools.AGENT_INFO:
+            raise ValueError(f"Unknown agent ID: {agent_id}")
+            
+        agent_info = agent_tools.AGENT_INFO[agent_id]
+        self.name = agent_info["display_name"]
+        self.description = agent_info["description"]
+        
+        # Initialize LLM with default model
+        self.model = kwargs.get("model", "gpt-4o-mini")
+        self.temperature = kwargs.get("temperature", 0)
+        self.llm = llm or ChatOpenAI(model=self.model, temperature=self.temperature)
+        
+        # Initialize memory
+        self.memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            return_messages=True
+        )
+        
+        # Allow subclasses to do custom initialization
+        self._custom_init(**kwargs)
+        
+        # Create tools (must be implemented by subclass)
+        self.tools = self._create_tools()
+        
+        # Create agent
+        self.agent = self._create_agent()
+    
+    def _custom_init(self, **kwargs):
+        """Override this method for agent-specific initialization."""
+        pass
+    
+    @abstractmethod
+    def _create_tools(self) -> List[Tool]:
+        """Create tools for this agent. Must be implemented by subclass."""
+        pass
+    
+    @abstractmethod
+    def _get_system_prompt(self) -> str:
+        """Get the system prompt for this agent. Must be implemented by subclass."""
+        pass
+    
+    def _create_agent(self) -> AgentExecutor:
+        """Create the LangChain agent with common setup."""
+        # Get system prompt from subclass
+        system_prompt = self._get_system_prompt()
+        system_message = SystemMessage(content=system_prompt)
+        
+        # Create prompt template
+        prompt = ChatPromptTemplate.from_messages([
+            system_message,
+            MessagesPlaceholder(variable_name="chat_history"),
+            ("user", "{input}"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ])
+        
+        # Bind tools to LLM
+        llm_with_tools = self.llm.bind_functions(
+            functions=[convert_tool_to_openai_function(tool) for tool in self.tools]
+        )
+        
+        # Create agent chain
+        agent = (
+            {
+                "input": lambda x: x["input"],
+                "agent_scratchpad": lambda x: format_to_openai_function_messages(x["intermediate_steps"]),
+                "chat_history": lambda x: x.get("chat_history", [])
+            }
+            | prompt
+            | llm_with_tools
+            | OpenAIFunctionsAgentOutputParser()
+        )
+        
+        # Create agent executor
+        agent_executor = AgentExecutor(
+            agent=agent,
+            tools=self.tools,
+            verbose=True,
+            return_intermediate_steps=True,
+            max_iterations=5
+        )
+        
+        return agent_executor
+    
+    def run(self, query: str, context: Optional[Dict] = None) -> Dict[str, Any]:
+        """
+        Run the agent with a query.
+        
+        Args:
+            query: User query
+            context: Optional context dictionary
+            
+        Returns:
+            Dictionary with output, agent_id, and optional agent_switch
+        """
+        # Allow subclasses to enhance the query
+        query = self._enhance_query(query, context)
+        
+        # Get chat history from memory
+        chat_history = self.memory.chat_memory.messages
+        
+        # Count tokens before sending
+        try:
+            # Get the encoding for the model
+            try:
+                encoding = tiktoken.encoding_for_model(self.model)
+            except KeyError:
+                # Fall back to cl100k_base encoding for newer models
+                encoding = tiktoken.get_encoding("cl100k_base")
+            
+            # Estimate token count (this is approximate since we can't easily access the full prompt)
+            system_prompt = self._get_system_prompt()
+            chat_history_str = " ".join([msg.content for msg in chat_history])
+            total_input = f"{system_prompt}\n{chat_history_str}\n{query}"
+            token_count = len(encoding.encode(total_input))
+            
+            logger.info(f"[{self.name}] Sending request to {self.model}")
+            logger.info(f"[{self.name}] Query length: {len(query)} chars")
+            logger.info(f"[{self.name}] Estimated tokens: ~{token_count}")
+            logger.info(f"[{self.name}] Chat history messages: {len(chat_history)}")
+            
+        except Exception as e:
+            logger.warning(f"[{self.name}] Could not count tokens: {e}")
+        
+        # Run agent with graceful iteration limit handling
+        try:
+            result = self.agent.invoke({
+                "input": query,
+                "chat_history": chat_history
+            })
+        except Exception as agent_error:
+            # Check if this is an iteration limit error
+            error_msg = str(agent_error).lower()
+            if "iteration limit" in error_msg or "time limit" in error_msg:
+                logger.info(f"[{self.name}] Hit iteration limit, making final call without tools")
+                
+                # Extract intermediate steps if available
+                intermediate_steps = []
+                if hasattr(agent_error, 'intermediate_steps'):
+                    intermediate_steps = agent_error.intermediate_steps
+                
+                # Make a final call with no tools to generate answer
+                final_prompt = f"""Based on the information gathered so far, provide a comprehensive answer to the user's question.
+                
+User's question: {query}
+
+You must provide a complete answer using the search results you've already obtained."""
+                
+                try:
+                    # Use raw LLM without tools
+                    final_response = self.llm.invoke(final_prompt)
+                    result = {
+                        "output": final_response.content if hasattr(final_response, 'content') else str(final_response),
+                        "intermediate_steps": intermediate_steps
+                    }
+                except Exception as final_error:
+                    logger.error(f"[{self.name}] Failed to generate final answer: {final_error}")
+                    raise agent_error  # Re-raise original error
+            else:
+                # Not an iteration limit error, re-raise
+                raise
+        
+        try:
+            # Check if any tool requested agent switching
+            target_agent_id = self.agent_id  # Default to current agent
+            final_output = result["output"]
+            
+            # Look through intermediate steps for switching signals
+            for action, observation in result.get("intermediate_steps", []):
+                if isinstance(observation, str) and observation.startswith("__SWITCH_AGENT__|"):
+                    parts = observation.split("|", 2)
+                    if len(parts) >= 3:
+                        target_agent_id = parts[1]
+                        final_output = parts[2]
+                        logger.info(f"Agent switch detected: {self.agent_id} -> {target_agent_id}")
+                        break
+            
+            # Save to memory - clean the output first
+            self.memory.chat_memory.add_user_message(query)
+            cleaned_output = self._clean_output_for_history(final_output)
+            self.memory.chat_memory.add_ai_message(cleaned_output)
+            
+            # Build response
+            response = {
+                "output": final_output,
+                "intermediate_steps": result.get("intermediate_steps", []),
+                "agent_id": target_agent_id  # This will be the new agent if switching occurred
+            }
+            
+            # Allow subclasses to add custom response data
+            self._enhance_response(response, result)
+            
+            return response
+            
+        except Exception as e:
+            error_type = type(e).__name__
+            error_msg = str(e)
+            
+            logger.error(f"[{self.name}] Error type: {error_type}")
+            logger.error(f"[{self.name}] Error message: {error_msg}")
+            logger.error(f"[{self.name}] Query that caused error: {query[:500]}...")
+            logger.error(f"[{self.name}] Model: {self.model}")
+            logger.error(f"[{self.name}] Stack trace:\n{traceback.format_exc()}")
+            
+            # Provide user-friendly error message
+            if "server had an error" in error_msg.lower():
+                user_message = "The AI service is temporarily unavailable. This might be due to high demand or a long request. Please try again with a shorter query."
+            else:
+                user_message = f"I encountered an error: {error_msg}"
+            
+            return {
+                "output": f"I apologize, but {user_message}",
+                "error": error_msg,
+                "error_type": error_type,
+                "agent_id": self.agent_id
+            }
+    
+    def _enhance_query(self, query: str, context: Optional[Dict] = None) -> str:
+        """Override this method to enhance the query before processing."""
+        return query
+    
+    def _clean_output_for_history(self, output: str) -> str:
+        """
+        Clean output before saving to chat history.
+        Removes transfer messages, tool usage details, and other noise.
+        
+        Args:
+            output: Raw output string
+            
+        Returns:
+            Cleaned output suitable for chat history
+        """
+        import re
+        
+        # Remove transfer messages
+        output = re.sub(r'Transferring to [^:]+:[^\n]+\n*', '', output)
+        
+        # Remove tool usage details section
+        if '---\n**Tool Usage Details:**' in output:
+            output = output.split('---\n**Tool Usage Details:**')[0]
+        elif 'Tool Usage Details:' in output:
+            output = output.split('Tool Usage Details:')[0]
+        
+        # Remove __SWITCH_AGENT__ markers
+        output = re.sub(r'__SWITCH_AGENT__\|[^|]+\|[^\n]+\n*', '', output)
+        
+        # Remove any trailing whitespace
+        output = output.strip()
+        
+        return output
+    
+    def _enhance_response(self, response: Dict[str, Any], result: Dict[str, Any]):
+        """Override this method to add custom data to the response."""
+        pass
+    
+    def clear_memory(self):
+        """Clear conversation memory."""
+        self.memory.clear()
+    
+    def _build_tool_descriptions_and_agents(self) -> tuple[List[str], List[str]]:
+        """
+        Build tool descriptions and switching agent lists for system prompt.
+        
+        Returns:
+            Tuple of (tool_descriptions, switching_agents)
+        """
+        tool_descriptions = []
+        switching_agents = []
+        
+        for tool in self.tools:
+            if tool.name.startswith("switch_to_"):
+                agent_id = tool.name.replace("switch_to_", "")
+                if agent_id in agent_tools.AGENT_INFO:
+                    switching_agents.append(agent_tools.AGENT_INFO[agent_id]["display_name"])
+            else:
+                tool_descriptions.append(f"- {tool.name}: {tool.description}")
+        
+        return tool_descriptions, switching_agents

py/agents/document_reader.py

@@ -0,0 +1,168 @@
+"""
+Document Reader Agent using LangChain with modular tools
+"""
+
+import logging
+from typing import Dict, List, Optional, Any
+
+from agents.base_agent import BaseAgent
+from langchain.agents import Tool
+
+# Import modular tools
+from tools import document_tools, agent_tools
+from config_loader import get_config
+
+logger = logging.getLogger(__name__)
+
+
+class DocumentReaderAgent(BaseAgent):
+    """Document reader agent using LangChain with RAG capabilities."""
+    
+    def __init__(self, llm: Optional[Any] = None):
+        # Initialize base agent
+        super().__init__(agent_id="document_reader", llm=llm)
+        
+    def _custom_init(self, **kwargs):
+        """Custom initialization for document reader."""
+        self.config = get_config()
+        # Initialize ChromaDB manager for RAG pre-query
+        from backend.chromadb_manager import ChromaDBManager
+        self.db_manager = ChromaDBManager()
+        
+    def _create_tools(self) -> List[Tool]:
+        """Create tools for the document reader agent."""
+        # Add document-specific tools
+        tools = [
+            document_tools.search_documentation_tool(),
+            document_tools.list_available_versions_tool()
+        ]
+        
+        # Add switching tools for all other agents
+        tools.extend(agent_tools.create_switching_tools_for_agent(self.agent_id))
+        
+        return tools
+    
+    def _get_system_prompt(self) -> str:
+        """Get the system prompt for document reader agent."""
+        # Build tool descriptions and switching agents
+        tool_descriptions, switching_agents = self._build_tool_descriptions_and_agents()
+        
+        return f"""You are a technical documentation assistant for Harmony and Chorus products.
+
+Your approach:
+1. ALWAYS respond to the CURRENT user message - ignore previous searches or queries
+2. You receive initial documentation context - check if it answers the user's question
+3. If not, search for the specific information they need
+4. Provide COMPLETE, self-contained answers with all relevant details from the documentation
+5. Quote extensively from the documents you find - users want the actual content
+6. Transfer to other agents when users need help beyond documentation
+
+CRITICAL Answer Requirements:
+- Your answers must be comprehensive and self-sufficient
+- Include ALL relevant information you find in the documentation
+- NEVER tell users to "refer to the guide" or "see page X" - instead, include that information in your response
+- If you mention something exists in the documentation, quote it fully
+- Users come to you to avoid reading documents - give them complete answers
+
+Search principles:
+- The search tool uses vector RAG (semantic similarity), so similar terms return similar results
+- When users mention a product and version, use them as separate parameters (e.g., "install harmony 1.5" → query="install", product="harmony", version="1.5")
+- Products are lowercase: "harmony" or "chorus"
+- After searching, provide ALL the relevant content you found, not just a summary
+
+Available tools:
+{chr(10).join(tool_descriptions)}
+
+You can transfer the conversation to these agents:
+{', '.join(switching_agents)}
+
+When to transfer:
+- Profile Settings: User wants to view/update their settings, preferences, or account
+  Examples: "set my profile name", "update my email", "change my settings", "view my profile"
+- Network Configuration: User needs to configure NAT, VLANs, IP addresses, or network settings
+- Subscriber Management: User needs to create/manage subscribers, import CSV data, or handle IMSI ranges
+- System Query: User wants analytics, performance metrics, or system status reports
+- Policy & DNN: User needs to manage DNNs, QoS profiles, or policy rules
+
+CRITICAL: When switching agents, ONLY use the switching tool. Do NOT add any text, explanations, or messages - the tool handles everything."""
+    
+    def _enhance_query(self, query: str, context: Optional[Dict] = None) -> str:
+        """Enhance query with RAG context."""
+        if not context:
+            context = {}
+            
+        product = context.get("product", "harmony")
+        version = context.get("version", "1.8")
+        
+        # Query RAG with current product/version
+        try:
+            rag_results = self.db_manager.query_with_filter(
+                query, 
+                product, 
+                version, 
+                k=self.config.get_rag_k()
+            )
+            
+            # Format RAG results for context - TRUNCATE to prevent token overflow
+            rag_context_parts = []
+            total_chars = 0
+            max_total_chars = 3000    # Limit total context
+            
+            for i, doc in enumerate(rag_results):
+                content = doc.page_content
+               
+                # Check if adding this would exceed total limit
+                if total_chars + len(content) > max_total_chars:
+                    logger.info(f"Truncating RAG context at document {i+1} to stay within limits")
+                    break
+                    
+                rag_context_parts.append(f"[{i+1}] {content}")
+                total_chars += len(content)
+            
+            rag_context = "\n\n".join(rag_context_parts)
+            
+            logger.info(f"RAG context: {len(rag_results)} documents found, {len(rag_context_parts)} used")
+            logger.info(f"RAG context size: {len(rag_context)} chars")
+            
+            # Create enhanced prompt with RAG context
+            enhanced_query = f"""User Query: {query}
+
+Initial Documentation Context:
+{rag_context}
+
+Please answer the user's query. If the initial documentation above doesn't contain the answer, use your search tools to find the relevant information."""
+            
+            logger.info(f"Enhanced query total size: {len(enhanced_query)} chars")
+            return enhanced_query
+            
+        except Exception as e:
+            logger.error(f"Error during RAG pre-query: {e}")
+            # Fall back to original query with context
+            return f"[Context: {product} {version}] {query}"
+    
+    def _enhance_response(self, response: Dict[str, Any], result: Dict[str, Any]):
+        """Add tool usage information to the response."""
+        # Extract tool calls from intermediate_steps
+        tool_calls = []
+        
+        for action, observation in result.get("intermediate_steps", []):
+            if hasattr(action, 'tool') and hasattr(action, 'tool_input'):
+                tool_info = {
+                    'tool': action.tool,
+                    'inputs': action.tool_input
+                }
+                tool_calls.append(tool_info)
+        
+        # Append tool usage summary to output
+        if tool_calls:
+            tool_summary = "\n\n---\n**Tool Usage Details:**\n"
+            for i, call in enumerate(tool_calls, 1):
+                tool_summary += f"{i}. `{call['tool']}`"
+                # Format inputs based on type
+                if isinstance(call['inputs'], dict):
+                    params = ", ".join([f"{k}='{v}'" for k, v in call['inputs'].items() if v is not None])
+                    tool_summary += f"({params})\n"
+                else:
+                    tool_summary += f"({call['inputs']})\n"
+            
+            response["output"] += tool_summary

py/agents/network_config.py

@@ -0,0 +1,5 @@
+# TODO
+
+class NetworkConfigurationAgent:
+    """Placeholder for NetworkConfigurationAgent - not implemented yet"""
+    pass

py/agents/policy_dnn.py

@@ -0,0 +1,5 @@
+# TODO
+
+class PolicyDNNAgent:
+    """Placeholder for PolicyDNNAgent - not implemented yet"""
+    pass

py/agents/profile_settings.py

@@ -0,0 +1,180 @@
+"""
+Profile Settings Agent using LangChain
+"""
+
+import json
+import logging
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+
+from agents.base_agent import BaseAgent
+from langchain.tools import tool
+from pydantic import BaseModel, Field
+from tools import agent_tools
+
+logger = logging.getLogger(__name__)
+
+
+# Pydantic models for structured tools
+class PreferenceSetting(BaseModel):
+    """Model for preference updates."""
+    setting_name: str = Field(description="Name of the setting to update")
+    new_value: str = Field(description="New value for the setting")
+    
+class NotificationSetting(BaseModel):
+    """Model for notification settings."""
+    email_updates: Optional[bool] = Field(None, description="Enable email updates")
+    system_alerts: Optional[bool] = Field(None, description="Enable system alerts")
+    newsletter: Optional[bool] = Field(None, description="Subscribe to newsletter")
+
+
+class ProfileSettingsAgent(BaseAgent):
+    """Profile settings agent using LangChain tools."""
+    
+    def __init__(self, llm: Optional[Any] = None):
+        # Initialize base agent with slightly higher temperature for more natural responses
+        super().__init__(agent_id="profile_settings", llm=llm, temperature=0.3)
+        
+    def _custom_init(self, **kwargs):
+        """Custom initialization for profile settings."""
+        # Initialize dummy profile database
+        self.profile_db = self._init_profile_db()
+        
+        # Track pending changes
+        self.pending_changes = {}
+        self.awaiting_confirmation = False
+    
+    def _init_profile_db(self) -> Dict:
+        """Initialize dummy profile database."""
+        db_path = Path(__file__).parent.parent / "data" / "profiles.json"
+        
+        if db_path.exists():
+            with open(db_path, 'r') as f:
+                return json.load(f)
+        
+        # Default profile
+        return {
+            "users": {
+                "default_user": {
+                    "name": "Default User",
+                    "email": "user@example.com",
+                    "preferences": {
+                        "default_product": "harmony",
+                        "default_version": "1.8",
+                        "preferred_model": "gpt-4o",
+                        "temperature": 0.0,
+                        "max_tokens": 4000,
+                        "theme": "light",
+                        "language": "en"
+                    },
+                    "notifications": {
+                        "email_updates": True,
+                        "system_alerts": True,
+                        "newsletter": False
+                    }
+                }
+            }
+        }
+    
+    def _create_tools(self) -> List:
+        """Create tools for profile management."""
+        tools = []
+        
+        # Tool to view profile
+        @tool
+        def view_profile() -> str:
+            """View current user profile and settings."""
+            # Mock implementation - just return example data
+            return """**Your Current Profile:**
+
+**Name:** John Doe
+**Email:** john.doe@example.com
+
+**Preferences:**
+  - Default Product: harmony
+  - Default Version: 1.8
+  - Preferred Model: gpt-4o
+  - Temperature: 0.0
+  - Max Tokens: 4000
+  - Theme: light
+  - Language: en
+
+**Notification Settings:**
+  - Email Updates: Enabled
+  - System Alerts: Enabled
+  - Newsletter: Disabled"""
+        
+        tools.append(view_profile)
+        
+        # Tool to update preferences
+        @tool
+        def update_preference(setting_name: str, new_value: str) -> str:
+            """Update a user preference setting. Requires confirmation."""
+            # Mock implementation - accept any setting
+            return f"I've updated your {setting_name} to '{new_value}'. Change applied successfully! (mock)"
+        
+        tools.append(update_preference)
+        
+        # Tool to update notifications
+        @tool
+        def update_notifications(email_updates: Optional[bool] = None,
+                               system_alerts: Optional[bool] = None,
+                               newsletter: Optional[bool] = None) -> str:
+            """Update notification settings. Requires confirmation."""
+            changes = []
+            
+            if email_updates is not None:
+                changes.append(f"Email updates: {'Enabled' if email_updates else 'Disabled'}")
+                
+            if system_alerts is not None:
+                changes.append(f"System alerts: {'Enabled' if system_alerts else 'Disabled'}")
+                
+            if newsletter is not None:
+                changes.append(f"Newsletter: {'Enabled' if newsletter else 'Disabled'}")
+            
+            if not changes:
+                return "No changes specified."
+            
+            # Mock response
+            return f"Updated notification settings:\n" + "\n".join(f"  - {c}" for c in changes) + "\n\nChanges applied successfully! (mock)"
+        
+        tools.append(update_notifications)
+        
+        
+        # Add switching tools for all other agents
+        tools.extend(agent_tools.create_switching_tools_for_agent(self.agent_id))
+        
+        return tools
+    
+    def _get_system_prompt(self) -> str:
+        """Get the system prompt for profile settings agent."""
+        # Build tool descriptions and switching agents
+        tool_descriptions, switching_agents = self._build_tool_descriptions_and_agents()
+        
+        return f"""You are a basic profile settings agent. You handle user profile and preference updates.
+
+What you do:
+- View profile settings
+- Update any setting when asked (all updates are mock)
+- Transfer to other agents when needed
+
+Transfer immediately for:
+- Documentation/how-to questions → switch_to_document_reader
+- Technical questions → switch_to_document_reader
+- Network configuration → switch_to_network_config
+- Other non-settings questions → appropriate agent
+
+CRITICAL Tool Usage:
+- To use a tool, you must CALL it properly, not just write its name
+- When switching agents, ONLY use the switching tool - no additional text
+- The tool invocation format is handled by the system - just use the tool normally
+
+Keep responses simple and always include "(mock)" for changes.
+
+Available tools:
+{chr(10).join(tool_descriptions)}"""
+    
+    def _enhance_response(self, response: Dict[str, Any], result: Dict[str, Any]):
+        """Add pending changes status to response."""
+        # Add pending changes status
+        response["has_pending_changes"] = len(self.pending_changes) > 0

py/agents/subscriber_management.py

@@ -0,0 +1,5 @@
+# TODO
+
+class SubscriberManagementAgent:
+    """Placeholder for SubscriberManagementAgent - not implemented yet"""
+    pass

py/agents/system_query.py

@@ -0,0 +1,5 @@
+# TODO
+
+class SystemQueryAgent:
+    """Placeholder for SystemQueryAgent - not implemented yet"""
+    pass

py/app.py

@@ -0,0 +1,33 @@
+"""
+Main application entry point for LangChain-based Multi-Agent System
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add current directory to path
+sys.path.append(str(Path(__file__).parent))
+
+# Import and create the Gradio interface directly
+from frontend.gradio_app import PeerToPeerApp, create_gradio_interface
+
+# Launch the app
+if __name__ == "__main__":
+    # Check if we need to run migration first
+    chroma_db_path = Path(__file__).parent / "data" / "chroma_db"
+    
+    if not chroma_db_path.exists():
+        print("ChromaDB not found. Running migration script...")
+        from scripts.migrate_to_chromadb import main as migrate
+        migrate()
+        print("\nMigration complete! Starting application...\n")
+    
+    # Create and launch the interface
+    app = create_gradio_interface()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )

py/backend/__init__.py

@@ -0,0 +1 @@
+# Backend package

py/backend/api_gateway.py

@@ -0,0 +1,322 @@
+"""
+API Gateway for handling all backend requests with user confirmation
+"""
+
+import logging
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+from datetime import datetime
+import uuid
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ConfirmationRequest:
+    """Represents a pending action awaiting user confirmation"""
+    confirmation_id: str
+    user_id: str
+    action_type: str
+    action_details: Dict[str, Any]
+    created_at: datetime
+    expires_at: datetime
+    status: str  # pending, confirmed, denied, expired
+
+
+class APIGateway:
+    """
+    Central gateway for all API requests from agents to backend services.
+    Handles authentication, authorization, and user confirmation flows.
+    """
+    
+    def __init__(self):
+        # TODO: Initialize connection to backend services
+        # TODO: Set up authentication mechanism
+        # TODO: Configure rate limiting
+        self.pending_confirmations: Dict[str, ConfirmationRequest] = {}
+    
+    def authenticate(self, user_id: str, session_token: str) -> bool:
+        """
+        Authenticate user request
+        
+        Args:
+            user_id: User identifier
+            session_token: Session authentication token
+            
+        Returns:
+            bool: True if authenticated
+            
+        TODO: Implement actual authentication logic
+        TODO: Validate session tokens
+        TODO: Check user permissions
+        """
+        raise NotImplementedError("Authentication not implemented")
+    
+    def authorize(self, user_id: str, action: str, resource: str) -> bool:
+        """
+        Check if user is authorized to perform action on resource
+        
+        Args:
+            user_id: User identifier
+            action: Action to perform (create, read, update, delete)
+            resource: Resource type (network, subscriber, policy, etc.)
+            
+        Returns:
+            bool: True if authorized
+            
+        TODO: Implement RBAC (Role-Based Access Control)
+        TODO: Check tenant boundaries
+        TODO: Validate resource ownership
+        """
+        raise NotImplementedError("Authorization not implemented")
+    
+    def request_confirmation(self, user_id: str, action_type: str, 
+                           action_details: Dict[str, Any]) -> str:
+        """
+        Create a confirmation request for user action
+        
+        Args:
+            user_id: User requesting the action
+            action_type: Type of action (e.g., 'network_configure', 'subscriber_create')
+            action_details: Details of the action to be performed
+            
+        Returns:
+            str: Confirmation ID for tracking
+            
+        TODO: Store confirmation request
+        TODO: Set appropriate expiration time
+        TODO: Send notification to user
+        """
+        raise NotImplementedError("Confirmation request not implemented")
+    
+    def get_confirmation_status(self, confirmation_id: str) -> Optional[ConfirmationRequest]:
+        """
+        Get status of a confirmation request
+        
+        Args:
+            confirmation_id: ID of the confirmation request
+            
+        Returns:
+            ConfirmationRequest or None if not found
+            
+        TODO: Retrieve from storage
+        TODO: Check expiration
+        """
+        raise NotImplementedError("Get confirmation status not implemented")
+    
+    def confirm_action(self, confirmation_id: str, user_id: str, confirmed: bool) -> bool:
+        """
+        Confirm or deny a pending action
+        
+        Args:
+            confirmation_id: ID of the confirmation request
+            user_id: User confirming (must match requester)
+            confirmed: True to confirm, False to deny
+            
+        Returns:
+            bool: Success status
+            
+        TODO: Validate confirmation exists
+        TODO: Verify user matches requester
+        TODO: Update confirmation status
+        """
+        raise NotImplementedError("Confirm action not implemented")
+    
+    def execute_action(self, confirmation_id: str) -> Dict[str, Any]:
+        """
+        Execute a confirmed action
+        
+        Args:
+            confirmation_id: ID of confirmed action
+            
+        Returns:
+            dict: Result of the action execution
+            
+        TODO: Verify action is confirmed
+        TODO: Route to appropriate backend service
+        TODO: Handle errors and rollback if needed
+        """
+        raise NotImplementedError("Execute action not implemented")
+    
+    # Network Configuration APIs
+    
+    def configure_network(self, config: Dict[str, Any], user_id: str) -> str:
+        """
+        Configure network settings (NAT, VLAN, etc.)
+        
+        Args:
+            config: Network configuration details
+            user_id: User making the request
+            
+        Returns:
+            str: Confirmation ID
+            
+        TODO: Validate network configuration
+        TODO: Check for conflicts
+        TODO: Create confirmation request
+        """
+        raise NotImplementedError("Network configuration not implemented")
+    
+    def bulk_configure_networks(self, configs: List[Dict[str, Any]], user_id: str) -> str:
+        """
+        Configure multiple network settings in bulk
+        
+        Args:
+            configs: List of network configurations
+            user_id: User making the request
+            
+        Returns:
+            str: Confirmation ID for bulk operation
+            
+        TODO: Validate all configurations
+        TODO: Check resource limits
+        TODO: Create bulk confirmation request
+        """
+        raise NotImplementedError("Bulk network configuration not implemented")
+    
+    # Subscriber Management APIs
+    
+    def create_subscriber(self, imsi: str, config: Dict[str, Any], user_id: str) -> str:
+        """
+        Create a single subscriber
+        
+        Args:
+            imsi: IMSI of the subscriber
+            config: Subscriber configuration
+            user_id: User making the request
+            
+        Returns:
+            str: Confirmation ID
+            
+        TODO: Validate IMSI format
+        TODO: Check if IMSI already exists
+        TODO: Validate configuration
+        """
+        raise NotImplementedError("Create subscriber not implemented")
+    
+    def bulk_create_subscribers(self, subscribers: List[Dict[str, Any]], user_id: str) -> str:
+        """
+        Create multiple subscribers in bulk
+        
+        Args:
+            subscribers: List of subscriber configurations
+            user_id: User making the request
+            
+        Returns:
+            str: Confirmation ID for bulk operation
+            
+        TODO: Validate all IMSIs
+        TODO: Check for duplicates
+        TODO: Validate bulk limits
+        """
+        raise NotImplementedError("Bulk create subscribers not implemented")
+    
+    def import_subscribers_csv(self, csv_data: str, template_id: Optional[str], user_id: str) -> str:
+        """
+        Import subscribers from CSV data
+        
+        Args:
+            csv_data: CSV content with subscriber data
+            template_id: Optional template to apply
+            user_id: User making the request
+            
+        Returns:
+            str: Confirmation ID
+            
+        TODO: Parse CSV data
+        TODO: Validate CSV format
+        TODO: Apply template if provided
+        """
+        raise NotImplementedError("CSV import not implemented")
+    
+    # System Query APIs (Read-only, no confirmation needed)
+    
+    def query_system_status(self, query: Dict[str, Any], user_id: str) -> Dict[str, Any]:
+        """
+        Query system status and metrics (read-only)
+        
+        Args:
+            query: Query parameters
+            user_id: User making the request
+            
+        Returns:
+            dict: Query results
+            
+        TODO: Route to appropriate backend
+        TODO: Apply user filters/permissions
+        TODO: Format response
+        """
+        raise NotImplementedError("System query not implemented")
+    
+    def get_analytics(self, metric_type: str, time_range: Dict[str, Any], user_id: str) -> Dict[str, Any]:
+        """
+        Get analytics and insights (read-only)
+        
+        Args:
+            metric_type: Type of metric to retrieve
+            time_range: Time range for analytics
+            user_id: User making the request
+            
+        Returns:
+            dict: Analytics data
+            
+        TODO: Fetch metrics from backend
+        TODO: Apply aggregations
+        TODO: Generate insights
+        """
+        raise NotImplementedError("Analytics not implemented")
+    
+    # Policy & DNN APIs
+    
+    def create_dnn(self, dnn_config: Dict[str, Any], user_id: str) -> str:
+        """
+        Create a new DNN configuration
+        
+        Args:
+            dnn_config: DNN configuration details
+            user_id: User making the request
+            
+        Returns:
+            str: Confirmation ID
+            
+        TODO: Validate DNN parameters
+        TODO: Check for naming conflicts
+        TODO: Create confirmation request
+        """
+        raise NotImplementedError("Create DNN not implemented")
+    
+    def update_policy(self, policy_id: str, updates: Dict[str, Any], user_id: str) -> str:
+        """
+        Update policy configuration
+        
+        Args:
+            policy_id: ID of policy to update
+            updates: Policy updates
+            user_id: User making the request
+            
+        Returns:
+            str: Confirmation ID
+            
+        TODO: Validate policy exists
+        TODO: Validate update parameters
+        TODO: Check impact analysis
+        """
+        raise NotImplementedError("Update policy not implemented")
+    
+    def apply_policy_template(self, template_id: str, target_subscribers: List[str], user_id: str) -> str:
+        """
+        Apply policy template to multiple subscribers
+        
+        Args:
+            template_id: ID of policy template
+            target_subscribers: List of subscriber IMSIs
+            user_id: User making the request
+            
+        Returns:
+            str: Confirmation ID
+            
+        TODO: Validate template exists
+        TODO: Validate all subscribers exist
+        TODO: Create bulk update request
+        """
+        raise NotImplementedError("Apply policy template not implemented")

py/backend/chat_history_manager.py

@@ -0,0 +1,315 @@
+"""
+SQLite-based Chat History Manager for persistent conversation storage
+"""
+
+import sqlite3
+import json
+import logging
+from datetime import datetime
+from typing import List, Dict, Optional, Any
+from pathlib import Path
+import uuid
+
+logger = logging.getLogger(__name__)
+
+
+class ChatHistoryManager:
+    def __init__(self, db_path: Optional[str] = None):
+        """Initialize the chat history manager with SQLite database."""
+        if db_path is None:
+            db_path = Path(__file__).parent.parent / "data" / "chat_history.db"
+        
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Initialize database
+        self._init_database()
+        
+    def _init_database(self):
+        """Initialize the SQLite database with required tables."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # Create users table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS users (
+                    user_id TEXT PRIMARY KEY,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    last_active TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    preferences TEXT
+                )
+            """)
+            
+            # Create conversations table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS conversations (
+                    conversation_id TEXT PRIMARY KEY,
+                    user_id TEXT NOT NULL,
+                    title TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    active_agent TEXT,
+                    metadata TEXT,
+                    FOREIGN KEY (user_id) REFERENCES users(user_id)
+                )
+            """)
+            
+            # Create messages table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS messages (
+                    message_id TEXT PRIMARY KEY,
+                    conversation_id TEXT NOT NULL,
+                    role TEXT NOT NULL,
+                    content TEXT NOT NULL,
+                    agent_id TEXT,
+                    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    metadata TEXT,
+                    FOREIGN KEY (conversation_id) REFERENCES conversations(conversation_id)
+                )
+            """)
+            
+            # Create indexes for better performance
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_messages_conversation 
+                ON messages(conversation_id, timestamp)
+            """)
+            
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_conversations_user 
+                ON conversations(user_id, updated_at)
+            """)
+            
+            conn.commit()
+            
+        logger.info(f"Initialized chat history database at {self.db_path}")
+    
+    def create_user(self, user_id: Optional[str] = None, preferences: Optional[Dict] = None) -> str:
+        """Create a new user or return existing user_id."""
+        if user_id is None:
+            user_id = f"user_{uuid.uuid4().hex[:8]}"
+        
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # Check if user exists
+            cursor.execute("SELECT user_id FROM users WHERE user_id = ?", (user_id,))
+            if cursor.fetchone():
+                # Update last active
+                cursor.execute("""
+                    UPDATE users SET last_active = CURRENT_TIMESTAMP 
+                    WHERE user_id = ?
+                """, (user_id,))
+            else:
+                # Create new user
+                cursor.execute("""
+                    INSERT INTO users (user_id, preferences) 
+                    VALUES (?, ?)
+                """, (user_id, json.dumps(preferences or {})))
+            
+            conn.commit()
+        
+        return user_id
+    
+    def create_conversation(self, user_id: str, title: Optional[str] = None, 
+                          metadata: Optional[Dict] = None) -> str:
+        """Create a new conversation for a user."""
+        conversation_id = f"conv_{uuid.uuid4().hex[:12]}"
+        
+        if title is None:
+            title = f"Conversation {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+        
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO conversations 
+                (conversation_id, user_id, title, active_agent, metadata)
+                VALUES (?, ?, ?, ?, ?)
+            """, (
+                conversation_id, 
+                user_id, 
+                title,
+                "document_reader",  # Default agent
+                json.dumps(metadata or {})
+            ))
+            conn.commit()
+        
+        logger.info(f"Created conversation {conversation_id} for user {user_id}")
+        return conversation_id
+    
+    def add_message(self, conversation_id: str, role: str, content: str, 
+                   agent_id: Optional[str] = None, metadata: Optional[Dict] = None):
+        """Add a message to a conversation."""
+        message_id = f"msg_{uuid.uuid4().hex[:12]}"
+        
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # Add message
+            cursor.execute("""
+                INSERT INTO messages 
+                (message_id, conversation_id, role, content, agent_id, metadata)
+                VALUES (?, ?, ?, ?, ?, ?)
+            """, (
+                message_id,
+                conversation_id,
+                role,
+                content,
+                agent_id,
+                json.dumps(metadata or {})
+            ))
+            
+            # Update conversation timestamp
+            cursor.execute("""
+                UPDATE conversations 
+                SET updated_at = CURRENT_TIMESTAMP 
+                WHERE conversation_id = ?
+            """, (conversation_id,))
+            
+            conn.commit()
+        
+        logger.debug(f"Added {role} message to conversation {conversation_id}")
+    
+    def get_conversation_history(self, conversation_id: str, 
+                               limit: Optional[int] = None) -> List[Dict[str, Any]]:
+        """Get message history for a conversation."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            cursor = conn.cursor()
+            
+            query = """
+                SELECT message_id, role, content, agent_id, timestamp, metadata
+                FROM messages
+                WHERE conversation_id = ?
+                ORDER BY timestamp ASC
+            """
+            
+            if limit:
+                query += f" LIMIT {limit}"
+            
+            cursor.execute(query, (conversation_id,))
+            messages = []
+            
+            for row in cursor.fetchall():
+                msg = dict(row)
+                # Parse metadata JSON
+                if msg['metadata']:
+                    msg['metadata'] = json.loads(msg['metadata'])
+                messages.append(msg)
+            
+            return messages
+    
+    def get_user_conversations(self, user_id: str, limit: int = 10) -> List[Dict[str, Any]]:
+        """Get recent conversations for a user."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            cursor = conn.cursor()
+            
+            cursor.execute("""
+                SELECT c.conversation_id, c.title, c.created_at, c.updated_at, 
+                       c.active_agent, c.metadata,
+                       COUNT(m.message_id) as message_count
+                FROM conversations c
+                LEFT JOIN messages m ON c.conversation_id = m.conversation_id
+                WHERE c.user_id = ?
+                GROUP BY c.conversation_id
+                ORDER BY c.updated_at DESC
+                LIMIT ?
+            """, (user_id, limit))
+            
+            conversations = []
+            for row in cursor.fetchall():
+                conv = dict(row)
+                if conv['metadata']:
+                    conv['metadata'] = json.loads(conv['metadata'])
+                conversations.append(conv)
+            
+            return conversations
+    
+    def update_active_agent(self, conversation_id: str, agent_id: str):
+        """Update the active agent for a conversation."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                UPDATE conversations 
+                SET active_agent = ?, updated_at = CURRENT_TIMESTAMP
+                WHERE conversation_id = ?
+            """, (agent_id, conversation_id))
+            conn.commit()
+    
+    def get_formatted_history(self, conversation_id: str, 
+                            format_type: str = "langchain") -> Any:
+        """Get conversation history in different formats."""
+        messages = self.get_conversation_history(conversation_id)
+        
+        if format_type == "langchain":
+            # Format for LangChain memory
+            from langchain.schema import HumanMessage, AIMessage
+            
+            formatted = []
+            for msg in messages:
+                if msg['role'] == 'user':
+                    formatted.append(HumanMessage(content=msg['content']))
+                elif msg['role'] == 'assistant':
+                    formatted.append(AIMessage(content=msg['content']))
+            return formatted
+            
+        elif format_type == "openai":
+            # Format for OpenAI messages
+            return [
+                {"role": msg['role'], "content": msg['content']}
+                for msg in messages
+            ]
+            
+        elif format_type == "string":
+            # Format as string for context
+            lines = []
+            for msg in messages:
+                role = "User" if msg['role'] == 'user' else "Assistant"
+                if msg['agent_id']:
+                    role += f" ({msg['agent_id']})"
+                lines.append(f"{role}: {msg['content']}")
+            return "\n\n".join(lines)
+            
+        else:
+            return messages
+    
+    def delete_conversation(self, conversation_id: str):
+        """Delete a conversation and all its messages."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # Delete messages first
+            cursor.execute("DELETE FROM messages WHERE conversation_id = ?", 
+                         (conversation_id,))
+            
+            # Delete conversation
+            cursor.execute("DELETE FROM conversations WHERE conversation_id = ?", 
+                         (conversation_id,))
+            
+            conn.commit()
+        
+        logger.info(f"Deleted conversation {conversation_id}")
+    
+    def export_conversation(self, conversation_id: str) -> Dict[str, Any]:
+        """Export a conversation with all its data."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            cursor = conn.cursor()
+            
+            # Get conversation details
+            cursor.execute("""
+                SELECT * FROM conversations WHERE conversation_id = ?
+            """, (conversation_id,))
+            
+            conv_row = cursor.fetchone()
+            if not conv_row:
+                raise ValueError(f"Conversation {conversation_id} not found")
+            
+            conversation = dict(conv_row)
+            if conversation['metadata']:
+                conversation['metadata'] = json.loads(conversation['metadata'])
+            
+            # Get messages
+            conversation['messages'] = self.get_conversation_history(conversation_id)
+            
+            return conversation

py/backend/chromadb_manager.py

@@ -0,0 +1,118 @@
+"""
+ChromaDB Manager - HuggingFace version using SimpleVectorDB
+This version uses in-memory vector search instead of ChromaDB for simplicity
+"""
+
+import logging
+from typing import Dict, List, Optional, Tuple
+from pathlib import Path
+from langchain.schema import Document
+
+# Import config loader
+import sys
+sys.path.append(str(Path(__file__).parent.parent))
+from config_loader import get_config
+
+# Import our simple vector DB instead of ChromaDB
+from .simple_vector_db import get_simple_vector_db
+
+logger = logging.getLogger(__name__)
+
+
+class ChromaDBManager:
+    """
+    ChromaDB Manager interface that uses SimpleVectorDB underneath.
+    Maintains the same interface for compatibility with existing code.
+    """
+    
+    def __init__(self, persist_directory: Optional[Path] = None):
+        """Initialize the manager with SimpleVectorDB."""
+        # Load config
+        self.config = get_config()
+        
+        # Use SimpleVectorDB instead of ChromaDB
+        self.db = get_simple_vector_db(self.config)
+        
+        # For compatibility - these aren't used in simple version
+        self.persist_directory = str(persist_directory) if persist_directory else None
+        self.vectorstore = None
+        self.client = None
+        self.embeddings = self.db.embeddings_model
+        
+        # Cache for available versions
+        self._available_versions = None
+        
+        logger.info("Initialized ChromaDBManager with SimpleVectorDB backend")
+    
+    def query_with_filter(self, query: str, product: str, version: str, k: int = 5) -> List[Document]:
+        """Query with product and version filter."""
+        return self.db.query_with_filter(query, product, version, k)
+    
+    def query_product_all_versions(self, query: str, product: str, k: int = 5) -> List[Document]:
+        """Query across all versions of a product."""
+        return self.db.query_product_all_versions(query, product, k)
+    
+    def query_version_and_general(self, product: str, version: str, query: str, 
+                                 max_results: int = 5) -> Tuple[List[Dict], List[Dict]]:
+        """Query both version-specific and general docs (compatible with old interface)."""
+        # Query version-specific
+        version_docs = self.query_with_filter(query, product, version, max_results)
+        version_results = self._docs_to_results(version_docs)
+        
+        # Query general/FAQ
+        general_docs = self.query_with_filter(query, "general", "all", max_results)
+        general_results = self._docs_to_results(general_docs)
+        
+        return version_results, general_results
+    
+    def _docs_to_results(self, docs: List[Document]) -> List[Dict]:
+        """Convert LangChain documents to old result format for compatibility."""
+        results = []
+        
+        for doc in docs:
+            # Extract similarity score if available
+            similarity = 0.8  # Default if not available
+            if hasattr(doc, 'metadata') and '_score' in doc.metadata:
+                similarity = doc.metadata['_score']
+            
+            result = {
+                'text': doc.page_content,
+                'quote': doc.page_content,  # For compatibility
+                'chunk_id': doc.metadata.get('chunk_id', 'unknown'),
+                'file_id': doc.metadata.get('source', 'unknown'),
+                'similarity': similarity,
+                'metadata': doc.metadata
+            }
+            results.append(result)
+        
+        return results
+    
+    def search_across_stores(self, query: str, store_names: Optional[List[str]] = None, 
+                           max_results_per_store: int = 3) -> Dict[str, List[Dict]]:
+        """Search across multiple stores (compatible with old interface)."""
+        results = {}
+        
+        if store_names is None:
+            # Get all unique product-version combinations
+            store_names = []
+            for product, versions in self.list_available_versions().items():
+                for version in versions:
+                    store_name = f"{product}_{version.replace('.', '_')}"
+                    store_names.append(store_name)
+        
+        for store_name in store_names:
+            # Parse product and version from store name
+            if "_" in store_name:
+                parts = store_name.split("_", 1)
+                product = parts[0]
+                version = parts[1].replace("_", ".")
+                
+                docs = self.query_with_filter(query, product, version, max_results_per_store)
+                if docs:
+                    results[store_name] = self._docs_to_results(docs)
+        
+        return results
+    
+    def list_available_versions(self) -> Dict[str, List[str]]:
+        """List all available product versions."""
+        return self.db.list_available_versions()

py/backend/simple_vector_db.py

@@ -0,0 +1,251 @@
+"""
+Simple in-memory vector database for HuggingFace deployment
+Replaces ChromaDB with O(N) similarity search
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import List, Dict, Optional, Tuple
+import numpy as np
+from langchain.schema import Document
+from langchain_openai import OpenAIEmbeddings
+
+logger = logging.getLogger(__name__)
+
+
+class SimpleVectorDB:
+    """Simple in-memory vector database using numpy for similarity search."""
+    
+    def __init__(self, config=None):
+        """Initialize the vector database."""
+        self.config = config or {}
+        self.embeddings_model = OpenAIEmbeddings(
+            model=self.config.get("rag.embedding_model", "text-embedding-3-small")
+        )
+        
+        # Storage for documents and vectors
+        self.documents: List[Dict] = []
+        self.vectors: Optional[np.ndarray] = None
+        self._available_versions = None
+        
+        # Load embeddings on initialization
+        self._load_embeddings()
+        
+    def _load_embeddings(self):
+        """Load all embedding files into memory."""
+        embeddings_dir = Path(__file__).parent.parent / "data" / "embeddings"
+        
+        if not embeddings_dir.exists():
+            logger.warning(f"Embeddings directory not found: {embeddings_dir}")
+            return
+            
+        all_documents = []
+        all_vectors = []
+        
+        # Load each JSON file
+        for json_file in sorted(embeddings_dir.glob("*.json")):
+            logger.info(f"Loading embeddings from {json_file.name}")
+            
+            try:
+                with open(json_file, 'r') as f:
+                    data = json.load(f)
+                
+                # Extract metadata from filename
+                store_name = json_file.stem
+                if store_name == "general_faq":
+                    product = "general"
+                    version = "all"
+                else:
+                    parts = store_name.split("_", 1)
+                    if len(parts) == 2:
+                        product = parts[0]
+                        version = parts[1].replace("_", ".")
+                    else:
+                        product = "unknown"
+                        version = "unknown"
+                
+                # Process chunks
+                for i, chunk in enumerate(data.get("chunks", [])):
+                    doc = {
+                        "content": chunk.get("text", ""),
+                        "metadata": {
+                            "product": product,
+                            "version": version,
+                            "store_name": store_name,
+                            "chunk_index": i,
+                            "chunk_id": f"{store_name}_chunk_{i}"
+                        }
+                    }
+                    
+                    # Add optional metadata if available
+                    if "metadata" in chunk:
+                        chunk_meta = chunk["metadata"]
+                        doc["metadata"].update({
+                            "source": chunk_meta.get("source", ""),
+                            "page": chunk_meta.get("page", -1),
+                            "document": chunk_meta.get("document", ""),
+                            "token_count": chunk_meta.get("token_count", 0)
+                        })
+                    
+                    all_documents.append(doc)
+                    all_vectors.append(chunk.get("embedding", []))
+                    
+            except Exception as e:
+                logger.error(f"Error loading {json_file.name}: {e}")
+                continue
+        
+        # Convert to numpy array for efficient computation
+        if all_vectors:
+            self.documents = all_documents
+            self.vectors = np.array(all_vectors, dtype=np.float32)
+            logger.info(f"Loaded {len(self.documents)} documents with embeddings")
+        else:
+            logger.warning("No embeddings loaded")
+    
+    def _cosine_similarity(self, query_vector: np.ndarray, vectors: np.ndarray) -> np.ndarray:
+        """Compute cosine similarity between query vector and all vectors."""
+        # Normalize query vector
+        query_norm = query_vector / (np.linalg.norm(query_vector) + 1e-10)
+        
+        # Normalize all vectors
+        norms = np.linalg.norm(vectors, axis=1, keepdims=True) + 1e-10
+        vectors_norm = vectors / norms
+        
+        # Compute dot product (cosine similarity)
+        similarities = np.dot(vectors_norm, query_norm)
+        
+        return similarities
+    
+    def _filter_documents(self, indices: List[int], filter_dict: Optional[Dict] = None) -> List[int]:
+        """Filter document indices based on metadata criteria."""
+        if not filter_dict:
+            return indices
+            
+        filtered = []
+        
+        for idx in indices:
+            doc = self.documents[idx]
+            metadata = doc["metadata"]
+            
+            # Handle $and operator
+            if "$and" in filter_dict:
+                all_match = True
+                for condition in filter_dict["$and"]:
+                    for key, value in condition.items():
+                        if metadata.get(key) != value:
+                            all_match = False
+                            break
+                    if not all_match:
+                        break
+                if all_match:
+                    filtered.append(idx)
+                    
+            # Handle simple key-value filters
+            else:
+                match = True
+                for key, value in filter_dict.items():
+                    if isinstance(value, dict) and "$eq" in value:
+                        if metadata.get(key) != value["$eq"]:
+                            match = False
+                            break
+                    elif metadata.get(key) != value:
+                        match = False
+                        break
+                if match:
+                    filtered.append(idx)
+        
+        return filtered
+    
+    def query_with_filter(self, query: str, product: str, version: str, k: int = 5) -> List[Document]:
+        """Query with product and version filter."""
+        logger.info(f"Querying {product} {version} for: {query}")
+        
+        filter_dict = {"$and": [{"product": product}, {"version": version}]}
+        return self._query(query, k, filter_dict)
+    
+    def query_product_all_versions(self, query: str, product: str, k: int = 5) -> List[Document]:
+        """Query across all versions of a product."""
+        logger.info(f"Querying all {product} versions for: {query}")
+        
+        filter_dict = {"product": {"$eq": product}}
+        return self._query(query, k, filter_dict)
+    
+    def query_all_products(self, query: str, k: int = 5) -> List[Document]:
+        """Query across all products and versions."""
+        logger.info(f"Querying all products for: {query}")
+        return self._query(query, k, None)
+    
+    def _query(self, query: str, k: int = 5, filter_dict: Optional[Dict] = None) -> List[Document]:
+        """Internal query method."""
+        if self.vectors is None or len(self.documents) == 0:
+            logger.warning("No documents loaded")
+            return []
+        
+        # Get query embedding
+        try:
+            query_embedding = self.embeddings_model.embed_query(query)
+            query_vector = np.array(query_embedding, dtype=np.float32)
+        except Exception as e:
+            logger.error(f"Error getting query embedding: {e}")
+            return []
+        
+        # Compute similarities
+        similarities = self._cosine_similarity(query_vector, self.vectors)
+        
+        # Get top k indices
+        top_indices = np.argsort(similarities)[::-1]  # Sort descending
+        
+        # Apply filters
+        if filter_dict:
+            top_indices = self._filter_documents(top_indices.tolist(), filter_dict)
+        
+        # Take top k after filtering
+        top_indices = top_indices[:k]
+        
+        # Convert to LangChain Document objects
+        results = []
+        for idx in top_indices:
+            doc_data = self.documents[idx]
+            doc = Document(
+                page_content=doc_data["content"],
+                metadata=doc_data["metadata"]
+            )
+            results.append(doc)
+        
+        logger.info(f"Found {len(results)} documents")
+        return results
+    
+    def list_available_versions(self) -> Dict[str, List[str]]:
+        """List all available product versions."""
+        if self._available_versions is not None:
+            return self._available_versions
+        
+        versions_map = {}
+        
+        for doc in self.documents:
+            product = doc["metadata"].get("product", "unknown")
+            version = doc["metadata"].get("version", "unknown")
+            
+            if product not in versions_map:
+                versions_map[product] = set()
+            versions_map[product].add(version)
+        
+        # Convert sets to sorted lists
+        self._available_versions = {
+            product: sorted(list(versions))
+            for product, versions in versions_map.items()
+        }
+        
+        return self._available_versions
+
+
+# Create a singleton instance
+_db_instance = None
+
+def get_simple_vector_db(config=None) -> SimpleVectorDB:
+    """Get or create the singleton vector database instance."""
+    global _db_instance
+    if _db_instance is None:
+        _db_instance = SimpleVectorDB(config)
+    return _db_instance

py/config.yaml

@@ -0,0 +1,259 @@
+# AI Assistant Configuration File
+# This file contains all hyperparameters and settings for the multi-agent system
+
+# Model Configuration
+models:
+  available:
+    - model_id: "gpt-4o-mini"
+      display_name: "GPT-4o Mini"
+      max_tokens: 128000
+      input_cost_per_1m: 0.15  # $0.15 per 1M tokens
+      output_cost_per_1m: 0.60  # $0.60 per 1M tokens
+      description: "Most cost-efficient model for high-volume tasks"
+      default: true
+    - model_id: "gpt-4"
+      display_name: "GPT-4"
+      max_tokens: 8192
+      input_cost_per_1m: 30.00  # $30.00 per 1M tokens
+      output_cost_per_1m: 60.00  # $60.00 per 1M tokens
+      description: "Original GPT-4 with 8k context"
+    - model_id: "gpt-4o"
+      display_name: "GPT-4o"
+      max_tokens: 128000
+      input_cost_per_1m: 2.50  # $2.50 per 1M tokens (latest pricing)
+      output_cost_per_1m: 10.00  # $10.00 per 1M tokens
+      description: "Most capable model with vision capabilities"
+    - model_id: "gpt-4o-nano"
+      display_name: "GPT-4o Nano"
+      max_tokens: 8192
+      input_cost_per_1m: 0.10
+      output_cost_per_1m: 0.40
+      description: "Fastest model (when available)"
+    - model_id: "gpt-3.5-turbo"
+      display_name: "GPT-3.5 Turbo"
+      max_tokens: 16384
+      input_cost_per_1m: 0.50  # $0.50 per 1M tokens
+      output_cost_per_1m: 1.50  # $1.50 per 1M tokens
+      description: "Fast and efficient for simple tasks"
+  
+  # Default model parameters
+  default_temperature: 0.0
+  default_max_tokens: 4000
+
+# Product Configuration
+products:
+  available:
+    - id: "harmony"
+      display_name: "Harmony"
+      versions: ["1.8", "1.6", "1.5", "1.2"]
+      default_version: "1.8"
+    - id: "chorus"
+      display_name: "Chorus"
+      versions: ["1.1"]
+      default_version: "1.1"
+  
+  default_product: "harmony"
+
+# RAG (Retrieval-Augmented Generation) Settings
+rag:
+  # Number of documents to retrieve for context
+  default_k: 6
+  
+  # ChromaDB settings
+  collection_name: "documentation"
+  embedding_model: "text-embedding-3-small"
+  
+  # Unused RAG parameters (kept for reference)
+  # max_k: 15
+  # similarity_threshold: 0.7
+  # include_metadata: true
+
+# Agent Configuration
+agents:
+  # Document Reader Agent
+  document_reader:
+    enabled: true
+    display_name: "Document Reader"
+    description: "Handles documentation queries with RAG"
+    # Tools list not currently used - tools are defined in agent code
+    # tools:
+    #   - search_version_documentation
+    #   - search_all_versions
+    #   - list_available_versions
+    #   - switch_to_profile_settings
+    max_iterations: 3
+    verbose: true
+  
+  # Profile Settings Agent
+  profile_settings:
+    enabled: true
+    display_name: "Profile Settings"
+    description: "Manages user preferences and settings"
+    # Tools list not currently used - tools are defined in agent code
+    # tools:
+    #   - view_profile
+    #   - update_preference
+    #   - update_notifications
+    #   - confirm_changes
+    #   - show_settings_menu
+    #   - switch_to_document_reader
+    max_iterations: 3
+    verbose: true
+  
+  # Network Configuration Agent
+  network_config:
+    enabled: false
+    display_name: "Network Configuration"
+    description: "Manages network configurations (NAT, VLAN, IP)"
+    # Tools list not currently used - tools are defined in agent code
+    # tools:
+    #   - configure_nat
+    #   - configure_vlan
+    #   - bulk_create_vlans
+    #   - configure_ip_address
+    #   - configure_dhcp
+    #   - apply_network_template
+    #   - preview_network_config
+    #   - list_network_interfaces
+    max_iterations: 3
+    verbose: true
+  
+  # Subscriber Management Agent
+  subscriber_management:
+    enabled: false
+    display_name: "Subscriber Management"
+    description: "Manages subscriber operations and CSV imports"
+    # Tools list not currently used - tools are defined in agent code
+    # tools:
+    #   - create_subscriber
+    #   - create_subscriber_range
+    #   - import_subscribers_csv
+    #   - clone_subscriber
+    #   - update_subscriber
+    #   - bulk_update_subscribers
+    #   - toggle_subscribers
+    #   - generate_csv_template
+    #   - preview_import
+    max_iterations: 3
+    verbose: true
+  
+  # System Query Agent
+  system_query:
+    enabled: false
+    display_name: "System Query"
+    description: "Provides read-only analytics and insights"
+    # Tools list not currently used - tools are defined in agent code
+    # tools:
+    #   - query_radio_status
+    #   - query_subscriber_sessions
+    #   - query_network_performance
+    #   - query_system_logs
+    #   - generate_analytics_report
+    #   - query_slice_performance
+    #   - query_resource_utilization
+    #   - query_service_health
+    #   - query_top_talkers
+    max_iterations: 3
+    verbose: true
+  
+  # Policy & DNN Agent
+  policy_dnn:
+    enabled: false
+    display_name: "Policy & DNN"
+    description: "Manages policies, DNNs, and QoS profiles"
+    # Tools list not currently used - tools are defined in agent code
+    # tools:
+    #   - create_dnn
+    #   - update_dnn
+    #   - assign_dnn_to_subscribers
+    #   - create_qos_profile
+    #   - create_policy_rule
+    #   - apply_policy_template
+    #   - bulk_update_qos
+    #   - list_dnns
+    #   - create_service_profile
+    max_iterations: 3
+    verbose: true
+  
+  # Default active agent
+  default_agent: "document_reader"
+
+# Tool Configuration (NOT CURRENTLY USED - Kept for reference)
+# tools:
+#   # Maximum number of tool calls per query
+#   max_tool_calls: 5
+#   
+#   # Tool timeout in seconds
+#   tool_timeout: 30
+#   
+#   # Enable/disable specific tools globally
+#   enabled_tools:
+#     # Document Reader tools
+#     - search_version_documentation
+#     - search_all_versions
+#     - list_available_versions
+#     # Profile Settings tools
+#     - view_profile
+#     - update_preference
+#     - update_notifications
+#     - confirm_changes
+#     - show_settings_menu
+#     # Network Configuration tools
+#     - configure_nat
+#     - configure_vlan
+#     - bulk_create_vlans
+#     - configure_ip_address
+#     - configure_dhcp
+#     - apply_network_template
+#     - preview_network_config
+#     - list_network_interfaces
+#     # Subscriber Management tools
+#     - create_subscriber
+#     - create_subscriber_range
+#     - import_subscribers_csv
+#     - clone_subscriber
+#     - update_subscriber
+#     - bulk_update_subscribers
+#     - toggle_subscribers
+#     - generate_csv_template
+#     - preview_import
+#     # System Query tools
+#     - query_radio_status
+#     - query_subscriber_sessions
+#     - query_network_performance
+#     - query_system_logs
+#     - generate_analytics_report
+#     - query_slice_performance
+#     - query_resource_utilization
+#     - query_service_health
+#     - query_top_talkers
+#     # Policy & DNN tools
+#     - create_dnn
+#     - update_dnn
+#     - assign_dnn_to_subscribers
+#     - create_qos_profile
+#     - create_policy_rule
+#     - apply_policy_template
+#     - bulk_update_qos
+#     - list_dnns
+#     - create_service_profile
+#     # Agent switching tools
+#     - switch_to_profile_settings
+#     - switch_to_document_reader
+#     - switch_to_network_config
+#     - switch_to_subscriber_management
+#     - switch_to_system_query
+#     - switch_to_policy_dnn
+
+# Conversation Settings
+conversation:
+  # SQLite settings
+  database_path: "data/chat_history.db"
+
+
+# Logging Configuration
+logging:
+  level: "INFO"  # DEBUG, INFO, WARNING, ERROR
+  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+  file: "logs/assistant.log"
+  console: true

py/config_loader.py

@@ -0,0 +1,217 @@
+"""
+Configuration loader for the AI Assistant
+"""
+
+import yaml
+import os
+import logging
+from typing import Dict, Any, Optional, List
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigLoader:
+    """Loads and manages configuration from YAML file"""
+    
+    def __init__(self, config_path: Optional[str] = None):
+        """Initialize config loader with optional custom path"""
+        if config_path is None:
+            config_path = Path(__file__).parent / "config.yaml"
+        
+        self.config_path = Path(config_path)
+        self.config = self._load_config()
+        
+        # Apply environment variable overrides
+        self._apply_env_overrides()
+    
+    def _load_config(self) -> Dict[str, Any]:
+        """Load configuration from YAML file"""
+        try:
+            with open(self.config_path, 'r') as f:
+                config = yaml.safe_load(f)
+            logger.info(f"Loaded configuration from {self.config_path}")
+            return config
+        except FileNotFoundError:
+            logger.warning(f"Config file not found at {self.config_path}, using defaults")
+            return self._get_default_config()
+        except Exception as e:
+            logger.error(f"Error loading config: {e}, using defaults")
+            return self._get_default_config()
+    
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Return default configuration if file not found"""
+        return {
+            "models": {
+                "available": [
+                    {"model_id": "gpt-4o-mini", "display_name": "GPT-4 Omni Mini", "max_tokens": 16384, "default": True},
+                    {"model_id": "gpt-4o", "display_name": "GPT-4 Omni", "max_tokens": 128000},
+                    {"model_id": "gpt-4", "display_name": "GPT-4", "max_tokens": 8192},
+                    {"model_id": "gpt-3.5-turbo", "display_name": "GPT-3.5 Turbo", "max_tokens": 16384}
+                ],
+                "default_temperature": 0.0,
+                "default_max_tokens": 4000
+            },
+            "products": {
+                "available": [
+                    {"id": "harmony", "display_name": "Harmony", "versions": ["1.8", "1.6", "1.5", "1.2"], "default_version": "1.8"},
+                    {"id": "chorus", "display_name": "Chorus", "versions": ["1.1"], "default_version": "1.1"}
+                ],
+                "default_product": "harmony"
+            },
+            "rag": {
+                "default_k": 5,
+                "max_k": 10
+            },
+            "tools": {
+                "max_tool_calls": 5,
+                "tool_timeout": 30
+            },
+            "agents": {
+                "default_agent": "document_reader"
+            }
+        }
+    
+    def _apply_env_overrides(self):
+        """Apply environment variable overrides to config"""
+        # Example: ASSISTANT_RAG_DEFAULT_K=10 overrides rag.default_k
+        prefix = "ASSISTANT_"
+        
+        for key, value in os.environ.items():
+            if key.startswith(prefix):
+                # Convert ASSISTANT_RAG_DEFAULT_K to rag.default_k
+                config_path = key[len(prefix):].lower().replace('_', '.')
+                self._set_nested_value(config_path, value)
+    
+    def _set_nested_value(self, path: str, value: str):
+        """Set a nested configuration value using dot notation"""
+        keys = path.split('.')
+        current = self.config
+        
+        for key in keys[:-1]:
+            if key not in current:
+                current[key] = {}
+            current = current[key]
+        
+        # Try to convert value to appropriate type
+        try:
+            if value.lower() in ['true', 'false']:
+                value = value.lower() == 'true'
+            elif value.isdigit():
+                value = int(value)
+            elif '.' in value and value.replace('.', '').isdigit():
+                value = float(value)
+        except:
+            pass  # Keep as string
+        
+        current[keys[-1]] = value
+        logger.debug(f"Override config {path} = {value}")
+    
+    def get(self, path: str, default: Any = None) -> Any:
+        """Get configuration value using dot notation"""
+        keys = path.split('.')
+        current = self.config
+        
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            else:
+                return default
+        
+        return current
+    
+    def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get list of available models"""
+        return self.get("models.available", [])
+    
+    def get_model_ids(self) -> List[str]:
+        """Get list of model IDs"""
+        return [m["model_id"] for m in self.get_available_models()]
+    
+    def get_default_model(self) -> str:
+        """Get default model ID"""
+        models = self.get_available_models()
+        for model in models:
+            if model.get("default", False):
+                return model["model_id"]
+        return models[0]["model_id"] if models else "gpt-4o-mini"
+    
+    def get_available_products(self) -> List[Dict[str, Any]]:
+        """Get list of available products"""
+        return self.get("products.available", [])
+    
+    def get_product_ids(self) -> List[str]:
+        """Get list of product IDs"""
+        return [p["id"] for p in self.get_available_products()]
+    
+    def get_product_versions(self, product_id: str) -> List[str]:
+        """Get versions for a specific product"""
+        products = self.get_available_products()
+        for product in products:
+            if product["id"] == product_id:
+                return product.get("versions", [])
+        return []
+    
+    def get_default_product(self) -> str:
+        """Get default product ID"""
+        return self.get("products.default_product", "harmony")
+    
+    def get_default_version(self, product_id: str) -> str:
+        """Get default version for a product"""
+        products = self.get_available_products()
+        for product in products:
+            if product["id"] == product_id:
+                return product.get("default_version", product["versions"][0])
+        return "1.0"
+    
+    def get_rag_k(self) -> int:
+        """Get default number of RAG results"""
+        return self.get("rag.default_k", 5)
+    
+    def get_max_tool_calls(self) -> int:
+        """Get maximum number of tool calls"""
+        return self.get("tools.max_tool_calls", 5)
+    
+    def get_agent_config(self, agent_id: str) -> Dict[str, Any]:
+        """Get configuration for a specific agent"""
+        return self.get(f"agents.{agent_id}", {})
+    
+    def is_agent_enabled(self, agent_id: str) -> bool:
+        """Check if an agent is enabled"""
+        return self.get(f"agents.{agent_id}.enabled", True)
+    
+    def get_ui_config(self) -> Dict[str, Any]:
+        """Get UI configuration"""
+        return self.get("ui", {})
+    
+    def get_logging_config(self) -> Dict[str, Any]:
+        """Get logging configuration"""
+        return self.get("logging", {})
+    
+    def reload(self):
+        """Reload configuration from file"""
+        self.config = self._load_config()
+        self._apply_env_overrides()
+        logger.info("Configuration reloaded")
+    
+    def save(self, config_path: Optional[str] = None):
+        """Save current configuration to file"""
+        save_path = config_path or self.config_path
+        try:
+            with open(save_path, 'w') as f:
+                yaml.dump(self.config, f, default_flow_style=False, sort_keys=False)
+            logger.info(f"Configuration saved to {save_path}")
+        except Exception as e:
+            logger.error(f"Error saving configuration: {e}")
+            raise
+
+
+# Global config instance
+_config = None
+
+def get_config() -> ConfigLoader:
+    """Get global configuration instance"""
+    global _config
+    if _config is None:
+        _config = ConfigLoader()
+    return _config

py/frontend/__init__.py

@@ -0,0 +1 @@
+# Frontend package

py/frontend/gradio_app.py

@@ -0,0 +1,723 @@
+"""
+Peer-to-Peer Agent Frontend for Multi-Agent System
+"""
+
+import gradio as gr
+import logging
+import traceback
+from typing import Dict, List, Tuple, Optional, Any
+from pathlib import Path
+import uuid
+from datetime import datetime
+
+# Add parent directory to path for imports
+import sys
+sys.path.append(str(Path(__file__).parent.parent))
+
+from backend.chat_history_manager import ChatHistoryManager
+from backend.api_gateway import APIGateway
+from config_loader import get_config
+from tools import agent_tools
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class PeerToPeerApp:
+    def __init__(self):
+        """Initialize the peer-to-peer application."""
+        # Load configuration
+        self.config = get_config()
+        
+        # Initialize API Gateway
+        self.api_gateway = APIGateway()
+        
+        # Initialize chat history manager
+        db_path = self.config.get("conversation.database_path")
+        self.history_manager = ChatHistoryManager(db_path)
+        
+        # Track pending confirmations
+        self.pending_confirmations = {}
+        
+        # Available versions (hardcoded for now since ChromaDB is in Document Reader)
+        self.available_versions = {
+            "harmony": ["1.8", "1.6", "1.5", "1.2"],
+            "chorus": ["1.1"]
+        }
+        logger.info(f"Available versions: {self.available_versions}")
+        
+        # Initialize agents using agent_tools singleton registry
+        self.current_agent = self.config.get("agents.default_agent", "document_reader")
+        
+        # Store user selections from config
+        self.current_model = self.config.get_default_model()
+        self.current_product = self.config.get_default_product()
+        self.current_version = self.config.get_default_version(self.current_product)
+        
+        # User and conversation management
+        self.current_user_id = None
+        self.current_conversation_id = None
+        
+        # Initialize default agent
+        self._initialize_agents()
+        
+        # Conversation history (for current session)
+        self.conversation_history = []
+    
+    def _initialize_agents(self):
+        """Initialize agents with current model using agent_tools singleton registry."""
+        from langchain_openai import ChatOpenAI
+        
+        # Create LLM with selected model from config
+        llm = ChatOpenAI(
+            model=self.current_model,
+            temperature=self.config.get("models.default_temperature", 0.0),
+            max_tokens=self.config.get("models.default_max_tokens", 4000)
+        )
+        
+        # Initialize all agents in the singleton registry
+        agent_tools.initialize_agents(llm, self.api_gateway)
+        logger.info("Agent singleton registry initialized")
+    
+    def get_agent_status(self) -> str:
+        """Get current agent status for display."""
+        agent_names = {
+            "document_reader": "Document Reader",
+            "profile_settings": "Profile Settings",
+            "network_config": "Network Configuration",
+            "subscriber_management": "Subscriber Management",
+            "system_query": "System Query",
+            "policy_dnn": "Policy & DNN"
+        }
+        return f"**Active Agent:** {agent_names.get(self.current_agent, self.current_agent)}"
+    
+    def get_product_versions(self, product: str) -> List[str]:
+        """Get available versions for a product."""
+        versions = self.available_versions.get(product.lower(), [])
+        return sorted(list(versions), reverse=True)
+    
+    def initialize_user(self, user_id: Optional[str] = None) -> str:
+        """Initialize or create a user."""
+        self.current_user_id = self.history_manager.create_user(user_id)
+        logger.info(f"Initialized user: {self.current_user_id}")
+        return self.current_user_id
+    
+    def start_new_conversation(self, title: Optional[str] = None) -> str:
+        """Start a new conversation for the current user."""
+        if not self.current_user_id:
+            self.initialize_user()
+        
+        # Create new conversation
+        self.current_conversation_id = self.history_manager.create_conversation(
+            self.current_user_id, 
+            title,
+            metadata={
+                "model": self.current_model,
+                "product": self.current_product,
+                "version": self.current_version
+            }
+        )
+        
+        # Clear agent memories and reload history
+        self._reload_conversation_history()
+        
+        logger.info(f"Started new conversation: {self.current_conversation_id}")
+        return self.current_conversation_id
+    
+    def _reload_conversation_history(self):
+        """Reload conversation history into agent memories."""
+        if self.current_conversation_id:
+            # Get history from database
+            history = self.history_manager.get_formatted_history(
+                self.current_conversation_id, format_type="langchain"
+            )
+            
+            # Load into all agents from the singleton registry
+            for agent_id in agent_tools.AGENT_INFO.keys():
+                agent = agent_tools.get_agent(agent_id)
+                if agent and hasattr(agent, "memory") and agent.memory:
+                    agent.memory.chat_memory.messages = history.copy()
+    
+    def update_settings(self, model: str, product: str, version: str) -> str:
+        """Update current settings."""
+        # Update settings
+        self.current_model = model
+        self.current_product = product
+        self.current_version = version
+        
+        # Reinitialize agents with new model but preserve history
+        self._initialize_agents()
+        
+        # Reload conversation history if we have one
+        if self.current_conversation_id:
+            self._reload_conversation_history()
+        
+        return f"✅ Settings updated: {model}, {product} {version}"
+    
+    def process_message(self, message: str, history: List[Dict[str, str]], 
+                       model: str, product: str, version: str) -> Tuple[List[Dict[str, str]], str, str]:
+        """Process user message through the current agent."""
+        if not message.strip():
+            return history, "", self.get_agent_status()
+        
+        # Initialize user and conversation if needed
+        if not self.current_user_id:
+            self.initialize_user()
+        
+        if not self.current_conversation_id:
+            self.start_new_conversation()
+        
+        # Update settings if changed
+        if (model != self.current_model or 
+            product != self.current_product or 
+            version != self.current_version):
+            self.update_settings(model, product, version)
+        
+        # Add user message to history
+        history.append({"role": "user", "content": message})
+        
+        # Save user message to database
+        self.history_manager.add_message(
+            self.current_conversation_id,
+            "user",
+            message,
+            metadata={
+                "product": self.current_product,
+                "version": self.current_version
+            }
+        )
+        
+        try:
+            # Check for manual agent switch
+            if message.strip().lower().startswith("/agent"):
+                parts = message.strip().split()
+                if len(parts) > 1:
+                    agent_name = parts[1].lower()
+                    if agent_tools.get_agent(agent_name):
+                        self.current_agent = agent_name
+                        response = f"Switched to {agent_name.replace('_', ' ').title()} agent"
+                        history.append({"role": "assistant", "content": response})
+                        
+                        # Save switch message and update active agent
+                        self.history_manager.add_message(
+                            self.current_conversation_id,
+                            "assistant",
+                            response,
+                            agent_id=self.current_agent
+                        )
+                        self.history_manager.update_active_agent(
+                            self.current_conversation_id, 
+                            self.current_agent
+                        )
+                        
+                        # Transfer conversation history to new agent
+                        self._reload_conversation_history()
+                        
+                        return history, "", self.get_agent_status()
+            
+            # Create context for agents to use
+            agent_context = {
+                "product": self.current_product,
+                "version": self.current_version,
+                "model": self.current_model
+            }
+            
+            # Run the current agent with the message and context
+            logger.info(f"Running {self.current_agent} agent with message: {message[:100]}...")
+            result_dict = agent_tools.run_agent(self.current_agent, message, agent_context)
+            
+            # Extract output and check if agent changed
+            result = result_dict.get("output", "No response generated")
+            new_agent_id = result_dict.get("agent_id", self.current_agent)
+            
+            # If agent changed, update current agent
+            if new_agent_id != self.current_agent:
+                logger.info(f"Agent switch detected: {self.current_agent} -> {new_agent_id}")
+                previous_agent = self.current_agent
+                self.current_agent = new_agent_id
+                
+                # Update in database
+                if self.current_conversation_id:
+                    self.history_manager.update_active_agent(
+                        self.current_conversation_id, 
+                        self.current_agent
+                    )
+                
+                # Transfer conversation history to new agent
+                self._reload_conversation_history()
+                
+                # The new agent should automatically respond in the next interaction
+                
+                # TODO: Check if agent attempted any write operations
+                # If so, create confirmation request through API Gateway
+                # Example:
+                # if self.current_agent in ["network_config", "subscriber_management", "policy_dnn"]:
+                #     if "tool_calls" in result_dict and result_dict["tool_calls"]:
+                #         confirmation_id = str(uuid.uuid4())
+                #         self.pending_confirmations[confirmation_id] = {
+                #             "action_type": "configuration_change",
+                #             "description": result,
+                #             "agent": self.current_agent,
+                #             "timestamp": datetime.now()
+                #         }
+                #         # Show confirmation dialog
+                #         # Return special response to trigger confirmation UI
+            
+            # Add agent prefix to the response
+            agent_prefixes = {
+                "document_reader": "[Document Reader]:",
+                "profile_settings": "[Profile Settings]:",
+                "network_config": "[Network Config]:",
+                "subscriber_management": "[Subscriber Management]:",
+                "system_query": "[System Query]:",
+                "policy_dnn": "[Policy & DNN]:"
+            }
+            prefix = agent_prefixes.get(self.current_agent, f"[{self.current_agent}]:")
+            result = f"{prefix} {result}"
+            
+            # Update history
+            history.append({"role": "assistant", "content": result})
+            
+            # Save assistant response to database
+            self.history_manager.add_message(
+                self.current_conversation_id,
+                "assistant",
+                result,
+                agent_id=self.current_agent,
+                metadata={
+                    "model": self.current_model,
+                    "product": self.current_product,
+                    "version": self.current_version
+                }
+            )
+            
+            # Store in conversation history
+            self.conversation_history.append({
+                "user": message,
+                "assistant": result,
+                "agent": self.current_agent,
+                "product": self.current_product,
+                "version": self.current_version,
+                "model": self.current_model
+            })
+            
+        except Exception as e:
+            logger.error(f"Error processing message: {str(e)}")
+            error_msg = f"An error occurred: {str(e)}"
+            history.append({"role": "assistant", "content": error_msg})
+            
+            # Save error message
+            if self.current_conversation_id:
+                self.history_manager.add_message(
+                    self.current_conversation_id,
+                    "assistant",
+                    error_msg,
+                    agent_id=self.current_agent,
+                    metadata={"error": str(e)}
+                )
+        
+        return history, "", self.get_agent_status()
+    
+    def clear_conversation(self) -> Tuple[List[Dict[str, str]], str, str]:
+        """Clear conversation history and start a new conversation."""
+        # Start a new conversation
+        self.start_new_conversation()
+        
+        # Clear local history
+        self.conversation_history.clear()
+        
+        # Reset to default agent
+        self.current_agent = "document_reader"
+        
+        return [], f"Started new conversation! ID: {self.current_conversation_id[:8]}...", self.get_agent_status()
+    
+    def get_user_conversations(self) -> List[Dict[str, Any]]:
+        """Get recent conversations for the current user."""
+        if not self.current_user_id:
+            return []
+        
+        return self.history_manager.get_user_conversations(self.current_user_id)
+    
+    def load_conversation(self, conversation_id: str) -> Tuple[List[Dict[str, str]], str]:
+        """Load a previous conversation."""
+        try:
+            # Set current conversation
+            self.current_conversation_id = conversation_id
+            
+            # Get conversation details
+            conv_data = self.history_manager.export_conversation(conversation_id)
+            
+            # Update settings from conversation metadata
+            metadata = conv_data.get('metadata', {})
+            if metadata:
+                self.current_model = metadata.get('model', self.current_model)
+                self.current_product = metadata.get('product', self.current_product)
+                self.current_version = metadata.get('version', self.current_version)
+                
+                # Reinitialize agents with saved model
+                self._initialize_agents()
+            
+            # Set active agent
+            self.current_agent = conv_data.get('active_agent', 'document_reader')
+            
+            # Reload history into agents
+            self._reload_conversation_history()
+            
+            # Convert messages to Gradio format
+            history = [
+                {"role": msg["role"], "content": msg["content"]}
+                for msg in conv_data["messages"]
+            ]
+            
+            return history, f"Loaded conversation: {conv_data.get('title', 'Untitled')}"
+            
+        except Exception as e:
+            logger.error(f"Error loading conversation: {e}")
+            return [], f"Error loading conversation: {str(e)}"
+    
+    def _update_ui_info(self) -> str:
+        """Update the UI info display."""
+        info = (
+            f"**User:** {self.current_user_id or 'Not initialized'}\n"
+            f"**Conversation:** {self.current_conversation_id[:8] + '...' if self.current_conversation_id else 'Not started'}"
+        )
+        
+        # Add pending confirmations if any
+        if self.pending_confirmations:
+            info += f"\n**Pending Confirmations:** {len(self.pending_confirmations)}"
+        
+        return info
+    
+    def handle_confirmation(self, confirmation_id: str, approved: bool) -> str:
+        """Handle user confirmation response"""
+        if confirmation_id not in self.pending_confirmations:
+            return "No pending confirmation found with that ID."
+        
+        confirmation = self.pending_confirmations[confirmation_id]
+        
+        if approved:
+            # TODO: Execute the action through API Gateway
+            result = f"Action approved: {confirmation['action_type']}\n"
+            result += f"Details: {confirmation['description']}\n"
+            result += "NOTE: This would execute through the API Gateway (not implemented)"
+        else:
+            result = f"Action cancelled: {confirmation['action_type']}"
+        
+        # Remove from pending
+        del self.pending_confirmations[confirmation_id]
+        
+        return result
+    
+    def create_interface(self) -> gr.Blocks:
+        """Create the Gradio interface."""
+        with gr.Blocks(title="Peer-to-Peer Multi-Agent Assistant", theme=gr.themes.Soft()) as demo:
+            gr.Markdown("# Peer-to-Peer Multi-Agent Assistant")
+            gr.Markdown("Direct agent interaction with immediate RAG querying for documentation.")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    # Model and document selection
+                    gr.Markdown("### Settings")
+                    
+                    # Get model choices from config
+                    model_choices = [(m["display_name"], m["model_id"]) for m in self.config.get_available_models()]
+                    model_dropdown = gr.Dropdown(
+                        choices=model_choices,
+                        value=self.current_model,
+                        label="AI Model",
+                        interactive=True
+                    )
+                    
+                    # Get product choices from config
+                    product_choices = [(p["display_name"], p["id"]) for p in self.config.get_available_products()]
+                    product_dropdown = gr.Dropdown(
+                        choices=product_choices,
+                        value=self.current_product,
+                        label="Product",
+                        interactive=True
+                    )
+                    
+                    # Get initial versions for default product
+                    initial_versions = self.get_product_versions(self.current_product)
+                    version_dropdown = gr.Dropdown(
+                        choices=initial_versions,
+                        value=self.current_version if self.current_version in initial_versions else initial_versions[0],
+                        label="Version",
+                        interactive=True
+                    )
+                    
+                    # Update versions when product changes
+                    def update_version_choices(product):
+                        versions = self.get_product_versions(product)
+                        return gr.update(choices=versions, value=versions[0] if versions else "")
+                    
+                    product_dropdown.change(
+                        update_version_choices,
+                        inputs=[product_dropdown],
+                        outputs=[version_dropdown]
+                    )
+                    
+                    # Conversation Management
+                    gr.Markdown("### Conversation")
+                    
+                    # User info display
+                    user_info = gr.Markdown(
+                        f"**User:** {self.current_user_id or 'Not initialized'}\n"
+                        f"**Conversation:** {self.current_conversation_id[:8] + '...' if self.current_conversation_id else 'Not started'}"
+                    )
+                    
+                    # Conversation history dropdown
+                    with gr.Accordion("Previous Conversations", open=False):
+                        conversation_list = gr.Dropdown(
+                            choices=[],
+                            label="Select a conversation to load",
+                            interactive=True
+                        )
+                        load_conv_btn = gr.Button("Load Selected", size="sm")
+                        
+                        # Refresh conversations list
+                        def refresh_conversations():
+                            if not self.current_user_id:
+                                return gr.update(choices=[])
+                            
+                            convs = self.get_user_conversations()
+                            choices = []
+                            for conv in convs:
+                                updated_at = conv.get('updated_at', 'Unknown')
+                                if isinstance(updated_at, str) and len(updated_at) >= 16:
+                                    updated_at = updated_at[:16]
+                                title = conv.get('title', 'Untitled')
+                                msg_count = conv.get('message_count', 0)
+                                conv_id = conv.get('conversation_id', '')
+                                choices.append((
+                                    f"{title} ({updated_at}, {msg_count} msgs)",
+                                    conv_id
+                                ))
+                            return gr.update(choices=choices)
+                    
+                    # Agent status
+                    gr.Markdown("### Agent Status")
+                    agent_status = gr.Markdown(self.get_agent_status())
+                    
+                    # Agent info
+                    with gr.Accordion("Agent Information", open=False):
+                        gr.Markdown("""
+                        **Available Agents:**
+                        
+                        **Document Reader**
+                        - Default agent for documentation queries
+                        - Automatically searches selected product/version
+                        
+                        **Profile Settings**
+                        - Manages user preferences and settings
+                        
+                        **Network Configuration**
+                        - Configure NAT, VLANs, IP addresses
+                        - Handle bulk network operations
+                        
+                        **Subscriber Management**
+                        - Create/update subscribers
+                        - CSV import and bulk operations
+                        
+                        **System Query**
+                        - Read-only analytics and insights
+                        - System health and performance
+                        
+                        **Policy & DNN**
+                        - Manage DNNs and QoS profiles
+                        - Configure policies and services
+                        
+                        **Tips:**
+                        - Type `/agent <name>` to manually switch agents
+                        - All configuration changes require confirmation
+                        """)
+                    
+                    # Confirmation Dialog
+                    with gr.Accordion("Pending Confirmations", open=True, visible=False) as confirmation_accordion:
+                        gr.Markdown("### Action Requires Confirmation")
+                        confirmation_text = gr.Markdown("")
+                        with gr.Row():
+                            approve_btn = gr.Button("Approve", variant="primary", size="sm")
+                            deny_btn = gr.Button("Deny", variant="secondary", size="sm")
+                        confirmation_id_state = gr.State("")
+                    
+                    # Action buttons
+                    with gr.Row():
+                        clear_btn = gr.Button("New Conversation", variant="secondary")
+                        export_btn = gr.Button("Export Chat", variant="secondary")
+                
+                with gr.Column(scale=3):
+                    # Chat interface
+                    chatbot = gr.Chatbot(
+                        height=500,
+                        show_label=False,
+                        elem_id="chatbot",
+                        bubble_full_width=False,
+                        type="messages"
+                    )
+                    
+                    msg = gr.Textbox(
+                        label="Message",
+                        placeholder=f"Ask about {self.current_product.capitalize()} {self.current_version} documentation...",
+                        lines=2,
+                        max_lines=10,
+                        autofocus=True
+                    )
+                    
+                    with gr.Row():
+                        submit = gr.Button("Send", variant="primary", scale=1)
+                    
+                    # Example queries
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("**Documentation Examples:**")
+                            doc_examples = gr.Examples(
+                                examples=[
+                                    "How do I install this version?",
+                                    "What are the system requirements?",
+                                    "Show me troubleshooting steps",
+                                    "What's new in this version?",
+                                    "Search for configuration options"
+                                ],
+                                inputs=msg,
+                                label=""
+                            )
+                        
+                        with gr.Column():
+                            gr.Markdown("**Agent Switching Examples:**")
+                            agent_examples = gr.Examples(
+                                examples=[
+                                    "I need to update my settings",
+                                    "Show me my profile preferences",
+                                    "/agent profile_settings",
+                                    "/agent document_reader",
+                                    "Switch to documentation search"
+                                ],
+                                inputs=msg,
+                                label=""
+                            )
+            
+            # Update placeholder when product/version changes
+            def update_placeholder(product, version):
+                return gr.update(placeholder=f"Ask about {product.capitalize()} {version} documentation...")
+            
+            product_dropdown.change(
+                update_placeholder,
+                inputs=[product_dropdown, version_dropdown],
+                outputs=[msg]
+            )
+            
+            version_dropdown.change(
+                update_placeholder,
+                inputs=[product_dropdown, version_dropdown],
+                outputs=[msg]
+            )
+            
+            # Event handlers
+            msg.submit(
+                self.process_message,
+                inputs=[msg, chatbot, model_dropdown, product_dropdown, version_dropdown],
+                outputs=[chatbot, msg, agent_status]
+            ).then(
+                lambda: self._update_ui_info(),
+                outputs=[user_info]
+            )
+            
+            submit.click(
+                self.process_message,
+                inputs=[msg, chatbot, model_dropdown, product_dropdown, version_dropdown],
+                outputs=[chatbot, msg, agent_status]
+            ).then(
+                lambda: self._update_ui_info(),
+                outputs=[user_info]
+            )
+            
+            clear_btn.click(
+                self.clear_conversation,
+                outputs=[chatbot, msg, agent_status]
+            ).then(
+                lambda: (self._update_ui_info(), refresh_conversations()),
+                outputs=[user_info, conversation_list]
+            )
+            
+            # Load conversation handler
+            def load_selected_conversation(conv_id):
+                if conv_id:
+                    history, status_msg = self.load_conversation(conv_id)
+                    return history, "", self.get_agent_status(), self._update_ui_info()
+                return [], "", self.get_agent_status(), self._update_ui_info()
+            
+            load_conv_btn.click(
+                load_selected_conversation,
+                inputs=[conversation_list],
+                outputs=[chatbot, msg, agent_status, user_info]
+            )
+            
+            # Export conversation handler
+            def export_current_conversation():
+                if self.current_conversation_id:
+                    try:
+                        data = self.history_manager.export_conversation(self.current_conversation_id)
+                        # Convert to downloadable format
+                        import json
+                        export_str = json.dumps(data, indent=2)
+                        return gr.update(value=export_str, visible=True)
+                    except Exception as e:
+                        return gr.update(value=f"Error: {str(e)}", visible=True)
+                return gr.update(value="No conversation to export", visible=True)
+            
+            # Hidden textbox for export
+            export_output = gr.Textbox(visible=False, label="Export Data")
+            
+            export_btn.click(
+                export_current_conversation,
+                outputs=[export_output]
+            )
+            
+            # Confirmation handlers
+            def handle_approval():
+                """Handle approval button click"""
+                # TODO: Implement actual approval through API Gateway
+                return (
+                    gr.update(visible=False),  # Hide accordion
+                    "",  # Clear confirmation text
+                    "Action approved (not yet implemented)"  # Status message
+                )
+            
+            def handle_denial():
+                """Handle denial button click"""
+                return (
+                    gr.update(visible=False),  # Hide accordion
+                    "",  # Clear confirmation text
+                    "Action cancelled"  # Status message
+                )
+            
+            approve_btn.click(
+                handle_approval,
+                outputs=[confirmation_accordion, confirmation_text, msg]
+            )
+            
+            deny_btn.click(
+                handle_denial,
+                outputs=[confirmation_accordion, confirmation_text, msg]
+            )
+            
+            # Refresh conversations on load
+            demo.load(
+                refresh_conversations,
+                outputs=[conversation_list]
+            )
+        
+        return demo
+
+
+def create_gradio_interface() -> gr.Blocks:
+    """Create and return the Gradio interface."""
+    app = PeerToPeerApp()
+    return app.create_interface()
+
+
+# For testing
+if __name__ == "__main__":
+    interface = create_gradio_interface()
+    interface.launch(share=False, debug=True)

py/requirements.txt

@@ -0,0 +1,23 @@
+# Core dependencies
+openai>=1.50.0
+gradio>=4.0.0
+tiktoken>=0.5.0
+
+# LangChain (without ChromaDB)
+langchain>=0.1.0
+langchain-openai>=0.0.5
+langchain-community>=0.0.10
+
+# Vector operations
+numpy>=1.24.0
+
+# Utilities
+python-dotenv>=1.0.0
+packaging>=23.0
+tqdm>=4.65.0
+PyYAML>=6.0
+
+# Development dependencies (optional)
+# pytest>=7.0.0
+# black>=23.0.0
+# pylint>=2.17.0

py/scripts/migrate_to_chromadb.py

@@ -0,0 +1,210 @@
+"""
+Script to migrate JSON embeddings to ChromaDB with metadata
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import List, Dict
+import chromadb
+from chromadb.config import Settings
+from tqdm import tqdm
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class EmbeddingMigrator:
+    def __init__(self, embeddings_dir: Path, chroma_db_path: Path):
+        self.embeddings_dir = embeddings_dir
+        self.chroma_db_path = chroma_db_path
+        
+        # Initialize ChromaDB with persistent storage
+        self.client = chromadb.PersistentClient(
+            path=str(chroma_db_path),
+            settings=Settings(
+                anonymized_telemetry=False,
+                allow_reset=True
+            )
+        )
+        
+    def create_collection(self):
+        """Create or get the documentation collection."""
+        # Delete existing collection if it exists (for clean migration)
+        try:
+            self.client.delete_collection("documentation")
+            logger.info("Deleted existing collection")
+        except:
+            pass
+            
+        # Create new collection
+        self.collection = self.client.create_collection(
+            name="documentation",
+            metadata={"description": "Technical documentation for Harmony and Chorus products"}
+        )
+        logger.info("Created new collection: documentation")
+        
+    def migrate_embedding_file(self, file_path: Path) -> int:
+        """Migrate a single embedding JSON file to ChromaDB."""
+        logger.info(f"Migrating {file_path.name}...")
+        
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        
+        # Extract metadata from filename
+        store_name = file_path.stem  # e.g., "harmony_1_8"
+        
+        # Parse product and version
+        if store_name == "general_faq":
+            product = "general"
+            version = "all"
+        else:
+            parts = store_name.split("_", 1)
+            if len(parts) == 2:
+                product = parts[0]
+                version = parts[1].replace("_", ".")
+            else:
+                product = "unknown"
+                version = "unknown"
+        
+        chunks = data.get("chunks", [])
+        
+        # Prepare batch data
+        ids = []
+        embeddings = []
+        metadatas = []
+        documents = []
+        
+        for i, chunk in enumerate(chunks):
+            # Generate unique ID
+            chunk_id = f"{store_name}_chunk_{i}"
+            ids.append(chunk_id)
+            
+            # Extract text and embedding
+            text = chunk.get("text", "")
+            embedding = chunk.get("embedding", [])
+            
+            documents.append(text)
+            embeddings.append(embedding)
+            
+            # Build metadata
+            metadata = {
+                "product": product,
+                "version": version,
+                "store_name": store_name,
+                "chunk_index": i,
+                "chunk_id": chunk_id
+            }
+            
+            # Add optional metadata if available
+            if "metadata" in chunk:
+                chunk_meta = chunk["metadata"]
+                metadata.update({
+                    "source": chunk_meta.get("source", ""),
+                    "page": chunk_meta.get("page", -1),
+                    "token_count": chunk_meta.get("token_count", 0)
+                })
+            
+            # Add chunk_id from original if available
+            if "chunk_id" in chunk:
+                metadata["original_chunk_id"] = chunk["chunk_id"]
+            
+            metadatas.append(metadata)
+        
+        # Add to ChromaDB in batches
+        batch_size = 100
+        total_added = 0
+        
+        for i in range(0, len(ids), batch_size):
+            batch_end = min(i + batch_size, len(ids))
+            
+            self.collection.add(
+                ids=ids[i:batch_end],
+                embeddings=embeddings[i:batch_end],
+                metadatas=metadatas[i:batch_end],
+                documents=documents[i:batch_end]
+            )
+            
+            total_added += (batch_end - i)
+            logger.info(f"  Added {total_added}/{len(ids)} chunks")
+        
+        return len(ids)
+    
+    def migrate_all(self):
+        """Migrate all embedding files to ChromaDB."""
+        self.create_collection()
+        
+        # Find all JSON files
+        json_files = list(self.embeddings_dir.glob("*.json"))
+        logger.info(f"Found {len(json_files)} embedding files to migrate")
+        
+        total_chunks = 0
+        
+        for file_path in json_files:
+            chunks_added = self.migrate_embedding_file(file_path)
+            total_chunks += chunks_added
+        
+        logger.info(f"\nMigration complete!")
+        logger.info(f"Total chunks migrated: {total_chunks}")
+        
+        # Verify collection
+        count = self.collection.count()
+        logger.info(f"ChromaDB collection count: {count}")
+        
+        # Test query
+        self.test_query()
+    
+    def test_query(self):
+        """Test the migrated data with a sample query."""
+        logger.info("\nTesting ChromaDB queries...")
+        
+        # Test 1: Query with product/version filter
+        results = self.collection.query(
+            query_texts=["How to install Harmony?"],
+            n_results=3,
+            where={"$and": [{"product": "harmony"}, {"version": "1.8"}]}
+        )
+        
+        logger.info(f"Test query 1 returned {len(results['ids'][0])} results")
+        if results['ids'][0]:
+            logger.info(f"  First result metadata: {results['metadatas'][0][0]}")
+        
+        # Test 2: Query across all versions
+        results = self.collection.query(
+            query_texts=["system requirements"],
+            n_results=3,
+            where={"product": {"$eq": "harmony"}}
+        )
+        
+        logger.info(f"Test query 2 returned {len(results['ids'][0])} results")
+        
+        # Test 3: Get unique products and versions
+        all_data = self.collection.get()
+        products_versions = set()
+        
+        for metadata in all_data['metadatas']:
+            products_versions.add((metadata['product'], metadata['version']))
+        
+        logger.info("\nAvailable products and versions:")
+        for product, version in sorted(products_versions):
+            logger.info(f"  - {product} {version}")
+
+
+def main():
+    """Run the migration."""
+    # Set up paths
+    script_dir = Path(__file__).parent
+    project_root = script_dir.parent
+    embeddings_dir = project_root / "data" / "embeddings"
+    chroma_db_path = project_root / "data" / "chroma_db"
+    
+    # Create ChromaDB directory
+    chroma_db_path.mkdir(parents=True, exist_ok=True)
+    
+    # Run migration
+    migrator = EmbeddingMigrator(embeddings_dir, chroma_db_path)
+    migrator.migrate_all()
+
+
+if __name__ == "__main__":
+    main()

py/tools/README.md

@@ -0,0 +1,21 @@
+# Modular Tools System
+
+This directory contains the refactored modular tools system for the AI Assistant Multi-Agent System.
+
+## Overview
+
+The tools have been extracted from individual agents into reusable modules, with clear separation between read and write operations.
+
+## Potential Structure
+
+```
+tools/
+├── agent_tools.py           # Central agent registry and switching tools
+├── document_tools.py        # Document search/RAG tools (READ-ONLY)
+├── network_tools.py         # Network configuration tools (READ/WRITE)
+├── subscriber_tools.py      # Subscriber management tools (READ/WRITE)
+├── system_query_tools.py    # Analytics and monitoring tools (READ-ONLY)
+├── policy_dnn_tools.py      # Policy and DNN tools (READ/WRITE)
+├── profile_read_tools.py    # Profile viewing tools (READ-ONLY)
+└── profile_write_tools.py   # Profile modification tools (WRITE)
+```

py/tools/__init__.py

@@ -0,0 +1,17 @@
+"""
+Tools package for the AI Assistant Multi-Agent System
+
+This package contains modular tools that can be used by different agents.
+Tools are organized by functionality and separated into read/write operations
+where applicable.
+"""
+
+from . import (
+    agent_tools,
+    document_tools,
+)
+
+__all__ = [
+    "agent_tools",
+    "document_tools",
+]

py/tools/agent_tools.py

@@ -0,0 +1,343 @@
+"""
+Agent tools and information management
+
+This module contains:
+- Agent metadata and configuration
+- Agent singleton registry
+- Functions to get available agents
+- Agent switching tool creation
+- Tool conversion utilities for OpenAI function format
+"""
+
+import inspect
+import logging
+from typing import Dict, List, Optional, Callable, Any, get_type_hints
+from langchain.agents import Tool
+from langchain.tools import StructuredTool
+from langchain_openai import ChatOpenAI
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+
+# Agent information dictionary - single source of truth for all agents
+AGENT_INFO = {
+    "document_reader": {
+        "display_name": "Document Reader",
+        "description": "Handles documentation queries with RAG capabilities",
+        "tools": {
+            "read": ["search_version_documentation", "search_all_versions", "list_available_versions"],
+            "write": []  # No write operations
+        }
+    },
+    "profile_settings": {
+        "display_name": "Profile Settings",
+        "description": "Manages user preferences and settings",
+        "tools": {
+            "read": ["view_profile", "list_preferences", "view_notification_settings"],
+            "write": ["update_preference", "update_notifications", "reset_profile"]
+        }
+    }
+}
+
+
+# Global agent singleton registry
+_AGENT_INSTANCES: Dict[str, Any] = {}
+_LLM: Optional[ChatOpenAI] = None
+_API_GATEWAY = None
+_CURRENT_CONTEXT: Dict[str, Any] = {}  # Store context for switching tools
+
+
+def initialize_agents(llm: ChatOpenAI, api_gateway=None) -> None:
+    """
+    Initialize all agent singletons
+    
+    Args:
+        llm: The language model to use for all agents
+        api_gateway: Optional API gateway for certain agents
+    """
+    global _AGENT_INSTANCES, _LLM, _API_GATEWAY
+    
+    # Avoid circular imports by importing here
+    from agents.document_reader import DocumentReaderAgent
+    from agents.profile_settings import ProfileSettingsAgent
+    
+    _LLM = llm
+    _API_GATEWAY = api_gateway
+    
+    logger.info("Initializing agent singletons...")
+    
+    # Create agent instances (only implemented ones)
+    _AGENT_INSTANCES = {
+        "document_reader": DocumentReaderAgent(llm),
+        "profile_settings": ProfileSettingsAgent(llm),
+    }
+    
+    logger.info(f"Initialized {len(_AGENT_INSTANCES)} agents")
+
+
+def get_agent(agent_id: str) -> Optional[Any]:
+    """
+    Get agent instance by ID
+    
+    Args:
+        agent_id: The agent identifier
+        
+    Returns:
+        Agent instance or None if not found
+    """
+    return _AGENT_INSTANCES.get(agent_id)
+
+
+def run_agent(agent_id: str, message: str, context: Optional[Dict] = None) -> Dict[str, Any]:
+    """
+    Run an agent with a message
+    
+    Args:
+        agent_id: The agent identifier
+        message: The message to process
+        context: Optional context dictionary
+        
+    Returns:
+        Agent response dictionary
+    """
+    agent = get_agent(agent_id)
+    if not agent:
+        raise ValueError(f"Unknown agent: {agent_id}")
+    
+    # Store context globally for switching tools to access
+    global _CURRENT_CONTEXT
+    _CURRENT_CONTEXT = {
+        "message": message,
+        "context": context or {}
+    }
+    
+    return agent.run(message, context)
+
+
+def get_available_agents(exclude_agent_id: Optional[str] = None) -> Dict[str, Dict]:
+    """
+    Get all available agents, optionally excluding one
+    
+    Args:
+        exclude_agent_id: Agent ID to exclude from results
+        
+    Returns:
+        Dictionary of agent_id -> agent_info
+    """
+    return {
+        agent_id: info 
+        for agent_id, info in AGENT_INFO.items() 
+        if agent_id != exclude_agent_id
+    }
+
+
+def create_agent_switching_tool(target_agent_id: str, target_agent_name: str) -> Callable:
+    """
+    Create a tool function for switching to a specific agent
+    
+    Args:
+        target_agent_id: ID of the agent to switch to
+        target_agent_name: Display name of the agent
+        
+    Returns:
+        Callable function that performs the agent switch
+    """
+    def switch_to_agent(reason: str = "") -> str:
+        """Switch conversation to another agent. 
+        
+        Args:
+            reason: Brief explanation of why switching (e.g., 'User wants to update profile settings')
+        """
+        # Get current context
+        global _CURRENT_CONTEXT
+        message = _CURRENT_CONTEXT.get("message", "")
+        context = _CURRENT_CONTEXT.get("context", {})
+        
+        logger.info(f"Switching from current agent to {target_agent_id}")
+        
+        # Log the transfer
+        transfer_msg = f"Transferring to {target_agent_name}"
+        if reason:
+            transfer_msg += f": {reason}"
+        
+        try:
+            # Run the target agent with the current message
+            result = run_agent(target_agent_id, message, context)
+            
+            # Return a special marker with the target agent's response
+            # This tells BaseAgent to update agent_id and use this response
+            return f"__SWITCH_AGENT__|{target_agent_id}|{transfer_msg}\n\n{result.get('output', '')}"
+        except Exception as e:
+            logger.error(f"Error during agent switch: {e}")
+            return f"__SWITCH_AGENT__|{target_agent_id}|{transfer_msg}\n\n[Error: Failed to run {target_agent_name} - {str(e)}]"
+    
+    # Set function metadata for LangChain
+    switch_to_agent.__name__ = f"switch_to_{target_agent_id}"
+    switch_to_agent.__doc__ = f"Transfer conversation to {target_agent_name} agent. Always provide a reason parameter explaining why you're switching (e.g., 'User wants to update profile settings')."
+    
+    return switch_to_agent
+
+
+def create_switching_tools_for_agent(current_agent_id: str) -> List[StructuredTool]:
+    """
+    Create all agent switching tools for a given agent
+    
+    Args:
+        current_agent_id: ID of the current agent
+        
+    Returns:
+        List of StructuredTool objects for switching to other agents
+    """
+    tools = []
+    other_agents = get_available_agents(exclude_agent_id=current_agent_id)
+    
+    for agent_id, agent_info in other_agents.items():
+        # Create a dynamic Pydantic model for this specific agent
+        class SwitchToAgentInput(BaseModel):
+            reason: str = Field(
+                default="", 
+                description=f"Brief explanation of why switching to {agent_info['display_name']} (e.g., 'User wants to update profile settings')"
+            )
+        
+        # Set the class name dynamically for better debugging
+        SwitchToAgentInput.__name__ = f"SwitchTo{agent_id.title().replace('_', '')}Input"
+        
+        switch_func = create_agent_switching_tool(
+            agent_id, 
+            agent_info['display_name']
+        )
+        
+        tool = StructuredTool.from_function(
+            func=switch_func,
+            name=f"switch_to_{agent_id}",
+            description=f"Transfer to {agent_info['display_name']} - {agent_info['description']}",
+            args_schema=SwitchToAgentInput
+        )
+        tools.append(tool)
+    
+    return tools
+
+
+def get_agent_tools(agent_id: str) -> Dict[str, List[str]]:
+    """
+    Get the tools (read and write) for a specific agent
+    
+    Args:
+        agent_id: ID of the agent
+        
+    Returns:
+        Dictionary with 'read' and 'write' tool lists
+    """
+    if agent_id not in AGENT_INFO:
+        raise ValueError(f"Unknown agent ID: {agent_id}")
+    
+    return AGENT_INFO[agent_id]["tools"]
+
+
+def is_write_tool(agent_id: str, tool_name: str) -> bool:
+    """
+    Check if a tool is a write operation (requires confirmation)
+    
+    Args:
+        agent_id: ID of the agent
+        tool_name: Name of the tool
+        
+    Returns:
+        True if the tool is a write operation
+    """
+    agent_tools = get_agent_tools(agent_id)
+    return tool_name in agent_tools.get("write", [])
+
+
+def convert_tool_to_openai_function(tool: Any) -> Dict[str, Any]:
+    """
+    Convert a LangChain Tool or StructuredTool to OpenAI function format.
+    
+    Handles both Tool and StructuredTool instances appropriately.
+    """
+    # Check if this is a StructuredTool with args_schema
+    if hasattr(tool, 'args_schema') and tool.args_schema:
+        # Use the Pydantic schema directly
+        schema = tool.args_schema.schema()
+        
+        # Extract properties and required fields from Pydantic schema
+        properties = {}
+        required = []
+        
+        for field_name, field_info in schema.get('properties', {}).items():
+            properties[field_name] = field_info
+            
+        # Get required fields from schema
+        required = schema.get('required', [])
+        
+        return {
+            "name": tool.name,
+            "description": tool.description,
+            "parameters": {
+                "type": "object",
+                "properties": properties,
+                "required": required
+            }
+        }
+    
+    # Fall back to signature introspection for regular Tool
+    func = tool.func
+    sig = inspect.signature(func)
+    type_hints = get_type_hints(func)
+    
+    # Build properties from function parameters
+    properties = {}
+    required = []
+    
+    for param_name, param in sig.parameters.items():
+        # Skip 'self' parameter if it exists
+        if param_name == 'self':
+            continue
+            
+        # Determine the type
+        param_type = type_hints.get(param_name, type(param.default) if param.default != param.empty else str)
+        
+        # Convert Python types to JSON Schema types
+        if param_type == str:
+            json_type = "string"
+        elif param_type == int:
+            json_type = "integer"
+        elif param_type == float:
+            json_type = "number"
+        elif param_type == bool:
+            json_type = "boolean"
+        elif param_type == list or str(param_type).startswith('typing.List'):
+            json_type = "array"
+        elif param_type == dict or str(param_type).startswith('typing.Dict'):
+            json_type = "object"
+        else:
+            json_type = "string"  # Default fallback
+        
+        # Build property definition
+        prop_def = {"type": json_type}
+        
+        # Add description from docstring if available
+        if func.__doc__:
+            # Simple extraction - could be enhanced with docstring parsing
+            prop_def["description"] = f"Parameter: {param_name}"
+        
+        # Add default value if present
+        if param.default != param.empty:
+            prop_def["default"] = param.default
+        else:
+            # If no default, it's required
+            required.append(param_name)
+        
+        properties[param_name] = prop_def
+    
+    # Return the OpenAI function schema
+    return {
+        "name": tool.name,
+        "description": tool.description,
+        "parameters": {
+            "type": "object",
+            "properties": properties,
+            "required": required
+        }
+    }

py/tools/document_tools.py

@@ -0,0 +1,151 @@
+"""
+Document tools for searching and querying documentation
+
+These are READ-ONLY tools used by the Document Reader agent.
+"""
+
+from typing import Optional
+from langchain.agents import Tool
+from langchain.tools import StructuredTool
+from pydantic import BaseModel, Field
+from backend.chromadb_manager import ChromaDBManager
+
+
+# Pydantic models for structured tool inputs
+class SearchDocumentationInput(BaseModel):
+    """Input model for searching documentation"""
+    query: str = Field(description="The search query")
+    product: Optional[str] = Field(None, description="Product name (harmony or chorus). If not specified, searches all products")
+    version: Optional[str] = Field(None, description="Product version (e.g., '1.2', '1.8'). If not specified, searches all versions")
+
+
+class ListVersionsInput(BaseModel):
+    """Input model for listing versions"""
+    # No parameters needed, but StructuredTool requires a model
+
+
+# Initialize ChromaDB manager (singleton pattern)
+_db_manager = None
+
+def get_db_manager():
+    """Get or create ChromaDB manager instance"""
+    global _db_manager
+    if _db_manager is None:
+        _db_manager = ChromaDBManager()
+    return _db_manager
+
+
+def search_documentation(query: str, product: Optional[str] = None, version: Optional[str] = None) -> str:
+    """
+    Search documentation with flexible filtering
+    
+    Args:
+        query: Search query
+        product: Optional product name (harmony or chorus)
+        version: Optional product version (e.g., '1.2', '1.8')
+        
+    Returns:
+        Search results as formatted string with metadata
+    """
+    db_manager = get_db_manager()
+    
+    # Determine which search method to use based on parameters
+    if version is not None and product is not None:
+        # Search specific version of specific product
+        docs = db_manager.query_with_filter(query, product, version, k=5)
+        header = f"Results for '{query}' in {product} {version}:"
+    elif product is not None:
+        # Search all versions of specific product
+        docs = db_manager.query_product_all_versions(query, product, k=5)
+        header = f"Results for '{query}' across all {product} versions:"
+    else:
+        # Search across all products and versions
+        # Note: We'll need to search each product separately and combine results
+        all_docs = []
+        for prod in ["harmony", "chorus"]:
+            prod_docs = db_manager.query_product_all_versions(query, prod, k=3)
+            all_docs.extend(prod_docs)
+        docs = all_docs[:5]  # Limit total results
+        header = f"Results for '{query}' across all products:"
+    
+    if not docs:
+        return f"No results found for '{query}'"
+    
+    results = [header]
+    metadata_summary = []
+    
+    for i, doc in enumerate(docs, 1):
+        # Extract all metadata
+        metadata = doc.metadata
+        
+        # Include version info if searching across versions
+        if version is None and 'version' in metadata:
+            version_info = f"[{metadata.get('product', 'unknown')} {metadata.get('version', 'unknown')}] "
+        else:
+            version_info = ""
+        
+        # Add main content
+        results.append(f"\n{i}. {version_info}{doc.page_content[:500]}...")
+        
+        # Collect metadata for summary
+        meta_info = {
+            'chunk': i,
+            'product': metadata.get('product', 'unknown'),
+            'version': metadata.get('version', 'unknown'),
+            'document': metadata.get('document', 'unknown'),
+            'page': metadata.get('page', 'unknown'),
+            'chunk_id': metadata.get('chunk_id', 'unknown')
+        }
+        metadata_summary.append(meta_info)
+    
+    # Add metadata summary at the end
+    results.append("\n\n**Metadata of chunks retrieved:**")
+    for meta in metadata_summary:
+        results.append(f"- Chunk {meta['chunk']}: {meta['product']} v{meta['version']}, "
+                      f"{meta['document']} (page {meta['page']})")
+        
+    return "\n".join(results)
+
+
+
+
+def list_available_versions() -> str:
+    """
+    List all available product versions
+        
+    Returns:
+        List of available products and versions
+    """
+    db_manager = get_db_manager()
+    versions = db_manager.list_available_versions()
+    result = "Available product versions:\n"
+    
+    for product, version_list in versions.items():
+        result += f"\n{product.capitalize()}:\n"
+        for version in version_list:
+            result += f"  - {version}\n"
+            
+    return result
+
+
+# Tool creation functions for agents to use
+def search_documentation_tool() -> StructuredTool:
+    """Create a StructuredTool object for search_documentation"""
+    return StructuredTool.from_function(
+        func=search_documentation,
+        name="search_documentation",
+        description="Search technical documentation with flexible filtering by product and version",
+        args_schema=SearchDocumentationInput
+    )
+
+
+def list_available_versions_tool() -> StructuredTool:
+    """Create a StructuredTool object for list_available_versions"""
+    return StructuredTool.from_function(
+        func=list_available_versions,
+        name="list_available_versions",
+        description="List all available product versions in the documentation",
+        args_schema=ListVersionsInput
+    )
+
+

py/tools/profile_read_tools.py

@@ -0,0 +1,2 @@
+#TODO
+pass

py/tools/profile_write_tools.py

@@ -0,0 +1,2 @@
+#TODO
+pass

requirements.txt

@@ -0,0 +1,23 @@
+# Core dependencies
+openai>=1.50.0
+gradio>=4.0.0
+tiktoken>=0.5.0
+
+# LangChain (without ChromaDB)
+langchain>=0.1.0
+langchain-openai>=0.0.5
+langchain-community>=0.0.10
+
+# Vector operations
+numpy>=1.24.0
+
+# Utilities
+python-dotenv>=1.0.0
+packaging>=23.0
+tqdm>=4.65.0
+PyYAML>=6.0
+
+# Development dependencies (optional)
+# pytest>=7.0.0
+# black>=23.0.0
+# pylint>=2.17.0