Sync from GitHub Actions

Dockerfile

@@ -21,6 +21,6 @@ ENV GDOWN_CACHE=/tmp/lawverse_data/gdown_cache
 
 COPY . .
 
-EXPOSE 10000
+EXPOSE 7860
 
 CMD ["python", "-m", "api.app"]

Lawverse/agents/__init__.py

@@ -0,0 +1,3 @@
+from Lawverse.agents.graph import AgenticLawverseChain, create_agentic_chain
+
+__all__ = ["AgenticLawverseChain", "create_agentic_chain"]

Lawverse/agents/graph.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+from typing import Any, Dict, Iterable, Optional
+from langgraph.graph import END, StateGraph
+
+from Lawverse.agents.state import AgentState
+from Lawverse.agents.nodes import (
+    answer_generator_node,
+    citation_verifier_node,
+    evidence_grader_node,
+    hybrid_retriever_node,
+    intent_classifier_node,
+    query_rewriter_node,
+    retrieval_planner_node,
+)
+from Lawverse.logger import logging
+
+
+class AgenticLawverseChain:
+    def __init__(self, retriever, llm, use_langgraph: bool = True):
+        self.retriever = retriever
+        self.llm = llm
+        self.use_langgraph = use_langgraph
+        self._compiled_graph = None
+        if use_langgraph:
+            self._compiled_graph = self._try_build_langgraph()
+
+    def _try_build_langgraph(self):
+        try:
+            graph = StateGraph(AgentState)
+            graph.add_node("intent_classifier", lambda s: intent_classifier_node(s, self.llm))
+            graph.add_node("query_rewriter", lambda s: query_rewriter_node(s, self.llm))
+            graph.add_node("retrieval_planner", lambda s: retrieval_planner_node(s, self.llm))
+            graph.add_node("hybrid_retriever", lambda s: hybrid_retriever_node(s, self.retriever))
+            graph.add_node("evidence_grader", lambda s: evidence_grader_node(s, self.llm))
+            graph.add_node("answer_generator", lambda s: answer_generator_node(s, self.llm))
+            graph.add_node("citation_verifier", lambda s: citation_verifier_node(s, self.llm))
+
+            graph.set_entry_point("intent_classifier")
+            graph.add_edge("intent_classifier", "query_rewriter")
+            graph.add_edge("query_rewriter", "retrieval_planner")
+            graph.add_edge("retrieval_planner", "hybrid_retriever")
+            graph.add_edge("hybrid_retriever", "evidence_grader")
+            graph.add_edge("evidence_grader", "answer_generator")
+            graph.add_edge("answer_generator", "citation_verifier")
+            graph.add_edge("citation_verifier", END)
+
+            compiled = graph.compile()
+            logging.info("LangGraph agent workflow compiled successfully.")
+            return compiled
+        
+        except Exception as e:
+            logging.warning(f"LangGraph is unavailable or failed to compile; using fallback sequential graph. Error: {e}")
+            return None
+
+    def _run_fallback_graph(self, state: AgentState) -> AgentState:
+        state = intent_classifier_node(state, self.llm)
+        state = query_rewriter_node(state, self.llm)
+        state = retrieval_planner_node(state, self.llm)
+        state = hybrid_retriever_node(state, self.retriever)
+        state = evidence_grader_node(state, self.llm)
+        state = answer_generator_node(state, self.llm)
+        state = citation_verifier_node(state, self.llm)
+        return state
+
+    def invoke(self, inputs: Dict[str, Any], config: Optional[dict] = None) -> str:
+        state: AgentState = {
+            "input": inputs.get("input", ""),
+            "chat_history": inputs.get("chat_history", []),
+        }
+
+        if self._compiled_graph is not None:
+            output_state = self._compiled_graph.invoke(state, config=config)
+        else:
+            output_state = self._run_fallback_graph(state)
+
+        return output_state.get("final_answer") or output_state.get("draft_answer") or ""
+
+    def stream(self, inputs: Dict[str, Any], config: Optional[dict] = None) -> Iterable[str]:
+        answer = self.invoke(inputs, config=config)
+        chunk_size = 80
+        for i in range(0, len(answer), chunk_size):
+            yield answer[i:i + chunk_size]
+
+
+def create_agentic_chain(components, llm, use_langgraph: bool = True) -> AgenticLawverseChain:
+    retriever = components["retriever"]
+    return AgenticLawverseChain(retriever=retriever, llm=llm, use_langgraph=use_langgraph)

Lawverse/agents/nodes.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+from typing import Any, List
+from langchain_core.documents import Document
+from Lawverse.agents.state import AgentState
+from Lawverse.agents.prompts import QUERY_REWRITE_PROMPT, EVIDENCE_GRADER_PROMPT, ANSWER_GENERATION_PROMPT
+from Lawverse.agents.tools import (
+    build_source,
+    format_docs_for_prompt,
+    lexical_evidence_score,
+    retrieve_with_hybrid_tool
+)
+from Lawverse.guardrails.answer_policy import (
+    CLOSING_RESPONSE,
+    GREETING_RESPONSE,
+    INSUFFICIENT_EVIDENCE_RESPONSE,
+    NON_LEGAL_RESPONSE,
+    classify_simple_intent   
+)
+from Lawverse.guardrails.legal_disclaimer import append_legal_disclaimer
+from Lawverse.logger import logging
+
+
+def _content_from_llm_response(response: Any) -> str:
+    if response is None:
+        return ""
+    if hasattr(response, "content"):
+        return str(response.content)
+    return str(response)
+
+
+def _history_to_text(chat_history: List[Any], max_items: int = 6) -> str:
+    if not chat_history:
+        return "No previous chat history."
+    items = []
+    for msg in chat_history[-max_items:]:
+        role = msg.__class__.__name__.replace("Message", "")
+        content = getattr(msg, "content", str(msg))
+        items.append(f"{role}: {content}")
+    return "\n".join(items)
+
+
+def intent_classifier_node(state: AgentState, llm=None) -> AgentState:
+    user_input = state.get("input", "")
+    intent, reason = classify_simple_intent(user_input)
+    state["intent"] = intent
+    state["intent_reason"] = reason
+    logging.info(f"Agent intent classified as {intent}: {reason}")
+    return state
+
+
+
+def query_rewriter_node(state: AgentState, llm=None) -> AgentState:
+    question = state.get("input", "")
+    if state.get("intent") != "legal_question":
+        state["standalone_query"] = question
+        return state
+
+    try:
+        prompt = QUERY_REWRITE_PROMPT.format(
+            chat_history=_history_to_text(state.get("chat_history", [])),
+            question=question,
+        )
+        rewritten = _content_from_llm_response(llm.invoke(prompt)).strip() if llm else question
+        state["standalone_query"] = rewritten or question
+    except Exception as e:
+        logging.warning(f"Query rewrite failed; falling back to original query. Error: {e}")
+        state["standalone_query"] = question
+
+    return state
+
+
+def retrieval_planner_node(state: AgentState, llm=None) -> AgentState:
+    if state.get("intent") != "legal_question":
+        state["retrieval_plan"] = "no_retrieval"
+    else:
+        state["retrieval_plan"] = "hybrid_dense_sparse_rerank"
+    return state
+
+
+def hybrid_retriever_node(state: AgentState, retriever=None) -> AgentState:
+    if state.get("retrieval_plan") == "no_retrieval":
+        state["retrieved_docs"] = []
+        return state
+
+    query = state.get("standalone_query") or state.get("input", "")
+    try:
+        docs = retrieve_with_hybrid_tool(retriever, query, top_k=5)
+        state["retrieved_docs"] = docs
+        state["sources"] = build_source(docs)
+    except Exception as e:
+        logging.error(f"Agent retrieval failed: {e}")
+        state["retrieved_docs"] = []
+        state["sources"] = []
+        state["error"] = str(e)
+    return state
+
+
+
+def evidence_grader_node(state: AgentState, llm=None) -> AgentState:
+    docs: List[Document] = state.get("retrieved_docs", []) or []
+    question = state.get("standalone_query") or state.get("input", "")
+
+    if state.get("intent") != "legal_question":
+        state["has_enough_evidence"] = False
+        state["evidence_score"] = 0.0
+        state["evidence_reason"] = "No legal retrieval required."
+        return state
+
+    score = lexical_evidence_score(question, docs)
+    state["evidence_score"] = score
+
+    if not docs:
+        state["has_enough_evidence"] = False
+        state["evidence_reason"] = "No retrieved documents."
+        return state
+
+    try:
+        context = format_docs_for_prompt(docs, max_chars=5000)
+        prompt = EVIDENCE_GRADER_PROMPT.format(question=question, context=context)
+        grade = _content_from_llm_response(llm.invoke(prompt)).strip() if llm else ""
+        lower = grade.lower()
+        if lower.startswith("sufficient"):
+            state["has_enough_evidence"] = True
+            state["evidence_reason"] = grade
+            return state
+        if lower.startswith("insufficient"):
+            state["has_enough_evidence"] = score >= 0.45
+            state["evidence_reason"] = grade
+            return state
+    except Exception as e:
+        logging.warning(f"LLM evidence grading failed; using lexical score. Error: {e}")
+
+    state["has_enough_evidence"] = score >= 0.25
+    state["evidence_reason"] = f"Lexical evidence score={score}."
+    return state
+
+
+def answer_generator_node(state: AgentState, llm=None) -> AgentState:
+    intent = state.get("intent")
+
+    if intent == "greeting":
+        state["draft_answer"] = GREETING_RESPONSE
+        return state
+    if intent == "closing":
+        state["draft_answer"] = CLOSING_RESPONSE
+        return state
+    if intent in {"non_legal", "empty"}:
+        state["draft_answer"] = NON_LEGAL_RESPONSE
+        return state
+    if not state.get("has_enough_evidence"):
+        state["draft_answer"] = INSUFFICIENT_EVIDENCE_RESPONSE
+        return state
+
+    docs = state.get("retrieved_docs", []) or []
+    context = format_docs_for_prompt(docs)
+    question = state.get("input", "")
+
+    try:
+        prompt = ANSWER_GENERATION_PROMPT.format(question=question, context=context)
+        answer = _content_from_llm_response(llm.invoke(prompt)).strip() if llm else ""
+        state["draft_answer"] = answer or INSUFFICIENT_EVIDENCE_RESPONSE
+    except Exception as e:
+        logging.error(f"Answer generation failed: {e}")
+        state["draft_answer"] = INSUFFICIENT_EVIDENCE_RESPONSE
+        state["error"] = str(e)
+
+    return state
+
+
+def citation_verifier_node(state: AgentState, llm=None) -> AgentState:
+    answer = state.get("draft_answer", "") or ""
+    docs = state.get("retrieved_docs", []) or []
+    issues = []
+
+    if state.get("intent") == "legal_question" and state.get("has_enough_evidence"):
+        if "### Sources" not in answer:
+            issues.append("Answer did not include a Sources section; sources were appended automatically.")
+            sources = build_source(docs)
+            source_lines = []
+            for src in sources:
+                source_lines.append(
+                    f"- Source {src['rank']}: {src['source']} | Page: {src['page']} | "
+                    f"Chunk: {src['chunk_id']} | Score: {src['score']}"
+                )
+            answer = f"{answer}\n\n### Sources\n" + "\n".join(source_lines)
+
+    state["citation_issues"] = issues
+    state["citation_check_passed"] = len(issues) == 0
+    state["final_answer"] = append_legal_disclaimer(answer)
+    return state

Lawverse/agents/prompts.py

@@ -0,0 +1,50 @@
+QUERY_REWRITE_PROMPT = """
+You are a legal retrieval query rewriter for Bangladeshi legal documents.
+Rewrite the latest user question into a standalone search query.
+Keep legal keywords, section names, act names, and important facts.
+Do not answer the question.
+
+Chat history summary:
+{chat_history}
+
+User question:
+{question}
+
+Standalone retrieval query:
+"""
+
+EVIDENCE_GRADER_PROMPT = """
+You are checking whether retrieved legal context is sufficient for answering a user question.
+Return only one of these two labels followed by a short reason:
+- SUFFICIENT: reason
+- INSUFFICIENT: reason
+
+Question:
+{question}
+
+Retrieved context:
+{context}
+"""
+
+ANSWER_GENERATION_PROMPT = """
+You are Lawverse, an educational legal document intelligence assistant for Bangladeshi legal documents.
+
+BOUNDARIES:
+- You provide legal information from retrieved documents, not professional legal advice.
+- Answer only from the retrieved context.
+- Do not invent laws, sections, document names, citations, page numbers, or facts.
+- If the retrieved context is insufficient, say that the provided documents do not contain sufficient information.
+
+User question:
+{question}
+
+Retrieved context:
+{context}
+
+Required output format:
+### Answer
+Clear answer based only on the retrieved context.
+
+### Sources
+List sources used. Include document/source name, page if available, chunk id if available, and why it supports the answer.
+"""

Lawverse/agents/state.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from typing import Any, Dict, List, Optional, TypedDict
+from langchain_core.documents import Document
+
+
+class AgentState(TypedDict, total=False):
+    input: str
+    chat_history: List[Any]
+    
+    intent: str
+    intent_reason: str
+    standalone_query: str
+    retrieval_plan: str
+    
+    retrieved_docs: List[Document]
+    evidence_score: float
+    has_enough_evidence: bool
+    evidence_reason: str
+    
+    draft_answer: str
+    final_answer: str
+    sources: List[Dict[str, Any]]
+    citation_check_passed: bool
+    citation_issues: List[str]
+
+    error: Optional[str]

Lawverse/agents/tools.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from typing import Dict, Any, List
+from langchain_core.documents import Document
+
+
+def retrieve_with_hybrid_tool(retriever, query: str, top_k: int = 5) -> List[Document]:
+    if retriever is None:
+        return None
+    
+    try:
+        docs = retriever.invoke(query)
+    except Exception:
+        try:
+            docs = retriever.get_relevant_documents(query)
+        except Exception:
+            docs = retriever._get_relevant_documents(query)
+
+    return list(docs or [])[:top_k]
+
+
+def document_to_source(doc: Document, rank: int | None=None) -> Dict[str, Any]:
+    metadata = dict(doc.metadata or {})
+    
+    return {
+        "rank": rank or metadata.get("rank"),
+        "source": metadata.get("source", "unknown"),
+        "page": metadata.get("page_label", metadata.get("page", "unknown")),
+        "chunk_id": metadata.get("chunk_id", "unknown"),
+        "score": metadata.get("score", metadata.get("rrf_score", "unknown")),
+        "retriever": metadata.get("retriever", "hybrid"),
+        "preview": (doc.page_content or "")[:350].replace("\n", " "),
+    }
+    
+
+def format_docs_for_prompt(docs: List[Document], max_chars: int = 7000) -> str:
+    blocks = []
+    total = 0
+    for idx, doc in enumerate(docs or [], 1):
+        source = document_to_source(doc, rank=idx)
+        text = doc.page_content or ""
+        block = (
+            f"[Source {idx}: {source['source']} | Page: {source['page']} | "
+            f"Chunk: {source['chunk_id']} | Score: {source['score']}]\n{text}"
+        )
+        if total + len(block) > max_chars:
+            break
+        blocks.append(block)
+        total += len(block)
+    return "\n\n---\n\n".join(blocks)
+
+
+def build_source(docs: List[Document]) -> List[Dict[str, Any]]:
+    return [document_to_source(doc, rank=i) for i, doc in enumerate(docs or [], 1)]
+
+
+def lexical_evidence_score(question: str, docs: List[Document]) -> float:
+    if not question or not docs:
+        return 0.0
+
+    stop = {
+        "the", "a", "an", "and", "or", "to", "of", "in", "for", "is", "are", "am", "i",
+        "what", "how", "why", "when", "can", "could", "should", "me", "my", "about",
+    }
+    q_words = {w.strip(".,?!;:()[]{}'\"").lower() for w in question.split()}
+    q_words = {w for w in q_words if len(w) > 2 and w not in stop}
+    if not q_words:
+        return 0.0
+
+    context = " ".join((doc.page_content or "") for doc in docs).lower()
+    hits = sum(1 for w in q_words if w in context)
+    return round(hits / max(len(q_words), 1), 4)

Lawverse/guardrails/__init__.py

@@ -0,0 +1,3 @@
+from Lawverse.guardrails.legal_disclaimer import LEGAL_DISCLAIMER, append_legal_disclaimer
+
+__all__ = ["LEGAL_DISCLAIMER", "append_legal_disclaimer"]

Lawverse/guardrails/answer_policy.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from typing import Iterable
+from langchain_core.documents import Document
+
+INSUFFICIENT_EVIDENCE_RESPONSE = (
+    "### Answer\n"
+    "The provided documents do not contain sufficient information to answer this question safely.\n\n"
+    "### Sources\n"
+    "No sufficiently relevant source was found in the indexed documents."
+)
+
+NON_LEGAL_RESPONSE = (
+    "### Answer\n"
+    "I'm designed to assist with Bangladeshi legal document questions. "
+    "Please ask a legal question or upload/provide legal context."
+)
+
+GREETING_RESPONSE = (
+    "### Answer\n"
+    "Hello! I can help you ask questions about Bangladeshi legal documents and show sources from the retrieved context."
+)
+
+CLOSING_RESPONSE = (
+    "### Answer\n"
+    "You're welcome. Ask another legal-document question whenever you need help."
+)
+
+
+LEGAL_KEYWORDS = {
+    "law", "legal", "court", "case", "act", "section", "rule", "rights", "contract",
+    "agreement", "crime", "criminal", "civil", "penalty", "bail", "appeal", "property",
+    "labour", "labor", "worker", "employee", "employer", "termination", "notice", "salary",
+    "wage", "rent", "tax", "company", "constitution", "ordinance", "বাংলাদেশ", "আইন",
+    "ধারা", "আদালত", "মামলা", "অধিকার", "শ্রম", "চুক্তি", "জামিন", "অপরাধ",
+}
+
+GREETING_WORDS = {"hi", "hello", "hey", "assalamu", "salam", "হাই", "হ্যালো", "সালাম"}
+CLOSING_WORDS = {"thanks", "thank you", "bye", "goodbye", "ধন্যবাদ", "আচ্ছা", "বিদায়"}
+
+
+def classify_simple_intent(text: str) -> tuple[str, str]:
+    clean = (text or "").strip().lower()
+    if not clean:
+        return "empty", "Empty user input."
+
+    token_hits = [kw for kw in LEGAL_KEYWORDS if kw in clean]
+    if any(word in clean for word in GREETING_WORDS) and len(clean.split()) <= 8:
+        return "greeting", "Short greeting detected."
+    if any(word in clean for word in CLOSING_WORDS) and len(clean.split()) <= 10:
+        return "closing", "Short closing/thanks message detected."
+    if token_hits:
+        return "legal_question", f"Legal keywords detected: {', '.join(token_hits[:5])}."
+
+    if len(clean.split()) >= 8:
+        return "legal_question", "Long-form question; routed to retrieval for evidence check."
+
+    return "non_legal", "No legal intent signal detected."
+
+def has_documents(docs: Iterable[Document]) -> bool:
+    return bool(list(docs or []))

Lawverse/guardrails/legal_disclaimer.py

@@ -0,0 +1,14 @@
+LEGAL_DISCLAIMER = (
+    "Lawverse is an educational legal information assistant. "
+    "It is not a substitute for a licensed lawyer."
+)
+
+def append_legal_disclaimer(answer: str) -> str:
+    answer = (answer or "").strip()
+    if not answer:
+        return f"### Legal Disclaimer\n{LEGAL_DISCLAIMER}"
+
+    if "not a substitute for a licensed lawyer" in answer.lower():
+        return answer
+
+    return f"{answer}\n\n### Legal Disclaimer\n{LEGAL_DISCLAIMER}"

api/app.py

@@ -1,8 +1,11 @@
-from Lawverse.pipeline.rag_pipeline import rag_components, create_chat_chain
 from flask import Flask, render_template, request, jsonify, session, stream_with_context, Response
+from Lawverse.pipeline.rag_pipeline import rag_components
+from Lawverse.pipeline.llm_loader import llm
+from Lawverse.memory.langchain_memory import ChatMemory
 from Lawverse.utils.config import MEMORY_DIR
 from Lawverse.logger import logging
 from Lawverse.monitoring.dashboard import monitor_bp
+from Lawverse.agents.graph import create_agentic_chain
 from api.auth import auth_bp, login_required
 from api.models import db
 from api.admin import admin
@@ -27,9 +30,32 @@ app.register_blueprint(monitor_bp)
 with app.app_context():
     db.create_all()
 
-BASE_COMPONENTS = rag_components()
+BASE_COMPONENTS = None
 active_chains = {}
 
+
+def get_base_components():
+    global BASE_COMPONENTS
+
+    if BASE_COMPONENTS is None:
+        logging.info("Loading Lawverse RAG base components...")
+        BASE_COMPONENTS = rag_components()
+        logging.info("Lawverse RAG base components loaded successfully.")
+
+    return BASE_COMPONENTS
+
+
+def create_agent_session(chat_id=None):
+    components = get_base_components()
+    chain = create_agentic_chain(components, llm)
+    memory_manager = ChatMemory(chat_id=chat_id)
+
+    active_chains[memory_manager.chat_id] = (chain, memory_manager)
+    session["chat_id"] = memory_manager.chat_id
+    memory_manager.save_memory()
+
+    return chain, memory_manager
+
 @app.route("/", methods=["GET"])
 def home():
     return render_template("index.html")
@@ -39,21 +65,19 @@ def home():
 def chat():
     chat_id = session.get("chat_id")
     if not chat_id or chat_id not in active_chains:
-        chain, memory_manager = create_chat_chain(BASE_COMPONENTS)
-        active_chains[memory_manager.chat_id] = (chain, memory_manager)
-        session["chat_id"] = memory_manager.chat_id
-        memory_manager.save_memory()
-
+        create_agent_session()
+        
     return render_template("chat.html")
 
 @app.route("/new_chat", methods=["POST"])
 @login_required
 def new_chat():
-    chain, memory_manager = create_chat_chain(BASE_COMPONENTS)
-    active_chains[memory_manager.chat_id] = (chain, memory_manager)
-    session["chat_id"] = memory_manager.chat_id
-    memory_manager.save_memory()
-    return jsonify({"chat_id": memory_manager.chat_id, "title": memory_manager._get_title()})
+    _, memory_manager = create_agent_session()
+
+    return jsonify({
+        "chat_id": memory_manager.chat_id,
+        "title": memory_manager._get_title()
+    })
 
 
 @app.route("/response", methods=["POST"])
@@ -62,15 +86,13 @@ def rag_response():
     try:
         chat_id = session.get("chat_id")
         if not chat_id or chat_id not in active_chains:
-            chain, memory_manager = create_chat_chain(BASE_COMPONENTS)
-            active_chains[memory_manager.chat_id] = (chain, memory_manager)
-            session["chat_id"] = memory_manager.chat_id
+            _, memory_manager = create_agent_session()
             chat_id = memory_manager.chat_id
 
         qa, memory_manager = active_chains[chat_id]
-
         data = request.get_json(silent=True) or {}
         query = data.get("message", "").strip()
+
         if not query:
             return jsonify({"error": "Empty message"}), 400
 
@@ -105,19 +127,23 @@ def rag_response():
 def get_chats():
     chats = []
     user_id = session.get("user_id")
-
+    os.makedirs(MEMORY_DIR, exist_ok=True)
     for file_path in glob.glob(f"{MEMORY_DIR}/*.json"):
-        with open(file_path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-
-        if data.get("user_id") == user_id:
-            chats.append({
-                "chat_id": data.get("chat_id"),
-                "last_updated": data.get("last_updated"),
-                "title": data.get("title", f"Chat-{data.get('chat_id')}")
-            })
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            if data.get("user_id") == user_id:
+                chats.append({
+                    "chat_id": data.get("chat_id"),
+                    "last_updated": data.get("last_updated"),
+                    "title": data.get("title", f"Chat-{data.get('chat_id')}")
+                })
 
-    chats.sort(key=lambda x: x.get("last_updated", x["chat_id"]), reverse=True)
+        except Exception as e:
+            logging.warning(f"Skipping unreadable memory file {file_path}: {e}")
+
+    chats.sort(key=lambda x: x.get("last_updated") or x.get("chat_id"), reverse=True)
     return jsonify(chats)
 
 
@@ -129,9 +155,7 @@ def load_chat(chat_id):
     if not os.path.exists(memory_path):
         return jsonify({"error": "Chat not found"}), 404
 
-    chain, memory_manager = create_chat_chain(BASE_COMPONENTS, chat_id=chat_id)
-    active_chains[memory_manager.chat_id] = (chain, memory_manager)
-    session["chat_id"] = memory_manager.chat_id
+    _, memory_manager = create_agent_session(chat_id=chat_id)
 
     messages_list = memory_manager.memory.chat_memory.messages
     messages = []
@@ -140,7 +164,10 @@ def load_chat(chat_id):
         user_msg = messages_list[i].content if i < len(messages_list) else None
         ai_msg = messages_list[i + 1].content if i + 1 < len(messages_list) else ""
         if user_msg:
-            messages.append({"user": user_msg, "ai": ai_msg})
+            messages.append({
+                "user": user_msg,
+                "ai": ai_msg
+            })
 
     return jsonify({
         "chat_id": chat_id,
@@ -164,7 +191,13 @@ def delete_chat(chat_id):
         if was_active:
             del active_chains[chat_id]
 
-        return jsonify({"success": True, "was_active": was_active}), 200
+        if session.get("chat_id") == chat_id:
+            session.pop("chat_id", None)
+
+        return jsonify({
+            "success": True,
+            "was_active": was_active
+        }), 200
 
     except Exception as e:
         logging.error(f"Error deleting chat {chat_id}: {e}")

template.py

@@ -31,6 +31,17 @@ list_of_files = [
     
     f"{project_name}/monitoring/dashboard.py",
     
+    f"{project_name}/agents/__init__.py",
+    f"{project_name}/agents/state.py",
+    f"{project_name}/agents/prompts.py",
+    f"{project_name}/agents/tools.py",
+    f"{project_name}/agents/nodes.py",
+    f"{project_name}/agents/graph.py",
+    
+    f"{project_name}/guardrails/__init__.py",
+    f"{project_name}/guardrails/legal_disclaimer.py",
+    f"{project_name}/guardrails/answer_policy.py",
+    
     ".github/workflows/to_hf.yml",
     
     "api/admin.py",

templates/index.html

@@ -369,9 +369,6 @@
           <a href="https://www.linkedin.com/in/mohsin416/" target="_blank" class="text-gray-400 hover:text-cyan-300 transition"
             ><i data-feather="linkedin"></i
           ></a>
-          <a href="siam.mohsin2005@gmail.com" class="text-gray-400 hover:text-purple-300 transition"
-            ><i data-feather="mail"></i
-          ></a>
           <a href="https://www.facebook.com/mohsin.siam6" target="_blank" class="text-gray-400 hover:text-blue-300 transition"
             ><i data-feather="facebook"></i
           ></a>