import streamlit as st import random import time # import ollama # from ollama import Client from langchain_core.messages import HumanMessage, SystemMessage from langchain_community.llms import Ollama # __import__('pysqlite3') # import sys # sys.modules['sqlite3'] = sys.modules.pop('pysqlite3') modelname = 'ch-doonoi-01:latest' # client = Client(host="http://68.173.160.106:11434") host="http://68.173.160.106:11434" llm = Ollama(base_url=host, model="ch-doonoi-01:latest", num_gpu=2) # Data Loading ####### from langchain import hub from langchain_chroma import Chroma from langchain_community.document_loaders import WebBaseLoader from langchain_core.output_parsers import StrOutputParser from langchain_core.runnables import RunnablePassthrough # from langchain_openai import OpenAIEmbeddings from langchain_text_splitters import RecursiveCharacterTextSplitter from langchain_community.document_loaders import UnstructuredMarkdownLoader from langchain_community.embeddings.sentence_transformer import SentenceTransformerEmbeddings # from sentence_transformers import SentenceTransformer from langchain_core.messages import HumanMessage, SystemMessage # import bs4 from langchain.chains import create_history_aware_retriever, create_retrieval_chain from langchain.chains.combine_documents import create_stuff_documents_chain from langchain_chroma import Chroma from langchain_community.chat_message_histories import ChatMessageHistory from langchain_community.document_loaders import WebBaseLoader from langchain_core.chat_history import BaseChatMessageHistory from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder, PromptTemplate from langchain_core.runnables.history import RunnableWithMessageHistory # from langchain_openai import ChatOpenAI, OpenAIEmbeddings from langchain_text_splitters import RecursiveCharacterTextSplitter from langchain_community.document_loaders import BSHTMLLoader from langchain.chains import RetrievalQA from langchain.memory import ConversationBufferMemory from langchain.chains import ConversationalRetrievalChain # Load, chunk and index the contents md_path = "./ComposTogether.md" # loader = WebBaseLoader( # web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",), # bs_kwargs=dict( # parse_only=bs4.SoupStrainer( # class_=("post-content", "post-title", "post-header") # ) # ), # ) loader = UnstructuredMarkdownLoader(md_path) docs = loader.load() text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200) splits = text_splitter.split_documents(docs) # create the open-source embedding function embedding_function = SentenceTransformerEmbeddings(model_name="all-MiniLM-L6-v2") # ChromaDB vectorstore = Chroma.from_documents(documents=splits, embedding=embedding_function) # Retrieve and generate using the relevant snippets of the blog. retriever = vectorstore.as_retriever() ### Contextualize question ### contextualize_q_system_prompt = ( "Given a chat history and the latest user question " "which might reference context in the chat history, " "formulate a standalone question which can be understood " "without the chat history. Do NOT answer the question, " "just reformulate it if needed and otherwise return it as is." ) contextualize_q_prompt = ChatPromptTemplate.from_messages( [ ("system", contextualize_q_system_prompt), MessagesPlaceholder("chat_history"), ('human', "{input}") ] ) history_aware_retriever = create_history_aware_retriever( llm, retriever, contextualize_q_prompt ) ### Answer question ### system_prompt = ( "You are an assistant for question-answering tasks. " """Use the following pieces of context to answer the question at the end. If you don't know the answer and the question is specifically regarding ComposTogether (the community composting program based in Fort Lee), just say that you don't know this particular detail and to email the program, never try to make up an answer. If you don't know the answer and the question is not specifically about ComposTogether but related to composting, you can get the answer from the Internet but never make up an answer. If the question is completely unrelated to composting or ComposTogether, specify that you only answer questions regarding ComposTogether. Use three sentences maximum. Keep the answer as concise as possible. Also, never explicitly state that the answer is based on the given context. Finally, always say "thanks for asking!" at the end of the answer. """ "\n\n" "{context}" ) qa_prompt = ChatPromptTemplate.from_messages( [ ('system', system_prompt), MessagesPlaceholder("chat_history"), ('human', "{input}") ] ) question_answer_chain = create_stuff_documents_chain(llm, qa_prompt) rag_chain = create_retrieval_chain(history_aware_retriever, question_answer_chain) ### Statefully manage chat history ### # store = {} # def get_session_history(session_id: str) -> BaseChatMessageHistory: # if session_id not in store: # store[session_id] = ChatMessageHistory() # return store[session_id] # conversational_rag_chain = RunnableWithMessageHistory( # rag_chain, # get_session_history, # input_message_key="input", # history_messages_key="chat_history", # output_messages_key="answer" # ) # prompt = hub.pull("rlm/rag-prompt") # rag_chain = ( # {"context": retriever | format_docs, "question": RunnablePassthrough()} # | prompt # | llm # | StrOutputParser() # ) # # Load the sentence transformer model for computing similarities # # similarity_model = SentenceTransformer('all-MiniLM-L6-v2') # # # Function to determine if the context contains a valid answer # # def is_answer_in_context(context_response, question, threshold=0.7): # # question_embedding = similarity_model.encode(question, convert_to_tensor=True) # # response_embedding = similarity_model.encode(context_response, convert_to_tensor=True) # # simmiliarity_score = similarity_model.similarity(question_embedding, response_embedding) # # return simmiliarity_score > threshold ## DEPRECATED # memory = ConversationBufferMemory( # memory_key="chat_history", #chat history as a list instead of a string # return_messages=True # ) # qa = ConversationalRetrievalChain.from_llm( # llm, # retriever=retriever, # memory=memory # ) ## DEPRECATED # Streamed response emulator chat_history = [] def get_response(question): # response = rag_chain.invoke(question) # response = conversational_rag_chain.invoke( # { # "input": question # }, # config = { # "configurable": {"session_id": "abc123"} # })['answer'] # if is_answer_in_context(response, question): # yield "## From Context:\n" + response # else: # fallback_response = llm.invoke(question) # yield "## From LLM: \n" + fallback_response result = rag_chain.invoke({"input": question, "chat_history": chat_history}) chat_history.extend([HumanMessage(content=question), result["answer"]]) yield result["answer"] # def format_docs(docs): # return "\n\n".join(doc.page_content for doc in docs) st.title("ComposTogether AI Q&A Answerer") st.write("**This is an AI-run chatbot where you can ask anything about ComposTogether and get live responses 24/7. If you want to confirm the responses from here, you can contact or email us.**") if "messages" not in st.session_state: st.session_state.messages = [] for message in st.session_state.messages: with st.chat_message(message["role"]): st.markdown(message["content"]) # Accept user input prompt = st.chat_input("What is up?") if prompt: # Add user message to chat history st.session_state.messages.append({"role": "user", "content": prompt}) # Display user message in chat message container with st.chat_message("user"): st.markdown(prompt) # Display assistant response in chat message container with st.chat_message("assistant"): response = st.write_stream(get_response(prompt)) # Add assistant response to chat history st.session_state.messages.append({"role": "assistant", "content": response}) # for i in range(5): # question = input("Ask anything: ").strip() # result = qa({"question":"What is ComposTogether?"}) # print(result["answer"])