Create app.py

app.py

@@ -0,0 +1,777 @@
+import gradio as gr
+import os
+import tempfile
+import uuid
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+import json
+import asyncio
+from dataclasses import dataclass, asdict
+import logging
+
+# Document processing imports
+import PyPDF2
+import pandas as pd
+from docx import Document
+from pptx import Presentation
+import markdown
+
+# ML/AI imports
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.vectorstores import FAISS
+from langchain.schema import Document as LCDocument
+from huggingface_hub import InferenceClient
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# MCP Message Structure
+@dataclass
+class MCPMessage:
+    sender: str
+    receiver: str
+    type: str
+    trace_id: str
+    payload: Dict[str, Any]
+    timestamp: str = None
+    
+    def __post_init__(self):
+        if self.timestamp is None:
+            self.timestamp = datetime.now().isoformat()
+    
+    def to_dict(self):
+        return asdict(self)
+
+# MCP Communication Layer
+class MCPCommunicator:
+    def __init__(self):
+        self.message_queue = asyncio.Queue()
+        self.subscribers = {}
+    
+    async def send_message(self, message: MCPMessage):
+        logger.info(f"MCP: {message.sender} -> {message.receiver}: {message.type}")
+        await self.message_queue.put(message)
+    
+    async def receive_message(self, agent_name: str) -> MCPMessage:
+        while True:
+            message = await self.message_queue.get()
+            if message.receiver == agent_name:
+                return message
+            # Re-queue if not for this agent
+            await self.message_queue.put(message)
+
+# Global MCP instance
+mcp = MCPCommunicator()
+
+# Base Agent Class
+class BaseAgent:
+    def __init__(self, name: str):
+        self.name = name
+        self.mcp = mcp
+    
+    async def send_mcp_message(self, receiver: str, msg_type: str, payload: Dict[str, Any], trace_id: str):
+        message = MCPMessage(
+            sender=self.name,
+            receiver=receiver,
+            type=msg_type,
+            trace_id=trace_id,
+            payload=payload
+        )
+        await self.mcp.send_message(message)
+    
+    async def receive_mcp_message(self) -> MCPMessage:
+        return await self.mcp.receive_message(self.name)
+
+# Document Ingestion Agent
+class IngestionAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("IngestionAgent")
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=200,
+            length_function=len,
+        )
+    
+    def parse_pdf(self, file_path: str) -> str:
+        """Parse PDF file and extract text"""
+        try:
+            with open(file_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                text = ""
+                for page in pdf_reader.pages:
+                    text += page.extract_text() + "\n"
+                return text
+        except Exception as e:
+            logger.error(f"Error parsing PDF: {e}")
+            return ""
+    
+    def parse_docx(self, file_path: str) -> str:
+        """Parse DOCX file and extract text"""
+        try:
+            doc = Document(file_path)
+            text = ""
+            for paragraph in doc.paragraphs:
+                text += paragraph.text + "\n"
+            return text
+        except Exception as e:
+            logger.error(f"Error parsing DOCX: {e}")
+            return ""
+    
+    def parse_pptx(self, file_path: str) -> str:
+        """Parse PPTX file and extract text"""
+        try:
+            prs = Presentation(file_path)
+            text = ""
+            for slide_num, slide in enumerate(prs.slides, 1):
+                text += f"Slide {slide_num}:\n"
+                for shape in slide.shapes:
+                    if hasattr(shape, "text"):
+                        text += shape.text + "\n"
+                text += "\n"
+            return text
+        except Exception as e:
+            logger.error(f"Error parsing PPTX: {e}")
+            return ""
+    
+    def parse_csv(self, file_path: str) -> str:
+        """Parse CSV file and convert to text"""
+        try:
+            df = pd.read_csv(file_path)
+            return df.to_string()
+        except Exception as e:
+            logger.error(f"Error parsing CSV: {e}")
+            return ""
+    
+    def parse_txt_md(self, file_path: str) -> str:
+        """Parse TXT or MD file"""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as file:
+                content = file.read()
+                # If markdown, convert to plain text
+                if file_path.lower().endswith('.md'):
+                    content = markdown.markdown(content)
+                return content
+        except Exception as e:
+            logger.error(f"Error parsing TXT/MD: {e}")
+            return ""
+    
+    async def process_documents(self, files: List[str], trace_id: str) -> List[LCDocument]:
+        """Process uploaded documents and return chunked documents"""
+        all_documents = []
+        
+        for file_path in files:
+            file_ext = os.path.splitext(file_path)[1].lower()
+            filename = os.path.basename(file_path)
+            
+            # Parse based on file extension
+            if file_ext == '.pdf':
+                content = self.parse_pdf(file_path)
+            elif file_ext == '.docx':
+                content = self.parse_docx(file_path)
+            elif file_ext == '.pptx':
+                content = self.parse_pptx(file_path)
+            elif file_ext == '.csv':
+                content = self.parse_csv(file_path)
+            elif file_ext in ['.txt', '.md']:
+                content = self.parse_txt_md(file_path)
+            else:
+                logger.warning(f"Unsupported file type: {file_ext}")
+                continue
+            
+            if content.strip():
+                # Split content into chunks
+                chunks = self.text_splitter.split_text(content)
+                
+                # Create LangChain documents
+                for i, chunk in enumerate(chunks):
+                    doc = LCDocument(
+                        page_content=chunk,
+                        metadata={
+                            "source": filename,
+                            "chunk_id": i,
+                            "file_type": file_ext
+                        }
+                    )
+                    all_documents.append(doc)
+        
+        return all_documents
+
+# Retrieval Agent
+class RetrievalAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("RetrievalAgent")
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name="sentence-transformers/all-MiniLM-L6-v2"
+        )
+        self.vector_store = None
+    
+    async def create_vector_store(self, documents: List[LCDocument], trace_id: str):
+        """Create vector store from documents"""
+        try:
+            if documents:
+                self.vector_store = FAISS.from_documents(documents, self.embeddings)
+                logger.info(f"Created vector store with {len(documents)} documents")
+            else:
+                logger.warning("No documents to create vector store")
+        except Exception as e:
+            logger.error(f"Error creating vector store: {e}")
+    
+    async def retrieve_relevant_chunks(self, query: str, k: int = 5, trace_id: str = None) -> List[Dict]:
+        """Retrieve relevant chunks for a query"""
+        if not self.vector_store:
+            return []
+        
+        try:
+            # Similarity search
+            docs = self.vector_store.similarity_search(query, k=k)
+            
+            # Format results
+            results = []
+            for doc in docs:
+                results.append({
+                    "content": doc.page_content,
+                    "source": doc.metadata.get("source", "Unknown"),
+                    "chunk_id": doc.metadata.get("chunk_id", 0),
+                    "file_type": doc.metadata.get("file_type", "Unknown")
+                })
+            
+            return results
+        except Exception as e:
+            logger.error(f"Error retrieving chunks: {e}")
+            return []
+
+# LLM Response Agent
+class LLMResponseAgent(BaseAgent):
+    def __init__(self, hf_token: str = None):
+        super().__init__("LLMResponseAgent")
+        self.client = InferenceClient(
+            model="meta-llama/Llama-3.1-8B-Instruct",
+            token=hf_token
+        )
+    
+    def format_prompt(self, query: str, context_chunks: List[Dict]) -> str:
+        """Format prompt with context and query"""
+        context_text = "\n\n".join([
+            f"Source: {chunk['source']}\nContent: {chunk['content']}"
+            for chunk in context_chunks
+        ])
+        
+        prompt = f"""Based on the following context from uploaded documents, please answer the user's question.
+
+Context:
+{context_text}
+
+Question: {query}
+
+Please provide a comprehensive answer based on the context above. If the context doesn't contain enough information to fully answer the question, please mention what information is available and what might be missing.
+
+Answer:"""
+        
+        return prompt
+    
+    async def generate_response(self, query: str, context_chunks: List[Dict], trace_id: str) -> str:
+        """Generate response using LLM"""
+        try:
+            prompt = self.format_prompt(query, context_chunks)
+            
+            # Generate response using HuggingFace Inference
+            response = self.client.text_generation(
+                prompt,
+                max_new_tokens=512,
+                temperature=0.7,
+                do_sample=True,
+                return_full_text=False
+            )
+            
+            return response
+        except Exception as e:
+            logger.error(f"Error generating response: {e}")
+            return f"I apologize, but I encountered an error while generating the response: {str(e)}"
+
+# Coordinator Agent
+class CoordinatorAgent(BaseAgent):
+    def __init__(self, hf_token: str = None):
+        super().__init__("CoordinatorAgent")
+        self.ingestion_agent = IngestionAgent()
+        self.retrieval_agent = RetrievalAgent()
+        self.llm_agent = LLMResponseAgent(hf_token)
+        self.documents_processed = False
+    
+    async def process_documents(self, files: List[str]) -> str:
+        """Orchestrate document processing"""
+        trace_id = str(uuid.uuid4())
+        
+        try:
+            # Step 1: Ingestion
+            await self.send_mcp_message(
+                "IngestionAgent", 
+                "DOCUMENT_INGESTION_REQUEST", 
+                {"files": files}, 
+                trace_id
+            )
+            
+            documents = await self.ingestion_agent.process_documents(files, trace_id)
+            
+            await self.send_mcp_message(
+                "RetrievalAgent", 
+                "VECTOR_STORE_CREATE_REQUEST", 
+                {"documents": len(documents)}, 
+                trace_id
+            )
+            
+            # Step 2: Create vector store
+            await self.retrieval_agent.create_vector_store(documents, trace_id)
+            
+            self.documents_processed = True
+            
+            return f"Successfully processed {len(documents)} document chunks from {len(files)} files."
+            
+        except Exception as e:
+            logger.error(f"Error in document processing: {e}")
+            return f"Error processing documents: {str(e)}"
+    
+    async def answer_query(self, query: str) -> tuple[str, List[Dict]]:
+        """Orchestrate query answering"""
+        if not self.documents_processed:
+            return "Please upload and process documents first.", []
+        
+        trace_id = str(uuid.uuid4())
+        
+        try:
+            # Step 1: Retrieval
+            await self.send_mcp_message(
+                "RetrievalAgent", 
+                "RETRIEVAL_REQUEST", 
+                {"query": query}, 
+                trace_id
+            )
+            
+            context_chunks = await self.retrieval_agent.retrieve_relevant_chunks(query, k=5, trace_id=trace_id)
+            
+            # Step 2: LLM Response
+            await self.send_mcp_message(
+                "LLMResponseAgent", 
+                "LLM_GENERATION_REQUEST", 
+                {"query": query, "context_chunks": len(context_chunks)}, 
+                trace_id
+            )
+            
+            response = await self.llm_agent.generate_response(query, context_chunks, trace_id)
+            
+            return response, context_chunks
+            
+        except Exception as e:
+            logger.error(f"Error in query processing: {e}")
+            return f"Error processing query: {str(e)}", []
+
+# Global coordinator instance
+coordinator = None
+
+def initialize_app(hf_token):
+    """Initialize the application with HuggingFace token"""
+    global coordinator
+    coordinator = CoordinatorAgent(hf_token)
+    return "✅ Application initialized successfully!"
+
+async def process_files(files):
+    """Process uploaded files"""
+    if not coordinator:
+        return "❌ Please set your HuggingFace token first!"
+    
+    if not files:
+        return "❌ Please upload at least one file."
+    
+    # Save uploaded files to temporary directory
+    file_paths = []
+    for file in files:
+        temp_path = os.path.join(tempfile.gettempdir(), file.name)
+        with open(temp_path, 'wb') as f:
+            f.write(file.read())
+        file_paths.append(temp_path)
+    
+    result = await coordinator.process_documents(file_paths)
+    
+    # Cleanup temporary files
+    for path in file_paths:
+        try:
+            os.remove(path)
+        except:
+            pass
+    
+    return result
+
+async def answer_question(query, history):
+    """Answer user question"""
+    if not coordinator:
+        return "❌ Please set your HuggingFace token first!"
+    
+    if not query.strip():
+        return "❌ Please enter a question."
+    
+    response, context_chunks = await coordinator.answer_query(query)
+    
+    # Format response with sources
+    if context_chunks:
+        sources = "\n\n**Sources:**\n"
+        for i, chunk in enumerate(context_chunks[:3], 1):  # Show top 3 sources
+            sources += f"{i}. {chunk['source']} (Chunk {chunk['chunk_id']})\n"
+        response += sources
+    
+    return response
+
+# Custom CSS
+custom_css = """
+/* Main container styling */
+.gradio-container {
+    max-width: 1200px !important;
+    margin: 0 auto !important;
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif !important;
+}
+
+/* Header styling */
+.header-container {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    color: white !important;
+    padding: 2rem !important;
+    border-radius: 15px !important;
+    margin-bottom: 2rem !important;
+    text-align: center !important;
+    box-shadow: 0 8px 32px rgba(0,0,0,0.1) !important;
+}
+
+.header-title {
+    font-size: 2.5rem !important;
+    font-weight: 700 !important;
+    margin-bottom: 0.5rem !important;
+    text-shadow: 2px 2px 4px rgba(0,0,0,0.3) !important;
+}
+
+.header-subtitle {
+    font-size: 1.2rem !important;
+    opacity: 0.9 !important;
+    font-weight: 300 !important;
+}
+
+/* Tab styling */
+.tab-nav {
+    background: white !important;
+    border-radius: 12px !important;
+    box-shadow: 0 4px 20px rgba(0,0,0,0.08) !important;
+    padding: 0.5rem !important;
+    margin-bottom: 1rem !important;
+}
+
+/* Card styling */
+.setup-card, .upload-card, .chat-card {
+    background: white !important;
+    border-radius: 15px !important;
+    padding: 2rem !important;
+    box-shadow: 0 4px 20px rgba(0,0,0,0.08) !important;
+    border: 1px solid #e1e5e9 !important;
+    margin-bottom: 1.5rem !important;
+}
+
+/* Button styling */
+.primary-button {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    color: white !important;
+    border: none !important;
+    border-radius: 10px !important;
+    padding: 0.75rem 2rem !important;
+    font-weight: 600 !important;
+    transition: all 0.3s ease !important;
+    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.3) !important;
+}
+
+.primary-button:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 6px 20px rgba(102, 126, 234, 0.4) !important;
+}
+
+/* Chat interface styling */
+.chat-container {
+    max-height: 600px !important;
+    overflow-y: auto !important;
+    background: #f8f9fa !important;
+    border-radius: 15px !important;
+    padding: 1rem !important;
+    border: 1px solid #e1e5e9 !important;
+}
+
+/* Input styling */
+.input-container input, .input-container textarea {
+    border: 2px solid #e1e5e9 !important;
+    border-radius: 10px !important;
+    padding: 0.75rem 1rem !important;
+    font-size: 1rem !important;
+    transition: border-color 0.3s ease !important;
+}
+
+.input-container input:focus, .input-container textarea:focus {
+    border-color: #667eea !important;
+    box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1) !important;
+    outline: none !important;
+}
+
+/* Status indicators */
+.status-success {
+    color: #28a745 !important;
+    background: #d4edda !important;
+    padding: 0.75rem 1rem !important;
+    border-radius: 8px !important;
+    border: 1px solid #c3e6cb !important;
+    margin: 1rem 0 !important;
+}
+
+.status-error {
+    color: #dc3545 !important;
+    background: #f8d7da !important;
+    padding: 0.75rem 1rem !important;
+    border-radius: 8px !important;
+    border: 1px solid #f5c6cb !important;
+    margin: 1rem 0 !important;
+}
+
+/* File upload styling */
+.file-upload {
+    border: 2px dashed #667eea !important;
+    border-radius: 15px !important;
+    padding: 2rem !important;
+    text-align: center !important;
+    background: #f8f9ff !important;
+    transition: all 0.3s ease !important;
+}
+
+.file-upload:hover {
+    border-color: #764ba2 !important;
+    background: #f0f4ff !important;
+}
+
+/* Architecture diagram container */
+.architecture-container {
+    background: white !important;
+    border-radius: 15px !important;
+    padding: 2rem !important;
+    margin: 1rem 0 !important;
+    box-shadow: 0 4px 20px rgba(0,0,0,0.08) !important;
+    text-align: center !important;
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .header-title {
+        font-size: 2rem !important;
+    }
+    
+    .setup-card, .upload-card, .chat-card {
+        padding: 1.5rem !important;
+    }
+}
+
+/* Animation for loading states */
+@keyframes pulse {
+    0% { opacity: 1; }
+    50% { opacity: 0.5; }
+    100% { opacity: 1; }
+}
+
+.loading {
+    animation: pulse 1.5s ease-in-out infinite !important;
+}
+"""
+
+# Create Gradio Interface
+def create_interface():
+    with gr.Blocks(css=custom_css, title="🤖 Agentic RAG Chatbot") as demo:
+        gr.HTML("""
+        <div class="header-container">
+            <h1 class="header-title">🤖 Agentic RAG Chatbot</h1>
+            <p class="header-subtitle">Multi-Format Document QA using Model Context Protocol (MCP)</p>
+        </div>
+        """)
+        
+        with gr.Tabs() as tabs:
+            # Setup Tab
+            with gr.TabItem("⚙️ Setup", elem_classes=["tab-nav"]):
+                gr.HTML("""
+                <div class="setup-card">
+                    <h3>🔑 Configuration</h3>
+                    <p>Enter your HuggingFace token to get started. This token is used to access the Llama-3.1-8B-Instruct model.</p>
+                </div>
+                """)
+                
+                with gr.Row():
+                    hf_token_input = gr.Textbox(
+                        label="HuggingFace Token",
+                        placeholder="hf_xxxxxxxxxxxxxxxxxxxxxxxxx",
+                        type="password",
+                        elem_classes=["input-container"]
+                    )
+                
+                with gr.Row():
+                    init_button = gr.Button(
+                        "Initialize Application", 
+                        variant="primary",
+                        elem_classes=["primary-button"]
+                    )
+                
+                init_status = gr.Textbox(
+                    label="Status",
+                    interactive=False,
+                    elem_classes=["input-container"]
+                )
+            
+            # Upload Tab
+            with gr.TabItem("📁 Upload Documents", elem_classes=["tab-nav"]):
+                gr.HTML("""
+                <div class="upload-card">
+                    <h3>📄 Document Upload</h3>
+                    <p>Upload your documents in any supported format: PDF, DOCX, PPTX, CSV, TXT, or Markdown.</p>
+                </div>
+                """)
+                
+                file_upload = gr.File(
+                    label="Choose Files",
+                    file_count="multiple",
+                    file_types=[".pdf", ".docx", ".pptx", ".csv", ".txt", ".md"],
+                    elem_classes=["file-upload"]
+                )
+                
+                upload_button = gr.Button(
+                    "Process Documents", 
+                    variant="primary",
+                    elem_classes=["primary-button"]
+                )
+                
+                upload_status = gr.Textbox(
+                    label="Processing Status",
+                    interactive=False,
+                    elem_classes=["input-container"]
+                )
+            
+            # Chat Tab
+            with gr.TabItem("💬 Chat", elem_classes=["tab-nav"]):
+                gr.HTML("""
+                <div class="chat-card">
+                    <h3>🗨️ Ask Questions</h3>
+                    <p>Ask questions about your uploaded documents. The AI will provide answers based on the document content.</p>
+                </div>
+                """)
+                
+                chatbot = gr.Chatbot(
+                    label="Conversation",
+                    height=400,
+                    elem_classes=["chat-container"]
+                )
+                
+                with gr.Row():
+                    query_input = gr.Textbox(
+                        label="Your Question",
+                        placeholder="What are the key findings in the document?",
+                        elem_classes=["input-container"]
+                    )
+                    ask_button = gr.Button(
+                        "Ask", 
+                        variant="primary",
+                        elem_classes=["primary-button"]
+                    )
+                
+                gr.Examples(
+                    examples=[
+                        "What are the main topics covered in the documents?",
+                        "Can you summarize the key findings?",
+                        "What are the important metrics mentioned?",
+                        "What recommendations are provided?",
+                    ],
+                    inputs=query_input,
+                    label="Example Questions"
+                )
+            
+            # Architecture Tab
+            with gr.TabItem("🏗️ Architecture", elem_classes=["tab-nav"]):
+                gr.HTML("""
+                <div class="architecture-container">
+                    <h3>🏛️ System Architecture</h3>
+                    <p>This system uses an agentic architecture with Model Context Protocol (MCP) for inter-agent communication.</p>
+                </div>
+                """)
+                
+                gr.Markdown("""
+                ## 🔄 Agent Flow Diagram
+                
+                ```
+                User Upload → CoordinatorAgent → IngestionAgent → RetrievalAgent → LLMResponseAgent
+                     ↓              ↓                ↓               ↓              ↓
+                 Documents    MCP Messages    Text Chunks    Vector Store    Final Response
+                ```
+                
+                ## 🤖 Agent Descriptions
+                
+                - **CoordinatorAgent**: Orchestrates the entire workflow and manages MCP communication
+                - **IngestionAgent**: Parses and preprocesses documents (PDF, DOCX, PPTX, CSV, TXT, MD)
+                - **RetrievalAgent**: Handles embeddings and semantic retrieval using FAISS
+                - **LLMResponseAgent**: Generates final responses using Llama-3.1-8B-Instruct
+                
+                ## 🔗 Tech Stack
+                
+                - **Frontend**: Gradio with custom CSS
+                - **LLM**: Meta Llama-3.1-8B-Instruct (via HuggingFace Inference)
+                - **Embeddings**: sentence-transformers/all-MiniLM-L6-v2
+                - **Vector Store**: FAISS
+                - **Document Processing**: PyPDF2, python-docx, python-pptx, pandas
+                - **Framework**: LangChain for document handling
+                
+                ## 📨 MCP Message Example
+                
+                ```json
+                {
+                  "sender": "RetrievalAgent",
+                  "receiver": "LLMResponseAgent", 
+                  "type": "RETRIEVAL_RESULT",
+                  "trace_id": "rag-457",
+                  "payload": {
+                    "retrieved_context": ["Revenue increased by 25%", "Q1 KPIs exceeded targets"],
+                    "query": "What were the Q1 KPIs?"
+                  },
+                  "timestamp": "2025-07-21T10:30:00Z"
+                }
+                ```
+                """)
+        
+        # Event handlers
+        init_button.click(
+            fn=initialize_app,
+            inputs=[hf_token_input],
+            outputs=[init_status]
+        )
+        
+        upload_button.click(
+            fn=process_files,
+            inputs=[file_upload],
+            outputs=[upload_status]
+        )
+        
+        ask_button.click(
+            fn=answer_question,
+            inputs=[query_input, chatbot],
+            outputs=[chatbot]
+        )
+        
+        query_input.submit(
+            fn=answer_question,
+            inputs=[query_input, chatbot],
+            outputs=[chatbot]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_api=False
+    )