Update model.py

model.py

@@ -1,62 +1,70 @@
 import os
+from typing import List
 from langchain.vectorstores import FAISS
-from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.embeddings.base import Embeddings
 from langchain_community.document_loaders import TextLoader
 from langchain.text_splitter import CharacterTextSplitter
 from langchain.docstore.document import Document
 from langchain.chains import RetrievalQA
 from langchain_community.llms import HuggingFaceHub
-from langchain.embeddings.base import Embeddings
+from langchain_huggingface import HuggingFaceEmbeddings
 
-# Set safe caching directories to avoid permission denied errors
-os.environ["TRANSFORMERS_CACHE"] = "/app/cache"
-os.environ["HF_HOME"] = "/app/cache"
-os.makedirs("/app/cache", exist_ok=True)
+# Configure safe cache directories (writable within container)
+CACHE_DIR = "/tmp/huggingface"
+os.environ["TRANSFORMERS_CACHE"] = CACHE_DIR
+os.environ["HF_HOME"] = CACHE_DIR
+os.makedirs(CACHE_DIR, exist_ok=True)
 
 # Constants
 DATA_PATH = "/app/data"
 VECTORSTORE_PATH = "/app/vectorstore"
 DOCS_FILENAME = "context.txt"
+VECTORSTORE_INDEX_NAME = "faiss_index"
 EMBEDDING_MODEL_NAME = "sentence-transformers/paraphrase-MiniLM-L6-v2"
+LLM_REPO_ID = "mistralai/Mistral-7B-Instruct-v0.1"
 
 
 def load_embedding_model() -> Embeddings:
-    """Initialize and return the HuggingFace embedding model."""
+    """Load Hugging Face sentence transformer embeddings."""
     return HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL_NAME)
 
 
-def load_documents() -> list[Document]:
-    """Load and split documents into chunks."""
+def load_documents() -> List[Document]:
+    """Load documents and split them into manageable chunks."""
     loader = TextLoader(os.path.join(DATA_PATH, DOCS_FILENAME))
-    raw_docs = loader.load()
+    documents = loader.load()
+
     splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
-    docs = splitter.split_documents(raw_docs)
-    return docs
+    return splitter.split_documents(documents)
 
 
 def load_vectorstore() -> FAISS:
-    """Load or create FAISS vectorstore from documents."""
-    vectorstore_file = os.path.join(VECTORSTORE_PATH, "faiss_index")
-
+    """Load FAISS vectorstore from disk or create it from documents."""
+    vectorstore_dir = os.path.join(VECTORSTORE_PATH, VECTORSTORE_INDEX_NAME)
     embedding_model = load_embedding_model()
 
-    if os.path.exists(vectorstore_file):
-        return FAISS.load_local(vectorstore_file, embedding_model, allow_dangerous_deserialization=True)
+    if os.path.exists(vectorstore_dir):
+        return FAISS.load_local(
+            folder_path=vectorstore_dir,
+            embeddings=embedding_model,
+            allow_dangerous_deserialization=True,
+        )
 
-    docs = load_documents()
-    vectorstore = FAISS.from_documents(docs, embedding_model)
-    vectorstore.save_local(vectorstore_file)
+    documents = load_documents()
+    vectorstore = FAISS.from_documents(documents, embedding_model)
+    vectorstore.save_local(vectorstore_dir)
     return vectorstore
 
 
 def ask_question(query: str) -> str:
-    """Query the vectorstore and return the answer using the language model."""
+    """Run a question-answering chain with the retriever and language model."""
     vectorstore = load_vectorstore()
+    retriever = vectorstore.as_retriever()
 
     llm = HuggingFaceHub(
-        repo_id="mistralai/Mistral-7B-Instruct-v0.1",
+        repo_id=LLM_REPO_ID,
         model_kwargs={"temperature": 0.5, "max_tokens": 256},
     )
 
-    qa = RetrievalQA.from_chain_type(llm=llm, retriever=vectorstore.as_retriever())
-    return qa.run(query)
+    qa_chain = RetrievalQA.from_chain_type(llm=llm, retriever=retriever)
+    return qa_chain.run(query)