update

app.py

@@ -16,7 +16,6 @@ from flask import Flask, render_template, redirect, url_for, flash, request, jso
 from flask_login import LoginManager, login_required, current_user
 from werkzeug.utils import secure_filename
 import sys
-import json
 from datetime import datetime
 
 # Adjust sys.path for import flexibility
@@ -75,65 +74,57 @@ _hf_model = None
 _hf_tokenizer = None
 
 def init_hf_model() -> None:
-    """Initialise the Hugging Face conversational model and tokenizer.
-
-    Loading large Transformer models can be expensive.  This helper ensures
-    that we only perform the download and model initialisation once.  On
-    subsequent calls the function returns immediately if the model and
-    tokenizer are already loaded.  The model is moved to GPU if one is
-    available; otherwise it will run on the CPU.  Any import of heavy
-    dependencies such as ``transformers`` or ``torch`` is performed inside
-    this function to keep the global import section lightweight.
-    """
+    """Initialise the Hugging Face conversational model and tokenizer."""
     global _hf_model, _hf_tokenizer
     if _hf_model is not None and _hf_tokenizer is not None:
         return
-    # Local imports to avoid pulling heavy dependencies during module import.
+
     from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
     import torch
 
-    # Determine execution device.  Prefer CUDA if available; otherwise
-    # fallback to CPU.  The application will run correctly on CPU-only
-    # systems albeit with higher latency.
+    model_name = "facebook/blenderbot-400M-distill"
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-    # Load tokenizer and model.  The model weights will be downloaded the
-    # first time this function runs.  Hugging Face caches models under
-    # ``HF_HOME`` / ``TRANSFORMERS_CACHE`` which are set at the top of
-    # this file to a writable temporary directory.
-    tokenizer = AutoTokenizer.from_pretrained(HF_MODEL_NAME)
-    model = AutoModelForSeq2SeqLM.from_pretrained(HF_MODEL_NAME)
-    model.to(device)
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to(device)
 
     _hf_model = model
     _hf_tokenizer = tokenizer
 
-# Global objects used by the chatbot.  They remain ``None`` until
-# ``init_chatbot()`` runs.  After initialisation, ``_chatbot_embedder`` holds
-# the SentenceTransformer model and ``_chatbot_collection`` is the Chroma
-# collection with embedded knowledge base documents.  A separate import of
-# the OpenAI client is performed in ``get_chatbot_response()`` to avoid
-# unintentional import side effects at module import time.
-_chatbot_embedder = None
-_chatbot_collection = None
-
-def init_hf_model() -> None:
-    """Initialise the Hugging Face conversational model and tokenizer."""
-    global _hf_model, _hf_tokenizer
-    if _hf_model is not None and _hf_tokenizer is not None:
+def init_chatbot() -> None:
+    """Initialise the Chroma vector DB with chatbot.txt content."""
+    global _chatbot_embedder, _chatbot_collection
+    if _chatbot_embedder is not None and _chatbot_collection is not None:
         return
+    
+    from langchain.text_splitter import RecursiveCharacterTextSplitter
+    from sentence_transformers import SentenceTransformer
+    import chromadb
+    from chromadb.config import Settings
+    import os
 
-    from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
-    import torch
+    os.makedirs(CHATBOT_DB_DIR, exist_ok=True)
 
-    model_name = "facebook/blenderbot-400M-distill"
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    with open(CHATBOT_TXT_PATH, encoding="utf-8") as f:
+        text = f.read()
+    splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=100)
+    docs = [doc.strip() for doc in splitter.split_text(text)]
 
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to(device)
+    embedder = SentenceTransformer("all-MiniLM-L6-v2")
+    embeddings = embedder.encode(docs, show_progress_bar=False, batch_size=32)
 
-    _hf_model = model
-    _hf_tokenizer = tokenizer
+    client = chromadb.Client(Settings(persist_directory=CHATBOT_DB_DIR, anonymized_telemetry=False))
+    collection = client.get_or_create_collection("chatbot")
+    ids = [f"doc_{i}" for i in range(len(docs))]
+    try:
+        existing = collection.get(ids=ids[:1])
+        if not existing.get("documents"):
+            raise ValueError("Empty Chroma DB")
+    except Exception:
+        collection.add(documents=docs, embeddings=embeddings, ids=ids)
+
+    _chatbot_embedder = embedder
+    _chatbot_collection = collection
 
 
 def get_chatbot_response(query: str) -> str: