Upload 12 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+uploads/documents/LLM_based_QA_chatbot_builder.pdf filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,28 @@
+# Use an official Python runtime as a parent image
+FROM python:3.11-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y gcc
+
+# Set the working directory to /app
+WORKDIR /app
+
+# Copy the requirements file and install dependencies
+COPY requirements.txt .
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Create necessary directories with appropriate permissions
+RUN mkdir -p /app/cache /app/uploads /app/data /app/chats && chmod -R 777 /app/cache /app/uploads /app/data /app/chats
+RUN chmod -R 777 /app
+
+# Copy the application code
+COPY . .
+
+# Set environment variables
+ENV FLASK_APP=app.py \
+    FLASK_ENV=production 
+
+EXPOSE 7860
+
+# Run the application using Gunicorn
+CMD ["gunicorn", "-k", "eventlet", "-w", "1", "-b", "0.0.0.0:7860", "--timeout", "600", "app:app"]

agent.py

@@ -0,0 +1,711 @@
+#─── Basic imports ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+import os
+import math
+import sqlite3
+import fitz  # PyMuPDF for PDF parsing
+from flask_socketio import SocketIO
+
+# ─── Langchain Frameworks ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+from langchain.tools import Tool
+from langchain.chat_models import ChatOpenAI
+from langchain_groq import ChatGroq
+from langchain_mistralai import ChatMistralAI
+from langchain.agents import initialize_agent, AgentType
+from langchain.schema import Document
+from langchain.chains import RetrievalQA
+from langchain.embeddings import OpenAIEmbeddings
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain.vectorstores import FAISS
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.prompts import PromptTemplate
+from langchain_community.document_loaders import TextLoader, PyMuPDFLoader
+# taking global variables from the app.py file
+#from app import DB_PATH, DOC_PATH, IMG_PATH, OTH_PATH
+
+# ─── File paths ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+import config
+# Ensure this is at the very top
+
+# ─── SQL Agent ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+from langchain_community.utilities import SQLDatabase
+from langchain_community.agent_toolkits import SQLDatabaseToolkit
+from langchain.chat_models import ChatOpenAI
+from langgraph.prebuilt import create_react_agent
+from langchain.agents import create_sql_agent
+
+# ─── Memory ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+from langchain.memory import ConversationBufferMemory
+from langchain.agents import initialize_agent, AgentType
+from langchain.tools import Tool
+from typing import List, Callable
+from langchain.memory import ConversationBufferMemory
+from langchain.schema import BaseMemory, AIMessage, HumanMessage, SystemMessage
+from langchain.llms.base import LLM
+from langchain.memory.chat_memory import BaseChatMemory
+from pydantic import PrivateAttr
+from langchain_core.messages import get_buffer_string
+
+# 1) Create your memory object
+from typing import List
+from langchain.memory import ConversationBufferMemory
+from langchain.schema import AIMessage, HumanMessage, SystemMessage
+from langchain.llms.base import LLM
+from langchain.memory.chat_memory import BaseChatMemory
+from pydantic import PrivateAttr
+
+class AutoSummaryMemory(ConversationBufferMemory):
+    _llm: LLM = PrivateAttr()
+    _max_entries: int = PrivateAttr()
+    _reduce_to: int = PrivateAttr()
+    _summary_system_prompt: str = PrivateAttr()
+
+    def __init__(
+        self,
+        llm: LLM,
+        memory_key: str = "chat_history",
+        return_messages: bool = True,
+        max_entries: int = 20,
+        reduce_to: int = 5,
+        summary_system_prompt: str = (
+            "Summarize the following conversation so far in a concise paragraph. "
+            "Keep important facts and questions."
+        )
+    ):
+        super().__init__(memory_key=memory_key, return_messages=return_messages)
+        self._llm = llm  # PrivateAttr
+        self._max_entries = max_entries  # PrivateAttr
+        self._reduce_to = reduce_to  # PrivateAttr
+        self._summary_system_prompt = summary_system_prompt  # PrivateAttr
+
+    def add_memory(self, inputs: dict, outputs: dict) -> None:
+        # Add the new turn as normal
+        super().add_memory(inputs=inputs, outputs=outputs)
+        
+        # Check if memory length exceeded
+        msgs = self.chat_memory.messages
+        if len(msgs) >= self._max_entries:
+            full_text = "\n".join([f"{m.type}: {m.content}" for m in msgs])
+            summary = self._llm.predict(f"{self._summary_system_prompt}\n\n{full_text}")
+
+            recent = msgs[-self._reduce_to:]
+            self.chat_memory.messages = [
+                SystemMessage(content="Conversation summary: " + summary),
+                *recent
+            ]
+            
+            
+# ─── Image Processing ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+ 
+from PIL import Image
+import pytesseract
+from transformers import pipeline
+from groq import Groq
+import config
+import requests
+from io import BytesIO
+from PIL import Image
+from transformers import pipeline, TrOCRProcessor, VisionEncoderDecoderModel
+from PIL import Image
+import requests
+from io import BytesIO
+import base64
+from PIL import UnidentifiedImageError
+
+# ─── Browser var ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+from typing import List, Dict
+import json
+from io import BytesIO
+from langchain.tools import tool  # or langchain_core.tools
+from playwright.sync_api import sync_playwright
+from duckduckgo_search import DDGS
+from bs4 import BeautifulSoup
+import requests
+
+
+
+from playwright.sync_api import sync_playwright
+# Attempt to import Playwright for dynamic page rendering
+try:
+    from playwright.sync_api import sync_playwright
+    _playwright_available = True
+except ImportError:
+    _playwright_available = False
+
+# Define forbidden keywords for basic NSFW filtering
+_forbidden = ["porn", "sex", "xxx", "nude", "erotic"]
+
+
+# ─── LLM Setup ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+
+# Load OpenAI API key from environment (required for LLM and embeddings)
+import os
+
+# API Keys from .env file
+os.environ.setdefault("OPENAI_API_KEY", "<YOUR_OPENAI_KEY>")  # Set your own key or env var
+os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY", "default_key_or_placeholder")
+os.environ["MISTRAL_API_KEY"] = os.getenv("MISTRAL_API_KEY", "default_key_or_placeholder")
+
+# Tavily API Key
+TAVILY_API_KEY = os.getenv("TAVILY_API_KEY", "default_key_or_placeholder")
+_forbidden = ["nsfw", "porn", "sex", "explicit"]
+_playwright_available = True  # set False to disable Playwright
+
+# Globals for RAG system
+vector_store = None
+rag_chain = None
+DB_PATH = None  # will be set when a .db is uploaded
+DOC_PATH = None  # will be set when a document is uploaded
+IMG_PATH = None  # will be set when an image is uploaded
+OTH_PATH = None  # will be set when an other file is uploaded
+
+
+# ─── LLMS ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+#llm = ChatOpenAI(model_name="gpt-3.5-turbo", streaming=True, temperature=0)
+llm = ChatGroq(model="meta-llama/llama-4-maverick-17b-128e-instruct", streaming=True, temperature=0)
+#llm = ChatMistralAI(model="mistral-large-latest", streaming=True, temperature=0)
+
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Tool for browsing ────────────────────────────────────────────────���───────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+def tavily_search(query: str, top_k: int = 3) -> List[Dict]:
+    """Call Tavily API and return a list of result dicts."""
+    if not TAVILY_API_KEY:
+        print("[Tavily] No API key set. Skipping Tavily search.")
+        return []
+    url = "https://api.tavily.com/search"
+    headers = {
+        "Authorization": f"Bearer {TAVILY_API_KEY}",
+        "Content-Type": "application/json",
+    }
+    payload = {"query": query, "num_results": top_k}
+    try:
+        resp = requests.post(url, headers=headers, json=payload, timeout=10)
+        resp.raise_for_status()
+        data = resp.json()
+        results = []
+        for item in data.get("results", []):
+            results.append({
+                "title": item.get("title", ""),
+                "url": item.get("url", ""),
+                "snippet": item.get("content", "")[:200],
+                "source": "Tavily"
+            })
+        return results
+    except (requests.exceptions.RequestException, ValueError) as e:
+        print(f"[Tavily] search failed: {e}")
+        return []
+
+def duckduckgo_search(query: str, top_k: int = 3) -> List[Dict]:
+    """Query DuckDuckGo and return up to top_k raw SERP hits."""
+    try:
+        results = []
+        with DDGS() as ddgs:
+            for hit in ddgs.text(query, safesearch="On", max_results=top_k):
+                results.append({
+                    "title": hit.get("title", ""),
+                    "url": hit.get("href") or hit.get("url", ""),
+                    "snippet": hit.get("body", ""),
+                    "source": "DuckDuckGo"
+                })
+                if len(results) >= top_k:
+                    break
+        return results
+    except Exception as e:
+        print(f"[DuckDuckGo] search failed: {e}")
+        return []
+
+def hybrid_web_search(query: str, top_k: int = 3) -> str:
+    """
+    Returns a JSON string with combined Tavily + DuckDuckGo results.
+    Always returns non-empty JSON with at least a placeholder result.
+    """
+    tavily = tavily_search(query, top_k)
+    ddg = duckduckgo_search(query, top_k)
+    combined = tavily + ddg
+
+    # Always return at least a message to avoid agent crashes
+    if not combined:
+        combined = [{
+            "title": "No results found",
+            "url": "",
+            "snippet": f"Could not find suitable web results for '{query}'.",
+            "source": "None"
+        }]
+    output = {"query": query, "results": combined}
+    return json.dumps(output, ensure_ascii=False, indent=2)
+
+def web_search(query: str, top_k: int = 3) -> str:
+    """
+    Full hybrid search with Playwright/BeautifulSoup scraping + Tavily/DuckDuckGo.
+    Always returns valid JSON output.
+    """
+    results: List[Dict] = []
+
+    # Step 1: DuckDuckGo + scraping
+    try:
+        with DDGS() as ddgs:
+            hits = ddgs.text(query, safesearch="On", max_results=top_k)
+    except Exception as e:
+        print(f"[web_search] DuckDuckGo lookup failed: {e}")
+        hits = []
+
+    for hit in hits:
+        url = hit.get("href") or hit.get("url")
+        if not url:
+            continue
+
+        try:
+            with sync_playwright() as pw:
+                browser = pw.chromium.launch(headless=True)
+                page = browser.new_page()
+                page.goto(url, wait_until="domcontentloaded", timeout=15000)
+                html = page.content()
+                browser.close()
+            soup = BeautifulSoup(html, "html.parser")
+            text = soup.get_text(separator=" ", strip=True)
+        except Exception as e:
+            print(f"[web_search] scraping failed for {url}: {e}")
+            continue
+
+        if any(f in text.lower() for f in _forbidden):
+            continue
+
+        excerpt = " ".join(text.split()[:200])
+        results.append({
+            "title": hit.get("title", ""),
+            "url": url,
+            "snippet": hit.get("body", ""),
+            "content": excerpt
+        })
+
+    # Step 2: Parse hybrid Tavily + DDG JSON into list
+    try:
+        raw = hybrid_web_search(query, top_k)
+        parsed = json.loads(raw)
+        other = parsed.get("results", [])
+    except Exception as e:
+        print(f"[web_search] parsing hybrid results failed: {e}")
+        other = []
+
+    # Step 3: Combine and return
+    combined = results + other
+    if not combined:
+        combined = [{
+            "title": "No results found",
+            "url": "",
+            "snippet": f"Could not find suitable content for '{query}'.",
+            "source": "None"
+        }]
+
+    output = {
+        "query": query,
+        "sources_count": len(combined),
+        "results": combined,
+        "sources": list({item.get("url", "") for item in combined if item.get("url")})
+    }
+    return json.dumps(output, ensure_ascii=False, indent=2)
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Tool for calculation ─────────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+def calculate(expr: str) -> str:
+    """
+    Evaluates a mathematical expression safely.
+    Uses Python's numexpr for security and speed:contentReference[oaicite:21]{index=21}.
+    """
+    try:
+        # Allow math constants
+        local_dict = {"pi": math.pi, "e": math.e}
+        # Evaluate expression using numexpr for safety/performance
+        import numexpr
+        result = numexpr.evaluate(expr, local_dict=local_dict)
+        return str(result.item())
+    except Exception as e:
+        return f"Error calculating expression: {e}"
+    
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Tool for Date and time ───────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+def get_current_date(_: str = "") -> str:
+    """
+    Returns the current date and time. Ignoring input.
+    """
+    from datetime import datetime
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Tool for SQL Database ────────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+
+
+def create_sql_agent_function(db_uri: str, top_k: int = 5):
+    """
+    Creates a full-fledged SQL agent function that can answer natural language questions over a SQL database.
+
+    Args:
+        db_uri (str): The SQLAlchemy database URI, e.g. "sqlite:///Chinook.db"
+        top_k (int): Number of rows to limit in results (default 5)
+
+    Returns:
+        agent_executor: LangChain agent that can .run() or .stream()
+    """
+
+    # 1) Initialize the database + LLM + toolkit
+    db = SQLDatabase.from_uri(db_uri)
+    llm = ChatGroq(model="meta-llama/llama-4-maverick-17b-128e-instruct", streaming=False, temperature=0)
+    toolkit = SQLDatabaseToolkit(db=db, llm=llm)
+
+    # 2) Prompt with all required variables declared AND used
+    prompt = PromptTemplate(
+        template="""
+        You are an agent designed to interact with a SQL database.
+        Given the user question below, first generate a syntactically correct {dialect} query.
+        Then look at the results of that query, and return the answer.
+        Always limit to at most {top_k} rows unless the user specifies otherwise.
+        If you encounter an error, rewrite your SQL and retry.
+        DO NOT issue any INSERT/UPDATE/DELETE/DROP/ statements.
+        DO NOT try to create new database tables or columns when user has not asked for.
+        Always inspect the schema before querying.
+
+        Available tools: {tools}
+        Tool names: {tool_names}
+
+        User question: {input}
+
+        {agent_scratchpad}
+        """.strip(),
+                input_variables=["input", "dialect", "top_k", "agent_scratchpad", "tools", "tool_names"],
+            )
+
+    # 3) Create the agent with prompt + toolkit tools
+    agent_executor = create_sql_agent(
+        llm=llm,
+        toolkit=toolkit,
+        prompt=prompt,
+        verbose=False,
+        # pass top_k dynamically
+        extra_prompt_kwargs={"top_k": str(top_k), "dialect": db.dialect},
+    )
+
+    return agent_executor
+
+def execute_sql(query: str) -> str:
+    """
+    Executes a SQL query against the uploaded SQLite DB (GLOBAL_DB_PATH).
+    Returns a string of results or error.
+    """
+    if DB_PATH is None:
+        return "No database uploaded. Please upload a SQLite file first."
+    
+    print("DB_PATH--------->:", DB_PATH)
+    
+    db_uri = f"sqlite:///{DB_PATH}"
+    agent_executor2 = create_sql_agent_function(db_uri, top_k=5)
+  
+    try:
+        result = agent_executor2.run(query)
+    except Exception as e:
+        result = f"Agent / SQL error: {e}"
+    return result
+    
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Tool for RAG (Document Intelligence) ─────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+    
+def rag_index_document(DOC_PATH: str) -> str:
+    """
+    Indexes the given document into the RAG vector store.
+    Supports text files or PDFs. Uses recursive text splitting for better chunking.
+    """
+    global vector_store, rag_chain
+    text = ""
+    
+    # Read text from file
+    if DOC_PATH and DOC_PATH.lower().endswith(".pdf"):
+        doc = fitz.open(DOC_PATH)
+        for page in doc:
+            text += page.get_text()
+    else:
+        with open(DOC_PATH, 'r', encoding='utf-8') as f:
+            text = f.read()
+    
+    # Split text using recursive text splitter
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=500,  # You can adjust this (e.g., 500-1000)
+        chunk_overlap=100  # Overlap for better context between chunks
+    )
+    
+    # Split into chunks
+    texts = text_splitter.split_text(text)
+    
+    # Create Document objects with metadata
+    docs = [Document(page_content=t, metadata={"source": DOC_PATH}) for t in texts]
+    
+    # Initialize or append to FAISS vector store
+    embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
+    
+    if vector_store is None:
+        vector_store = FAISS.from_documents(docs, embeddings)
+    else:
+        vector_store.add_documents(docs)
+        
+    retriever = vector_store.as_retriever(
+        search_type="mmr",
+        search_kwargs={
+            "k": 10,
+            "fetch_k": 10,
+            "lambda_mult": 0.25
+        }
+    )
+    
+    # Build or update the RetrievalQA chain
+    rag_chain = RetrievalQA.from_chain_type(
+        llm=llm,
+        chain_type="stuff",
+        retriever=retriever,
+        return_source_documents=False
+    )
+
+
+def rag_answer(query: str) -> str:
+    """
+    Answers a question using the RAG chain (on indexed documents).
+    """
+    global rag_chain
+    if rag_chain is None:
+        return "No documents indexed. Please upload documents via /upload_doc."
+    try:
+        answer = rag_chain.run(query)
+        return answer
+    except Exception as e:
+        return f"RAG error: {e}"
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ───────────────────────────────────── Tool for Image (understading, captioning & classification) ─────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+# Vision tools and functions  
+# Load image function
+# def _load_image():
+#     try:
+#         if IMG_PATH.startswith("http"):
+#             res = requests.get(IMG_PATH)
+#             res.raise_for_status()
+#             img = Image.open(BytesIO(res.content))
+#         else:
+#             img = Image.open(IMG_PATH)
+#         return img.convert("RGB")
+#     except Exception as e:
+#         raise RuntimeError(f"Failed to load image: {e}")
+
+
+def _load_image(resize_to=(512, 512)):
+    """
+    Load and resize the image from IMG_PATH.
+    If the image is not valid, raise an error.
+    """    
+    try:
+        if IMG_PATH is None:
+            raise ValueError("No image uploaded. Please upload an image first.")
+            #return "No image uploaded. Please upload an image first."
+        with open(IMG_PATH, "rb") as f:
+            img = Image.open(f)
+            img.verify()  # Verify it's an image
+        img = Image.open(IMG_PATH).convert("RGB")  # Reopen after verify and convert
+        img = img.resize(resize_to)  # resize image to reduce token size
+        return img
+    except UnidentifiedImageError:
+        raise ValueError(f"File at {IMG_PATH} is not a valid image.")
+    except Exception as e:
+        raise ValueError(f"Failed to load image at {IMG_PATH}: {str(e)}")
+
+def _encode_image_to_base64():
+    img = _load_image()
+    buffer = BytesIO()
+    img.save(buffer, format="PNG", optimize=True)  # save optimized PNG
+    return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+def _call_llama_llm(prompt_text: str) -> str:
+    b64 = _encode_image_to_base64()
+    message = HumanMessage(
+        content=[
+            {"type": "text", "text": prompt_text},
+            {
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:image/png;base64,{b64}"
+                }
+            }
+        ]
+    )
+    response = llm.invoke([message])
+    return response.content.strip()
+
+def vision_query(task_prompt: str) -> str:
+    try:
+        return _call_llama_llm(task_prompt)
+    except Exception as llama_error:
+        print(f"[LLaMA-4V failed] {llama_error}")
+        try:
+            img = _load_image()
+            return pytesseract.image_to_string(img).strip()
+        except Exception as ocr_error:
+            print(f"[OCR fallback failed] {ocr_error}")
+            return "Unable to process the image or image is not uploaded. Please try again with a different input."
+    
+#### Create LangChain Tools ####
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Assigning tools as list ───────────────────────────────────────���──────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+tool_list = [
+    Tool(name="browse", func=web_search, description="Search the web and scrape top results. Uses DuckDuckGo (safe mode) for query. Prefers Playwright for loading pages, with requests/BeautifulSoup as fallback. Filters out any explicit content. Returns JSON with titles, URLs, and page text."),
+    Tool(name="calculate", func=calculate, description="Perform math calculations safely."),
+    Tool(name="date", func=get_current_date, description="Fetch the current date and time."),
+    Tool(name="sql", func=execute_sql, description="Execute SQL query on the uploaded database."),
+    Tool(name="rag", func=rag_answer, description="Answer questions using the uploaded documents with retrieval-augmented generation (RAG)."),
+    Tool(
+    name="vision",
+    func=vision_query,
+    description=(
+        "Perform any image-understanding task—e.g. read text, classify objects, "
+        "generate captions, count or locate items, answer questions about the scene, "
+        "detect NSFW content, etc.—powered by LLaMA 4-Vision. "
+        "If the request is OCR-style and LLaMA fails, it falls back to Tesseract OCR."
+    ),
+    ),
+]
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Added Memory to Agent ────────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+# 1) instantiate with your LLM
+memory = AutoSummaryMemory(
+    llm=llm,
+    max_entries=20,     # when chat ≥20 messages, trigger summary
+    reduce_to=5         # keep only last 5 after summarizing
+)
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Initialize Agent ─────────────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+# Initialize the agent with OpenAI and our tools. We use a zero-shot-react-description agent.
+agent_executor = initialize_agent(
+    tools=tool_list,
+    llm=llm,
+    agent=AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION,
+    memory=memory,
+    verbose=True,
+    handle_parsing_errors=True,
+    #max_iterations=10,
+)
+
+# ─── Streaming & Fallback ─────────────────────────────────────────────────────
+# ─── Streaming helper ────────────────────────────────────────────────────────────
+def run_stream(query: str, data_paths: List[str] = None):
+    """
+    Progressive token‐by‐token streaming from the agent.
+
+    Args:
+      query: The user’s natural-language question.
+      data_paths: List of file paths (DB_PATH, DOC_PATH, IMG_PATH, OTH_PATH).
+    """
+    # If no explicit list passed, rebuild from module globals
+    # if not data_paths:
+    #     data_paths = [DB_PATH, DOC_PATH, IMG_PATH, OTH_PATH]
+    data_paths = [p for p in data_paths if p]
+    print(f"Data paths----------------->: {data_paths}")
+    # Re-inject each into the appropriate global (optional—keeps them current)
+    for path in data_paths:
+        ext = os.path.splitext(path)[1].lower()
+        if ext in {".png", ".jpg", ".jpeg", ".gif"}:
+            globals()['IMG_PATH'] = path
+        elif ext in {".pdf", ".txt", ".doc", ".docx"}:
+            globals()['DOC_PATH'] = path
+        elif ext in {".db", ".sqlite"}:
+            globals()['DB_PATH'] = path
+        else:
+            globals()['OTH_PATH'] = path
+
+    # Stream the agent response
+    hist = get_buffer_string(memory.chat_memory.messages)
+    print("Memory now contains:", memory.chat_memory.messages)
+    for chunk in agent_executor.stream({"input": query}):
+        text = chunk.get("text")
+        if text:
+            yield text
+            
+# # ─── Streaming & Fallback ─────────────────────────────────────────────────────
+# def run_stream(query: str, data: str = None):
+#     """
+#     Progressive token‐by‐token streaming from the agent.
+
+#     Args:
+#       query: The user’s natural-language question.
+#       data: Path to a single uploaded file (image, document, or database).
+#             We will inspect its extension and set the appropriate config variable:
+#               .png/.jpg/.jpeg/.gif → IMG_PATH
+#               .pdf/.txt/.doc/.docx   → DOC_PATH
+#               .db/.sqlite            → DB_PATH
+#               others                 → OTH_PATH
+#     """
+#     global DB_PATH, DOC_PATH, IMG_PATH, OTH_PATH
+#     # 1) If data provided, dispatch into the right config variable
+#     if data:
+#         ext = os.path.splitext(data)[1].lower()
+#         if ext in {".png", ".jpg", ".jpeg", ".gif"}:
+#             IMG_PATH = data
+#             print(f"Image path set to: {IMG_PATH}")
+#         elif ext in {".pdf", ".txt", ".doc", ".docx"}:
+#             DOC_PATH = data
+#             print(f"Document path set to: {DOC_PATH}")
+#         elif ext in {".db", ".sqlite"}:
+#             DB_PATH = data
+#             print(f"Database path set to: {DB_PATH}")
+#         else:
+#             OTH_PATH = data
+#             print(f"Other file path set to: {OTH_PATH}")
+
+#     # 2) Stream the agent’s response
+#     for chunk in agent_executor.stream({"input": query}):
+#         text = chunk.get("text")
+#         if text:
+#             yield text
+
+def run_full(query: str) -> str:
+    """
+    Fallback single‐shot answer (for pure-tool or final completeness).
+    """
+    return agent_executor.run(query)
+
+# Expose for Flask
+class AgentInterface:
+    def __init__(self, executor):
+        self.executor = executor
+    def run_stream(self, q):
+        return run_stream(q)
+    def run_full(self, q):
+        return run_full(q)
+
+agent = AgentInterface(agent_executor)
+
+__all__ = [
+    'agent_executor', 'run_stream', 'run_full',
+    'AgentInterface', 'GLOBAL_DB_PATH', 'rag_index_document'
+]
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Refresh Memory Session ───────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# Refresh Memory 
+def refresh_memory():
+    memory.clear()  # clear memory at start of each new session
+    memory.chat_memory.clear()  # clear chat history

app.py

@@ -0,0 +1,337 @@
+# app.py
+
+import eventlet
+eventlet.monkey_patch()
+
+from flask import Flask, render_template, request, redirect, url_for, flash, session, send_from_directory
+from flask_socketio import SocketIO
+import traceback
+import os
+from werkzeug.utils import secure_filename
+import json
+import logging
+import agent # your agent.py module
+from agent import refresh_memory
+from agent import run_stream 
+from typing import List, Dict
+import markdown2
+import re
+import time
+
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Inialized VAR & FS ───────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+BASE_DIR = os.path.abspath(os.path.dirname(__file__))
+
+UPLOAD_FOLDER = os.path.join(BASE_DIR, "uploads")
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+CHAT_FOLDER = os.path.join(BASE_DIR, "chats")
+os.makedirs(CHAT_FOLDER, exist_ok=True)
+
+app = Flask(__name__, template_folder="templates")
+
+# For storing the processed files
+app.config["UPLOAD_FOLDER"] = UPLOAD_FOLDER
+# For storing the Chat history and other files
+app.config["CHAT_FOLDER"] = CHAT_FOLDER
+
+app.secret_key = os.getenv("FLASK_SECRET", "supersecret")
+
+# Use eventlet for async SocketIO
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode="eventlet")
+
+# Allowed file extensions
+ALLOWED_EXTENSIONS = {
+    ".db", ".sqlite",              # SQLite databases
+    ".pdf", ".txt", ".doc", ".docx",  # Documents
+    ".png", ".jpg", ".jpeg", ".gif"    # Images
+}
+
+import config
+DB_PATH = None  # will be set when a .db is uploaded
+DOC_PATH = None  # will be set when a document is uploaded
+IMG_PATH = None  # will be set when an image is uploaded
+OTH_PATH = None  # will be set when an other file is uploaded
+
+# import config
+# IMG_PATH = "path/to/user_uploaded_file.jpg"
+# DOC_PATH = "path/to/user_uploaded_file.pdf"
+# DB_PATH = "path/to/user_uploaded_file.db"
+# OTH_PATH = "path/to/user_uploaded_file.txt"
+
+def allowed_file(filename: str) -> bool:
+    ext = os.path.splitext(filename.lower())[1]
+    return ext in ALLOWED_EXTENSIONS
+
+#text cleaning function
+def clean_html_chunk(text):
+    """
+    Removes outer <p>...</p> tags and trims extra backticks or 'json' words.
+    Similar to your 'format:' cleaning logic.
+    """
+    text = text.strip()
+    
+    # Pattern to match single <p>...</p> wrapping
+    pattern = r'^<p>(.*?)</p>$'
+    match = re.match(pattern, text, re.DOTALL)
+    if match:
+        text = match.group(1).strip()
+
+    # Extra clean-up (optional, like your example)
+    text = text.strip('`').strip('json').strip()
+
+    return text
+
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── AGENT Defination ────────────────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+def run_agent_thread(
+    prompt: str,
+    user_id: str,
+    chat_history: List[Dict],           # ← new parameter
+):
+    """
+    Launches the agent in a background thread, streaming results back over SocketIO.
+    `data` is the uploaded file path (image, document, or DB) that will be injected
+    into config before the agent runs.
+    """
+    global DB_PATH, DOC_PATH, IMG_PATH, OTH_PATH  # force re-initializing agent
+           
+    # Build the list of all paths, skipping None or empty
+    data_paths = [DB_PATH, DOC_PATH, IMG_PATH, OTH_PATH]
+    data_paths = [p for p in data_paths if p]
+    print(f"Data paths----------------->: {data_paths}")
+    text_accum = ""
+    try:
+        # Stream using run_stream (which will also pick up the same globals)
+        for piece in run_stream(prompt, data_paths):
+            html_chunk = markdown2.markdown(piece, extras=["fenced-code-blocks", "tables", "strike", "task_list", "break-on-newline"])
+            print(f"HTML chunk: {html_chunk}")  # Debugging output
+            html_chunk = clean_html_chunk(html_chunk)
+            text_accum  += html_chunk            # accumulate HTML
+            socketio.emit("final_stream", {"message": html_chunk})
+            print(f"Streaming chunk: {html_chunk}")  # Debugging output
+    except Exception as e:
+        socketio.emit("error", {"message": f"Streaming error: {e}"})
+        traceback.print_exc()
+        return
+
+    # Fallback / finalize
+    try:
+        if not text_accum:
+            text_accum = markdown2.markdown(agent.agent.executor.run(prompt), extras=["fenced-code-blocks", "tables", "strike", "task_list", "break-on-newline"])
+            print(f"Final HTML chunk: {text_accum}")  # Debugging output
+            text_accum = clean_html_chunk(text_accum)
+            print(f"Final text: {text_accum}")  # Debugging output
+            
+        socketio.emit("stream_complete", {"message": text_accum})
+        socketio.emit("final", {"message": text_accum})
+        chat_history.append({"user": prompt, "assistant": text_accum})
+
+        output_path = os.path.join(
+            app.config["CHAT_FOLDER"],
+            f"user_chat_no_{user_id}.json"
+        )
+        with open(output_path, "w", encoding="utf-8") as f:
+            json.dump(chat_history, f, ensure_ascii=False, indent=4)
+
+    except Exception as e:
+        socketio.emit("error", {"message": f"Final generation error: {e}"})
+        traceback.print_exc()
+        
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Main Page ────────────────────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+@app.route("/")
+def index():
+    if "user_id" not in session:
+        session["user_id"] = os.urandom(16).hex()
+        session["uploads"] = []
+        session["chat_history"] = []
+        refresh_memory()
+    else:
+        # Load previous chat history from JSON file if exists
+        user_id = session["user_id"]
+        chat_file = os.path.join(app.config.get("CHAT_FOLDER", "chat_history"), f"user_chat_no_{user_id}.json")
+        if os.path.exists(chat_file):
+            with open(chat_file, "r", encoding="utf-8") as f:
+                session["chat_history"] = json.load(f)
+
+    return render_template("index.html", chat_history=session.get("chat_history", []))
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Upload section  ──────────────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+@app.route("/upload", methods=["GET", "POST"])
+def upload():
+    global DB_PATH, DOC_PATH, IMG_PATH, OTH_PATH  # force re-initializing agent
+
+    if request.method == "POST":
+        f = request.files.get("file")
+        if not f or f.filename == "":
+            flash("No file selected", "error")
+            return render_template("upload.html")
+
+        filename = secure_filename(f.filename)
+        if not allowed_file(filename):
+            flash("File type not supported", "error")
+            return render_template("upload.html")
+
+        ext = os.path.splitext(filename.lower())[1]
+
+        if ext in (".db", ".sqlite"):
+            save_path = os.path.join(app.config["UPLOAD_FOLDER"], "databases", filename)
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            global DB_PATH
+            DB_PATH = save_path
+            # DB_PATH = f"http://127.0.0.1:5000/uploads/databases/{filename}"
+            print(f"Database path: {save_path}")
+            f.save(save_path)
+        elif ext in (".pdf", ".txt", ".doc", ".docx"):
+            save_path = os.path.join(app.config["UPLOAD_FOLDER"], "documents", filename)
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            global DOC_PATH
+            DOC_PATH = save_path
+            # DOC_PATH = f"http://127.0.0.1:5000/uploads/documents/{filename}"
+            print(f"Document path: {save_path}")
+            f.save(save_path)
+        elif ext in (".png", ".jpg", ".jpeg", ".gif"):
+            save_path = os.path.join(app.config["UPLOAD_FOLDER"], "images", filename)
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            global IMG_PATH
+            IMG_PATH = save_path
+            # IMG_PATH = f"http://127.0.0.1:5000/uploads/images/{filename}"
+            print(f"Image path: {save_path}")
+            f.save(save_path)
+        else:
+            save_path = os.path.join(app.config["UPLOAD_FOLDER"], "others", filename)
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            global OTH_PATH
+            OTH_PATH = save_path
+            # OTH_PATH = f"http://127.0.0.1:5000/uploads/others/{filename}"
+            print(f"Other file path: {save_path}")
+            f.save(save_path)
+
+        #f.save(save_path)
+        
+        # Add the uploaded file to the session
+        session["uploads"].append(filename)
+
+        # — Database files —
+        if ext in (".db", ".sqlite"):
+            DB_PATH = save_path
+            agent.GLOBAL_DB_PATH = DB_PATH
+            flash(f"Database uploaded and set: {filename}", "success")
+
+        # — Documents for RAG indexing —
+        elif ext in (".pdf", ".txt", ".doc", ".docx"):
+            agent.rag_index_document(save_path)
+            flash(f"Document indexed for RAG: {filename}", "success")
+
+        # — Images or other files —
+        else:
+            flash(f"File uploaded: {filename}", "success")
+
+        return redirect(url_for("index"))
+
+    # GET
+    return render_template("upload.html")
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── Static Upload  ───────────────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+@app.route('/uploads/databases/<filename>')
+def serve_database(filename):
+    """
+    Serve an database file from the uploads/databases folder.
+    """
+    return send_from_directory(os.path.join(app.root_path, 'uploads', 'databases'), filename)
+
+@app.route('/uploads/images/<filename>')
+def serve_image(filename):
+    """
+    Serve an document file from the uploads/images folder.
+    """
+    return send_from_directory(os.path.join(app.root_path, 'uploads', 'images'), filename)
+
+@app.route('/uploads/documents/<filename>')
+def serve_document(filename):
+    """
+    Serve an image file from the uploads/documents folder.
+    """
+    return send_from_directory(os.path.join(app.root_path, 'uploads', 'documents'), filename)
+
+@app.route('/uploads/others/<filename>')
+def serve_other(filename):
+    """
+    Serve an other file from the uploads/others folder.
+    """
+    return send_from_directory(os.path.join(app.root_path, 'uploads', 'others'), filename)
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ─────────────────────────────────────────────── AGENT calling  ───────────────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+@app.route("/generate", methods=["POST"])
+def generate():
+    prompt = request.json.get("prompt", "").strip()
+    if not prompt:
+        return "No prompt provided", 400
+
+    socketio.start_background_task(
+        run_agent_thread,
+        prompt,
+        session["user_id"],
+        session["chat_history"]
+               # ← pass it here
+    )
+    return "OK", 200
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ───────────────────────────────────────────────  SESSION handling  ───────────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+@app.route("/session-info")
+def session_info():
+    # Endpoint to view session details (for debugging purposes)
+    return {
+        "user_id": session.get("user_id"),
+        "uploads": session.get("uploads", [])
+    }
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+# ───────────────────────────────────────────────  SESSION clearing  ───────────────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+@app.route("/clear_chat", methods=["POST"])
+def clear_chat():
+    user_id = session.get("user_id")
+    
+    # Remove saved JSON chat file
+    if user_id:
+        chat_file = os.path.join(app.config["CHAT_FOLDER"], f"user_chat_no_{user_id}.json")
+        if os.path.exists(chat_file):
+            os.remove(chat_file)
+    
+    # Reset session
+    session.clear()
+    
+    # Generate new session id and chat history
+    session["user_id"] = os.urandom(16).hex()
+    session["uploads"] = []
+    session["chat_history"] = []
+
+    # Refresh agent memory
+    refresh_memory()
+    
+    return {"message": "Chat history and session cleared!"}, 200
+
+if __name__ == "__main__":
+    socketio.run(app, debug=True, port=5000)

chats/user_chat_no_113a02f93587a6622aa86c130e31f025.json

@@ -0,0 +1,18 @@
+[
+    {
+        "assistant": "Mistral AI is a privately held company founded in April 2023 by Arthur Mensch, Guillaume Lample, and Timothée Lacroix. The ownership is distributed among its founders, investors, and possibly key employees.",
+        "user": "who is the owner of mistral  ?"
+    },
+    {
+        "assistant": "The database is empty or does not contain any tables.",
+        "user": "can you get me details about the database ?"
+    },
+    {
+        "assistant": "The database contains the following tables with their respective CREATE statements: </p>\n\n<p>CREATE TABLE employees (id INTEGER PRIMARY KEY, name TEXT, department TEXT);<br />\nCREATE TABLE departments (id INTEGER PRIMARY KEY, name TEXT);<br />\nCREATE TABLE projects (id INTEGER PRIMARY KEY, name TEXT, employee<em>id INTEGER);<br />\nCREATE TABLE sqlite</em>sequence(name,seq);",
+        "user": "can you get me details about the database ?"
+    },
+    {
+        "user": "ok you get me the top can you format this into table ?",
+        "assistant": "<table>\n<thead>\n<tr>\n  <th>id</th>\n  <th>name</th>\n  <th>salary</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n  <td>1</td>\n  <td>John Doe</td>\n  <td>100000</td>\n</tr>\n<tr>\n  <td>2</td>\n  <td>Jane Smith</td>\n  <td>90000</td>\n</tr>\n<tr>\n  <td>3</td>\n  <td>Bob Brown</td>\n  <td>85000</td>\n</tr>\n<tr>\n  <td>4</td>\n  <td>Alice White</td>\n  <td>80000</td>\n</tr>\n<tr>\n  <td>5</td>\n  <td>Mike Davis</td>\n  <td>75000</td>\n</tr>\n</tbody>\n</table>"
+    }
+]

config.py

@@ -0,0 +1,8 @@
+import json
+import os
+
+# config.py
+DB_PATH = "your_db_path_here"
+DOC_PATH = "your_doc_path_here"
+IMG_PATH = "your_img_path_here"
+OTH_PATH = "your_other_path_here"

requirements.txt

@@ -0,0 +1,134 @@
+accelerate
+agent
+aiohappyeyeballs
+aiohttp
+aiosignal
+annotated-types
+anyio
+asttokens
+attrs
+beautifulsoup4
+bidict
+blinker
+bs4
+certifi
+charset-normalizer
+click
+colorama
+comm
+dataclasses-json
+debugpy
+decorator
+distro
+dnspython
+duckduckgo_search
+eventlet
+executing
+faiss-cpu
+filelock
+Flask
+Flask-SocketIO
+frozenlist
+fsspec
+greenlet
+groq
+gunicorn
+h11
+httpcore
+httpx
+httpx-sse
+huggingface-hub
+idna
+ipykernel
+ipython
+ipython_pygments_lexers
+itsdangerous
+jedi
+Jinja2
+joblib
+jsonpatch
+jsonpointer
+jupyter_client
+jupyter_core
+langchain
+langchain-community
+langchain-core
+langchain-groq
+langchain-mistralai
+langchain-text-splitters
+langgraph
+langgraph-checkpoint
+langgraph-prebuilt
+langgraph-sdk
+langsmith
+lxml
+markdown2
+MarkupSafe
+marshmallow
+matplotlib-inline
+mpmath
+multidict
+mypy_extensions
+nest-asyncio
+networkx
+numexpr
+numpy
+orjson
+ormsgpack
+packaging
+parso
+pillow
+platformdirs
+playwright
+primp
+prompt_toolkit
+propcache
+psutil
+pure_eval
+pydantic
+pydantic-settings
+pydantic_core
+pyee
+Pygments
+PyMuPDF
+pytesseract
+python-dateutil
+python-dotenv
+python-engineio
+python-socketio
+pywin32
+PyYAML
+pyzmq
+regex
+requests
+requests-toolbelt
+safetensors
+scikit-learn
+scipy
+sentence-transformers
+setuptools
+simple-websocket
+six
+sniffio
+soupsieve
+SQLAlchemy
+stack-data
+sympy
+tenacity
+threadpoolctl
+tokenizers
+torch
+tornado
+tqdm
+traitlets
+transformers
+typing-inspect
+typing-inspection
+typing_extensions
+urllib3
+wcwidth
+Werkzeug
+wsproto
+xxhash
+yarl
+zstandard

templates/index.html

@@ -0,0 +1,775 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Agent Chat</title>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.5.4/socket.io.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+  <style>
+    :root {
+      --primary: #10a37f;
+      --primary-dark: #0d8a6a;
+      --bg-color: #343541;
+      --chat-bg: #444654;
+      --user-bg: #343541;
+      --text-color: #ececf1;
+      --text-secondary: #acacbe;
+      --border-color: #565869;
+      --log-bg: #2a2b32;
+      --error-color: #ef4146;
+      --warning-color: #f0b72f;
+      --panel-width: 300px;
+      /* Define panel width */
+    }
+
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    body {
+      background-color: var(--bg-color);
+      color: var(--text-color);
+      font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+      display: flex;
+      flex-direction: column;
+      height: 100vh;
+      overflow: hidden;
+    }
+
+    nav {
+      background-color: var(--user-bg);
+      padding: 12px 20px;
+      border-bottom: 1px solid var(--border-color);
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      flex-shrink: 0;
+      /* Prevent nav from shrinking */
+    }
+
+    .nav-title {
+      font-size: 1.2rem;
+      font-weight: 600;
+    }
+
+    .nav-actions {
+      display: flex;
+      gap: 10px;
+    }
+
+    .btn {
+      background-color: var(--primary);
+      color: white;
+      border: none;
+      border-radius: 4px;
+      padding: 8px 12px;
+      font-size: 0.9rem;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      transition: background-color 0.2s;
+    }
+
+    .btn:hover {
+      background-color: var(--primary-dark);
+    }
+
+    .btn-sm {
+      padding: 6px 10px;
+      font-size: 0.8rem;
+    }
+
+    .btn-icon {
+      padding: 8px;
+      border-radius: 4px;
+      background: transparent;
+      color: var(--text-color);
+      border: none;
+      /* Ensure no default button border */
+      cursor: pointer;
+    }
+
+    .btn-icon:hover {
+      background-color: rgba(255, 255, 255, 0.1);
+    }
+
+    main {
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+      overflow: hidden;
+    }
+
+    .chat-container {
+      flex: 1;
+      overflow-y: auto;
+      padding: 20px 0;
+    }
+
+    .message {
+      padding: 20px;
+      display: flex;
+      max-width: 900px;
+      margin: 0 auto;
+      gap: 20px;
+    }
+
+    .message-user {
+      background-color: var(--user-bg);
+    }
+
+    .message-agent {
+      background-color: var(--chat-bg);
+    }
+
+    .avatar {
+      width: 36px;
+      height: 36px;
+      border-radius: 4px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      flex-shrink: 0;
+    }
+
+    .avatar-user {
+      background-color: var(--primary);
+    }
+
+    .avatar-agent {
+      background-color: #5436da;
+    }
+
+    .message-content {
+      flex: 1;
+      line-height: 1.5;
+      padding-top: 4px;
+    }
+
+    .input-container {
+      padding: 20px;
+      border-top: 1px solid var(--border-color);
+      background-color: var(--user-bg);
+      position: relative;
+      flex-shrink: 0;
+      /* Prevent input area from shrinking */
+    }
+
+    .input-wrapper {
+      max-width: 900px;
+      margin: 0 auto;
+      position: relative;
+    }
+
+    .input-actions {
+      position: absolute;
+      right: 12px;
+      bottom: 12px;
+      display: flex;
+      gap: 8px;
+      z-index: 2;
+    }
+
+    textarea {
+      width: 100%;
+      min-height: 60px;
+      max-height: 200px;
+      padding: 12px 50px 12px 16px;
+      border-radius: 8px;
+      border: 1px solid var(--border-color);
+      background-color: var(--chat-bg);
+      color: var(--text-color);
+      resize: none;
+      font-size: 1rem;
+      line-height: 1.5;
+    }
+
+    textarea:focus {
+      outline: none;
+      border-color: var(--primary);
+      box-shadow: 0 0 0 1px var(--primary);
+    }
+
+    .typing-indicator {
+      display: flex;
+      gap: 4px;
+      padding: 0 20px 10px;
+      color: var(--text-secondary);
+      font-size: 0.9rem;
+      flex-shrink: 0;
+      /* Prevent indicator from shrinking */
+    }
+
+    .typing-dots {
+      display: flex;
+      gap: 2px;
+      align-items: flex-end;
+    }
+
+    .typing-dot {
+      width: 6px;
+      height: 6px;
+      background-color: var(--text-secondary);
+      border-radius: 50%;
+      animation: typingAnimation 1.4s infinite ease-in-out;
+    }
+
+    .typing-dot:nth-child(1) {
+      animation-delay: 0s;
+    }
+
+    .typing-dot:nth-child(2) {
+      animation-delay: 0.2s;
+    }
+
+    .typing-dot:nth-child(3) {
+      animation-delay: 0.4s;
+    }
+
+    @keyframes typingAnimation {
+
+      0%,
+      60%,
+      100% {
+        transform: translateY(0);
+      }
+
+      30% {
+        transform: translateY(-4px);
+      }
+    }
+
+    footer {
+      background-color: var(--user-bg);
+      padding: 12px 20px;
+      border-top: 1px solid var(--border-color);
+      font-size: 0.8rem;
+      color: var(--text-secondary);
+      text-align: center;
+      flex-shrink: 0;
+      /* Prevent footer from shrinking */
+    }
+
+    /* Side Panel Styles */
+    .side-panel {
+      position: fixed;
+      top: 0;
+      right: calc(-1 * var(--panel-width));
+      /* Initially hidden */
+      width: var(--panel-width);
+      height: 100vh;
+      background-color: var(--log-bg);
+      border-left: 1px solid var(--border-color);
+      box-shadow: -4px 0 12px rgba(0, 0, 0, 0.15);
+      transition: right 0.3s ease-in-out;
+      display: flex;
+      flex-direction: column;
+      z-index: 999;
+      /* Ensure it's above other content */
+    }
+
+    .side-panel.open {
+      right: 0;
+      /* Slide in */
+    }
+
+    .side-panel-header {
+      padding: 12px 20px;
+      background-color: var(--user-bg);
+      border-bottom: 1px solid var(--border-color);
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      flex-shrink: 0;
+    }
+
+    .side-panel-header h3 {
+      font-size: 1rem;
+      margin: 0;
+    }
+
+    .side-panel-content {
+      flex: 1;
+      overflow-y: auto;
+      padding: 12px 20px;
+      font-size: 0.85rem;
+      color: var(--text-secondary);
+    }
+
+    .log-entry {
+      margin-bottom: 6px;
+      display: flex;
+      gap: 10px;
+    }
+
+    .log-timestamp {
+      color: var(--text-secondary);
+      flex-shrink: 0;
+    }
+
+    .log-message {
+      flex: 1;
+      word-break: break-word;
+      /* Prevent long words from overflowing */
+    }
+
+    .log-error {
+      color: var(--error-color);
+    }
+
+    .log-warning {
+      color: var(--warning-color);
+    }
+
+
+    .alert {
+      position: fixed;
+      top: 20px;
+      left: 50%;
+      transform: translateX(-50%);
+      padding: 12px 20px;
+      border-radius: 8px;
+      background-color: var(--error-color);
+      color: white;
+      z-index: 1000;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+      animation: slideIn 0.3s ease-out;
+    }
+
+    .alert-success {
+      background-color: var(--primary);
+    }
+
+    .alert-warning {
+      background-color: var(--warning-color);
+    }
+
+    @keyframes slideIn {
+      from {
+        top: -50px;
+        opacity: 0;
+      }
+
+      to {
+        top: 20px;
+        opacity: 1;
+      }
+    }
+
+    /* Enhanced Markdown Styling */
+    .markdown-content {
+      line-height: 1.6;
+    }
+
+    .markdown-content h1,
+    .markdown-content h2,
+    .markdown-content h3,
+    .markdown-content h4,
+    .markdown-content h5,
+    .markdown-content h6 {
+      margin: 1.2em 0 0.6em;
+      font-weight: 600;
+      line-height: 1.3;
+    }
+
+    .markdown-content h1 {
+      font-size: 1.5em;
+      border-bottom: 1px solid var(--border-color);
+      padding-bottom: 0.3em;
+    }
+
+    .markdown-content h2 {
+      font-size: 1.3em;
+      border-bottom: 1px solid var(--border-color);
+      padding-bottom: 0.3em;
+    }
+
+    .markdown-content h3 {
+      font-size: 1.1em;
+    }
+
+    .markdown-content h4 {
+      font-size: 1em;
+    }
+
+    .markdown-content h5 {
+      font-size: 0.9em;
+    }
+
+    .markdown-content h6 {
+      font-size: 0.8em;
+      color: var(--text-secondary);
+    }
+
+    .markdown-content p {
+      margin: 0.8em 0;
+    }
+
+    .markdown-content pre {
+      background-color: rgba(0, 0, 0, 0.2);
+      padding: 1em;
+      border-radius: 6px;
+      overflow-x: auto;
+      margin: 1em 0;
+      border-left: 3px solid var(--primary);
+    }
+
+    .markdown-content code {
+      font-family: 'Courier New', Courier, monospace;
+      font-size: 0.9em;
+      background-color: rgba(27, 31, 35, 0.15);
+      padding: 0.2em 0.4em;
+      border-radius: 3px;
+    }
+
+    .markdown-content pre code {
+      background: transparent;
+      padding: 0;
+      border-radius: 0;
+    }
+
+    .markdown-content blockquote {
+      border-left: 4px solid var(--primary);
+      padding: 0 1em;
+      color: var(--text-secondary);
+      margin: 1em 0;
+      font-style: italic;
+    }
+
+    .markdown-content ul,
+    .markdown-content ol {
+      margin: 0.8em 0;
+      padding-left: 2em;
+    }
+
+    .markdown-content li {
+      margin: 0.4em 0;
+    }
+
+    .markdown-content table {
+      border-collapse: collapse;
+      width: 100%;
+      margin: 1em 0;
+      border: 1px solid var(--border-color);
+    }
+
+    .markdown-content th,
+    .markdown-content td {
+      padding: 0.5em 1em;
+      border: 1px solid var(--border-color);
+    }
+
+    .markdown-content th {
+      background-color: rgba(0, 0, 0, 0.1);
+      font-weight: 600;
+    }
+
+    .markdown-content tr:nth-child(even) {
+      background-color: rgba(0, 0, 0, 0.05);
+    }
+
+    .markdown-content a {
+      color: var(--primary);
+      text-decoration: none;
+    }
+
+    .markdown-content a:hover {
+      text-decoration: underline;
+    }
+
+    .markdown-content img {
+      max-width: 100%;
+      border-radius: 4px;
+      margin: 1em 0;
+    }
+
+    .markdown-content hr {
+      border: none;
+      border-top: 1px solid var(--border-color);
+      margin: 1.5em 0;
+    }
+  </style>
+</head>
+
+<body>
+  <nav>
+    <div class="nav-title">Agent Chat</div>
+    <div class="nav-actions">
+      <button class="btn" id="new-chat-btn">
+        <i class="fas fa-plus"></i> New Chat
+      </button>
+      <!-- Button to open logs panel -->
+      <button class="btn-icon" id="open-logs-btn" title="Show Logs">
+        <i class="fas fa-list-alt"></i>
+      </button>
+    </div>
+  </nav>
+
+  <main>
+    <div class="chat-container" id="chat">
+      <!-- Messages will be inserted here -->
+      {% for chat in chat_history %}
+      <div class="message message-user">
+        <div class="avatar avatar-user"><i class="fas fa-user"></i></div>
+        <div class="message-content"><div class="markdown-content">{{ chat.user }}</div></div>
+      </div>
+      <div class="message message-agent">
+        <div class="avatar avatar-agent"><i class="fas fa-robot"></i></div>
+        <div class="message-content"><div class="markdown-content">{{ chat.assistant | safe }}</div></div>
+      </div>
+    {% endfor %}
+    </div>
+
+    <div class="typing-indicator" id="typing-indicator" style="display: none;">
+      <div class="typing-dots">
+        <div class="typing-dot"></div>
+        <div class="typing-dot"></div>
+        <div class="typing-dot"></div>
+      </div>
+      <span>Agent is typing...</span>
+    </div>
+
+    <div class="input-container">
+      <div class="input-wrapper">
+        <textarea id="prompt" rows="1" placeholder="Message Agent..." autofocus></textarea>
+        <div class="input-actions">
+          <button class="btn-icon" id="upload-btn" title="Upload Database">
+            <i class="fas fa-upload"></i>
+          </button>
+          <button class="btn-icon" id="send-btn" title="Send message">
+            <i class="fas fa-paper-plane"></i>
+          </button>
+        </div>
+      </div>
+    </div>
+
+  </main>
+
+  <footer>
+    <div>Agent Chat v1.0 · © 2023</div>
+  </footer>
+
+  <!-- Side Panel for Logs -->
+  <div id="side-panel" class="side-panel">
+    <div class="side-panel-header">
+      <h3>Logs</h3>
+      <button class="btn-icon" id="close-panel-btn" title="Hide Logs">
+        <i class="fas fa-times"></i>
+      </button>
+    </div>
+    <div class="side-panel-content" id="logs">
+      <!-- Logs will be inserted here -->
+    </div>
+  </div>
+
+  <div id="flash-message" class="alert" style="display: none;"></div>
+
+  <script>
+    const socket = io();
+    const chatContainer = document.getElementById("chat");
+    const logsContainer = document.getElementById("logs"); // This is now the content div inside the panel
+    const sendButton = document.getElementById("send-btn");
+    const uploadButton = document.getElementById("upload-btn");
+    const promptTextarea = document.getElementById("prompt");
+    const flashMessage = document.getElementById('flash-message');
+    const typingIndicator = document.getElementById('typing-indicator');
+
+    // New elements for side panel
+    const sidePanel = document.getElementById('side-panel');
+    const openLogsBtn = document.getElementById('open-logs-btn');
+    const closePanelBtn = document.getElementById('close-panel-btn');
+
+
+    // Auto-resize textarea
+    promptTextarea.addEventListener('input', function () {
+      this.style.height = 'auto';
+      this.style.height = (this.scrollHeight) + 'px';
+    });
+
+    // Handle Enter key (Shift+Enter for new line)
+    promptTextarea.addEventListener('keydown', function (e) {
+      if (e.key === 'Enter' && !e.shiftKey) {
+        e.preventDefault();
+        sendMessage();
+      }
+    });
+
+    // Send button click handler
+    sendButton.addEventListener('click', sendMessage);
+
+    // Upload button click handler
+    uploadButton.addEventListener('click', () => {
+      window.location.href = '/upload';
+    });
+
+    // Side panel toggle handlers
+    openLogsBtn.addEventListener('click', () => {
+      sidePanel.classList.add('open');
+    });
+
+    closePanelBtn.addEventListener('click', () => {
+      sidePanel.classList.remove('open');
+    });
+
+
+    function sendMessage() {
+      const prompt = promptTextarea.value.trim();
+      if (!prompt) return;
+
+      addMessage("user", prompt);
+      promptTextarea.value = '';
+      promptTextarea.style.height = 'auto';
+      typingIndicator.style.display = 'flex';
+
+      fetch("/generate", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ prompt: prompt })
+      });
+    }
+
+    function addMessage(sender, text) {
+      const messageDiv = document.createElement("div");
+      messageDiv.classList.add("message", `message-${sender}`);
+
+      const avatarDiv = document.createElement("div");
+      avatarDiv.classList.add("avatar", `avatar-${sender}`);
+      avatarDiv.innerHTML = sender === 'user' ?
+        '<i class="fas fa-user"></i>' :
+        '<i class="fas fa-robot"></i>';
+
+      const contentDiv = document.createElement("div");
+      contentDiv.classList.add("message-content");
+      contentDiv.innerHTML = `<div class="markdown-content">${text}</div>`;
+
+      messageDiv.appendChild(avatarDiv);
+      messageDiv.appendChild(contentDiv);
+      chatContainer.appendChild(messageDiv);
+      chatContainer.scrollTop = chatContainer.scrollHeight;
+    }
+
+    function addLogMessage(text, type = 'info') {
+      const now = new Date();
+      const timestamp = now.toLocaleTimeString();
+
+      const logDiv = document.createElement("div");
+      logDiv.classList.add("log-entry");
+
+      const timeDiv = document.createElement("div");
+      timeDiv.classList.add("log-timestamp");
+      timeDiv.textContent = timestamp;
+
+      const messageDiv = document.createElement("div");
+      messageDiv.classList.add("log-message");
+      if (type !== 'info') messageDiv.classList.add(`log-${type}`);
+      messageDiv.textContent = text;
+
+      logDiv.appendChild(timeDiv);
+      logDiv.appendChild(messageDiv);
+      logsContainer.appendChild(logDiv); // Append to the logs content div
+      logsContainer.scrollTop = logsContainer.scrollHeight; // Scroll logs panel
+    }
+
+    function showFlashMessage(message, type = 'error') {
+      flashMessage.textContent = message;
+      flashMessage.className = `alert alert-${type}`;
+      flashMessage.style.display = 'flex';
+
+      setTimeout(() => {
+        flashMessage.style.display = 'none';
+      }, 3000);
+    }
+
+    // Socket.io handlers
+    let agentMessageDiv = null;
+
+    socket.on("final_stream", (data) => {
+      if (!agentMessageDiv) {
+        agentMessageDiv = document.createElement("div");
+        agentMessageDiv.classList.add("message", "message-agent");
+
+        const avatarDiv = document.createElement("div");
+        avatarDiv.classList.add("avatar", "avatar-agent");
+        avatarDiv.innerHTML = '<i class="fas fa-robot"></i>';
+
+        const contentDiv = document.createElement("div");
+        contentDiv.classList.add("message-content");
+        contentDiv.id = "agent-message-content";
+
+        agentMessageDiv.appendChild(avatarDiv);
+        agentMessageDiv.appendChild(contentDiv);
+        chatContainer.appendChild(agentMessageDiv);
+      }
+
+      const contentDiv = document.getElementById("agent-message-content");
+      // const markdownHTML = marked.parse(data.message);
+      // contentDiv.innerHTML = `<div class="markdown-content">${markdownHTML}</div>`;
+      const html = marked.parse(data.message);
+      // contentDiv.innerHTML = `<div class="markdown-content">${html}</div>`;
+      contentDiv.innerHTML = `<div class="markdown-content">${html}</div>`;
+      chatContainer.scrollTop = chatContainer.scrollHeight;
+    });
+
+    socket.on("final", (data) => {
+      typingIndicator.style.display = 'none';
+
+      if (agentMessageDiv) {
+        const contentDiv = document.getElementById("agent-message-content");
+        // const markdownHTML = marked.parse(data.message);
+        // contentDiv.innerHTML = `<div class="markdown-content">${markdownHTML}</div>`;
+        const html = marked.parse(data.message);
+        // contentDiv.innerHTML = `<div class="markdown-content">${html}</div>`;
+        contentDiv.innerHTML = `<div class="markdown-content">${html}</div>`;
+        agentMessageDiv = null;
+      } else {
+        addMessage("agent", data.message);
+      }
+    });
+
+    socket.on("log", (data) => {
+      addLogMessage(data.message, data.type || 'info');
+    });
+
+    socket.on("error", (data) => {
+      showFlashMessage(data.message, 'error');
+      typingIndicator.style.display = 'none';
+    });
+
+    // Handle flash messages from server
+    if (flashMessage) {
+      setTimeout(() => {
+        flashMessage.style.display = 'none';
+      }, 3000);
+    }
+
+    // Handle new chat button click
+    // This button will clear the chat and reload the page
+    document.getElementById('new-chat-btn').addEventListener('click', () => {
+      fetch('/clear_chat', { method: 'POST' })
+        .then(response => {
+          if (response.ok) {
+            location.reload(); // Reload the page to clear the chat
+          } else {
+            alert('Failed to clear chat.');
+          }
+        })
+        .catch(error => {
+          console.error('Error:', error);
+          alert('An error occurred while clearing the chat.');
+        });
+    });
+
+  </script>
+</body>
+
+</html>

templates/index2.html

@@ -0,0 +1,289 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Agent Chat - Idea Generator</title>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.5.4/socket.io.js"></script>
+  <style>
+    /* Overall dark theme */
+    body {
+      background-color: #1a1a2e;
+      color: #eaeaea;
+      font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+      margin: 0;
+      padding: 0;
+    }
+    .container {
+      max-width: 800px;
+      margin: 0 auto;
+      padding: 20px;
+      display: flex;
+      flex-direction: column;
+      gap: 20px;
+    }
+    h1 {
+      text-align: center;
+      margin-bottom: 10px;
+      color: #eaeaea;
+    }
+    /* Wrapper for chat area, logs, and input */
+    .chat-section {
+      display: flex;
+      flex-direction: column;
+      border: 1px solid #0f3460;
+      border-radius: 8px;
+      overflow: hidden;
+    }
+    /* Chat container */
+    .chat-container {
+      background-color: #16213e;
+      padding: 20px;
+      height: 400px;
+      overflow-y: auto;
+    }
+    /* Logs container with a flash (fade-in) effect */
+    .logs-container {
+      background-color: #0f3460;
+      padding: 10px 20px;
+      height: 80px;
+      overflow-y: auto;
+    }
+    .bubble.log {
+      background-color: #444;
+      color: #ccc;
+      font-size: 0.85rem;
+      border-radius: 5px;
+      padding: 5px 10px;
+      margin: 2px 0;
+      animation: flash 0.5s ease-in-out;
+    }
+    @keyframes flash {
+      0% { opacity: 0; }
+      100% { opacity: 1; }
+    }
+    /* Chat message styles */
+    .message {
+      margin-bottom: 10px;
+      display: flex;
+      align-items: flex-start;
+    }
+    .message.user {
+      justify-content: flex-end;
+    }
+    .message.agent {
+      justify-content: flex-start;
+    }
+    .bubble {
+      max-width: 70%;
+      padding: 10px 15px;
+      border-radius: 15px;
+      line-height: 1.4;
+      word-wrap: break-word;
+    }
+    .bubble.user {
+      background-color: #007bff;
+      color: #fff;
+      border-bottom-right-radius: 0;
+    }
+    .bubble.agent {
+      background-color: #2d3a55;
+      color: #fff;
+      border-bottom-left-radius: 0;
+      position: relative;
+        }
+       /* Input area styles */
+    .input-area {
+      display: flex;
+      flex-direction: column;
+      gap: 10px;
+      padding: 10px;               /* Reduced padding */
+      background-color: #16213e;
+      box-sizing: border-box;      /* Ensure padding counts toward total width/height */
+    }
+
+    .input-area input,
+    .input-area textarea {
+      width: 100%;
+      padding: 10px;
+      border-radius: 5px;
+      border: none;
+      resize: none;
+      font-size: 1rem;
+      box-sizing: border-box;      /* Prevents overflow when combined with padding */
+    }
+
+    .input-area button {
+      padding: 10px 20px;
+      border-radius: 5px;
+      border: none;
+      background-color: #007bff;
+      color: #fff;
+      cursor: pointer;
+      align-self: flex-end;
+    }    
+    
+    .input-area button:hover {
+      background-color: #0056b3;
+    }
+    /* Loader spinner styling */
+    .loader {
+      border: 3px solid #f3f3f3;
+      border-top: 3px solid #007bff;
+      border-radius: 50%;
+      width: 16px;
+      height: 16px;
+      animation: spin 1s linear infinite;
+      margin-right: 10px;
+      display: inline-block;
+      vertical-align: middle;
+    }
+    @keyframes spin {
+      0% { transform: rotate(0deg); }
+      100% { transform: rotate(360deg); }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Agent Chat - Idea Generator</h1>
+    <div class="chat-section">
+      <!-- Chat conversation container -->
+      <div class="chat-container" id="chat">
+        <!-- Conversation messages will appear here -->
+      </div>
+      <!-- Logs container -->
+      <div class="logs-container" id="logs">
+        <!-- Log messages will appear here -->
+      </div>
+      <!-- Input area -->
+      <div class="input-area">
+        <input type="text" id="title" placeholder="Title of Idea (optional)" />
+        <textarea id="roughIdea" rows="2" placeholder="Rough Idea (optional)"></textarea>
+        <input type="text" id="category" placeholder="Category (optional)" />
+        <textarea id="query" rows="3" placeholder="User Query (mandatory)"></textarea>
+        <button id="send">Send</button>
+      </div>
+    </div>
+  </div>
+  
+  <script>
+    const socket = io();
+    const chatContainer = document.getElementById("chat");
+    const logsContainer = document.getElementById("logs");
+    const sendButton = document.getElementById("send");
+
+    // Function to add a chat message bubble
+    function addMessage(sender, text) {
+      const messageDiv = document.createElement("div");
+      messageDiv.classList.add("message", sender);
+      const bubbleDiv = document.createElement("div");
+      bubbleDiv.classList.add("bubble", sender);
+      bubbleDiv.textContent = text;
+      messageDiv.appendChild(bubbleDiv);
+      chatContainer.appendChild(messageDiv);
+      chatContainer.scrollTop = chatContainer.scrollHeight;
+    }
+
+    // Function to add a log message bubble with flash effect
+    function addLogMessage(text) {
+      const logDiv = document.createElement("div");
+      logDiv.classList.add("bubble", "log");
+      logDiv.textContent = text;
+      logsContainer.appendChild(logDiv);
+      logsContainer.scrollTop = logsContainer.scrollHeight;
+    }
+
+    // Variable to hold the agent's message bubble (with loader)
+    let agentMessageBubble = null;
+
+    // When the user clicks Send
+    sendButton.addEventListener("click", () => {
+      const title = document.getElementById("title").value.trim();
+      const roughIdea = document.getElementById("roughIdea").value.trim();
+      const category = document.getElementById("category").value.trim();
+      const query = document.getElementById("query").value.trim();
+
+      if (!query) {
+        alert("User Query is required.");
+        return;
+      }
+      
+      // Display the user's message in chat.
+      addMessage("user", query);
+
+      // Clear input fields.
+      document.getElementById("title").value = "";
+      document.getElementById("roughIdea").value = "";
+      document.getElementById("category").value = "";
+      document.getElementById("query").value = "";
+
+      // Create an agent bubble with a loader to indicate AI is processing.
+      if (!agentMessageBubble) {
+        const messageDiv = document.createElement("div");
+        messageDiv.classList.add("message", "agent");
+        agentMessageBubble = document.createElement("div");
+        agentMessageBubble.classList.add("bubble", "agent");
+        
+        // Create and add loader element.
+        const loader = document.createElement("div");
+        loader.classList.add("loader");
+        agentMessageBubble.appendChild(loader);
+        
+        messageDiv.appendChild(agentMessageBubble);
+        chatContainer.appendChild(messageDiv);
+        chatContainer.scrollTop = chatContainer.scrollHeight;
+      }
+
+      // Send the collected fields to the server.
+      fetch("/generate", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          title: title,
+          rough_idea: roughIdea,
+          category: category,
+          query: query
+        })
+      });
+    });
+
+    // Handle streaming tokens from the agent.
+    socket.on("final_stream", (data) => {
+      if (agentMessageBubble) {
+        // Remove loader if still present.
+        const loader = agentMessageBubble.querySelector(".loader");
+        if (loader) {
+          loader.remove();
+          // Clear any leftover content.
+          agentMessageBubble.textContent = "";
+        }
+        // Append the streaming token.
+        agentMessageBubble.textContent += data.message;
+        chatContainer.scrollTop = chatContainer.scrollHeight;
+      } else {
+        // Fallback: create a new agent message if needed.
+        addMessage("agent", data.message);
+      }
+    });
+
+    // When the final answer is complete.
+    // When the final answer is complete.
+    socket.on("final", (data) => {
+      // If there's no existing agent bubble, create one.
+      if (!agentMessageBubble) {
+        addMessage("agent", "");
+      }
+      // Use innerHTML to preserve any HTML tags or Markdown-converted HTML
+      agentMessageBubble.innerHTML = data.message;
+      // Reset agentMessageBubble for next time
+      agentMessageBubble = null;
+    });
+
+    // Append log messages as they arrive.
+    socket.on("log", (data) => {
+      addLogMessage(data.message);
+    });
+  </script>
+</body>
+</html>

templates/upload.html

@@ -0,0 +1,332 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Upload Database</title>
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+  <style>
+    :root {
+      --primary: #10a37f;
+      --primary-dark: #0d8a6a;
+      --bg-color: #343541;
+      --chat-bg: #444654;
+      --user-bg: #343541;
+      --text-color: #ececf1;
+      --text-secondary: #acacbe;
+      --border-color: #565869;
+      --error-color: #ef4146;
+      --warning-color: #f0b72f;
+    }
+
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    body {
+      background-color: var(--bg-color);
+      color: var(--text-color);
+      font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+      display: flex;
+      flex-direction: column;
+      min-height: 100vh;
+    }
+
+    nav {
+      background-color: var(--user-bg);
+      padding: 12px 20px;
+      border-bottom: 1px solid var(--border-color);
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+
+    .nav-title {
+      font-size: 1.2rem;
+      font-weight: 600;
+    }
+
+    .btn {
+      background-color: var(--primary);
+      color: white;
+      border: none;
+      border-radius: 4px;
+      padding: 8px 12px;
+      font-size: 0.9rem;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      transition: background-color 0.2s;
+      text-decoration: none;
+    }
+
+    .btn:hover {
+      background-color: var(--primary-dark);
+    }
+
+    main {
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      padding: 40px 20px;
+    }
+
+    .upload-container {
+      max-width: 600px;
+      width: 100%;
+      background-color: var(--chat-bg);
+      border-radius: 8px;
+      padding: 30px;
+      box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+    }
+
+    .upload-header {
+      margin-bottom: 24px;
+      text-align: center;
+    }
+
+    .upload-header h1 {
+      font-size: 1.5rem;
+      margin-bottom: 8px;
+    }
+
+    .upload-header p {
+      color: var(--text-secondary);
+      font-size: 0.9rem;
+    }
+
+    .upload-icon {
+      font-size: 2.5rem;
+      color: var(--primary);
+      margin-bottom: 16px;
+    }
+
+    .form-group {
+      margin-bottom: 20px;
+    }
+
+    .form-group label {
+      display: block;
+      margin-bottom: 8px;
+      font-size: 0.9rem;
+      color: var(--text-secondary);
+    }
+
+    .file-input-wrapper {
+      position: relative;
+      margin-bottom: 20px;
+    }
+
+    .file-input-label {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      padding: 40px 20px;
+      border: 2px dashed var(--border-color);
+      border-radius: 8px;
+      cursor: pointer;
+      transition: all 0.2s;
+      text-align: center;
+    }
+
+    .file-input-label:hover {
+      border-color: var(--primary);
+      background-color: rgba(16, 163, 127, 0.05);
+    }
+
+    .file-input-label i {
+      font-size: 2rem;
+      color: var(--primary);
+      margin-bottom: 12px;
+    }
+
+    .file-input-label span {
+      font-size: 0.9rem;
+      color: var(--text-secondary);
+    }
+
+    .file-input-label strong {
+      color: var(--primary);
+      font-weight: 600;
+    }
+
+    .file-input {
+      position: absolute;
+      width: 0.1px;
+      height: 0.1px;
+      opacity: 0;
+      overflow: hidden;
+      z-index: -1;
+    }
+
+    .file-name {
+      margin-top: 8px;
+      font-size: 0.9rem;
+      color: var(--text-color);
+      display: none;
+    }
+
+    .submit-btn {
+      width: 100%;
+      padding: 12px;
+      font-size: 1rem;
+      font-weight: 500;
+    }
+
+    .submit-btn:disabled {
+      background-color: var(--border-color);
+      cursor: not-allowed;
+    }
+
+    .alert {
+      position: fixed;
+      top: 20px;
+      left: 50%;
+      transform: translateX(-50%);
+      padding: 12px 20px;
+      border-radius: 8px;
+      background-color: var(--error-color);
+      color: white;
+      z-index: 1000;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+      animation: slideIn 0.3s ease-out;
+    }
+
+    .alert-success {
+      background-color: var(--primary);
+    }
+
+    .alert-warning {
+      background-color: var(--warning-color);
+    }
+
+    @keyframes slideIn {
+      from { top: -50px; opacity: 0; }
+      to { top: 20px; opacity: 1; }
+    }
+
+    footer {
+      background-color: var(--user-bg);
+      padding: 12px 20px;
+      border-top: 1px solid var(--border-color);
+      font-size: 0.8rem;
+      color: var(--text-secondary);
+      text-align: center;
+    }
+  </style>
+</head>
+<body>
+  <nav>
+    <div class="nav-title">Agent Chat</div>
+    <a href="/" class="btn">
+      <i class="fas fa-arrow-left"></i> Back to Chat
+    </a>
+  </nav>
+
+  <main>
+    <div class="upload-container">
+      <div class="upload-header">
+        <div class="upload-icon">
+          <i class="fas fa-upload"></i>
+        </div>
+        <h1>Upload File</h1>
+        <p>Select file to upload </p>
+      </div>
+
+      <form method="POST" action="/upload" enctype="multipart/form-data" id="uploadForm">
+        <div class="form-group">
+          <div class="file-input-wrapper">
+            <input type="file" id="dbFile" name="file" accept=".db" class="file-input" required>
+            <label for="dbFile" class="file-input-label" id="fileInputLabel">
+              <i class="fas fa-file-arrow-up"></i>
+              <span>Drag & drop your file here or <strong>browse</strong></span>
+              <span class="file-name" id="fileName"></span>
+            </label>
+          </div>
+        </div>
+        <div class="form-group">
+          <button type="submit" class="btn submit-btn" id="submitBtn" disabled>
+            <i class="fas fa-upload"></i> Upload files
+          </button>
+        </div>
+      </form>
+    </div>
+  </main>
+
+  <footer>
+    <div>Agent Chat v1.0 · © 2023</div>
+  </footer>
+
+  <div id="flash-message" class="alert" style="display: none;"></div>
+
+  <script>
+    const fileInput = document.getElementById('dbFile');
+    const fileInputLabel = document.getElementById('fileInputLabel');
+    const fileName = document.getElementById('fileName');
+    const submitBtn = document.getElementById('submitBtn');
+    const uploadForm = document.getElementById('uploadForm');
+    const flashMessage = document.getElementById('flash-message');
+
+    // Handle file selection
+    fileInput.addEventListener('change', function() {
+      if (this.files.length > 0) {
+        const file = this.files[0];
+        fileName.textContent = file.name;
+        fileName.style.display = 'block';
+        submitBtn.disabled = false;
+        
+        // Update label text
+        fileInputLabel.querySelector('span').textContent = 'Selected file:';
+        fileInputLabel.querySelector('i').className = 'fas fa-check-circle';
+        fileInputLabel.querySelector('i').style.color = 'var(--primary)';
+      } else {
+        fileName.style.display = 'none';
+        submitBtn.disabled = true;
+        
+        // Reset label text
+        fileInputLabel.querySelector('span').textContent = 'Drag & drop your file here or <strong>browse</strong>';
+        fileInputLabel.querySelector('i').className = 'fas fa-cloud-upload-alt';
+      }
+    });
+
+    // Handle drag and drop
+    fileInputLabel.addEventListener('dragover', (e) => {
+      e.preventDefault();
+      fileInputLabel.style.borderColor = 'var(--primary)';
+      fileInputLabel.style.backgroundColor = 'rgba(16, 163, 127, 0.1)';
+    });
+
+    fileInputLabel.addEventListener('dragleave', () => {
+      fileInputLabel.style.borderColor = 'var(--border-color)';
+      fileInputLabel.style.backgroundColor = 'transparent';
+    });
+
+    fileInputLabel.addEventListener('drop', (e) => {
+      e.preventDefault();
+      fileInputLabel.style.borderColor = 'var(--border-color)';
+      fileInputLabel.style.backgroundColor = 'transparent';
+      
+      if (e.dataTransfer.files.length) {
+        fileInput.files = e.dataTransfer.files;
+        const event = new Event('change');
+        fileInput.dispatchEvent(event);
+      }
+    });
+
+    // Handle flash messages
+    if (flashMessage) {
+      setTimeout(() => {
+        flashMessage.style.display = 'none';
+      }, 3000);
+    }
+  </script>
+</body>
+</html>

uploads/documents/LLM_based_QA_chatbot_builder.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:633e305a9a7fcdc69769e77d96db1fa715ab387c9f8745ebe77fa75590772848
+size 1887485