Upload 17 files

README.md

@@ -1,19 +1,82 @@
 ---
-title: Agentic RAG Chatbot
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
+app_file: ui/streamlit_app.py
+sdk: streamlit
 ---
+# Agentic RAG Chatbot
 
-# Welcome to Streamlit!
+## Project Description
+This project implements an Agentic RAG (Retrieval Augmented Generation) Chatbot designed to answer questions based on uploaded documents. It leverages various agents for ingestion, retrieval, and LLM response generation, providing a conversational interface through a Streamlit application.
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## Features
+- **Document Upload**: Supports PDF, PPTX, CSV, DOCX, TXT, and MD file formats.
+- **Intelligent Retrieval**: Retrieves relevant information from uploaded documents to answer user queries.
+- **Conversational Interface**: Interact with the chatbot through a user-friendly Streamlit UI.
+- **Modular Agentic Architecture**: Built with distinct agents for better maintainability and scalability.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## Hugging Face Spaces Deployment
+
+To deploy this application on Hugging Face Spaces, follow these steps:
+
+1.  **Create a New Space**: Go to [Hugging Face Spaces](https://huggingface.co/spaces/new) and create a new Space. Choose `Streamlit` as the SDK.
+2.  **Upload Files**: Upload all project files and directories (`agents/`, `config/`, `core/`, `ui/`, `main.py`, `requirements.txt`, `ad.txt`, `PHILIP_SIMON_DEROCK.pdf`) to your Hugging Face Space repository.
+3.  **Entry Point**: Ensure your main application file is named `app.py`. If you have a `main.py` like in this project, you will need to rename it to `app.py` or create an `app.py` that imports and runs your Streamlit app.
+    *   In this project, `app.py` has been created to serve as the entry point, which calls `StreamlitApp` from `ui/streamlit_app.py`.
+4.  **Dependencies**: The `requirements.txt` file specifies all necessary Python dependencies. Hugging Face Spaces will automatically install these when building your Space.
+5.  **Environment Variables**: Set the `GOOGLE_API_KEY` environment variable in your Space settings.
+    *   Go to your Space settings (usually `Settings` tab in your Space).
+    *   Scroll down to "Repository secrets" or "Environment variables".
+    *   Add a new secret/variable named `GOOGLE_API_KEY` with your actual Google API Key.
+
+Your Space should now be ready to deploy and run the Agentic RAG Chatbot.
+
+## Local Setup (Optional)
+
+To run this project locally, follow these steps:
+
+1.  **Clone the repository**:
+    ```bash
+    git clone <repository_url>
+    cd Z
+    ```
+2.  **Create a virtual environment** (recommended):
+    ```bash
+    python -m venv virtual_container
+    source virtual_container/bin/activate
+    ```
+3.  **Install dependencies**:
+    ```bash
+    pip install -r requirements.txt
+    ```
+4.  **Set Environment Variable**: Set your `GOOGLE_API_KEY`:
+    ```bash
+    export GOOGLE_API_KEY="your_google_api_key"
+    # For Windows (Command Prompt):
+    # set GOOGLE_API_KEY="your_google_api_key"
+    # For Windows (PowerShell):
+    # $env:GOOGLE_API_KEY="your_google_api_key"
+    ```
+5.  **Run the Streamlit application**:
+    ```bash
+    streamlit run app.py
+    ```
+    The application will typically open in your web browser at `http://localhost:8501`.
+
+## Usage
+
+1.  **Upload Documents**: Use the sidebar to upload PDF, PPTX, CSV, DOCX, TXT, or MD files.
+2.  **Ask Questions**: Once documents are uploaded, type your questions in the chat input field to get answers based on the document content.
+
+## Project Structure
+
+```
+Z/
+├── agents/                  # Contains different agents (base, ingestion, llm_response, retrieval)
+├── config/                  # Configuration settings
+├── core/                    # Core functionalities like document parsing and vector store
+├── ui/                      # Streamlit UI components
+├── app.py                   # Main entry point for the Streamlit application (for Hugging Face Spaces)
+├── main_local.py            # Original main entry point (can be removed or kept for local dev)
+├── requirements.txt         # Python dependencies
+├── README.md                # Project README and deployment instructions
+└── ... other files (ad.txt, PHILIP_SIMON_DEROCK.pdf)
+```

agents/__init__.py

@@ -0,0 +1,9 @@
+# agents/__init__.py
+"""Agentic RAG Chatbot - Agent Package"""
+
+from .base_agent import BaseAgent
+from .ingestion_agent import IngestionAgent
+from .retrieval_agent import RetrievalAgent
+from .llm_response_agent import LLMResponseAgent
+
+__all__ = ['BaseAgent', 'IngestionAgent', 'RetrievalAgent', 'LLMResponseAgent']

agents/base_agent.py

@@ -0,0 +1,36 @@
+"""Base Agent Class for MCP Communication"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+from core.mcp import MCPMessage, message_bus
+
+class BaseAgent(ABC):
+    """Abstract base class for all agents"""
+    
+    def __init__(self, name: str):
+        self.name = name
+        self.message_bus = message_bus
+        
+        # Subscribe to message bus
+        self.message_bus.subscribe(self.name, self.handle_message)
+    
+    @abstractmethod
+    async def handle_message(self, message: MCPMessage) -> None:
+        """Handle incoming MCP messages"""
+        pass
+    
+    async def send_message(self, receiver: str, msg_type, payload: Dict[str, Any], 
+                          trace_id: str = None) -> None:
+        """Send message to another agent"""
+        message = self.message_bus.create_message(
+            sender=self.name,
+            receiver=receiver,
+            msg_type=msg_type,
+            payload=payload,
+            trace_id=trace_id
+        )
+        await self.message_bus.send_message(message)
+    
+    def log(self, message: str, level: str = "INFO") -> None:
+        """Simple logging mechanism"""
+        print(f"[{level}] {self.name}: {message}")

agents/ingestion_agent.py

@@ -0,0 +1,64 @@
+"""Ingestion Agent for Document Processing"""
+
+from typing import Dict, Any
+from agents.base_agent import BaseAgent
+from core.mcp import MCPMessage, MessageType
+from core.document_parser import DocumentParser
+
+class IngestionAgent(BaseAgent):
+    """Agent responsible for document ingestion and parsing"""
+    
+    def __init__(self):
+        super().__init__("IngestionAgent")
+        self.parser = DocumentParser()
+    
+    async def handle_message(self, message: MCPMessage) -> None:
+        """Handle incoming messages"""
+        try:
+            if message.type == MessageType.DOC_UPLOADED:
+                await self._process_document(message)
+            else:
+                self.log(f"Unhandled message type: {message.type}", "WARNING")
+        except Exception as e:
+            self.log(f"Error handling message: {str(e)}", "ERROR")
+            await self._send_error_message(message, str(e))
+    
+    async def _process_document(self, message: MCPMessage) -> None:
+        """Process uploaded document"""
+        payload = message.payload
+        file_name = payload.get('file_name')
+        file_data = payload.get('file_data')
+        
+        if not file_name or not file_data:
+            raise ValueError("Missing file_name or file_data in payload")
+        
+        self.log(f"Processing document: {file_name}")
+        
+        # Parse document into chunks
+        chunks = self.parser.parse_document(file_data, file_name)
+        
+        self.log(f"Extracted {len(chunks)} chunks from {file_name}")
+        
+        # Send chunks to RetrievalAgent
+        await self.send_message(
+            receiver="RetrievalAgent",
+            msg_type=MessageType.DOC_INGESTED,
+            payload={
+                "chunks": chunks,
+                "file_name": file_name,
+                "total_chunks": len(chunks)
+            },
+            trace_id=message.trace_id
+        )
+    
+    async def _send_error_message(self, original_message: MCPMessage, error: str) -> None:
+        """Send error message back to sender"""
+        await self.send_message(
+            receiver=original_message.sender,
+            msg_type=MessageType.ERROR,
+            payload={
+                "error": error,
+                "original_message": original_message.to_dict()
+            },
+            trace_id=original_message.trace_id
+        )

agents/llm_response_agent.py

@@ -0,0 +1,158 @@
+"""LLM Response Agent for Answer Generation"""
+
+from typing import Dict, Any
+import google.generativeai as genai
+from agents.base_agent import BaseAgent
+from core.mcp import MCPMessage, MessageType
+from config.settings import get_settings
+
+class LLMResponseAgent(BaseAgent):
+    """Agent responsible for generating responses using LLM"""
+    
+    def __init__(self):
+        super().__init__("LLMResponseAgent")
+        self.settings = get_settings()
+        self._initialize_llm()
+    
+    def _initialize_llm(self) -> None:
+        """Initialize Google Gemini LLM"""
+        api_key = self.settings.get('GOOGLE_API_KEY')
+        if api_key:
+            genai.configure(api_key=api_key)
+            self.model = genai.GenerativeModel('gemini-1.5-flash-latest')
+            self.llm_available = True
+            self.log("Gemini LLM initialized")
+        else:
+            self.llm_available = False
+            self.log("No API key provided - using fallback responses", "WARNING")
+    
+    async def handle_message(self, message: MCPMessage) -> None:
+        """Handle incoming messages"""
+        try:
+            if message.type == MessageType.USER_QUERY:
+                await self._process_user_query(message)
+            elif message.type == MessageType.RETRIEVAL_RESULT:
+                await self._generate_response(message)
+            else:
+                self.log(f"Unhandled message type: {message.type}", "WARNING")
+        except Exception as e:
+            self.log(f"Error handling message: {str(e)}", "ERROR")
+            await self._send_error_message(message, str(e))
+    
+    async def _process_user_query(self, message: MCPMessage) -> None:
+        """Process user query and request retrieval"""
+        payload = message.payload
+        query = payload.get('query')
+        
+        if not query:
+            raise ValueError("Missing query in user message")
+        
+        self.log(f"Processing user query: {query}")
+        
+        # Request retrieval from RetrievalAgent
+        await self.send_message(
+            receiver="RetrievalAgent",
+            msg_type=MessageType.RETRIEVAL_REQUEST,
+            payload={
+                "query": query,
+                "n_results": 5
+            },
+            trace_id=message.trace_id
+        )
+    
+    async def _generate_response(self, message: MCPMessage) -> None:
+        """Generate response using LLM and retrieved context"""
+        payload = message.payload
+        query = payload.get('query')
+        retrieved_context = payload.get('retrieved_context', [])
+        
+        self.log(f"Generating response for query with {len(retrieved_context)} context items")
+        
+        # Generate response
+        if self.llm_available:
+            response = await self._generate_llm_response(query, retrieved_context)
+        else:
+            response = self._generate_fallback_response(query, retrieved_context)
+        
+        # Extract source information
+        source_info = []
+        for context in retrieved_context:
+            source_entry = {"document": context.get('source', 'unknown')}
+            
+            # Add location information
+            if 'page' in context:
+                source_entry['page'] = context['page']
+            elif 'slide' in context:
+                source_entry['slide'] = context['slide']
+            elif 'row' in context:
+                source_entry['row'] = context['row']
+            elif 'paragraph' in context:
+                source_entry['paragraph'] = context['paragraph']
+            
+            source_info.append(source_entry)
+        
+        # Send final response to UI
+        await self.send_message(
+            receiver="UI",
+            msg_type=MessageType.FINAL_RESPONSE,
+            payload={
+                "answer": response,
+                "source_info": source_info,
+                "query": query
+            },
+            trace_id=message.trace_id
+        )
+    
+    async def _generate_llm_response(self, query: str, context: list) -> str:
+        """Generate response using Gemini LLM"""
+        # Prepare context text
+        context_text = "\n\n".join([
+            f"Source: {item.get('source', 'unknown')}\n{item['text']}"
+            for item in context
+        ])
+        
+        # Create prompt
+        prompt = f"""
+Based on the following context from uploaded documents, answer the user's question. 
+Be accurate, concise, and cite the sources when possible.
+
+Context:
+{context_text}
+
+Question: {query}
+
+Answer:
+"""
+        
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            self.log(f"LLM generation error: {str(e)}", "ERROR")
+            return self._generate_fallback_response(query, context)
+    
+    def _generate_fallback_response(self, query: str, context: list) -> str:
+        """Generate fallback response when LLM is not available"""
+        if not context:
+            return "I couldn't find relevant information in the uploaded documents to answer your question."
+        
+        # Simple context-based response
+        context_snippets = []
+        for item in context[:3]:  # Limit to top 3 results
+            source = item.get('source', 'unknown')
+            text = item['text'][:200] + "..." if len(item['text']) > 200 else item['text']
+            context_snippets.append(f"From {source}: {text}")
+        
+        return f"Based on the uploaded documents, here are the most relevant passages:\n\n" + "\n\n".join(context_snippets)
+    
+    async def _send_error_message(self, original_message: MCPMessage, error: str) -> None:
+        """Send error message to UI"""
+        await self.send_message(
+            receiver="UI",
+            msg_type=MessageType.ERROR,
+            payload={
+                "error": error,
+                "original_message": original_message.to_dict()
+            },
+            trace_id=original_message.trace_id
+        )

agents/retrieval_agent.py

@@ -0,0 +1,107 @@
+"""Retrieval Agent for Vector Search Operations"""
+
+from typing import Dict, Any
+from agents.base_agent import BaseAgent
+from core.mcp import MCPMessage, MessageType
+from core.vector_store import VectorStore
+
+class RetrievalAgent(BaseAgent):
+    """Agent responsible for vector storage and retrieval"""
+    
+    def __init__(self):
+        super().__init__("RetrievalAgent")
+        self.vector_store = VectorStore()
+    
+    async def handle_message(self, message: MCPMessage) -> None:
+        """Handle incoming messages"""
+        try:
+            if message.type == MessageType.DOC_INGESTED:
+                await self._ingest_chunks(message)
+            elif message.type == MessageType.RETRIEVAL_REQUEST:
+                await self._perform_retrieval(message)
+            else:
+                self.log(f"Unhandled message type: {message.type}", "WARNING")
+        except Exception as e:
+            self.log(f"Error handling message: {str(e)}", "ERROR")
+            await self._send_error_message(message, str(e))
+    
+    async def _ingest_chunks(self, message: MCPMessage) -> None:
+        """Ingest document chunks into vector store"""
+        payload = message.payload
+        chunks = payload.get('chunks', [])
+        file_name = payload.get('file_name')
+        
+        self.log(f"Ingesting {len(chunks)} chunks from {file_name}")
+        
+        # Add chunks to vector store
+        self.vector_store.add_documents(chunks)
+        
+        # Log statistics
+        stats = self.vector_store.get_collection_stats()
+        self.log(f"Vector store now contains {stats['total_documents']} documents")
+    
+    async def _perform_retrieval(self, message: MCPMessage) -> None:
+        """Perform semantic search and return results"""
+        payload = message.payload
+        query = payload.get('query')
+        n_results = payload.get('n_results', 5)
+        
+        if not query:
+            raise ValueError("Missing query in retrieval request")
+        
+        self.log(f"Performing retrieval for query: {query}")
+        
+        # Search vector store
+        results = self.vector_store.search(query, n_results)
+        
+        self.log(f"Found {len(results)} relevant chunks")
+        
+        # Format context for LLM
+        retrieved_context = []
+        for result in results:
+            context_item = {
+                "text": result['text'],
+                "source": result.get('source', 'unknown'),
+                "score": result.get('score', 0.0)
+            }
+            
+            # Add location metadata based on document type
+            if result.get('type') == 'pdf':
+                context_item['page'] = result.get('page')
+            elif result.get('type') == 'pptx':
+                context_item['slide'] = result.get('slide')
+            elif result.get('type') == 'csv':
+                context_item['row'] = result.get('row')
+            elif result.get('type') in ['docx', 'txt', 'md']:
+                context_item['paragraph'] = result.get('paragraph')
+            
+            retrieved_context.append(context_item)
+        
+        # Send results to LLMResponseAgent
+        await self.send_message(
+            receiver="LLMResponseAgent",
+            msg_type=MessageType.RETRIEVAL_RESULT,
+            payload={
+                "retrieved_context": retrieved_context,
+                "query": query,
+                "total_results": len(results)
+            },
+            trace_id=message.trace_id
+        )
+    
+    async def _send_error_message(self, original_message: MCPMessage, error: str) -> None:
+        """Send error message back to sender"""
+        await self.send_message(
+            receiver=original_message.sender,
+            msg_type=MessageType.ERROR,
+            payload={
+                "error": error,
+                "original_message": original_message.to_dict()
+            },
+            trace_id=original_message.trace_id
+        )
+    
+    def clear_store(self) -> None:
+        """Clear all documents from vector store"""
+        self.vector_store.clear()
+        self.log("Vector store cleared")

app.py

@@ -0,0 +1,21 @@
+import sys
+import os
+
+# Add project root to Python path
+# This is usually not necessary in Hugging Face Spaces if the structure is flat,
+# but keeping it for robustness if subdirectories are needed.
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from ui.streamlit_app import StreamlitApp
+
+# Main function to run the application
+def main():
+    print("🚀 Starting Agentic RAG Chatbot on Hugging Face Spaces...")
+    print("📝 Make sure to set GOOGLE_API_KEY environment variable for full LLM functionality")
+    
+    # Create and run the Streamlit app
+    app = StreamlitApp()
+    app.run()
+
+if __name__ == "__main__":
+    main() 

config/__init__.py

@@ -0,0 +1,6 @@
+# config/__init__.py
+"""Agentic RAG Chatbot - Configuration Package"""
+
+from .settings import get_settings
+
+__all__ = ['get_settings']

config/settings.py

@@ -0,0 +1,14 @@
+"""Application Settings and Configuration"""
+
+import os
+from typing import Dict, Any
+
+def get_settings() -> Dict[str, Any]:
+    """Get application settings from environment variables"""
+    return {
+        'GOOGLE_API_KEY': os.environ.get('GOOGLE_API_KEY'),
+        'EMBEDDING_MODEL': os.environ.get('EMBEDDING_MODEL', 'all-MiniLM-L6-v2'),
+        'MAX_CHUNK_SIZE': int(os.environ.get('MAX_CHUNK_SIZE', '1000')),
+        'RETRIEVAL_TOP_K': int(os.environ.get('RETRIEVAL_TOP_K', '5')),
+        'DEBUG_MODE': os.environ.get('DEBUG_MODE', 'False').lower() == 'true'
+    }

core/__init__.py

@@ -0,0 +1,8 @@
+# core/__init__.py
+"""Agentic RAG Chatbot - Core Package"""
+
+from .mcp import MCPMessage, MessageType, message_bus
+from .document_parser import DocumentParser
+from .vector_store import VectorStore
+
+__all__ = ['MCPMessage', 'MessageType', 'message_bus', 'DocumentParser', 'VectorStore']

core/document_parser.py

@@ -0,0 +1,145 @@
+"""Document Parser for Multi-Format Support"""
+
+import io
+import PyPDF2
+from pptx import Presentation
+import pandas as pd
+from docx import Document
+import markdown
+from typing import List, Dict, Any, Tuple
+
+class DocumentParser:
+    """Unified document parsing for multiple formats"""
+    
+    @staticmethod
+    def parse_pdf(file_data: bytes) -> List[Dict[str, Any]]:
+        """Parse PDF and extract text chunks"""
+        chunks = []
+        try:
+            pdf_reader = PyPDF2.PdfReader(io.BytesIO(file_data))
+            for page_num, page in enumerate(pdf_reader.pages, 1):
+                text = page.extract_text()
+                if text.strip():
+                    chunks.append({
+                        "text": text.strip(),
+                        "page": page_num,
+                        "type": "pdf"
+                    })
+        except Exception as e:
+            raise ValueError(f"PDF parsing error: {str(e)}")
+        return chunks
+    
+    @staticmethod
+    def parse_pptx(file_data: bytes) -> List[Dict[str, Any]]:
+        """Parse PPTX and extract slide content"""
+        chunks = []
+        try:
+            prs = Presentation(io.BytesIO(file_data))
+            for slide_num, slide in enumerate(prs.slides, 1):
+                slide_text = []
+                for shape in slide.shapes:
+                    if hasattr(shape, "text") and shape.text:
+                        slide_text.append(shape.text)
+                
+                if slide_text:
+                    chunks.append({
+                        "text": "\n".join(slide_text),
+                        "slide": slide_num,
+                        "type": "pptx"
+                    })
+        except Exception as e:
+            raise ValueError(f"PPTX parsing error: {str(e)}")
+        return chunks
+    
+    @staticmethod
+    def parse_csv(file_data: bytes) -> List[Dict[str, Any]]:
+        """Parse CSV and convert to text chunks"""
+        chunks = []
+        try:
+            df = pd.read_csv(io.StringIO(file_data.decode('utf-8')))
+            
+            # Header chunk
+            chunks.append({
+                "text": f"CSV Headers: {', '.join(df.columns.tolist())}",
+                "row": 0,
+                "type": "csv"
+            })
+            
+            # Row chunks (group by 10 rows for efficiency)
+            for i in range(0, len(df), 10):
+                chunk_df = df.iloc[i:i+10]
+                text_repr = chunk_df.to_string(index=False)
+                chunks.append({
+                    "text": text_repr,
+                    "row": i+1,
+                    "type": "csv"
+                })
+        except Exception as e:
+            raise ValueError(f"CSV parsing error: {str(e)}")
+        return chunks
+    
+    @staticmethod
+    def parse_docx(file_data: bytes) -> List[Dict[str, Any]]:
+        """Parse DOCX and extract paragraphs"""
+        chunks = []
+        try:
+            doc = Document(io.BytesIO(file_data))
+            for para_num, paragraph in enumerate(doc.paragraphs, 1):
+                if paragraph.text.strip():
+                    chunks.append({
+                        "text": paragraph.text.strip(),
+                        "paragraph": para_num,
+                        "type": "docx"
+                    })
+        except Exception as e:
+            raise ValueError(f"DOCX parsing error: {str(e)}")
+        return chunks
+    
+    @staticmethod
+    def parse_text(file_data: bytes, file_extension: str) -> List[Dict[str, Any]]:
+        """Parse TXT/MD files"""
+        chunks = []
+        try:
+            text = file_data.decode('utf-8')
+            
+            if file_extension == '.md':
+                # Convert markdown to HTML then extract text
+                html = markdown.markdown(text)
+                text = html
+            
+            # Split by paragraphs
+            paragraphs = [p.strip() for p in text.split('\n\n') if p.strip()]
+            for para_num, paragraph in enumerate(paragraphs, 1):
+                chunks.append({
+                    "text": paragraph,
+                    "paragraph": para_num,
+                    "type": file_extension[1:]  # Remove dot
+                })
+        except Exception as e:
+            raise ValueError(f"Text parsing error: {str(e)}")
+        return chunks
+    
+    @classmethod
+    def parse_document(cls, file_data: bytes, file_name: str) -> List[Dict[str, Any]]:
+        """Main parsing method - routes to appropriate parser"""
+        file_extension = file_name.lower().split('.')[-1]
+        
+        parser_map = {
+            'pdf': cls.parse_pdf,
+            'pptx': cls.parse_pptx,
+            'csv': cls.parse_csv,
+            'docx': cls.parse_docx,
+            'txt': lambda data: cls.parse_text(data, '.txt'),
+            'md': lambda data: cls.parse_text(data, '.md')
+        }
+        
+        if file_extension not in parser_map:
+            raise ValueError(f"Unsupported file format: {file_extension}")
+        
+        chunks = parser_map[file_extension](file_data)
+        
+        # Add source metadata to all chunks
+        for chunk in chunks:
+            chunk['source'] = file_name
+        
+        return chunks

core/mcp.py

@@ -0,0 +1,71 @@
+"""Model Context Protocol (MCP) Implementation for Agent Communication"""
+
+import json
+import uuid
+from typing import Dict, Any, Optional
+from dataclasses import dataclass, asdict
+from enum import Enum
+import asyncio
+from collections import defaultdict
+
+class MessageType(Enum):
+    DOC_UPLOADED = "DOC_UPLOADED"
+    DOC_INGESTED = "DOC_INGESTED"
+    USER_QUERY = "USER_QUERY"
+    RETRIEVAL_REQUEST = "RETRIEVAL_REQUEST"
+    RETRIEVAL_RESULT = "RETRIEVAL_RESULT"
+    FINAL_RESPONSE = "FINAL_RESPONSE"
+    ERROR = "ERROR"
+
+@dataclass
+class MCPMessage:
+    sender: str
+    receiver: str
+    type: MessageType
+    trace_id: str
+    payload: Dict[str, Any]
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "sender": self.sender,
+            "receiver": self.receiver,
+            "type": self.type.value,
+            "trace_id": self.trace_id,
+            "payload": self.payload
+        }
+
+class MCPMessageBus:
+    """In-memory message bus for agent communication"""
+    
+    def __init__(self):
+        self._subscribers = defaultdict(list)
+        self._message_queue = asyncio.Queue()
+        self._handlers = {}
+        
+    def subscribe(self, agent_name: str, handler_func):
+        """Subscribe an agent to receive messages"""
+        self._subscribers[agent_name].append(handler_func)
+        self._handlers[agent_name] = handler_func
+    
+    async def send_message(self, message: MCPMessage):
+        """Send message to target agent"""
+        await self._message_queue.put(message)
+        
+        # Direct delivery to handler
+        if message.receiver in self._handlers:
+            handler = self._handlers[message.receiver]
+            await handler(message)
+    
+    def create_message(self, sender: str, receiver: str, msg_type: MessageType, 
+                      payload: Dict[str, Any], trace_id: Optional[str] = None) -> MCPMessage:
+        """Create standardized MCP message"""
+        return MCPMessage(
+            sender=sender,
+            receiver=receiver,
+            type=msg_type,
+            trace_id=trace_id or str(uuid.uuid4()),
+            payload=payload
+        )
+
+# Global message bus instance
+message_bus = MCPMessageBus()

core/vector_store.py

@@ -0,0 +1,93 @@
+"""Vector Store Implementation with ChromaDB"""
+
+import chromadb
+from chromadb.config import Settings
+from sentence_transformers import SentenceTransformer
+from typing import List, Dict, Any, Tuple
+import uuid
+
+class VectorStore:
+    """In-memory vector store using ChromaDB"""
+    
+    def __init__(self, embedding_model: str = "all-MiniLM-L6-v2"):
+        # Initialize ChromaDB in memory
+        self.client = chromadb.Client(Settings(
+            allow_reset=True,
+            anonymized_telemetry=False
+        ))
+        
+        # Initialize embedding model
+        self.embedding_model = SentenceTransformer(embedding_model)
+        
+        # Create collection
+        self.collection = self.client.get_or_create_collection(
+            name="documents",
+            metadata={"hnsw:space": "cosine"}
+        )
+    
+    def add_documents(self, chunks: List[Dict[str, Any]]) -> None:
+        """Add document chunks to vector store"""
+        if not chunks:
+            return
+            
+        # Prepare data for ChromaDB
+        documents = []
+        metadatas = []
+        ids = []
+        
+        for chunk in chunks:
+            # Generate unique ID
+            chunk_id = str(uuid.uuid4())
+            
+            # Extract text for embedding
+            text = chunk['text']
+            
+            # Prepare metadata (everything except text)
+            metadata = {k: v for k, v in chunk.items() if k != 'text'}
+            
+            documents.append(text)
+            metadatas.append(metadata)
+            ids.append(chunk_id)
+        
+        # Add to collection
+        self.collection.add(
+            documents=documents,
+            metadatas=metadatas,
+            ids=ids
+        )
+    
+    def search(self, query: str, n_results: int = 5) -> List[Dict[str, Any]]:
+        """Search for relevant documents"""
+        if self.collection.count() == 0:
+            return []
+        
+        # Perform similarity search
+        results = self.collection.query(
+            query_texts=[query],
+            n_results=min(n_results, self.collection.count())
+        )
+        
+        # Format results
+        formatted_results = []
+        for i, doc in enumerate(results['documents'][0]):
+            metadata = results['metadatas'][0][i]
+            
+            result = {
+                'text': doc,
+                'score': results['distances'][0][i] if 'distances' in results else 0.0,
+                **metadata
+            }
+            formatted_results.append(result)
+        
+        return formatted_results
+    
+    def get_collection_stats(self) -> Dict[str, Any]:
+        """Get statistics about the collection"""
+        return {
+            'total_documents': self.collection.count(),
+            'embedding_model': self.embedding_model.get_sentence_embedding_dimension()
+        }
+    
+    def clear(self) -> None:
+        """Clear all documents from the store"""
+        self.client.reset()

main_local.py

@@ -0,0 +1,22 @@
+"""Main entry point for Agentic RAG Chatbot"""
+
+import sys
+import os
+
+# Add project root to Python path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from ui.streamlit_app import StreamlitApp
+
+def main():
+    """Main function to run the application"""
+    print("🚀 Starting Agentic RAG Chatbot...")
+    print("📝 Make sure to set GOOGLE_API_KEY environment variable for full LLM functionality")
+    print("🌐 Access the application at: http://localhost:8501")
+    
+    # Create and run the Streamlit app
+    app = StreamlitApp()
+    app.run()
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,11 @@
+streamlit==1.28.1
+chromadb==0.5.3
+sentence-transformers==2.7.0
+pypdf2==3.0.1
+python-pptx==0.6.22
+pandas==1.5.3
+python-docx==0.8.11
+markdown==3.5.1
+google-generativeai==0.7.1
+numpy==1.24.3
+python-dotenv

ui/__init__.py

@@ -0,0 +1,6 @@
+# ui/__init__.py
+"""Agentic RAG Chatbot - UI Package"""
+
+from .streamlit_app import StreamlitApp
+
+__all__ = ['StreamlitApp']

ui/streamlit_app.py

@@ -0,0 +1,270 @@
+"""Streamlit UI for Agentic RAG Chatbot"""
+
+import streamlit as st
+import asyncio
+import uuid
+from typing import Dict, Any, List
+from agents.base_agent import BaseAgent
+from core.mcp import MCPMessage, MessageType, message_bus
+
+class UIAgent(BaseAgent):
+    """UI Agent for handling Streamlit interface"""
+    
+    def __init__(self):
+        super().__init__("UI")
+        self.responses = {}
+        self.errors = {}
+    
+    async def handle_message(self, message: MCPMessage) -> None:
+        """Handle incoming messages from other agents"""
+        trace_id = message.trace_id
+        
+        if message.type == MessageType.FINAL_RESPONSE:
+            self.responses[trace_id] = message.payload
+        elif message.type == MessageType.ERROR:
+            self.errors[trace_id] = message.payload
+    
+    async def upload_document(self, file_name: str, file_data: bytes) -> str:
+        """Upload document to ingestion agent"""
+        trace_id = str(uuid.uuid4())
+        
+        await self.send_message(
+            receiver="IngestionAgent",
+            msg_type=MessageType.DOC_UPLOADED,
+            payload={
+                "file_name": file_name,
+                "file_data": file_data
+            },
+            trace_id=trace_id
+        )
+        
+        return trace_id
+    
+    async def ask_question(self, query: str) -> str:
+        """Send user query to LLM response agent"""
+        trace_id = str(uuid.uuid4())
+        
+        await self.send_message(
+            receiver="LLMResponseAgent",
+            msg_type=MessageType.USER_QUERY,
+            payload={
+                "query": query
+            },
+            trace_id=trace_id
+        )
+        
+        return trace_id
+    
+    def get_response(self, trace_id: str) -> Dict[str, Any]:
+        """Get response for a trace ID"""
+        return self.responses.get(trace_id)
+    
+    def get_error(self, trace_id: str) -> Dict[str, Any]:
+        """Get error for a trace ID"""
+        return self.errors.get(trace_id)
+
+class StreamlitApp:
+    """Main Streamlit application"""
+    
+    def __init__(self):
+        self.ui_agent = UIAgent()
+        self.init_session_state()
+    
+    def init_session_state(self):
+        """Initialize Streamlit session state"""
+        if 'messages' not in st.session_state:
+            st.session_state.messages = []
+        if 'uploaded_files' not in st.session_state:
+            st.session_state.uploaded_files = []
+        if 'agents_initialized' not in st.session_state:
+            st.session_state.agents_initialized = False
+    
+    def initialize_agents(self):
+        """Initialize all agents"""
+        if not st.session_state.agents_initialized:
+            from agents.ingestion_agent import IngestionAgent
+            from agents.retrieval_agent import RetrievalAgent
+            from agents.llm_response_agent import LLMResponseAgent
+            
+            # Create agents
+            st.session_state.ingestion_agent = IngestionAgent()
+            st.session_state.retrieval_agent = RetrievalAgent()
+            st.session_state.llm_response_agent = LLMResponseAgent()
+            
+            st.session_state.agents_initialized = True
+    
+    def render_sidebar(self):
+        """Render sidebar with file upload and settings"""
+        st.sidebar.title("📁 Document Upload")
+        
+        uploaded_files = st.sidebar.file_uploader(
+            "Choose files",
+            type=['pdf', 'pptx', 'csv', 'docx', 'txt', 'md'],
+            accept_multiple_files=True
+        )
+        
+        if uploaded_files:
+            for uploaded_file in uploaded_files:
+                if uploaded_file.name not in [f['name'] for f in st.session_state.uploaded_files]:
+                    # Process file upload
+                    file_data = uploaded_file.read()
+                    
+                    # Upload to ingestion agent
+                    trace_id = asyncio.run(self.ui_agent.upload_document(
+                        uploaded_file.name, file_data
+                    ))
+                    
+                    # Add to session state
+                    st.session_state.uploaded_files.append({
+                        'name': uploaded_file.name,
+                        'size': len(file_data),
+                        'trace_id': trace_id
+                    })
+                    
+                    st.sidebar.success(f"✅ {uploaded_file.name} uploaded")
+        
+        # Display uploaded files
+        if st.session_state.uploaded_files:
+            st.sidebar.subheader("📄 Uploaded Files")
+            for file_info in st.session_state.uploaded_files:
+                st.sidebar.text(f"• {file_info['name']}")
+        
+        # Settings
+        st.sidebar.subheader("⚙️ Settings")
+        if st.sidebar.button("Clear All Documents"):
+            st.session_state.uploaded_files = []
+            st.session_state.retrieval_agent.clear_store()
+            st.sidebar.success("Documents cleared")
+    
+    def render_chat_interface(self):
+        """Render main chat interface"""
+        st.title("🤖 Agentic RAG Chatbot")
+        st.markdown("Upload documents and ask questions about their content!")
+        
+        # Display chat messages
+        for message in st.session_state.messages:
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+                
+                # Display sources if available
+                if message.get("sources"):
+                    with st.expander("📚 Sources"):
+                        for source in message["sources"]:
+                            source_text = f"**{source['document']}**"
+                            if 'page' in source:
+                                source_text += f" (Page {source['page']})"
+                            elif 'slide' in source:
+                                source_text += f" (Slide {source['slide']})"
+                            elif 'row' in source:
+                                source_text += f" (Row {source['row']})"
+                            elif 'paragraph' in source:
+                                source_text += f" (Paragraph {source['paragraph']})"
+                            
+                            st.markdown(source_text)
+        
+        # Chat input
+        if prompt := st.chat_input("Ask a question about your documents..."):
+            # Add user message
+            st.session_state.messages.append({"role": "user", "content": prompt})
+            
+            # Display user message
+            with st.chat_message("user"):
+                st.markdown(prompt)
+            
+            # Process question
+            with st.chat_message("assistant"):
+                with st.spinner("Thinking..."):
+                    trace_id = asyncio.run(self.ui_agent.ask_question(prompt))
+                    
+                    # Wait for response
+                    response = None
+                    error = None
+                    max_attempts = 50
+                    attempts = 0
+                    
+                    while attempts < max_attempts:
+                        response = self.ui_agent.get_response(trace_id)
+                        error = self.ui_agent.get_error(trace_id)
+                        
+                        if response or error:
+                            break
+                        
+                        asyncio.run(asyncio.sleep(0.1))
+                        attempts += 1
+                    
+                    if error:
+                        error_msg = f"❌ Error: {error.get('error', 'Unknown error')}"
+                        st.error(error_msg)
+                        st.session_state.messages.append({
+                            "role": "assistant", 
+                            "content": error_msg
+                        })
+                    elif response:
+                        answer = response.get('answer', 'No answer generated')
+                        sources = response.get('source_info', [])
+                        
+                        st.markdown(answer)
+                        
+                        # Display sources
+                        if sources:
+                            with st.expander("📚 Sources"):
+                                for source in sources:
+                                    source_text = f"**{source['document']}**"
+                                    if 'page' in source:
+                                        source_text += f" (Page {source['page']})"
+                                    elif 'slide' in source:
+                                        source_text += f" (Slide {source['slide']})"
+                                    elif 'row' in source:
+                                        source_text += f" (Row {source['row']})"
+                                    elif 'paragraph' in source:
+                                        source_text += f" (Paragraph {source['paragraph']})"
+                                    
+                                    st.markdown(source_text)
+                        
+                        st.session_state.messages.append({
+                            "role": "assistant", 
+                            "content": answer,
+                            "sources": sources
+                        })
+                    else:
+                        timeout_msg = "⏰ Request timed out. Please try again."
+                        st.error(timeout_msg)
+                        st.session_state.messages.append({
+                            "role": "assistant", 
+                            "content": timeout_msg
+                        })
+    
+    def run(self):
+        """Run the Streamlit application"""
+        st.set_page_config(
+            page_title="Agentic RAG Chatbot",
+            page_icon="🤖",
+            layout="wide"
+        )
+        
+        # CSS injection for black background and green text
+        st.markdown(
+            '''
+            <style>
+            html, body, [class*="st-"], [class*="css-"] {
+               background-color: #000000;
+               color: #00FF00; /* Retain green for general text */
+            }
+            h1 { /* Target for Streamlit titles */
+                color: red;
+                font-weight: bold; /* Make it thick */
+            }
+            </style>
+            ''',
+            unsafe_allow_html=True
+        )
+
+        self.initialize_agents()
+        
+        self.render_sidebar()
+        self.render_chat_interface()
+
+# Create and run the app
+if __name__ == "__main__":
+    app = StreamlitApp()
+    app.run()