Upload 15 files

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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

.gitignore

@@ -0,0 +1,118 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+venv/
+ENV/
+.venv/
+*.egg
+*.egg-info/
+dist/
+build/
+*.egg-info/
+
+# Jupyter Notebook checkpoints
+.ipynb_checkpoints
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+.pyre/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# Pyre type checker
+.pyre/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+.dmypy.json
+
+# environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs and editors
+.idea/
+.vscode/
+*.swp
+*.swo
+*.swn
+*.sublime-workspace
+*.sublime-project
+
+# VS Code extensions
+.vscode/
+
+# macOS
+.DS_Store
+
+# Windows
+Thumbs.db
+ehthumbs.db
+desktop.ini
+$RECYCLE.BIN/
+
+# PyCharm
+.idea/
+*.iml
+*.ipr
+*.iws
+
+# Local config files
+*.env
+*.local
+
+# System files
+.Python
+*~

README.md

@@ -0,0 +1,13 @@
+---
+title: ChatPDF RAG
+emoji: 📊
+colorFrom: red
+colorTo: red
+sdk: streamlit
+sdk_version: 1.39.0
+app_file: app.py
+pinned: false
+license: cc-by-4.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Uploaded/.file

@@ -0,0 +1 @@
+chatPDF by Bipin Saha

app.py

@@ -0,0 +1,189 @@
+import streamlit as st
+import os
+import uuid
+import shutil
+from datetime import datetime, timedelta
+from dotenv import load_dotenv
+from chatMode import chat_response
+from modules.pdfExtractor import PdfConverter
+from modules.rag import contextChunks, contextEmbeddingChroma, retrieveEmbeddingsChroma, ragQuery, similarityChroma
+from sentence_transformers import SentenceTransformer
+from modules.llm import GroqClient, GroqCompletion
+import chromadb
+import json
+
+# Load environment variables
+load_dotenv()
+
+######## Embedding Model ########
+embeddModel = SentenceTransformer(os.path.join(os.getcwd(), "embeddingModel"))
+embeddModel.max_seq_length = 512
+chunk_size, chunk_overlap, top_k_default = 2000, 200, 5
+
+######## Groq to LLM Connect ########
+api_key = os.getenv("GROQ_API_KEY")
+groq_client = GroqClient(api_key)
+llm_model = {
+    "Gemma9B": "gemma2-9b-it",
+    "Gemma7B": "gemma-7b-it", 
+    "LLama3-70B-Preview": "llama3-groq-70b-8192-tool-use-preview",       
+    "LLama3.1-70B": "llama-3.1-70b-versatile",
+    "LLama3-70B": "llama3-70b-8192",
+    "LLama3.2-90B": "llama-3.2-90b-text-preview", 
+    "Mixtral8x7B": "mixtral-8x7b-32768"
+}
+max_tokens = {
+    "Gemma9B": 8192,
+    "Gemma7B": 8192, 
+    "LLama3-70B": 8192,       
+    "LLama3.1-70B": 8000,
+    "LLama3-70B": 8192,
+    "LLama3.2-90B": 8192, 
+    "Mixtral8x7B": 32768
+}
+
+## Time-based cleanup settings
+EXPIRATION_TIME = timedelta(hours=6)
+UPLOAD_DIR = "Uploaded"
+VECTOR_DB_DIR = "vectorDB"
+LOG_FILE = "upload_log.json"
+
+## Initialize Streamlit app
+st.set_page_config(page_title="ChatPDF", layout="wide")
+st.markdown("<h2 style='text-align: center;'>chatPDF</h2>", unsafe_allow_html=True)
+
+## Function to log upload time
+def log_upload_time(unique_id):
+    upload_time = datetime.now().isoformat()
+    log_entry = {unique_id: upload_time}
+    if os.path.exists(LOG_FILE):
+        with open(LOG_FILE, "r") as f:
+            log_data = json.load(f)
+        log_data.update(log_entry)
+    else:
+        log_data = log_entry
+
+    with open(LOG_FILE, "w") as f:
+        json.dump(log_data, f)
+
+## Cleanup expired files based on log
+def cleanup_expired_files():
+    current_time = datetime.now()
+    
+    # Load upload log
+    if os.path.exists(LOG_FILE):
+        with open(LOG_FILE, "r") as f:
+            log_data = json.load(f)
+    
+        keys_to_delete = []  # List to keep track of keys to delete
+        # Check each entry in the log
+        for unique_id, upload_time in log_data.items():
+            upload_time_dt = datetime.fromisoformat(upload_time)
+            if current_time - upload_time_dt > EXPIRATION_TIME:
+                # Add key to the list for deletion
+                keys_to_delete.append(unique_id)
+                
+                # Remove files if expired
+                pdf_file_path = os.path.join(UPLOAD_DIR, f"{unique_id}_paper.pdf")
+                vector_db_path = os.path.join(VECTOR_DB_DIR, unique_id)
+                
+                if os.path.isfile(pdf_file_path):
+                    os.remove(pdf_file_path)
+                if os.path.isdir(vector_db_path):
+                    shutil.rmtree(vector_db_path)
+        
+        # Now delete the keys from log_data after iteration
+        for key in keys_to_delete:
+            del log_data[key]
+        
+        # Save updated log
+        with open(LOG_FILE, "w") as f:
+            json.dump(log_data, f)
+
+## Context Taking, PDF Upload, and Mode Selection
+with st.sidebar:
+    st.title("Upload PDF:")
+    
+    research_field = st.text_input("Research Field: ", key="research_field", placeholder="Enter research fields with commas")
+    option = ''
+
+    if not research_field:
+        st.info("Please enter a research field to proceed.")
+        option = st.selectbox('Select Mode', ('Chat', 'Graph and Table', 'Code', 'Custom Prompting'), disabled=True)
+        uploaded_file = st.file_uploader("", type=["pdf"], disabled=True)
+    else:
+        option = st.selectbox('Select Mode', ('Chat', 'Graph and Table', 'Code', 'Custom Prompting'))
+        uploaded_file = st.file_uploader("", type=["pdf"], disabled=False)
+
+    temperature = st.slider("Select Temperature", min_value=0.0, max_value=1.0, value=0.05, step=0.01)
+    selected_llm_model = st.selectbox("Select LLM Model", options=list(llm_model.keys()), index=3)
+    top_k = st.slider("Select Top K Matches", min_value=1, max_value=20, value=5)
+
+## Initialize unique ID, db_client, db_path, and timestamp if not already in session state
+if 'db_client' not in st.session_state:
+    unique_id = str(uuid.uuid4())
+    st.session_state['unique_id'] = unique_id
+    db_path = os.path.join(VECTOR_DB_DIR, unique_id)
+    os.makedirs(db_path, exist_ok=True)
+    st.session_state['db_path'] = db_path
+    st.session_state['db_client'] = chromadb.PersistentClient(path=db_path)
+
+    # Log the upload time
+    log_upload_time(unique_id)
+
+# Access session-stored variables
+db_client = st.session_state['db_client']
+unique_id = st.session_state['unique_id']
+db_path = st.session_state['db_path']
+
+if 'document_text' not in st.session_state:
+    st.session_state['document_text'] = None
+
+if 'text_embeddings' not in st.session_state:
+    st.session_state['text_embeddings'] = None
+
+## Handle PDF Upload and Processing
+if uploaded_file is not None and st.session_state['document_text'] is None:
+    os.makedirs(UPLOAD_DIR, exist_ok=True)
+    file_path = os.path.join(UPLOAD_DIR, f"{unique_id}_paper.pdf")
+    with open(file_path, "wb") as file:
+        file.write(uploaded_file.getvalue())
+
+    document_text = PdfConverter(file_path).convert_to_markdown()
+    st.session_state['document_text'] = document_text
+    
+    text_content_chunks = contextChunks(document_text, chunk_size, chunk_overlap)
+    text_contents_embeddings = contextEmbeddingChroma(embeddModel, text_content_chunks, db_client, db_path=db_path)
+    st.session_state['text_embeddings'] = text_contents_embeddings
+
+if st.session_state['document_text'] and st.session_state['text_embeddings']:
+    document_text = st.session_state['document_text']
+    text_contents_embeddings = st.session_state['text_embeddings']
+else:
+    st.stop()
+
+q_input = st.chat_input(key="input", placeholder="Ask your question")
+
+if q_input:
+    if option == "Chat":
+        query_embedding = ragQuery(embeddModel, q_input)
+        top_k_matches = similarityChroma(query_embedding, db_client, top_k)
+
+        LLMmodel = llm_model[selected_llm_model]
+        domain = research_field
+        prompt_template = q_input
+        user_content = top_k_matches
+        max_tokens = max_tokens[selected_llm_model]
+        print(max_tokens)
+        top_p = 1
+        stream = True
+        stop = None
+
+        groq_completion = GroqCompletion(groq_client, LLMmodel, domain, prompt_template, user_content, temperature, max_tokens, top_p, stream, stop)
+        result = groq_completion.create_completion()
+        
+        with st.spinner("Processing..."):
+            chat_response(q_input, result)
+
+## Call the cleanup function periodically
+cleanup_expired_files()

chatMode.py

@@ -0,0 +1,25 @@
+import streamlit as st
+import os
+
+def chat_response(user_prompt, assistant_response):
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = []
+
+    for message in st.session_state.chat_history:
+        if message["role"] == "user":
+            with st.chat_message("user"):
+                st.write(f"**You**: {message['content']}")
+
+        elif message["role"] == "assistant":
+            with st.chat_message("assistant"):
+                st.write(f"**Assistant**: {message['content']}")
+
+    if user_prompt:
+        st.session_state.chat_history.append({"role": "user", "content": user_prompt})
+        with st.chat_message("user"):
+            st.write(f"**You**: {user_prompt}")
+
+        with st.chat_message("assistant"):
+            st.write(f"**Assistant**: {assistant_response}")
+        
+        st.session_state.chat_history.append({"role": "assistant", "content": assistant_response})

modules/llm.py

@@ -0,0 +1,74 @@
+import os
+from dotenv import load_dotenv
+from groq import Groq
+
+load_dotenv()
+
+class GroqClient:
+    def __init__(self, api_key):
+        self.client = Groq(api_key=api_key)
+
+
+class GroqCompletion:
+    def __init__(self, client, model, domain, prompt_template, user_content, temperature, max_tokens, top_p, stream, stop):
+        self.client = client
+        self.model = model
+        self.domain = domain
+        self.prompt_template = prompt_template
+        self.user_content = user_content
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.top_p = top_p
+        self.stream = stream
+        self.stop = stop
+
+    def create_completion(self):
+        prompt = f"{self.prompt_template}\n\n{self.user_content}\n"
+        system_role = f"you are an helpful AI assistant in text based question answering and retriving context from given domain {self.domain}"
+
+        completion = self.client.client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {
+                    "role": "system",
+                    "content": system_role
+                },
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ],
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+            top_p=self.top_p,
+            stream=self.stream,
+            stop=self.stop,
+        )
+
+        result = ""
+        for chunk in completion:
+            result += chunk.choices[0].delta.content or ""
+
+        return result
+    
+
+
+# # Example usage
+# api_key = os.environ.get("GROQ_API_KEY")
+# groq_client = GroqClient(api_key)
+
+# model = "gemma2-9b-it"
+# domain = "LLM"
+# prompt_template = "Summarize me this content in just one line"
+# user_content = """1. **Domain Adaptation and Inference**: He developed a novel semantic encoding and decoding (SEDO) algorithm that uses knowledge graphs to generate semantic labels for unlabeled data. He applied this algorithm to detect suicide risk on social media.
+# 2. **Weighted Constraints Conditioned on Time-Evolving Events**: He developed a semi-deep infusion-based framework that integrates real-world knowledge as weighted constraints conditioned upon time-evolving events. He applied this framework to estimate the rise in infection rate during a crisis event.      
+# 3. **Matching and Ranking**: He developed a semi-deep K-IL system that models a patient's trust of GPs using knowledge of consultation history and ICD-10 graphs. He also applied this system to recommend patients to GPs."""
+# temperature = 0
+# max_tokens = 8192
+# top_p = 1
+# stream = True
+# stop = None
+
+# groq_completion = GroqCompletion(groq_client, model, domain, prompt_template, user_content, temperature, max_tokens, top_p, stream, stop)
+# result = groq_completion.create_completion()
+# print(result)

modules/pdfExtractor.py

@@ -0,0 +1,22 @@
+import os
+import pymupdf4llm
+
+
+class PdfConverter:
+    def __init__(self, pdf_file):
+        self.pdf_file = pdf_file
+        self.md_text = None
+
+    def convert_to_markdown(self):
+        self.md_text = pymupdf4llm.to_markdown(self.pdf_file)
+        return self.md_text
+
+    def save_markdown(self, output_file):
+        with open(output_file, 'w') as file:
+            file.write(self.md_text)
+
+# Example usage
+# pdf_file = os.path.join(os.getcwd(), "pdfs", "test.pdf")
+# converter = PdfConverter(pdf_file)
+# text = converter.convert_to_markdown()
+# print(text)

modules/rag.py

@@ -0,0 +1,109 @@
+import os
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from sentence_transformers.util import cos_sim
+from modules.pdfExtractor import PdfConverter
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.schema import Document
+
+# model = SentenceTransformer(
+#     "thenlper/gte-base", # switch to en/zh for English or Chinese
+#     trust_remote_code=True
+# )
+# model.save(os.path.join(os.getcwd(), "embeddingModel"))
+
+
+def contextChunks(document_text, chunk_size, chunk_overlap):
+    document = Document(page_content=document_text)
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+    text_chunks = text_splitter.split_documents([document])
+    text_content_chunks = [chunk.page_content for chunk in text_chunks]
+    return text_content_chunks
+
+
+def contextEmbedding(model, text_content_chunks):
+    text_contents_embeddings = [model.encode([text]) for text in text_content_chunks]
+    return text_contents_embeddings
+
+def contextEmbeddingChroma(model, text_content_chunks, db_client, db_path):
+
+    text_contents_embeddings = [model.encode([text])[0] for text in text_content_chunks]
+    ids = [f"id_{i}" for i in range(len(text_content_chunks))]
+
+    collection = db_client.get_or_create_collection("embeddings_collection")
+    
+    collection.add(
+        documents=text_content_chunks,
+        embeddings=text_contents_embeddings,
+        ids=ids  # Include the generated IDs
+    )
+
+    return text_contents_embeddings
+
+
+def retrieveEmbeddingsChroma(db_client):
+    collection_name = "embeddings_collection"
+    collection = db_client.get_collection(collection_name)
+
+    records = collection.get()
+    embeddings = []
+    text_chunks = []
+
+    if records and "documents" in records and "embeddings" in records:
+        text_chunks = records["documents"] or []  
+        embeddings = records["embeddings"] or [] 
+    else:
+        print("No documents or embeddings found in the collection.")
+
+    return embeddings, text_chunks  
+
+
+def ragQuery(model, query):
+    return model.encode([query])
+
+def similarity(query_embedding, text_contents_embeddings, text_content_chunks, top_k):
+    similarities = [(text, cos_sim(embedding, query_embedding[0])) 
+                    for text, embedding in zip(text_content_chunks, text_contents_embeddings)]
+    
+    similarities_sorted = sorted(similarities, key=lambda x: x[1], reverse=True)
+    top_k_texts = [text for text, _ in similarities_sorted[:top_k]]
+
+    return "\n".join(f"Text Chunk <{i + 1}>\n{element}" for i, element in enumerate(top_k_texts))
+
+
+def similarityChroma(query_embedding, db_client, top_k):
+    collection = db_client.get_collection("embeddings_collection")
+    results = collection.get(include=["documents", "embeddings"])
+    
+    text_content_chunks = results["documents"]
+    text_contents_embeddings = np.array(results["embeddings"])
+
+    text_contents_embeddings = text_contents_embeddings.astype(np.float32)
+    query_embedding = query_embedding.astype(np.float32)
+
+    similarities = [
+        (text, cos_sim(embedding.reshape(1, -1), query_embedding.reshape(1, -1))[0][0]) 
+        for text, embedding in zip(text_content_chunks, text_contents_embeddings)
+    ]
+    
+    similarities_sorted = sorted(similarities, key=lambda x: x[1], reverse=True)
+    
+    top_k_texts = [text for text, _ in similarities_sorted[:top_k]]
+
+    return "\n".join(f"Text Chunk <{i + 1}>\n{element}" for i, element in enumerate(top_k_texts))
+
+
+
+
+# pdf_file = os.path.join(os.getcwd(), "pdfs", "test2.pdf")
+# converter = PdfConverter(pdf_file)
+# document_text = converter.convert_to_markdown()
+
+# chunk_size, chunk_overlap, top_k = 2000, 200, 5
+# query = "what metric used in this paper for performance evaluation?"
+
+# text_content_chunks = contextChunks(document_text, chunk_size, chunk_overlap)
+# text_contents_embeddings = contextEmbedding(model, text_content_chunks)
+# query_embedding = ragQuery(model, query)
+# top_k_matches = similarity(query_embedding, text_contents_embeddings, text_content_chunks, top_k)
+# print(top_k_matches[1])

modules/ragoop.py

@@ -0,0 +1,73 @@
+import os
+from sentence_transformers import SentenceTransformer
+from sentence_transformers.util import cos_sim
+from modules.pdfExtractor import PdfConverter
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.schema import Document
+
+class EmbeddingModel:
+    def __init__(self, model_path=None):
+        if model_path is None:
+            self.model = SentenceTransformer(
+                "thenlper/gte-base",  # switch to en/zh for English or Chinese
+                trust_remote_code=True
+            )
+            self.model.save(os.path.join(os.getcwd(), "embeddingModel"))
+        else:
+            self.model = SentenceTransformer(model_path)
+        
+        self.model.max_seq_length = 512
+
+    def encode(self, texts):
+        return self.model.encode(texts)
+
+class DocumentProcessor:
+    def __init__(self, model, chunk_size=1000, chunk_overlap=200):
+        self.model = model
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+
+    def context_chunks(self, document_text):
+        document = Document(page_content=document_text)
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=self.chunk_size, 
+            chunk_overlap=self.chunk_overlap
+        )
+        text_chunks = text_splitter.split_documents([document])
+        text_content_chunks = [chunk.page_content for chunk in text_chunks]
+        return text_content_chunks
+
+    def context_embedding(self, text_content_chunks):
+        return [self.model.encode([text]) for text in text_content_chunks]
+
+    def rag_query(self, query):
+        return self.model.encode([query])
+
+    def similarity(self, query_embedding, text_contents_embeddings, text_content_chunks, top_k):
+        similarities = [
+            (text, cos_sim(embedding, query_embedding[0])) 
+            for text, embedding in zip(text_content_chunks, text_contents_embeddings)
+        ]
+        
+        similarities_sorted = sorted(similarities, key=lambda x: x[1], reverse=True)
+        top_k_texts = [text for text, _ in similarities_sorted[:top_k]]
+
+        return top_k_texts
+
+
+# Example usage:
+if __name__ == "__main__":
+    model = EmbeddingModel(model_path=os.path.join(os.getcwd(), "embeddingModel"))
+    processor = DocumentProcessor(model=model)
+
+    pdf_file = os.path.join(os.getcwd(), "pdfs", "test2.pdf")
+    converter = PdfConverter(pdf_file)
+    document_text = converter.convert_to_markdown()
+    text_chunks = processor.context_chunks(document_text)
+    text_embeddings = processor.context_embedding(text_chunks)
+
+    query = "what metric used in this paper for performance evaluation?"
+    query_embedding = processor.rag_query(query)
+    top_results = processor.similarity(query_embedding, text_embeddings, text_chunks, top_k=5)
+
+    print(top_results)

requirements.txt

@@ -0,0 +1,13 @@
+pymupdf4llm==0.0.17
+groq==0.11.0
+chromadb==0.5.11
+tiktoken==0.8.0
+langchain==0.3.2
+langchain-community==0.3.1
+langsmith==0.1.132
+sentence-transformers==3.1.1
+numpy
+fastapi
+uvicorn
+python-multipart==0.0.12
+python-dotenv==1.0.1

upload_log.json

@@ -0,0 +1 @@
+{"32fe6152-eb2b-4805-838c-6227bca07d94": "2024-11-01T11:27:09.540866", "d00bcf07-de71-46c4-b083-cb1baa6060e6": "2024-11-01T11:30:55.332869", "12c64717-c9f9-4f7d-9493-510c138844c3": "2024-11-01T11:34:40.360413", "ea73c9e8-f113-4a3c-8431-21ad6a7fcc9c": "2024-11-01T12:42:11.897498"}

upload_to_space.py

@@ -0,0 +1,23 @@
+from huggingface_hub import HfApi
+import os
+
+api = HfApi()
+space_id = "Kurian07/Ultimate_llm_rag"  
+folder_path = "C:/Users/kuria/OneDrive/Desktop/llm/chatPDF-RAG/embeddingModel"
+
+for root, _, files in os.walk(folder_path):
+    for file in files:
+        file_path = os.path.join(root, file)
+        relative_path = os.path.relpath(file_path, folder_path)  # Path inside the repo
+
+        try:
+            # Attempt to upload each file
+            api.upload_file(
+                path_or_fileobj=file_path,
+                path_in_repo=relative_path,
+                repo_id=space_id,
+                repo_type="space"
+            )
+            print(f"Uploaded {relative_path} to Hugging Face Space.")
+        except Exception as e:
+            print(f"Failed to upload {relative_path}: {e}")

vectorDB/.file

@@ -0,0 +1 @@
+chatPDF by Bipin Saha