Upload folder using huggingface_hub

app.py

@@ -154,11 +154,18 @@ def process_files(files):
     return "\n".join(messages), get_stats_text()
 
 
-def answer_question(question, top_k, chat_history):
-    """Answer a question with production-grade error handling."""
+def answer_question(question, top_k, chat_history, session_id):
+    """Answer a question with session-based conversation history."""
+    from src.session import get_session_manager
+    session_mgr = get_session_manager()
+    
+    # Create session if needed
+    if not session_id:
+        session_id = session_mgr.create_session()
+    
     # Input validation
     if not question or not question.strip():
-        return chat_history, ""
+        return chat_history, "", session_id
     
     question = question.strip()
     
@@ -167,7 +174,7 @@ def answer_question(question, top_k, chat_history):
     if len(question) > MAX_QUESTION_LENGTH:
         response = f"⚠️ Your question is too long ({len(question)} chars). Please keep it under {MAX_QUESTION_LENGTH} characters."
         chat_history.append((question[:100] + "...", response))
-        return chat_history, ""
+        return chat_history, "", session_id
     
     try:
         pipe = get_pipeline()
@@ -180,7 +187,8 @@ def answer_question(question, top_k, chat_history):
             )
         else:
             try:
-                result = pipe.query(question, top_k=int(top_k))
+                # Pass session_id for conversation history
+                result = pipe.query(question, top_k=int(top_k), session_id=session_id)
                 response = result.get("answer", "I couldn't generate a response. Please try again.")
                 
                 # Add sources if available
@@ -188,6 +196,9 @@ def answer_question(question, top_k, chat_history):
                 if sources:
                     unique_sources = list(set(s.get("filename", "Unknown") for s in sources))
                     response += f"\n\n---\n📚 *Sources: {', '.join(unique_sources)}*"
+                
+                # Store in session history
+                session_mgr.add_message(session_id, question, response)
                     
             except Exception as e:
                 logger.error(f"Query error: {e}")
@@ -203,7 +214,7 @@ def answer_question(question, top_k, chat_history):
         response = "⚠️ The system is temporarily unavailable. Please try again in a moment."
     
     chat_history.append((question, response))
-    return chat_history, ""
+    return chat_history, "", session_id
 
 
 def get_stats_text() -> str:
@@ -309,6 +320,9 @@ with gr.Blocks(
             with gr.Row():
                 submit_btn = gr.Button("🔍 Ask", variant="primary", scale=2)
                 clear_chat_btn = gr.Button("🧹 Clear Chat", scale=1)
+        
+        # Hidden state for session management
+        session_id = gr.State(value=None)
     
     # Event handlers
     upload_btn.click(
@@ -319,14 +333,14 @@ with gr.Blocks(
     
     submit_btn.click(
         fn=answer_question,
-        inputs=[question_input, top_k_slider, chatbot],
-        outputs=[chatbot, question_input]
+        inputs=[question_input, top_k_slider, chatbot, session_id],
+        outputs=[chatbot, question_input, session_id]
     )
     
     question_input.submit(
         fn=answer_question,
-        inputs=[question_input, top_k_slider, chatbot],
-        outputs=[chatbot, question_input]
+        inputs=[question_input, top_k_slider, chatbot, session_id],
+        outputs=[chatbot, question_input, session_id]
     )
     
     clear_btn.click(
@@ -334,9 +348,13 @@ with gr.Blocks(
         outputs=[upload_status, stats_display]
     )
     
+    def clear_chat_and_session():
+        """Clear chat history and reset session."""
+        return [], None
+    
     clear_chat_btn.click(
-        fn=lambda: [],
-        outputs=[chatbot]
+        fn=clear_chat_and_session,
+        outputs=[chatbot, session_id]
     )
     
     gr.Markdown("""

src/llm/phi_model.py

@@ -255,14 +255,16 @@ class PhiModel:
         self, 
         query: str, 
         context: str,
-        system_prompt: Optional[str] = None
+        system_prompt: Optional[str] = None,
+        conversation_history: Optional[str] = None
     ) -> str:
-        """Generate response with RAG context.
+        """Generate response with RAG context and conversation history.
         
         Args:
             query: User's question.
             context: Retrieved context from documents.
             system_prompt: Optional system prompt.
+            conversation_history: Optional formatted conversation history (last 6 messages).
             
         Returns:
             Generated response.
@@ -286,13 +288,22 @@ class PhiModel:
         if not context or not context.strip():
             context = "No relevant documents found."
         
-        user_message = f"""Here's some information from the documents:
+        # Build message with optional history
+        history_section = ""
+        if conversation_history and conversation_history.strip():
+            history_section = f"""Previous conversation:
+{conversation_history}
+
+---
+"""
+        
+        user_message = f"""{history_section}Here's some information from the documents:
 
 {context}
 
-User's question: {query}
+User's current question: {query}
 
-Please respond naturally and helpfully:"""
+Please respond naturally and helpfully, considering the conversation context:"""
         
         messages = [
             {"role": "system", "content": system_prompt},
@@ -300,3 +311,4 @@ Please respond naturally and helpfully:"""
         ]
         
         return self.chat(messages)
+

src/rag/pipeline.py

@@ -120,17 +120,18 @@ class RAGPipeline:
         print(f"Adding {len(chunks)} chunks to vector store...")
         return self.vector_store.add_chunks(chunks)
     
-    def query(self, question: str, top_k: Optional[int] = None) -> Dict[str, Any]:
-        """Query the RAG system with semantic caching.
+    def query(self, question: str, top_k: Optional[int] = None, session_id: Optional[str] = None) -> Dict[str, Any]:
+        """Query the RAG system with semantic caching and session history.
         
         Lookup order:
         1. Exact cache match (instant)
         2. Semantic similarity match (instant)
-        3. Model generation (slow)
+        3. Model generation with conversation history (slow)
         
         Args:
             question: User's question.
             top_k: Number of documents to retrieve.
+            session_id: Optional session ID for conversation history.
             
         Returns:
             Dict with answer and sources.
@@ -168,9 +169,20 @@ class RAGPipeline:
             }
         
         # 3. Generate answer using LLM (no cache hit)
+        # Get conversation history if session provided
+        conversation_history = None
+        if session_id:
+            from src.session import get_session_manager
+            session_mgr = get_session_manager()
+            conversation_history = session_mgr.get_history_for_prompt(session_id)
+        
         context = self.retriever.retrieve_text(question, top_k)
         sources = self.retriever.retrieve(question, top_k)
-        answer = self.llm.chat_with_context(question, context)
+        answer = self.llm.chat_with_context(
+            question, 
+            context, 
+            conversation_history=conversation_history
+        )
         
         # Build source list
         source_list = [

src/session.py

@@ -0,0 +1,223 @@
+"""Session management for FreeRAG chat history."""
+
+import json
+import logging
+import threading
+import uuid
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional, Dict, Any, List, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class SessionManager:
+    """Manages user sessions and chat history.
+    
+    Each session is identified by a UUID and stores:
+    - Chat history (question-answer pairs)
+    - Session metadata (created_at, last_active)
+    """
+    
+    def __init__(
+        self,
+        storage_dir: str = "./.cache/sessions",
+        max_history: int = 6,
+        session_ttl_hours: int = 24
+    ):
+        """Initialize session manager.
+        
+        Args:
+            storage_dir: Directory to store session data.
+            max_history: Maximum messages to keep (for context).
+            session_ttl_hours: Session expiry time in hours.
+        """
+        self.storage_dir = Path(storage_dir)
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+        self.max_history = max_history
+        self.session_ttl = timedelta(hours=session_ttl_hours)
+        self._lock = threading.Lock()
+        self._sessions: Dict[str, Dict[str, Any]] = {}
+        
+        # Load existing sessions
+        self._load_sessions()
+        self._cleanup_expired()
+        logger.info(f"📋 Session manager initialized with {len(self._sessions)} active sessions")
+    
+    def create_session(self) -> str:
+        """Create a new session and return its ID."""
+        session_id = str(uuid.uuid4())
+        
+        with self._lock:
+            self._sessions[session_id] = {
+                "id": session_id,
+                "created_at": datetime.now().isoformat(),
+                "last_active": datetime.now().isoformat(),
+                "history": []
+            }
+            self._save_session(session_id)
+        
+        logger.info(f"📝 Created new session: {session_id[:8]}...")
+        return session_id
+    
+    def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get session by ID, creating if doesn't exist."""
+        with self._lock:
+            if session_id not in self._sessions:
+                # Try to load from disk
+                self._load_session(session_id)
+            
+            if session_id in self._sessions:
+                # Update last_active
+                self._sessions[session_id]["last_active"] = datetime.now().isoformat()
+                return self._sessions[session_id]
+        
+        return None
+    
+    def add_message(
+        self, 
+        session_id: str, 
+        question: str, 
+        answer: str
+    ) -> None:
+        """Add a Q&A pair to session history."""
+        with self._lock:
+            if session_id not in self._sessions:
+                self._sessions[session_id] = {
+                    "id": session_id,
+                    "created_at": datetime.now().isoformat(),
+                    "last_active": datetime.now().isoformat(),
+                    "history": []
+                }
+            
+            session = self._sessions[session_id]
+            session["history"].append({
+                "question": question,
+                "answer": answer,
+                "timestamp": datetime.now().isoformat()
+            })
+            
+            # Keep only last N messages
+            if len(session["history"]) > self.max_history * 2:
+                session["history"] = session["history"][-self.max_history:]
+            
+            session["last_active"] = datetime.now().isoformat()
+            self._save_session(session_id)
+    
+    def get_history(self, session_id: str, limit: int = None) -> List[Tuple[str, str]]:
+        """Get chat history for a session.
+        
+        Args:
+            session_id: Session ID.
+            limit: Max messages to return (default: max_history).
+            
+        Returns:
+            List of (question, answer) tuples.
+        """
+        limit = limit or self.max_history
+        session = self.get_session(session_id)
+        
+        if not session:
+            return []
+        
+        history = session.get("history", [])[-limit:]
+        return [(h["question"], h["answer"]) for h in history]
+    
+    def get_history_for_prompt(self, session_id: str) -> str:
+        """Get formatted history for including in prompt.
+        
+        Returns last 6 messages formatted for the model.
+        """
+        history = self.get_history(session_id, self.max_history)
+        
+        if not history:
+            return ""
+        
+        formatted = []
+        for q, a in history:
+            # Truncate long messages
+            q_short = q[:200] + "..." if len(q) > 200 else q
+            a_short = a[:300] + "..." if len(a) > 300 else a
+            formatted.append(f"User: {q_short}\nAssistant: {a_short}")
+        
+        return "\n\n".join(formatted)
+    
+    def clear_history(self, session_id: str) -> None:
+        """Clear chat history for a session."""
+        with self._lock:
+            if session_id in self._sessions:
+                self._sessions[session_id]["history"] = []
+                self._save_session(session_id)
+    
+    def _save_session(self, session_id: str) -> None:
+        """Save session to disk."""
+        try:
+            session_file = self.storage_dir / f"{session_id}.json"
+            with open(session_file, 'w', encoding='utf-8') as f:
+                json.dump(self._sessions[session_id], f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            logger.warning(f"Failed to save session {session_id[:8]}: {e}")
+    
+    def _load_session(self, session_id: str) -> None:
+        """Load session from disk."""
+        try:
+            session_file = self.storage_dir / f"{session_id}.json"
+            if session_file.exists():
+                with open(session_file, 'r', encoding='utf-8') as f:
+                    self._sessions[session_id] = json.load(f)
+        except Exception as e:
+            logger.warning(f"Failed to load session {session_id[:8]}: {e}")
+    
+    def _load_sessions(self) -> None:
+        """Load all sessions from disk."""
+        try:
+            for session_file in self.storage_dir.glob("*.json"):
+                try:
+                    with open(session_file, 'r', encoding='utf-8') as f:
+                        session = json.load(f)
+                        self._sessions[session["id"]] = session
+                except Exception:
+                    pass
+        except Exception as e:
+            logger.warning(f"Failed to load sessions: {e}")
+    
+    def _cleanup_expired(self) -> None:
+        """Remove expired sessions."""
+        now = datetime.now()
+        expired = []
+        
+        for sid, session in self._sessions.items():
+            try:
+                last_active = datetime.fromisoformat(session["last_active"])
+                if now - last_active > self.session_ttl:
+                    expired.append(sid)
+            except Exception:
+                pass
+        
+        for sid in expired:
+            self._delete_session(sid)
+        
+        if expired:
+            logger.info(f"♻️ Cleaned up {len(expired)} expired sessions")
+    
+    def _delete_session(self, session_id: str) -> None:
+        """Delete a session."""
+        with self._lock:
+            if session_id in self._sessions:
+                del self._sessions[session_id]
+            
+            session_file = self.storage_dir / f"{session_id}.json"
+            if session_file.exists():
+                session_file.unlink()
+
+
+# Global session manager
+_session_manager: Optional[SessionManager] = None
+
+
+def get_session_manager() -> SessionManager:
+    """Get or create the global session manager."""
+    global _session_manager
+    if _session_manager is None:
+        _session_manager = SessionManager()
+    return _session_manager