Upload 6 files

app.py

@@ -0,0 +1,134 @@
+__import__('pysqlite3')
+import sys
+sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')
+
+# DATABASES = {
+#     'default': {
+#         'ENGINE': 'django.db.backends.sqlite3',
+#         'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
+#     }
+# }
+import streamlit as st
+from huggingface_hub import InferenceClient
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, ServiceContext, PromptTemplate
+from llama_index.vector_stores.chroma import ChromaVectorStore
+from llama_index.core import StorageContext
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.vectorstores import Chroma
+import chromadb
+from langchain.memory import ConversationBufferMemory
+
+
+
+# Set page config
+st.set_page_config(page_title="RAG Chatbot", page_icon="🤖", layout="wide")
+
+# Set your Hugging Face token here
+
+HF_TOKEN = st.secrets["HF_TOKEN"]
+
+# Initialize your models, databases, and other components here
+@st.cache_resource
+def init_chroma():
+    persist_directory = "chroma_db"
+    chroma_client = chromadb.PersistentClient(path=persist_directory)
+    chroma_collection = chroma_client.get_or_create_collection("my_collection")
+    return chroma_client, chroma_collection
+
+@st.cache_resource
+def init_vectorstore():
+    persist_directory = "chroma_db"
+    embeddings = HuggingFaceEmbeddings()
+    vectorstore = Chroma(persist_directory=persist_directory, embedding_function=embeddings, collection_name="my_collection")
+    return vectorstore
+
+# Initialize components
+client = InferenceClient("mistralai/Mistral-7B-Instruct-v0.3", token=HF_TOKEN)
+chroma_client, chroma_collection = init_chroma()
+vectorstore = init_vectorstore()
+
+# Initialize memory buffer
+memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+
+def rag_query(query):
+    # Retrieve relevant documents using similarity search
+    retrieved_docs = vectorstore.similarity_search(query, k=3)
+
+    # Prepare context for LLaMA
+    if retrieved_docs:
+        context = "\n".join([doc.page_content for doc in retrieved_docs])
+    else:
+        context = ""
+
+    # Append new interaction to memory
+    memory.chat_memory.add_user_message(query)
+
+    # Retrieve past interactions for context
+    past_interactions = memory.load_memory_variables({})[memory.memory_key]
+    context_with_memory = f"{context}\n\nConversation History:\n{past_interactions}"
+
+    # Debugging: Display context and past interactions
+    # st.write("Debugging Info:")
+    # st.write("Context Sent to Model:", context_with_memory)
+    # st.write("Retrieved Documents:", [doc.page_content for doc in retrieved_docs])
+    # st.write("Past Interactions:", past_interactions)
+
+    # Generate response using LLaMA
+    messages = [
+        {"role": "user", "content": f"Context: {context_with_memory}\n\nQuestion: {query},it is not mandatory to use the context\n\nAnswer:"}
+    ]
+
+    # Get the response from the client
+    response_content = client.chat_completion(messages=messages, max_tokens=500, stream=False)
+
+    # Process the response content
+    response = response_content.choices[0].message.content.split("Answer:")[-1].strip()
+
+    # If the response is empty or very short, or if no relevant documents were found, use the LLM's default knowledge
+    if not context or len(response.split()) < 35 or not retrieved_docs:
+        messages = [{"role": "user", "content": query}]
+        response_content = client.chat_completion(messages=messages, max_tokens=500, stream=False)
+        response = response_content.choices[0].message.content
+
+    # Append the response to memory
+    memory.chat_memory.add_ai_message(response)
+
+    return response
+
+def process_feedback(query, response, feedback):
+   # st.write(f"Feedback received: {'👍' if feedback else '👎'} for query: {query}")
+    if feedback:
+        # If thumbs up, store the response in memory buffer
+        memory.chat_memory.add_ai_message(response)
+    else:
+        # If thumbs down, remove the response from memory buffer and regenerate the response
+       # memory.chat_memory.messages = [msg for msg in memory.chat_memory.messages if msg.get("content") != response]
+        new_query=f"{query}. Give better response"
+        new_response = rag_query(new_query)
+        st.markdown(new_response)
+        memory.chat_memory.add_ai_message(new_response)
+
+# Streamlit interface
+
+st.title("Welcome to our RAG-Based Chatbot")
+st.markdown("***")
+st.info('''
+        To use Our Mistral supported Chatbot, click Chat.
+         
+        To push data, click on Store Document.
+        ''')
+
+col1, col2 = st.columns(2)
+
+with col1:
+    chat = st.button("Chat")
+    if chat:
+        st.switch_page("pages/chatbot.py")
+
+with col2:
+    rag = st.button("Store Document")
+    if rag:
+        st.switch_page("pages/management.py")
+
+st.markdown("<div style='text-align:center;'></div>", unsafe_allow_html=True)

pages/chatbot.py

@@ -0,0 +1,49 @@
+import streamlit as st
+from app import rag_query, process_feedback
+
+
+st.title("RAG Chatbot")
+
+# Initialize chat history
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# Display chat messages from history on app rerun
+for i, message in enumerate(st.session_state.messages):
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+        if message["role"] == "assistant":
+                col1, col2 = st.columns([1,15])
+                with col1:
+                    if st.button("👍", key=f"thumbs_up_{i}"):
+                        process_feedback(st.session_state.messages[i-1]["content"], message["content"], True)
+                with col2:
+                    if st.button("👎", key=f"thumbs_down_{i}"):
+                        process_feedback(st.session_state.messages[i-1]["content"], message["content"], False)
+                   # st.session_state.messages.pop()  # Remove the last assistant message
+                    #st.rerun()  # Rerun the app to regenerate the response
+
+# React to user input
+if prompt := st.chat_input("What is your question?"):
+    # Display user message in chat message container
+    st.chat_message("user").markdown(prompt)
+    # Add user message to chat history
+    st.session_state.messages.append({"role": "user", "content": prompt})
+
+    response = rag_query(prompt)
+    
+    # Display assistant response in chat message container
+    with st.chat_message("assistant"):
+        st.markdown(response)
+    # Add assistant response to chat history
+    st.session_state.messages.append({"role": "assistant", "content": response})
+
+    # Rerun the app to display the feedback buttons
+    st.experimental_rerun()
+
+# Sidebar for additional controls
+with st.sidebar:
+    st.header("Options")
+    if st.button("Clear Chat History"):
+        st.session_state.messages = []
+        st.experimental_rerun()

pages/management.py

@@ -0,0 +1,68 @@
+import os
+import streamlit as st
+from langchain.document_loaders import DirectoryLoader, TextLoader, PyPDFLoader
+from langchain.text_splitter import CharacterTextSplitter
+from app import vectorstore
+
+
+st.title("Document Management")
+
+# File uploader
+uploaded_file = st.file_uploader("Choose a file", type=['txt', 'pdf', 'docx'])
+
+if uploaded_file is not None:
+    # Create a temporary directory to store the uploaded file
+    temp_dir = "temp_uploads"
+    os.makedirs(temp_dir, exist_ok=True)
+    file_path = os.path.join(temp_dir, uploaded_file.name)
+    
+    # Save the uploaded file temporarily
+    with open(file_path, "wb") as f:
+        f.write(uploaded_file.getbuffer())
+    
+    st.success(f"File {uploaded_file.name} successfully uploaded!")
+
+    # Process the uploaded file
+    if st.button("Process Document"):
+        with st.spinner("Processing document..."):
+            try:
+                # Load the document based on file type
+                if uploaded_file.type == "application/pdf":
+                    loader = PyPDFLoader(file_path)
+                elif uploaded_file.type == "text/plain":
+                    loader = TextLoader(file_path)
+                else:
+                    st.error("Unsupported file type.")
+                    st.stop()
+                
+                documents = loader.load()
+                
+                # Split the document into chunks
+                text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+                texts = text_splitter.split_documents(documents)
+                
+                # Add the chunks to the vectorstore
+                vectorstore.add_documents(texts)
+                
+                st.success(f"Document processed and added to the knowledge base!")
+            except Exception as e:
+                st.error(f"An error occurred: {e}")
+        
+        # Clean up: remove the temporary file
+        os.remove(file_path)
+
+# Display current documents in the knowledge base
+# st.subheader("Current Documents in Knowledge Base")
+# # This is a placeholder. You'll need to implement a method to retrieve and display
+# # the list of documents currently in your Chroma database.
+# st.write("Placeholder for document list")
+
+# # Option to clear the entire knowledge base
+# if st.button("Clear Knowledge Base"):
+#     if st.sidebar.checkbox("Are you sure you want to clear the entire knowledge base? This action cannot be undone."):
+#         try:
+#             # Clear the Chroma database
+#             vectorstore.delete()
+#             st.success("Knowledge base cleared!")
+#         except Exception as e:
+#             st.error(f"An error occurred: {e}")

requirements.txt

@@ -0,0 +1,10 @@
+chromadb==0.5.5
+huggingface_hub==0.23.4
+langchain==0.2.12
+llama_index==0.10.62
+streamlit==1.36.0
+streamlit_extras==0.4.6
+llama-index-vector-stores-chroma==0.1.10
+pysqlite3-binary
+langchain-community==0.2.6
+sentence-transformers