gradio app

Chroma.py

@@ -0,0 +1,59 @@
+from langchain_community.document_loaders import DirectoryLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_chroma import Chroma
+import os
+import shutil
+
+
+def create_db(
+    chunk_size,
+    chunk_overlap,
+    INPUT_PATH="./data/books/",
+    INPUT_GLOB=["*.txt", "*.md"],
+    MODEL_NAME="Alibaba-NLP/gte-multilingual-base",
+    CHROMA_PATH="./chromadb/",
+):
+    # setup embeddings
+    embeddings = HuggingFaceEmbeddings(
+        model_name=MODEL_NAME,
+        model_kwargs={"device": "cuda", "trust_remote_code": True},
+        encode_kwargs={"normalize_embeddings": True},
+    )
+
+    # load documents
+    raw_documents = DirectoryLoader(INPUT_PATH, glob=INPUT_GLOB).load()
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=chunk_size,
+        chunk_overlap=chunk_overlap,
+        length_function=len,
+        add_start_index=True,
+    )
+    documents = text_splitter.split_documents(raw_documents)
+    print(f"Split {len(raw_documents)} documents into {len(documents)} chunks.")
+
+    # Clear out the database first.
+    if os.path.exists(CHROMA_PATH):
+        shutil.rmtree(CHROMA_PATH)
+
+    # Create a new DB from the documents.
+    db = Chroma.from_documents(
+        documents,
+        embeddings,
+        persist_directory=CHROMA_PATH,
+        collection_metadata={"hnsw:space": "cosine"},
+    )
+    print(f"Saved {len(documents)} chunks to {CHROMA_PATH}.")
+
+    return db
+
+
+if __name__ == "__main__":
+    create_db(
+        1000,
+        500,
+        INPUT_PATH="./data/books/dracula_segmented/",
+        INPUT_GLOB=["*.txt"],
+        MODEL_NAME="Alibaba-NLP/gte-multilingual-base",
+        CHROMA_PATH="./chromadb/",
+    )

query.py → LangChain.py

@@ -6,13 +6,8 @@ from langchain_core.prompts import ChatPromptTemplate
 from langchain_huggingface import HuggingFaceEmbeddings
 from langchain_chroma import Chroma
 
-CHROMA_PATH = "chromadb/"
 
-# free model
-MODEL_NAME = "Alibaba-NLP/gte-multilingual-base"
-
-
-def load_db():
+def load_db(CHROMA_PATH="chromadb/", MODEL_NAME="Alibaba-NLP/gte-multilingual-base"):
     # setup embeddings
     embeddings = HuggingFaceEmbeddings(
         model_name=MODEL_NAME,
@@ -41,13 +36,7 @@ def query_db(db, query_text):
     return context_text, sources
 
 
-if __name__ == "__main__":
-    db = load_db()
-
-    question = "Cor do cabelo de Van Helsing"
-
-    context, sources = query_db(db, question)
-
+def load_chain():
     # prompt chat
     prompt = ChatPromptTemplate(
         [
@@ -74,6 +63,38 @@ Answer the question based on the above context in question's original language:
     # pipeline
     chain = prompt | llm
 
+    return chain
+
+
+def query(question, db, chain):
+    context, sources = query_db(db, question)
+
+    print(f"Context:\n{context}\n*************************")
+
+    # ask
+    answer = chain.invoke(
+        {
+            "context": context,
+            "question": question,
+        }
+    ).content
+    print(f"Answer:\n{answer}\n*************************")
+
+    print(f"Sources:\n{sources}")
+
+    return answer, sources
+
+
+if __name__ == "__main__":
+    db = load_db()
+
+    question = "Cor do cabelo de Van Helsing"
+
+    context, sources = query_db(db, question)
+
+    # model creation
+    chain = load_chain()
+
     print(f"Context:\n{context}\n*************************")
 
     # ask

app.py

@@ -0,0 +1,137 @@
+# app interface related
+import gradio as gr
+import shutil
+import tempfile
+from pathlib import Path
+import time
+
+# ai related
+from Chroma import create_db
+from LangChain import query, load_chain
+
+
+# function to store the state
+def load_data(
+    chunk_size,
+    chunk_overlap,
+    uploaded_files,
+    existing_data,
+    progress=gr.Progress(),
+):
+    try:
+        progress(0, desc="Loading chain...")
+        time.sleep(0.5)
+        print("Loading chain...")
+        # chain load
+        chain = load_chain()
+        progress(0.3, desc="Chain loaded")
+        time.sleep(0.5)
+        print("Chain loaded")
+
+        print("Creating db...")
+        # clean up previous temporary directory if it exists
+        if existing_data and "temp_dir" in existing_data:
+            shutil.rmtree(existing_data["temp_dir"])
+
+        # create new consolidated temporary directory
+        temp_dir = tempfile.mkdtemp()
+
+        print(f"Copying files to {temp_dir}...")
+        # preserve original directory structure
+        for i, uploaded_file in enumerate(uploaded_files, 1):
+            src_path = Path(uploaded_file.name)
+            # move file to consolidated directory
+            shutil.move(src_path, temp_dir)
+            # update progress bar
+            progress(
+                0.3 + 0.2 * i / len(uploaded_files), f"Processing {uploaded_file.name.split('/')[-1]}"
+            )
+            time.sleep(0.1)
+
+        # create db file
+        progress(0.5, desc="Creating db...")
+        db = create_db(chunk_size, chunk_overlap, INPUT_PATH=temp_dir, CHROMA_PATH=temp_dir)
+        progress(1.0, desc="DB created")
+        print("DB created")
+
+        return {
+            "db": db,
+            "chain": chain,
+            "temp_dir": temp_dir,
+            "loaded": True,
+            "file_count": len(uploaded_files),
+        }, "✅ Data loaded successfully!"
+    except Exception as e:
+        return {"loaded": False, "error": str(e)}, f"❌ Error: {str(e)}"
+
+
+def chat_response(message, chat_history, data):
+    if not data or not data.get("loaded"):
+        error_msg = data.get("error", "Please load data first!")
+        chat_history.append((message, error_msg))
+        return chat_history
+
+    # responses based on the input data
+    answer, sources = query(message, data["db"], data["chain"])
+    sources = "\n".join([s_file.split("/")[-1] for s_file in sources.split("\n")])
+    response = f"{answer}\n\nSources:\n{sources}"
+
+    # Append messages as tuples (user, assistant) instead of dictionaries
+    chat_history.append((message, response))
+    return chat_history
+
+
+with gr.Blocks(title="Document Analysis Chatbot") as demo:
+    # store loaded data
+    data_store = gr.State()
+
+    with gr.Row():
+        # Left Column - Inputs
+        with gr.Column(scale=1):
+            gr.Markdown("## Data Upload")
+            # create db parameters
+            chunk_size = gr.Number(label="Chunk Size", value=1000)
+            chunk_overlap = gr.Number(label="Chunk Overlap", value=500)
+            # load file
+            folder_input = gr.File(file_count="directory", label="Upload Folder")
+            # Add status display
+            status_text = gr.Textbox(
+                label="Status",
+                interactive=False,
+                show_label=False
+            )
+            # load button
+            load_btn = gr.Button("Load Data", variant="primary")
+
+        # Right Column - Chat
+        with gr.Column(scale=3, visible=False) as chat_col:
+            gr.Markdown("## Chat Interface")
+            chatbot = gr.Chatbot(
+                label="Document Analysis Chat",
+                type="tuples",
+                bubble_full_width=False,  # Prevent stretching of messages
+                render_markdown=True,  # Handle markdown formatting properly,
+                height=500,
+            )
+            msg = gr.Textbox(label="Your Question", placeholder="Type your question...")
+            clear_btn = gr.Button("Clear Chat", variant="secondary")
+
+    # Loading indicators - update to handle multiple outputs
+    load_btn.click(
+        fn=load_data,
+        inputs=[chunk_size, chunk_overlap, folder_input, data_store],
+        outputs=[data_store, status_text],
+    ).then(fn=lambda: gr.Column(visible=True), outputs=chat_col)
+
+    # Chat interaction
+    msg.submit(
+        fn=chat_response,
+        inputs=[msg, chatbot, data_store],
+        outputs=[chatbot],
+    ).then(lambda: "", None, msg)
+
+    # Clear chat
+    clear_btn.click(lambda: [], None, chatbot)
+
+if __name__ == "__main__":
+    demo.launch()

create_db.py

@@ -1,42 +0,0 @@
-from langchain_community.document_loaders import DirectoryLoader
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_huggingface import HuggingFaceEmbeddings
-from langchain_chroma import Chroma
-import os
-import shutil
-
-CHROMA_PATH = "chromadb/"
-
-INPUT_PATH = "./data/books/dracula_segmented/"
-INPUT_GLOB = "*.txt"
-
-# free models
-MODEL_NAME = "Alibaba-NLP/gte-multilingual-base"
-
-# setup embeddings
-embeddings = HuggingFaceEmbeddings(
-    model_name=MODEL_NAME,
-    model_kwargs={"device": "cuda", "trust_remote_code": True},
-    encode_kwargs={"normalize_embeddings": True},
-)
-
-# load documents
-raw_documents = DirectoryLoader(INPUT_PATH, glob=INPUT_GLOB).load()
-text_splitter = RecursiveCharacterTextSplitter(
-    chunk_size=1000, chunk_overlap=500, length_function=len, add_start_index=True
-)
-documents = text_splitter.split_documents(raw_documents)
-print(f"Split {len(raw_documents)} documents into {len(documents)} chunks.")
-
-# Clear out the database first.
-if os.path.exists(CHROMA_PATH):
-    shutil.rmtree(CHROMA_PATH)
-
-# Create a new DB from the documents.
-db = Chroma.from_documents(
-    documents,
-    embeddings,
-    persist_directory=CHROMA_PATH,
-    collection_metadata={"hnsw:space": "cosine"},
-)
-print(f"Saved {len(documents)} chunks to {CHROMA_PATH}.")

requirements.txt

@@ -4,6 +4,8 @@ langchain-huggingface==0.1.2
 langchain-chroma==0.2.2 # vectorized documents for query
 sentence-transformers==3.4.1 # free embeddings
 unstructured==0.16.23
+unstructured[md]==0.16.23
+gradio==5.19.0
 # QWEN libs
 torch==2.4.1 
 triton==3.0.0

run.sh

@@ -13,6 +13,7 @@ fi
 eval "$($CONDA_PATH shell.bash hook)"
 
 conda activate specialist
-python query.py
+# python Chroma.py
+python LangChain.py
 conda deactivate
 echo "Completed."