Removed langchain and llama-cpp-python (not actively supported anymore) dependencies. Updated packages. Updated default dataset

Dockerfile

@@ -27,7 +27,6 @@ COPY requirements_aws.txt .
 RUN pip install torch==2.5.1+cpu --target=/install --index-url https://download.pytorch.org/whl/cpu \
 && pip install --no-cache-dir --target=/install sentence-transformers==4.1.0 --no-deps \
 && pip install --no-cache-dir --target=/install span-marker==1.7.0 --no-deps \
-&& pip install --no-cache-dir --target=/install langchain-huggingface==0.1.2 --no-deps \
 && pip install --no-cache-dir --target=/install keybert==0.9.0 --no-deps \
 && pip install --no-cache-dir --target=/install -r requirements_aws.txt
 

app.py

@@ -1,11 +1,10 @@
 import os
 from typing import Type
-#from langchain_huggingface.embeddings import HuggingFaceEmbeddings
-from langchain_community.vectorstores import FAISS
+from tools.faiss_store import FAISS
 import gradio as gr
 import pandas as pd
 from torch import float16, float32
-from llama_cpp import Llama
+
 from huggingface_hub import hf_hub_download
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM,  AutoModelForCausalLM
 
@@ -13,7 +12,7 @@ from tools.ingest import embed_faiss_save_to_zip, load_embeddings_model, get_fai
 from tools.helper_functions import get_connection_params, reveal_feedback_buttons, wipe_logs
 from tools.aws_functions import upload_file_to_s3
 from tools.auth import authenticate_user
-from tools.config import FEEDBACK_LOGS_FOLDER, ACCESS_LOGS_FOLDER, USAGE_LOGS_FOLDER, HOST_NAME, COGNITO_AUTH, INPUT_FOLDER, OUTPUT_FOLDER, MAX_QUEUE_SIZE, DEFAULT_CONCURRENCY_LIMIT, MAX_FILE_SIZE, GRADIO_SERVER_PORT, ROOT_PATH, DEFAULT_EMBEDDINGS_LOCATION, EMBEDDINGS_MODEL_NAME, DEFAULT_DATA_SOURCE, HF_TOKEN, LARGE_MODEL_REPO_ID, LARGE_MODEL_GGUF_FILE, LARGE_MODEL_NAME, SMALL_MODEL_NAME, SMALL_MODEL_REPO_ID, DEFAULT_DATA_SOURCE_NAME, DEFAULT_EXAMPLES, DEFAULT_MODEL_CHOICES, RUN_GEMINI_MODELS, LOAD_LARGE_MODEL
+from tools.config import FEEDBACK_LOGS_FOLDER, ACCESS_LOGS_FOLDER, USAGE_LOGS_FOLDER, HOST_NAME, COGNITO_AUTH, INPUT_FOLDER, OUTPUT_FOLDER, MAX_QUEUE_SIZE, DEFAULT_CONCURRENCY_LIMIT, MAX_FILE_SIZE, GRADIO_SERVER_PORT, ROOT_PATH, DEFAULT_EMBEDDINGS_LOCATION, EMBEDDINGS_MODEL_NAME, DEFAULT_DATA_SOURCE, HF_TOKEN, LARGE_MODEL_REPO_ID, LARGE_MODEL_GGUF_FILE, LARGE_MODEL_NAME, SMALL_MODEL_NAME, SMALL_MODEL_REPO_ID, DEFAULT_DATA_SOURCE_NAME, DEFAULT_EXAMPLES, DEFAULT_MODEL_CHOICES, RUN_GEMINI_MODELS, LOAD_LARGE_MODEL, GEMINI_API_KEY
 from tools.model_load import torch_device, gpu_config, cpu_config, context_length
 import tools.chatfuncs as chatf
 import tools.ingest as ing
@@ -39,10 +38,11 @@ if isinstance(DEFAULT_MODEL_CHOICES, str): default_model_choices = eval(DEFAULT_
 ###
 # Load in default embeddings and embeddings model name
 embeddings_model = load_embeddings_model(EMBEDDINGS_MODEL_NAME)
-vectorstore = get_faiss_store(zip_file_path=DEFAULT_EMBEDDINGS_LOCATION,embeddings_model=embeddings_model)#globals()["embeddings"])
+# vectorstore = get_faiss_store(zip_file_path=DEFAULT_EMBEDDINGS_LOCATION,embeddings_model=embeddings_model)#globals()["embeddings"])
+vectorstore = None
 
 chatf.embeddings = embeddings_model
-chatf.vectorstore = vectorstore
+# chatf.vectorstore = vectorstore
 
 def docs_to_faiss_save(docs_out:PandasDataFrame, embeddings_model=embeddings_model):
 
@@ -64,17 +64,17 @@ def create_hf_model(model_name:str, hf_token=HF_TOKEN):
             model = AutoModelForSeq2SeqLM.from_pretrained(model_name, device_map="auto")#, torch_dtype=torch.float16)
         else:
             if hf_token:
-                model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", token=hf_token, torch_dtype=float32) # , torch_dtype=float16 - not compatible with CPU and Gemma 3
+                model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", token=hf_token) # , torch_dtype=float16 - not compatible with CPU and Gemma 3
             else:
-                model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", torch_dtype=float32) # , torch_dtype=float16
+                model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto") # , torch_dtype=float16
     else:
         if "flan" in model_name:
             model = AutoModelForSeq2SeqLM.from_pretrained(model_name)#, torch_dtype=torch.float16)
         else:
             if hf_token:
-                model = AutoModelForCausalLM.from_pretrained(model_name, token=hf_token, torch_dtype=float32) # , torch_dtype=float16
+                model = AutoModelForCausalLM.from_pretrained(model_name, token=hf_token) # , torch_dtype=float16
             else:
-                model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=float32) # , torch_dtype=float16
+                model = AutoModelForCausalLM.from_pretrained(model_name) # , torch_dtype=float16
 
     if hf_token:
         tokenizer = AutoTokenizer.from_pretrained(model_name, model_max_length = context_length, token=hf_token)
@@ -97,6 +97,7 @@ def load_model(model_type:str, gpu_layers:int, gpu_config:dict=gpu_config, cpu_c
             print("Loading with", cpu_config.n_gpu_layers, "model layers sent to GPU.")
 
         try:
+            from llama_cpp import Llama
             model = Llama(
             model_path=hf_hub_download(
             repo_id=LARGE_MODEL_REPO_ID,
@@ -248,9 +249,9 @@ with app:
             with gr.Column(scale=3):
                 model_choice = gr.Radio(label="Choose a chat model", value=SMALL_MODEL_NAME, choices = default_model_choices)
                 if RUN_GEMINI_MODELS == "1":
-                    in_api_key = gr.Textbox(value = "", label="Enter Gemini API key (only if using Google API models)", lines=1, type="password",interactive=True, visible=True)
+                    in_api_key = gr.Textbox(value = GEMINI_API_KEY, label="Enter Gemini API key (only if using Google API models)", lines=1, type="password",interactive=True, visible=True)
                 else:
-                    in_api_key = gr.Textbox(value = "", label="Enter Gemini API key (only if using Google API models)", lines=1, type="password",interactive=True, visible=False)
+                    in_api_key = gr.Textbox(value = GEMINI_API_KEY, label="Enter Gemini API key (only if using Google API models)", lines=1, type="password",interactive=True, visible=False)
             with gr.Column(scale=1):
                 change_model_button = gr.Button(value="Load model")
 
@@ -264,7 +265,7 @@ with app:
         load_text = gr.Text(label="Load status")        
 
     gr.HTML(
-        "<center>This app is powered by Gradio, Transformers, and Llama.cpp.</center>"
+        "<center>This app is powered by Gradio and Transformers.</center>"
     )
 
     examples_set.change(fn=chatf.update_message, inputs=[examples_set], outputs=[message])

faiss_embedding/faiss_embedding.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:20d1c95c817837b8538657ded2fbc840677ccb28fa92becf8d678d51f5662199
-size 286111
+oid sha256:5e9d58ea966d7fb5bf05c6d13217ab0a4f15c18607976b3ed443b6bd163b390e
+size 293425

requirements.txt

@@ -1,26 +1,24 @@
-langchain==0.3.24
-langchain-huggingface==0.1.2
-langchain-community==0.3.22
 beautifulsoup4==4.13.4
-google-generativeai==0.8.5
+google-genai==1.50.0
 pandas==2.2.3
-transformers==4.51.3
+markdown==3.8.1
+transformers==4.57.1
 # For Windows https://github.com/abetlen/llama-cpp-python/releases/download/v0.3.2/llama_cpp_python-0.3.2-cp311-#cp311-win_amd64.whl -C cmake.args="-DGGML_BLAS=ON;-DGGML_BLAS_VENDOR=OpenBLAS" 
-llama-cpp-python==0.3.2 --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu # For linux if dependencies for below build command are not available in the environment
+# llama-cpp-python==0.3.2 --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu # For linux if dependencies for below build command are not available in the environment
 #llama-cpp-python==0.3.9 -C cmake.args="-DGGML_BLAS=ON;-DGGML_BLAS_VENDOR=OpenBLAS" # CPU
 #llama-cpp-python==0.3.9 -C cmake.args="-DGGML_CUDA=on" # With CUDA
-torch==2.5.1 --extra-index-url https://download.pytorch.org/whl/cpu
-sentence_transformers==4.1.0
+torch>=2.6.0 --extra-index-url https://download.pytorch.org/whl/cpu
+sentence_transformers==5.1.2
 faiss-cpu==1.10.0
 pypdf==5.4.0
 python-docx==1.1.2
 keybert==0.9.0
 span-marker==1.7.0
-gradio==5.25.2
+gradio==5.49.1
 nltk==3.9.1
-bm25s==0.2.12
+bm25s==0.2.14
 PyStemmer==2.2.0.3
-scipy==1.15.2
-numpy==1.26.4
-boto3==1.38.0
+scipy==1.16.3
+numpy==2.2.6
+boto3==1.40.72
 python-dotenv==1.1.0

requirements_aws.txt

@@ -1,15 +1,13 @@
-#langchain==0.3.24
-#langchain-huggingface==0.1.2 # Loaded in Dockerfile
 boto3==1.38.0
 python-dotenv==1.1.0
-langchain-community==0.3.22
 beautifulsoup4==4.13.4
-google-generativeai==0.8.5
+google-genai==1.50.0
 pandas==2.2.3
-transformers==4.51.3
+markdown==3.8.1
+transformers==4.57.1
 # For Windows https://github.com/abetlen/llama-cpp-python/releases/download/v0.3.2/llama_cpp_python-0.3.2-cp311-#cp311-win_amd64.whl -C cmake.args="-DGGML_BLAS=ON;-DGGML_BLAS_VENDOR=OpenBLAS" 
 #llama-cpp-python==0.3.2 --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu # For linux if dependencies for below build command are not available in the environment
-llama-cpp-python==0.3.8 -C cmake.args="-DGGML_BLAS=ON;-DGGML_BLAS_VENDOR=OpenBLAS"
+# llama-cpp-python==0.3.16 -C cmake.args="-DGGML_BLAS=ON;-DGGML_BLAS_VENDOR=OpenBLAS"
 #torch==2.5.1 --extra-index-url https://download.pytorch.org/whl/cpu # Loaded in Dockerfile
 #sentence_transformers==4.1.0 # Loaded in Dockerfile
 faiss-cpu==1.10.0
@@ -17,11 +15,11 @@ pypdf==5.4.0
 python-docx==1.1.2
 #keybert==0.9.0 # Loaded in Dockerfile
 #span-marker==1.7.0 # Loaded in Dockerfile
-gradio==5.25.2
+gradio==5.49.1
 nltk==3.9.1
-bm25s==0.2.12
+bm25s==0.2.14
 PyStemmer==2.2.0.3
-scikit-learn==1.6.1
-scipy==1.15.2
-numpy==1.26.4
+scikit-learn==1.7.2
+scipy==1.16.3
+numpy==2.2.6
 

requirements_gpu.txt

@@ -1,24 +1,22 @@
-#langchain==0.3.24
-langchain-community==0.3.22
-langchain-huggingface==0.1.2
 beautifulsoup4==4.13.4
-google-generativeai==0.8.5
+google-genai==1.50.0
 pandas==2.2.3
-transformers==4.51.3
-torch==2.5.1 --extra-index-url https://download.pytorch.org/whl/cu121
-#llama-cpp-python==0.3.2 --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu121
-llama-cpp-python==0.3.8 -C cmake.args="-DGGML_CUDA=on"
-sentence_transformers==4.1.0
+markdown==3.8.1
+transformers==4.57.1
+torch>=2.6.0 --extra-index-url https://download.pytorch.org/whl/cu126
+#llama-cpp-python==0.3.2 --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124
+# llama-cpp-python==0.3.16 -C cmake.args="-DGGML_CUDA=on"
+sentence_transformers==5.1.2
 faiss-cpu==1.10.0
 pypdf==5.4.0
 python-docx==1.1.2
 keybert==0.9.0
 span-marker==1.7.0
-gradio==5.25.2
+gradio==5.49.1
 nltk==3.9.1
-bm25s==0.2.12
+bm25s==0.2.14
 PyStemmer==2.2.0.3
-scipy==1.15.2
-numpy==1.26.4
-boto3==1.38.0
+scipy==1.16.3
+numpy==2.2.6
+boto3==1.40.72
 python-dotenv==1.1.0

tools/chatfuncs.py

@@ -1,11 +1,12 @@
 import re
 import os
 import datetime
-from typing import Type, Dict, List, Tuple
+from typing import Type, Dict, List, Tuple, Union
 import time
 from itertools import compress
 import pandas as pd
-import google.generativeai as ai
+from google import genai as ai
+from google.genai import types
 import gradio as gr
 from gradio import Progress
 import boto3
@@ -14,7 +15,10 @@ from nltk.corpus import stopwords
 from nltk.tokenize import RegexpTokenizer
 from nltk.stem import WordNetLemmatizer
 from keybert import KeyBERT
-from langchain_huggingface.embeddings import HuggingFaceEmbeddings
+from tools.embeddings import HuggingFaceEmbeddings
+from tools.faiss_store import FAISS
+from tools.text_splitter import RecursiveCharacterTextSplitter
+from tools.document import Document
 
 # For Name Entity Recognition model
 #from span_marker import SpanMarkerModel # Not currently used
@@ -26,12 +30,6 @@ import Stemmer
 import torch.cuda
 from threading import Thread
 from transformers import pipeline, TextIteratorStreamer
-# Langchain functions
-from langchain.prompts import PromptTemplate
-from langchain_community.vectorstores import FAISS
-from langchain_community.retrievers import SVMRetriever 
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.docstore.document import Document
 
 from tools.prompts import instruction_prompt_template_alpaca, instruction_prompt_mistral_orca, instruction_prompt_phi3, instruction_prompt_llama3, instruction_prompt_qwen, instruction_prompt_template_orca, instruction_prompt_gemma, instruction_prompt_template_gemini_aws
 from tools.model_load import temperature, max_new_tokens, sample, repetition_penalty, top_p, top_k, torch_device, CtransGenGenerationConfig, max_tokens
@@ -79,26 +77,19 @@ kw_model = pipeline("feature-extraction", model="sentence-transformers/all-MiniL
 
 def base_prompt_templates(model_type:str = SMALL_MODEL_NAME):    
   
-    #EXAMPLE_PROMPT = PromptTemplate(
-    #    template="\nCONTENT:\n\n{page_content}\n\nSOURCE: {source}\n\n",
-    #    input_variables=["page_content", "source"],
-    #)
-
-    CONTENT_PROMPT = PromptTemplate(
-        template="{page_content}\n\n",#\n\nSOURCE: {source}\n\n",
-        input_variables=["page_content"]
-    )
+    # Simple string template for content
+    CONTENT_PROMPT_TEMPLATE = "{page_content}\n\n"
 
 # The main prompt:  
 
     if model_type == SMALL_MODEL_NAME:
-        INSTRUCTION_PROMPT=PromptTemplate(template=instruction_prompt_gemma, input_variables=['question', 'summaries'])
+        INSTRUCTION_PROMPT_TEMPLATE = instruction_prompt_gemma
     elif model_type == LARGE_MODEL_NAME:
-        INSTRUCTION_PROMPT=PromptTemplate(template=instruction_prompt_phi3, input_variables=['question', 'summaries'])
+        INSTRUCTION_PROMPT_TEMPLATE = instruction_prompt_phi3
     else:
-        INSTRUCTION_PROMPT=PromptTemplate(template=instruction_prompt_template_gemini_aws, input_variables=['question', 'summaries'])
+        INSTRUCTION_PROMPT_TEMPLATE = instruction_prompt_template_gemini_aws
 
-    return INSTRUCTION_PROMPT, CONTENT_PROMPT
+    return INSTRUCTION_PROMPT_TEMPLATE, CONTENT_PROMPT_TEMPLATE
 
 def write_out_metadata_as_string(metadata_in:str):
     metadata_string = [f"{'  '.join(f'{k}: {v}' for k, v in d.items() if k != 'page_section')}" for d in metadata_in] # ['metadata']
@@ -175,7 +166,7 @@ def generate_expanded_prompt(
 
     sources_docs_content_string = '<br><br>'.join(doc_df['content_meta'])#.replace("  "," ")#.strip()
     
-    instruction_prompt_out = instruction_prompt.format(question=new_question_kworded, summaries=docs_content_string)
+    instruction_prompt_out = instruction_prompt.replace('{question}', new_question_kworded).replace('{summaries}', docs_content_string)
             
     return instruction_prompt_out, sources_docs_content_string, new_question_kworded
 
@@ -269,9 +260,9 @@ def call_aws_claude(prompt: str, system_prompt: str, temperature: float, max_tok
     
     return response
 
-def construct_gemini_generative_model(in_api_key: str, temperature: float, model_choice: str, system_prompt: str, max_tokens: int) -> Tuple[object, dict]:
+def construct_gemini_generative_model(in_api_key: str, temperature: float, model_choice: str, system_prompt: str, max_tokens: int, random_seed: int = None) -> Tuple[object, dict]:
     """
-    Constructs a GenerativeModel for Gemini API calls.
+    Constructs a Client for Gemini API calls using the new google.genai package.
 
     Parameters:
     - in_api_key (str): The API key for authentication.
@@ -279,34 +270,37 @@ def construct_gemini_generative_model(in_api_key: str, temperature: float, model
     - model_choice (str): The choice of model to use for generation.
     - system_prompt (str): The system prompt to guide the generation.
     - max_tokens (int): The maximum number of tokens to generate.
+    - random_seed (int, optional): Random seed for reproducibility.
 
     Returns:
-    - Tuple[object, dict]: A tuple containing the constructed GenerativeModel and its configuration.
+    - Tuple[object, dict]: A tuple containing the constructed Client and its configuration.
     """
-    # Construct a GenerativeModel
+    # Construct a Client for the new API
     try:
         if in_api_key:
             #print("Getting API key from textbox")
             api_key = in_api_key
-            ai.configure(api_key=api_key)
+            client = ai.Client(api_key=api_key)
         elif "GOOGLE_API_KEY" in os.environ:
             #print("Searching for API key in environmental variables")
             api_key = os.environ["GOOGLE_API_KEY"]
-            ai.configure(api_key=api_key)
+            client = ai.Client(api_key=api_key)
         else:
-            print("No API key foound")
+            print("No API key found")
             raise gr.Error("No API key found.")
     except Exception as e:
         print(e)
+        raise
     
-    config = ai.GenerationConfig(temperature=temperature, max_output_tokens=max_tokens)
+    # Create config with optional random_seed
+    config_kwargs = {"temperature": temperature, "max_output_tokens": max_tokens}
+    if random_seed is not None:
+        config_kwargs["seed"] = random_seed
+    config = types.GenerateContentConfig(**config_kwargs)
 
     print("model_choice:", model_choice)
-
-    #model = ai.GenerativeModel.from_cached_content(cached_content=cache, generation_config=config)
-    model = ai.GenerativeModel(model_name=model_choice, system_instruction=system_prompt, generation_config=config)
     
-    return model, config
+    return client, config
 
 # Function to send a request and update history
 def send_request(prompt: str, conversation_history: List[dict], model: object, config: dict, model_choice: str, system_prompt: str, temperature: float, progress=Progress(track_tqdm=True)) -> Tuple[str, List[dict]]:
@@ -333,7 +327,15 @@ def send_request(prompt: str, conversation_history: List[dict], model: object, c
     # Generate the model's response
     if "gemini" in model_choice:
         try:
-            response = model.generate_content(contents=full_prompt, generation_config=config)
+            # New API: client.models.generate_content instead of model.generate_content
+            gemini_response = model.models.generate_content(model=model_choice, contents=full_prompt, config=config)
+            # Wrap response in ResponseObject for backwards compatibility
+            usage_metadata = {}
+            if hasattr(gemini_response, 'usage_metadata'):
+                usage_metadata = gemini_response.usage_metadata
+            elif hasattr(gemini_response, 'usage'):
+                usage_metadata = gemini_response.usage
+            response = ResponseObject(text=gemini_response.text, usage_metadata=usage_metadata)
         except Exception as e:
             # If fails, try again after 10 seconds in case there is a throttle limit
             print(e)
@@ -343,7 +345,14 @@ def send_request(prompt: str, conversation_history: List[dict], model: object, c
                 print(out_message)
                 progress(0.5, desc=out_message)
                 time.sleep(30)
-                response = model.generate_content(contents=full_prompt, generation_config=config)
+                gemini_response = model.models.generate_content(model=model_choice, contents=full_prompt, config=config)
+                # Wrap response in ResponseObject for backwards compatibility
+                usage_metadata = {}
+                if hasattr(gemini_response, 'usage_metadata'):
+                    usage_metadata = gemini_response.usage_metadata
+                elif hasattr(gemini_response, 'usage'):
+                    usage_metadata = gemini_response.usage
+                response = ResponseObject(text=gemini_response.text, usage_metadata=usage_metadata)
             except Exception as e:
                 print(e)
                 return "", conversation_history
@@ -559,7 +568,7 @@ def produce_streaming_answer_chatbot(
         history.append({"metadata":None, "options":None, "role": "assistant", "content": ''})
         
         for char in clean_response_text:
-            time.sleep(0.005)
+            time.sleep(0.001)
             history[-1]['content'] += char
             yield history
     
@@ -594,7 +603,7 @@ def produce_streaming_answer_chatbot(
         history.append({"metadata":None, "options":None, "role": "assistant", "content": ''})
         
         for char in clean_response_text:
-            time.sleep(0.005)
+            time.sleep(0.001)
             history[-1]['content'] += char
             yield history
 
@@ -795,31 +804,29 @@ def hybrid_retrieval(
     
 
     # 3rd level check on retrieved docs with SVM retriever
-    # Check the type of the embeddings_model object
-    embeddings_type = type(embeddings_model)
-
-
-    #hf_embeddings = HuggingFaceEmbeddings(**embeddings)
-    hf_embeddings = embeddings_model
-    
-    svm_retriever = SVMRetriever.from_texts(content_keep, hf_embeddings, k = k_val)
-    svm_result = svm_retriever.invoke(new_question_kworded)
-
-    
-    svm_rank=[]
+    # Note: SVM retriever removed - using vector similarity only
+    # If svm_weight > 0, we'll use a simple ranking based on vector similarity
+    svm_rank = []
     svm_score = []
-
-    for vec_item in docs_keep:
-        x = 0
-        for svm_item in svm_result:
-            x = x + 1
-            if svm_item.page_content == vec_item[0].page_content:
-                svm_rank.append(x)
-                svm_score.append((docs_keep_length/x)*svm_weight)
+    
+    if svm_weight > 0:
+        # Use vector similarity ranking as a proxy for SVM ranking
+        # This maintains the same interface but uses vector scores
+        for i, vec_item in enumerate(docs_keep):
+            # Use inverse rank (lower rank = higher score)
+            rank = i + 1
+            svm_rank.append(rank)
+            svm_score.append((docs_keep_length/rank)*svm_weight)
+    else:
+        # If svm_weight is 0, set all scores to 0
+        svm_rank = [0] * docs_keep_length
+        svm_score = [0.0] * docs_keep_length
 
 
-    ## Calculate final score based on three ranking methods
-    final_score = [a  + b + c for a, b, c in zip(vec_score, bm25_score, svm_score)]
+    ## Calculate final score based on ranking methods (vector, BM25, and optionally SVM)
+    # Ensure all lists have the same length
+    min_len = min(len(vec_score), len(bm25_score), len(svm_score))
+    final_score = [a + b + c for a, b, c in zip(vec_score[:min_len], bm25_score[:min_len], svm_score[:min_len])]
     final_rank = [sorted(final_score, reverse=True).index(x)+1 for x in final_score]
     # Force final_rank to increment by 1 each time
     final_rank = list(pd.Series(final_rank).rank(method='first'))

tools/config.py

@@ -189,9 +189,9 @@ LOAD_LARGE_MODEL = get_or_create_env_var("LOAD_LARGE_MODEL", '0')
 
 LARGE_MODEL_NAME = get_or_create_env_var("LARGE_MODEL_NAME", "Phi 3.5 Mini (larger, slow)")
 
-LARGE_MODEL_REPO_ID = get_or_create_env_var("LARGE_MODEL_REPO_ID", "QuantFactory/Phi-3.5-mini-instruct-GGUF") # "QuantFactory/Phi-3-mini-128k-instruct-GGUF"), # "QuantFactory/Meta-Llama-3-8B-Instruct-GGUF-v2"), #"microsoft/Phi-3-mini-4k-instruct-gguf"),#"TheBloke/Mistral-7B-OpenOrca-GGUF"),
+LARGE_MODEL_REPO_ID = get_or_create_env_var("LARGE_MODEL_REPO_ID", "QuantFactory/Phi-3.5-mini-instruct-GGUF") # THIS METHOD IS DEPRECATED AND WILL NO LONGER BE USED IN FUTURE (Llama-cpp-python is no longer being updated)
 
-LARGE_MODEL_GGUF_FILE = get_or_create_env_var("LARGE_MODEL_GGUF_FILE", "Phi-3.5-mini-instruct.Q4_K_M.gguf") #"Phi-3-mini-128k-instruct.Q4_K_M.gguf")  #"Meta-Llama-3-8B-Instruct-v2.Q6_K.gguf") #"Phi-3-mini-4k-instruct-q4.gguf")#"mistral-7b-openorca.Q4_K_M.gguf"),
+LARGE_MODEL_GGUF_FILE = get_or_create_env_var("LARGE_MODEL_GGUF_FILE", "Phi-3.5-mini-instruct.Q4_K_M.gguf")
 
 # Build up options for models
 default_model_choices = [SMALL_MODEL_NAME]

tools/document.py

@@ -0,0 +1,16 @@
+"""
+Custom Document class to replace langchain Document.
+"""
+from typing import Dict, Any, Optional
+
+
+class Document:
+    """A simple document class with page_content and metadata."""
+    
+    def __init__(self, page_content: str, metadata: Optional[Dict[str, Any]] = None):
+        self.page_content = page_content
+        self.metadata = metadata if metadata is not None else {}
+    
+    def __repr__(self):
+        return f"Document(page_content='{self.page_content[:50]}...', metadata={self.metadata})"
+

tools/embeddings.py

@@ -0,0 +1,24 @@
+"""
+Custom embeddings wrapper using sentence-transformers to replace langchain HuggingFaceEmbeddings.
+"""
+from typing import List, Union
+from sentence_transformers import SentenceTransformer
+
+
+class HuggingFaceEmbeddings:
+    """Wrapper around SentenceTransformer to match langchain interface."""
+    
+    def __init__(self, model_name: str = "sentence-transformers/all-MiniLM-L6-v2", **kwargs):
+        self.model_name = model_name
+        self.model = SentenceTransformer(model_name, **kwargs)
+    
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed a list of documents."""
+        embeddings = self.model.encode(texts, convert_to_numpy=True, show_progress_bar=False)
+        return embeddings.tolist()
+    
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a single query."""
+        embedding = self.model.encode([text], convert_to_numpy=True, show_progress_bar=False)
+        return embedding[0].tolist()
+

tools/faiss_store.py

@@ -0,0 +1,201 @@
+"""
+Custom FAISS vectorstore to replace langchain FAISS.
+"""
+import os
+import pickle
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import List, Tuple, Optional, Dict, Any
+import numpy as np
+import faiss
+from uuid import uuid4
+
+from tools.document import Document
+
+
+class InMemoryDocstore:
+    """Simple in-memory document store."""
+    
+    def __init__(self):
+        self._dict: Dict[str, Document] = {}
+    
+    def add(self, mapping: Dict[str, Document]):
+        """Add documents to the store."""
+        if not isinstance(self._dict, dict):
+            # Ensure _dict is a dictionary
+            if hasattr(self._dict, '_dict'):
+                self._dict = self._dict._dict
+            else:
+                self._dict = {}
+        self._dict.update(mapping)
+    
+    def get(self, key: str) -> Optional[Document]:
+        """Get a document by key."""
+        if not isinstance(self._dict, dict):
+            # Ensure _dict is a dictionary
+            if hasattr(self._dict, '_dict'):
+                self._dict = self._dict._dict
+            else:
+                self._dict = {}
+        return self._dict.get(key)
+
+
+class FAISS:
+    """FAISS vectorstore wrapper."""
+    
+    def __init__(
+        self,
+        embedding_function,
+        index: Optional[faiss.Index] = None,
+        docstore: Optional[InMemoryDocstore] = None,
+        index_to_docstore_id: Optional[Dict[int, str]] = None
+    ):
+        self.embedding_function = embedding_function
+        self.index = index
+        self.docstore = docstore if docstore else InMemoryDocstore()
+        self.index_to_docstore_id = index_to_docstore_id if index_to_docstore_id else {}
+    
+    @classmethod
+    def from_documents(
+        cls,
+        documents: List[Document],
+        embedding
+    ) -> "FAISS":
+        """Create a FAISS index from documents."""
+        if not documents:
+            raise ValueError("No documents provided")
+        
+        # Generate embeddings
+        texts = [doc.page_content for doc in documents]
+        embeddings = embedding.embed_documents(texts)
+        embeddings_np = np.array(embeddings).astype("float32")
+        
+        # Create FAISS index
+        dimension = embeddings_np.shape[1]
+        index = faiss.IndexFlatIP(dimension)
+        index.add(embeddings_np)
+        
+        # Create docstore
+        docstore = InMemoryDocstore()
+        index_to_docstore_id = {}
+        
+        for i, doc in enumerate(documents):
+            doc_id = str(uuid4())
+            docstore.add({doc_id: doc})
+            index_to_docstore_id[i] = doc_id
+        
+        return cls(
+            embedding_function=embedding.embed_query,
+            index=index,
+            docstore=docstore,
+            index_to_docstore_id=index_to_docstore_id
+        )
+    
+    def similarity_search_with_score(
+        self,
+        query: str,
+        k: int = 4
+    ) -> List[Tuple[Document, float]]:
+        """Search for similar documents with scores."""
+        if self.index is None:
+            return []
+        
+        # Get query embedding
+        query_embedding = self.embedding_function(query)
+        query_vector = np.array([query_embedding]).astype("float32")
+        
+        # Search
+        scores, indices = self.index.search(query_vector, k)
+        
+        results = []
+        for score, idx in zip(scores[0], indices[0]):
+            if idx < 0:  # FAISS returns -1 for invalid indices
+                continue
+            doc_id = self.index_to_docstore_id.get(idx)
+            if doc_id:
+                doc = self.docstore.get(doc_id)
+                if doc:
+                    results.append((doc, float(score)))
+        
+        return results
+    
+    def save_local(self, folder_path: str):
+        """Save the FAISS index and docstore to disk."""
+        folder = Path(folder_path)
+        folder.mkdir(parents=True, exist_ok=True)
+        
+        # Save FAISS index
+        faiss.write_index(self.index, str(folder / "index.faiss"))
+        
+        # Save docstore and mapping
+        save_dict = {
+            "docstore": self.docstore._dict,
+            "index_to_docstore_id": self.index_to_docstore_id
+        }
+        with open(folder / "index.pkl", "wb") as f:
+            pickle.dump(save_dict, f)
+    
+    @classmethod
+    def load_local(
+        cls,
+        folder_path: str,
+        embeddings,
+        allow_dangerous_deserialization: bool = False
+    ) -> "FAISS":
+        """Load a FAISS index from disk."""
+        if not allow_dangerous_deserialization:
+            raise ValueError("allow_dangerous_deserialization must be True to load pickled files")
+        
+        folder = Path(folder_path)
+        
+        # Load FAISS index
+        index = faiss.read_index(str(folder / "index.faiss"))
+        
+        # Load docstore and mapping
+        with open(folder / "index.pkl", "rb") as f:
+            save_dict = pickle.load(f)
+        
+        # Handle different pickle formats (dict or tuple)
+        if isinstance(save_dict, dict):
+            # Expected format: dictionary with keys
+            docstore_data = save_dict.get("docstore", {})
+            index_to_docstore_id = save_dict.get("index_to_docstore_id", {})
+        elif isinstance(save_dict, tuple):
+            # Legacy format: might be a tuple, try to unpack
+            # If tuple has 2 elements, assume (docstore_dict, index_to_docstore_id)
+            if len(save_dict) == 2:
+                docstore_data, index_to_docstore_id = save_dict
+            else:
+                raise ValueError(
+                    f"Unexpected pickle format: tuple with {len(save_dict)} elements. "
+                    f"Expected dictionary or tuple with 2 elements."
+                )
+        else:
+            raise TypeError(
+                f"Unexpected pickle format: {type(save_dict)}. "
+                f"Expected dictionary or tuple."
+            )
+        
+        # Handle docstore_data - could be a dict or InMemoryDocstore object
+        docstore = InMemoryDocstore()
+        if isinstance(docstore_data, dict):
+            # It's a dictionary, use it directly
+            docstore._dict = docstore_data
+        elif isinstance(docstore_data, InMemoryDocstore):
+            # It's already an InMemoryDocstore object, copy its _dict
+            docstore._dict = docstore_data._dict.copy()
+        else:
+            # Try to convert to dict or raise error
+            raise TypeError(
+                f"Unexpected docstore format: {type(docstore_data)}. "
+                f"Expected dictionary or InMemoryDocstore object."
+            )
+        
+        return cls(
+            embedding_function=embeddings.embed_query,
+            index=index,
+            docstore=docstore,
+            index_to_docstore_id=index_to_docstore_id
+        )
+

tools/ingest.py

@@ -14,17 +14,18 @@ import zipfile
 import tempfile
 from pathlib import Path
 
-from langchain_huggingface.embeddings import HuggingFaceEmbeddings
-#from langchain_community.embeddings import HuggingFaceEmbeddings # HuggingFaceInstructEmbeddings, 
-from langchain_community.vectorstores.faiss import FAISS
-#from langchain_community.vectorstores import Chroma
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.docstore.document import Document
-#from chatfuncs.config import EMBEDDINGS_MODEL_NAME
-from langchain_core.embeddings import Embeddings # Import Embeddings for type hinting
+from tools.embeddings import HuggingFaceEmbeddings
+from tools.faiss_store import FAISS, InMemoryDocstore
+from tools.text_splitter import RecursiveCharacterTextSplitter
+from tools.document import Document
+from typing import Protocol # For type hinting
 from tqdm import tqdm
-from langchain_community.docstore.in_memory import InMemoryDocstore # To manually build the docstore
 from uuid import uuid4 # To generate unique IDs for documents in the docstore
+
+# Type hint for embeddings
+class Embeddings(Protocol):
+    def embed_documents(self, texts: List[str]) -> List[List[float]]: ...
+    def embed_query(self, text: str) -> List[float]: ...
 from bs4 import BeautifulSoup
 from docx import Document as Doc
 from pypdf import PdfReader
@@ -695,7 +696,7 @@ def embed_faiss_save_to_zip(
     raw_faiss_index = faiss.IndexFlatIP(embedding_dimension)
     raw_faiss_index.add(embeddings_np) # Add all vectors to the raw FAISS index
 
-    # 3. Create the LangChain FAISS Vectorstore from the components
+    # 3. Create the FAISS Vectorstore from the components
     # The `embedding_function` is used for subsequent queries to the vectorstore,
     # not for building the initial index here (as we've already done that).
     vectorstore = FAISS(
@@ -703,7 +704,6 @@ def embed_faiss_save_to_zip(
         index=raw_faiss_index,
         docstore=docstore,
         index_to_docstore_id=index_to_docstore_id
-        # distance_strategy defaults to COSINE, which is appropriate for IndexFlatIP
     )
     # --- Progress Bar Integration Ends Here ---
 

tools/text_splitter.py

@@ -0,0 +1,112 @@
+"""
+Custom text splitter to replace langchain RecursiveCharacterTextSplitter.
+"""
+from typing import List, Optional, Callable
+import re
+
+
+class RecursiveCharacterTextSplitter:
+    """Splits text recursively by characters."""
+    
+    def __init__(
+        self,
+        chunk_size: int = 1000,
+        chunk_overlap: int = 200,
+        separators: Optional[List[str]] = None,
+        length_function: Optional[Callable[[str], int]] = None,
+        add_start_index: bool = False
+    ):
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+        self.separators = separators if separators else ["\n\n", "\n", ". ", "! ", "? ", " ", ""]
+        self.length_function = length_function if length_function else len
+        self.add_start_index = add_start_index
+    
+    def split_text(self, text: str) -> List[str]:
+        """Split text into chunks."""
+        if not text:
+            return []
+        
+        # Start with the full text
+        splits = [text]
+        
+        # Try each separator in order
+        for separator in self.separators:
+            if not separator:
+                # Last separator - split by character
+                new_splits = []
+                for split in splits:
+                    if self.length_function(split) <= self.chunk_size:
+                        new_splits.append(split)
+                    else:
+                        # Split by character
+                        for i in range(0, len(split), self.chunk_size - self.chunk_overlap):
+                            chunk = split[i:i + self.chunk_size]
+                            if chunk:
+                                new_splits.append(chunk)
+                splits = new_splits
+                break
+            
+            new_splits = []
+            for split in splits:
+                if self.length_function(split) <= self.chunk_size:
+                    new_splits.append(split)
+                else:
+                    # Split by separator
+                    parts = split.split(separator)
+                    current_chunk = ""
+                    for part in parts:
+                        part_with_sep = part if not current_chunk else separator + part
+                        if self.length_function(current_chunk + part_with_sep) <= self.chunk_size:
+                            current_chunk += part_with_sep
+                        else:
+                            if current_chunk:
+                                new_splits.append(current_chunk)
+                            current_chunk = part_with_sep
+                    if current_chunk:
+                        new_splits.append(current_chunk)
+            splits = new_splits
+            
+            # If all splits are small enough, we're done
+            if all(self.length_function(s) <= self.chunk_size for s in splits):
+                break
+        
+        # Apply overlap
+        if self.chunk_overlap > 0 and len(splits) > 1:
+            overlapped_splits = []
+            for i, split in enumerate(splits):
+                if i == 0:
+                    overlapped_splits.append(split)
+                else:
+                    # Add overlap from previous chunk
+                    prev_chunk = splits[i - 1]
+                    overlap_text = prev_chunk[-self.chunk_overlap:] if len(prev_chunk) > self.chunk_overlap else prev_chunk
+                    overlapped_splits.append(overlap_text + split)
+            splits = overlapped_splits
+        
+        return splits
+    
+    def create_documents(
+        self,
+        texts: List[str],
+        metadatas: Optional[List[dict]] = None
+    ) -> List:
+        """Create Document objects from texts."""
+        from tools.document import Document
+        
+        all_docs = []
+        metadatas = metadatas if metadatas else [{}] * len(texts)
+        
+        for text, metadata in zip(texts, metadatas):
+            splits = self.split_text(text)
+            for i, split in enumerate(splits):
+                doc_metadata = metadata.copy()
+                if self.add_start_index:
+                    # Find start index in original text
+                    start_idx = text.find(split)
+                    if start_idx != -1:
+                        doc_metadata["start_index"] = start_idx
+                all_docs.append(Document(page_content=split, metadata=doc_metadata))
+        
+        return all_docs
+