Merge branch 'main' of https://github.com/Yugansh5013/resources-ai-chatbot-plugin into feature/context-aware-UI

Author: Yugansh5013

chatbot-core/api/routes/chatbot.py

@@ -26,6 +26,7 @@
     UploadFile,
     File,
     Form,
+    BackgroundTasks
 )
 
 # =========================
@@ -45,8 +46,9 @@
 )
 from api.services.memory import (
     delete_session,
-    init_session,
     session_exists,
+    persist_session,
+    init_session,
 )
 from api.services.file_service import (
     process_uploaded_file,
@@ -82,7 +84,7 @@
 async def chatbot_stream(websocket: WebSocket, session_id: str):
     """
     WebSocket endpoint for real-time token streaming.
-    
+
     Accepts WebSocket connections and streams chatbot responses
     token-by-token for a more interactive user experience.
     """
@@ -153,7 +155,7 @@ async def chatbot_stream(websocket: WebSocket, session_id: str):
 def start_chat(response: Response):
     """
     Create a new chat session.
-    
+
     Returns a unique session ID that can be used for subsequent
     chatbot interactions.
     """
@@ -163,15 +165,14 @@ def start_chat(response: Response):
     )
     return SessionResponse(session_id=session_id)
 
-
 @router.delete(
     "/sessions/{session_id}",
     response_model=DeleteResponse,
 )
 def delete_chat(session_id: str):
     """
     Delete an existing chat session.
-    
+
     Removes all conversation history and resources associated
     with the specified session.
     """
@@ -186,14 +187,10 @@ def delete_chat(session_id: str):
     )
 
 
-# =========================
-# Chat Endpoints
-# =========================
-@router.post(
-    "/sessions/{session_id}/message",
-    response_model=ChatResponse,
-)
-def chatbot_reply(session_id: str, request: ChatRequest):
+# Chat Endpoint
+@router.post("/sessions/{session_id}/message", response_model=ChatResponse)
+def chatbot_reply(session_id: str, request: ChatRequest, _background_tasks: BackgroundTasks):
+
     """
     POST endpoint to handle chatbot replies.
 
@@ -212,11 +209,13 @@ def chatbot_reply(session_id: str, request: ChatRequest):
             status_code=404,
             detail="Session not found.",
         )
-
-    return get_chatbot_reply(
+    reply =  get_chatbot_reply(session_id, request.message)
+    _background_tasks.add_task(
+        persist_session,
         session_id,
-        request.message,
-    )
+        )
+
+    return reply
 
 
 @router.post(

chatbot-core/api/services/memory.py

@@ -8,17 +8,25 @@
 from threading import Lock
 from langchain.memory import ConversationBufferMemory
 from api.config.loader import CONFIG
-
+from api.services.sessionmanager import(
+    delete_session_file,
+    load_session,
+    session_exists_in_json,
+    append_message
+)
 # sessionId --> {"memory": ConversationBufferMemory, "last_accessed": datetime}
+
+
 _sessions = {}
 _lock = Lock()
 
+
 def init_session() -> str:
     """
     Initialize a new chat session and store its memory object.
 
     Returns:
-        str: A newly generated UUID representing the session ID.
+    str: A newly generated UUID representing the session ID.
     """
     session_id = str(uuid.uuid4())
     with _lock:
@@ -28,54 +36,99 @@ def init_session() -> str:
         }
     return session_id
 
+
 def get_session(session_id: str) -> ConversationBufferMemory | None:
     """
-    Retrieve the conversation memory for a given session ID.
+    Retrieve the chat session memory for the given session ID.
+    Lazily restores from disk if missing in memory.
 
     Args:
         session_id (str): The session identifier.
 
     Returns:
         ConversationBufferMemory | None: The memory object if found, else None.
     """
+
     with _lock:
+
         session_data = _sessions.get(session_id)
-        if session_data:
-            # Update last accessed timestamp
+
+        if session_data :
             session_data["last_accessed"] = datetime.now()
             return session_data["memory"]
-    return None
 
-def delete_session(session_id: str) -> bool:
+        history = load_session(session_id)
+        if not history:
+            return None
+
+        memory = ConversationBufferMemory(return_messages=True)
+        for msg in history:
+            memory.chat_memory.add_message(# pylint: disable=no-member
+                {
+                    "role": msg["role"],
+                    "content": msg["content"],
+                }
+            )
+
+        _sessions[session_id] = {
+            "memory": memory,
+            "last_accessed": datetime.now()
+        }
+
+        return memory
+
+
+def persist_session(session_id: str)-> None:
     """
-    Delete an existing chat session and its memory.
+    Persist the current session messages to disk.
 
     Args:
         session_id (str): The session identifier.
+    """
+    session_data = get_session(session_id)
+    if session_data:
+        messages = list(session_data.chat_memory.messages)
+        append_message(session_id, messages)
+
+
+
+def delete_session(session_id: str) -> bool:
+    """
+    Delete a chat session and its persisted data.
+
+    Args:
+    session_id (str): The session identifier.
 
     Returns:
         bool: True if the session existed and was deleted, False otherwise.
     """
     with _lock:
-        deleted = _sessions.pop(session_id, None) is not None
-    return deleted
+        if session_id is None:
+            return True
+        in_memory_deleted = _sessions.pop(session_id, None) is not None
+
+    if in_memory_deleted:
+        delete_session_file(session_id)
+
+    return in_memory_deleted
+
 
 def session_exists(session_id: str) -> bool:
     """
-    Check if a chat session with the given ID exists.
+    Check if a chat session exists in memory.
 
     Args:
-        session_id (str): The session identifier.
+    session_id (str): The session identifier.
 
     Returns:
         bool: True if the session exists, False otherwise.
     """
     with _lock:
-        exists = session_id in _sessions
-    return exists
+        return session_id in _sessions
+
 
 def reset_sessions():
-    """Helper fucntion to clear all sessions. Useful for testing."""
+    """Helper function to clear all sessions. Useful for testing."""
     with _lock:
         _sessions.clear()
 
@@ -91,9 +144,15 @@ def get_last_accessed(session_id: str) -> datetime | None:
     """
     with _lock:
         session_data = _sessions.get(session_id)
-        if session_data:
+        if session_data is not None:
             return session_data["last_accessed"]
-    return None
+
+        history = load_session(session_id)
+        if not history:
+            return None
+
+
+    return history["last_accessed"]
 
 def set_last_accessed(session_id: str, timestamp: datetime) -> bool:
     """
@@ -111,6 +170,14 @@ def set_last_accessed(session_id: str, timestamp: datetime) -> bool:
         if session_data:
             session_data["last_accessed"] = timestamp
             return True
+
+        history = load_session(session_id)
+        if not history:
+            return False
+
+        history["last_accessed"] = timestamp
+        return True
+
     return False
 
 def get_session_count() -> int:
@@ -142,6 +209,8 @@ def cleanup_expired_sessions() -> int:
         ]
 
         for session_id in expired_session_ids:
-            del _sessions[session_id]
+            in_memory_deleted = _sessions.pop(session_id, None) is not None
+            if in_memory_deleted and session_exists_in_json(session_id):
+                delete_session_file(session_id)
 
     return len(expired_session_ids)

chatbot-core/api/services/sessionmanager.py

@@ -0,0 +1,95 @@
+"""Session management utilities."""
+import os
+import json
+import uuid
+from threading import Lock
+
+
+
+_SESSION_DIRECTORY = os.getenv("SESSION_FILE_PATH", "data/sessions")
+
+os.makedirs(_SESSION_DIRECTORY,mode = 0o755, exist_ok=True)
+
+_FILE_LOCK = Lock()
+
+
+def _get_session_file_path(session_id: str) -> str:
+    """
+    Returns the full path for a session file.
+    Example: data/sessions/<session_id>.json
+    """
+
+    try:
+        uuid.UUID(session_id)
+    except ValueError:
+        return ""
+    return os.path.join(_SESSION_DIRECTORY, f"{session_id}.json")
+
+
+def _load_session_from_json(session_id: str) -> list:
+    """
+    Load a session's history from disk.
+    """
+    path = _get_session_file_path(session_id)
+    if not os.path.exists(path):
+        return []
+
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _append_message_to_json(session_id: str, messages:list) -> None:
+    """
+    Persist the current session messages as a full snapshot using atomic write.
+    """
+    path = _get_session_file_path(session_id)
+    if os.path.exists(path):
+        tmp_path = f"{path}.tmp"
+
+        with _FILE_LOCK:
+
+            with open(tmp_path, "w", encoding="utf-8") as f:
+                json.dump(messages, f, indent=2, ensure_ascii=False)
+
+            os.replace(tmp_path, path)
+
+
+
+def _delete_session(session_id: str) -> bool:
+    """
+    Delete the persisted session file.
+    """
+    path = _get_session_file_path(session_id)
+
+    with _FILE_LOCK:
+        if os.path.exists(path):
+            os.remove(path)
+            return True
+    return False
+
+def session_exists_in_json(session_id: str) -> bool:
+    """
+    Check if a session file exists on disk.
+    """
+    path = _get_session_file_path(session_id)
+    return os.path.exists(path)
+
+# Public API functions
+
+def append_message(session_id: str, messages: list) -> None:
+    """
+    Public function to append messages to a session's JSON file.
+    """
+    _append_message_to_json(session_id, messages)
+
+def load_session(session_id: str) -> list:
+    """
+    Public function to load a session's history from its JSON file.
+    """
+    return _load_session_from_json(session_id)
+
+def delete_session_file(session_id: str) -> bool:
+    """
+    Public function to delete a session's JSON file.
+    """
+    return _delete_session(session_id)