How to leverage use of Conversationchain?

[CD-rajveer]

# Standard library imports
import os
import json
import time
import joblib
import pandas as pd
import requests
from streamlit_text_rating.st_text_rater import st_text_rater


# Third-party imports
import streamlit as st
from PyPDF2 import PdfReader
from docx import Document
import google.generativeai as genai
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_google_genai import GoogleGenerativeAIEmbeddings, ChatGoogleGenerativeAI
from langchain_community.vectorstores import FAISS
from langchain.chains.question_answering import load_qa_chain 
from langchain.chains import create_history_aware_retriever, ConversationalRetrievalChain
from langchain.chains.conversation.prompt import ENTITY_MEMORY_CONVERSATION_TEMPLATE
from langchain.prompts import PromptTemplate
from langchain.chains.conversation.memory import ConversationEntityMemory
from langchain.chains import ConversationChain



from langchain.document_loaders.pdf import PyMuPDFLoader
from langchain.document_loaders.xml import UnstructuredXMLLoader
from langchain.document_loaders.csv_loader import CSVLoader
from langchain.document_loaders import UnstructuredWordDocumentLoader

genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))

data_path = "/home/cimcon/Documents/Rajveer Rathod/CIMCopilot/chatwith datasheet/CIMdata"

loaders = {
    '.pdf': PyMuPDFLoader,
    '.xml': UnstructuredXMLLoader,
    '.csv': CSVLoader,
    '.docx':UnstructuredWordDocumentLoader, 
}

def fetch_files_from_folder(folder_path):
    pdf_files = []
    doc_files = []
    
    # Iterate over files in the folder
    for filename in os.listdir(folder_path):
        file_path = os.path.join(folder_path, filename)
        if filename.endswith(".pdf"):
            pdf_files.append(file_path)
        elif filename.endswith(".doc") or filename.endswith(".docx"):
            doc_files.append(file_path)
    
    return pdf_files, doc_files

def get_pdf_text(pdf_docs):
    text = ""
    for pdf in pdf_docs:
        if not pdf:  # Check if pdf is empty
            continue  # Skip to next iteration if empty
        pdf_reader = PdfReader(pdf)
        for page in pdf_reader.pages:
            text += page.extract_text()
    return text

def get_text_chunks(text):
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=5000, chunk_overlap=100)
    chunks = text_splitter.split_text(text)
    return chunks

@st.cache_data
def get_vector_store(text_chunks):
    embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
    vector_store = FAISS.from_texts(text_chunks, embedding=embeddings)
    vector_store.save_local("faiss_index")

def get_conversational_chain():

    prompt_template = """
You are CIMCopilot created by **CIMCON Digital**.
As an adept in analyzing technical specifications and configurations for a broad array of edge devices, I'm here to offer precise and detailed information regarding edge device specifications in response to specific queries. My proficiency spans across various manufacturers, encompassing crucial details such as make, model number, power consumption, processing capabilities, connectivity options, input/output interfaces, operating range, and firmware/software support.

Your primary task is to ask me about edge device specifications, and I'll provide you with the relevant information. If the requested data is unavailable directly from the context, I'll respond with "answer is not available in the context." Additionally, I'm equipped to provide information about the CIM10 upon request. For more detailed inquiries, you can contact our support team at support@cimcondigital.com.
you also need to consider the given context and the chat history to  provide answer.
---

**Regarding CIM10 Analog Input Configuration:**

For configuring analog input on the CIM10, there are two pins available, supporting up to two analog channels at maximum. Various parameters need configuration such as Range, Destination, Sampling Rate, Debug, NumOfChannels, Enable, Pin Number, Channel Type, Name, Peripheral ID, EnggLowCal, EnggHighCal, Scalelow, and Scalehigh. These parameters facilitate effective calibration, configuration, and conversion of raw and engineering values.

For instance, if configuring a field device with a 4-20mA output on AI pin, the configuration settings on CIM10 would include:

| Parameter           | Value                                    |
|---------------------|------------------------------------------|
| Pin Number          | 1                                        |
| Sampling rate (Sec) | 1 to 86400                               |
| Destination         | CIMCON Cloud                             |
| Name                | User-defined                             |
| Device ID           | User-defined                             |
| Channel Type        | Current (I)                              |
| Engg. Scale Low     | 4                                        |
| Engg. Scale High    | 20                                       |
| Scale Low           | Minimum value based on datasheet range   |
| Scale High          | Maximum value based on datasheet range   |

Or, if the channel is a voltage channel:

| Parameter           | Value                                    |
|---------------------|------------------------------------------|
| Pin Number          | 1                                        |
| Sampling rate (Sec) | 1 to 86400                               |
| Destination         | CIMCON Cloud                             |
| Name                | User-defined                             |
| Device ID           | User-defined                             |
| Channel Type        | Voltage (V)                              |
| Engg. Scale Low     | 0                                        |
| Engg. Scale High    | 10                                       |
| Scale Low           | Read from datasheet and fill here        |
| Scale High          | Read from datasheet and fill here        |

---

**Regarding CIM10 Digital Input Configuration:**

For configuring digital input on the CIM10, there are two pins available, supporting up to two digital channels at maximum. Parameters such as range, Sampling Rate, Debug, Number Of Channel, and Device ID need configuration.

| Parameter           | Value                                    |
|---------------------|------------------------------------------|
| Pin Number          | 1                                        |
| Sampling rate (Sec) | 1 to 86400                               |
| Destination         | CIMCON Cloud                             |
| Pin Name            | User-defined                             |
| Device ID           | User-defined                             |

**You can say "I don't have information about this, Please provide relavent and clear question! or Contact Support Team on this email :- support@cimcondigital.com" unless the question is completely unrelated.*
---
Context: {context}
    Question: {question}
    Entities Context: {entities}
    Conversation History: {history}
    Last Interaction: Human said: {last_input}
"""

    model = ChatGoogleGenerativeAI(
        model="gemini-1.5-pro-latest",
        temperature=0.2,
        max_output_tokens=8192,
        verbose=True
        )
     


    copilot_prompt = PromptTemplate(
        template=prompt_template, input_variables=["context", "question"]
    )
    
    memory_prompt = ENTITY_MEMORY_CONVERSATION_TEMPLATE

    master_prompt = copilot_prompt + memory_prompt
    # chain = load_qa_chain(model, chain_type="stuff", prompt=prompt)
    # chain = ConversationalRetrievalChain.from_llm(llm=model, retriever=db.as_retriever())
    # chain = ConversationalRetrievalChain.from_llm(
    #     llm=model,
    #     chain_type='stuff',
    #     retriever=docs.as_retriever(search_kwargs={"k": 6}),
    #     # memory=memory,
    #     # get_chat_history=lambda h: h,
    #     #verbose=True,
    #     combine_docs_chain_kwargs={'prompt': prompt}        

    # )
    # master_prompt =f"{copilot_prompt} + {memory_prompt}"
    # master_prompt = PromptTemplate(input_variables=["context", "entities", "history", "input", "question"],
    #                                template=copilot_prompt + memory_prompt)
    # prompt_to_remember = st.number_input(' (#)Summary of prompts to consider',min_value=3,max_value=1000)

    if 'entity_memory' not in st.session_state:
        st.session_state.entity_memory = ConversationEntityMemory(llm=model)
        # print(st.session_state.entity_memory)
        

    conversation_chain = ConversationChain(
        llm=model, 
        prompt=master_prompt,
        memory=st.session_state.entity_memory
    )

    return conversation_chain

def user_input(user_question):
    embeddings = GoogleGenerativeAIEmbeddings(model="models/text-embedding-004")
    new_db = FAISS.load_local(
        "faiss_index", embeddings, allow_dangerous_deserialization=True
    )
    docs = new_db.similarity_search(user_question, 4)


   
    # docs = new_db.sh
    chain = get_conversational_chain()
    response = chain(
        {"input_documents": docs,
         "question": user_question,
         },
         return_only_outputs=True
    )
  
    # Save user question and response in JSON format
    data = {
        "user_question": user_question,
        "response": response["output_text"]
    }
    with open("user_question_response.json", "w") as json_file:
        json.dump(data, json_file)

    # Save user question and response in text format
    with open("user_question_response.txt", "a") as txt_file:
        txt_file.write(f"User Question: {user_question}\n")
        txt_file.write(f"Response: {response['output_text']}\n")
        txt_file.write("\n")

    # Chatbot responses for greetings and small talks
    # answer = handle_greetings_and_small_talks(user_question)
    # if answer:
    #     st.write("Chatbot: ", answer)
    # else:
    #     
    return response["output_text"]

def download_pdf(url, directory="."):
    # Create directory if it doesn't exist
    if not os.path.exists(directory):
        os.makedirs(directory)

    # Extract filename from URL
    filename = os.path.join(directory, url.split('/')[-1])

    # Download PDF file
    with open(filename, 'wb') as f:
        response = requests.get(url)
        f.write(response.content)
    return filename

def response_to_json(response):
    # Convert response to JSON format
    json_data = {
        "request":"set_config",
        "request_parameters": response
    }
    return json_data

@st.cache_data
def convert_df_to_csv(data):
    df = pd.DataFrame(data)
    return df.to_csv().encode('utf-8')

def response_generator(response):
    for word in response.split():
        yield word + " "
        # word
        time.sleep(0.1)

def main():
    st.set_page_config("CIMCOPILOT")
    st.header("CIMCOPILOT")
    st.text("Start your chat")

    # Folder path where PDF and DOC files are stored
    folder_path = "/home/cimcon/Documents/Rajveer Rathod/CIMCopilot/chatwith datasheet/CIMdata"

    # Fetch PDF and DOC files from the folder
    pdf_files, doc_files = fetch_files_from_folder(folder_path)

    # Function to extract text from PDF files
    pdf_texts = []
    for pdf_file in pdf_files:
        pdf_texts.append(get_pdf_text([pdf_file]))

    # Get text chunks
    text_chunks = get_text_chunks(" ".join(pdf_texts))

    # Generate vector stst.session_state.messages.append({"role": "assistant", "content": response})ore
    get_vector_store(text_chunks)

#     if "chat_history" not in st.session_state:
#         st.session_state["chat_history"] = {}


#     if "messages" not in st.session_state:
#         st.session_state.messages = []

# # Display chat messages from history on app rerun
#     for message in st.session_state.messages:
#         with st.chat_message(message["role"]):
#             st.markdown(message["content"])


    # new_chat_id = f'{time.time()}'
    MODEL_ROLE = 'ai'
    AI_AVATAR_ICON = '✨'


    if "generated" not in st.session_state:
        st.session_state["generated"] = []
    if "past" not in st.session_state:
        st.session_state["past"] = []
    if "input" not in st.session_state:
        st.session_state["input"] = ""
    if "stored_session" not in st.session_state:
        st.session_state["stored_session"] = []

    # # Define function to get user input
    # def get_text():
    #     """
    #     Get the user input text.

    #     Returns:
    #         (str): The text entered by the user
    #     """
    #     input_text = st.text_input("You: ", st.session_state["input"], key="input",
    #                             placeholder="Your AI assistant here! Ask me anything ...", 
    #                             label_visibility='hidden')
    #     return input_text

# Define function to start a new chat
    def new_chat():
        """
        Clears session state and starts a new chat.
        """
        save = []
        for i in range(len(st.session_state['generated'])-1, -1, -1):
            save.append("User:" + st.session_state["past"][i])
            save.append("Bot:" + st.session_state["generated"][i])        
        st.session_state["stored_session"].append(save)
        st.session_state["generated"] = []
        st.session_state["past"] = []
        st.session_state["input"] = ""
        st.session_state.entity_memory.entity_store = {}
        st.session_state.entity_memory.buffer.clear()

    current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
    new_chat_id = f'{current_time}'


    try:
        past_chats: dict = joblib.load('data/past_chats_list')
    except:
        past_chats = {}

    with st.sidebar:
        st.write('# Past Chats')
        if st.session_state.get('chat_id') is None:
            st.session_state.chat_id = st.selectbox(
                label='Pick a past chat',
                options=[new_chat_id] + list(past_chats.keys()),
                format_func=lambda x: past_chats.get(x, 'New Chat'),
                placeholder='_',
            )
        else:
            st.session_state.chat_id = st.selectbox(
                label='Pick a past chat',
                options=[new_chat_id, st.session_state.chat_id] + list(past_chats.keys()),
                index=1,
                format_func=lambda x: past_chats.get(x, 'New Chat' if x != st.session_state.chat_id else st.session_state.chat_title),
                placeholder='_',
            )
        st.session_state.chat_title = f'CIMCopilot-{st.session_state.chat_id}'

    if "chat_history" not in st.session_state:
        st.session_state["chat_history"] = {}

    def create_new_chat(chat_id):
        st.session_state["chat_history"][chat_id] = []

    def add_message_to_chat(chat_id, message, role):
        if chat_id not in st.session_state["chat_history"]:
            create_new_chat(chat_id)
        st.session_state["chat_history"][chat_id].append({"role": role, "content": message})

    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"])

    user_question = st.chat_input("Message CIMCopilot", max_chars=5000)    
    if user_question:
        # user_input(user_question)
        st.session_state.messages.append({"role": "user", "content": user_question})
        # st.write(f"User: {user_question}")
        with st.chat_message("user"):
            st.markdown(user_question)
        
        response = user_input(user_question)
        st.session_state.messages.append({"role": "assistant", "content": response})
        with st.chat_message("assistant"):
            # st.write(response)
                          # ratings = st_text_rater(text=st.markdown(response))
            st.write_stream(response_generator(response))
            # st.download_button(label="Download Config", data=json_data, file_name='ai_config.json', mime='application/json')
        add_message_to_chat(st.session_state.chat_id, user_question, 'user')
        # Add assistant response to chat history
        add_message_to_chat(st.session_state.chat_id, response, 'assistant')
        
    # save_chat_history_to_csv(st.session_state.chat_history)
    

        # col1,col2,col3,col4 = st.columns([3,3,0.5,0.5])
        # with col3:
        #             if st.button(":thumbsup:"):
        #                 print("Like")
        # with col4:
        #             if st.button(":thumbsdown:"):
        #                 print("Dislike")
        # 
        # st.button("Download Config")
        # if  st.button("Download Config") and isinstance(json_data, dict):
            
        #         # Save JSON to file
        #     
        #         
        #         # Provide download link
        #     
            
        #         data = f.read()
        #     b64 = base64.b64encode(data).decode()
        #     href = f'<a href="data:application/octet-stream;base64,{b64}" download="ai_config.json">Download ai_config.json</a>'
        #     st.markdown(href, unsafe_allow_html=True)

        #     # st.subheader("Generated Configuration:")
        #     # st.json(json_data)
    data = {
    'Name': ['John', 'Emma', 'Michael', 'Sophia', 'William'],
    'Age': [25, 30, 35, 40, 45],
    'Gender': ['Male', 'Female', 'Male', 'Female', 'Male'],
    'City': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
}
    csv = convert_df_to_csv(data)

            

    with st.sidebar:
        st.sidebar.button("New Chat", on_click=new_chat, type='primary')
        st.title("Upload datasheet")
        pdf_docs = st.file_uploader("Upload your datasheets and Click on the Submit & Process Button", accept_multiple_files=True)
        if st.button("Submit & Process"):
            with st.spinner("Processing..."):
                raw_text = get_pdf_text(pdf_docs)
                print("raw text", raw_text)
                print("###########################################################################################")
                text_chunks = get_text_chunks(raw_text)
                print("tet chunks: ", text_chunks)
                get_vector_store(text_chunks)
                st.success("Done")
        st.text("whether to preview memory store and buffer")       
        if st.checkbox("Preview memory store"):
            with st.expander("Memory-Store", expanded=False):
                st.session_state.entity_memory.store
    # Option to preview memory buffer
        if st.checkbox("Preview memory buffer"):
            with st.expander("Bufffer-Store", expanded=False):
                st.session_state.entity_memory.buffer

        if st.session_state.stored_session:   
            if st.sidebar.checkbox("Clear-all"):
                del st.session_state.stored_session
        st.download_button(label="Download Config", data=csv, file_name="config.csv", mime="text/csv", use_container_width=True)


if __name__ == "__main__":
    main()

I want to use conversational chain with this kindly show some advice

[eyurtsev]

@CD-rajveer If you want a person to help with your problem, you need to invest some effort in describing the issue and what you're trying to do.

[CD-rajveer]

hey @eyurtsev, I am trying to use conversational chain for my application which is RAG based and it will also involve internet search through LLMs, I want to use LLM to remember the previous chat and also answer through the RAG so I am trying to combine both prompt copilot_prompt and memory_prompt = ENTITY_MEMORY_CONVERSATION_TEMPLATE into one prompt to fullfil the requirement. However I have faced below errors which I am trying to resolve.

ValidationError: 1 validation error for ConversationChain __root__ Got unexpected prompt input variables. The prompt expects ['context', 'entities', 'history', 'input', 'last_input', 'question'], but got ['entities', 'history'] as inputs from memory, and input as the normal input key. (type=value_error)
Traceback:
File "/home/cimcon/Documents/Rajveer Rathod/CIMCopilot/chatwith datasheet/venv/lib/python3.10/site-packages/streamlit/runtime/scriptrunner/script_runner.py", line 542, in _run_script
    exec(code, module.__dict__)
File "/home/cimcon/Documents/Rajveer Rathod/CIMCopilot/chatwith datasheet/copilot_v4_netsearch.py", line 474, in <module>
    main()
File "/home/cimcon/Documents/Rajveer Rathod/CIMCopilot/chatwith datasheet/copilot_v4_netsearch.py", line 397, in main
    response = user_input(user_question)
File "/home/cimcon/Documents/Rajveer Rathod/CIMCopilot/chatwith datasheet/copilot_v4_netsearch.py", line 202, in user_input
    chain = get_conversational_chain()
File "/home/cimcon/Documents/Rajveer Rathod/CIMCopilot/chatwith datasheet/copilot_v4_netsearch.py", line 184, in get_conversational_chain
    conversation_chain = ConversationChain(
File "/home/cimcon/Documents/Rajveer Rathod/CIMCopilot/chatwith datasheet/venv/lib/python3.10/site-packages/langchain_core/load/serializable.py", line 120, in __init__
    super().__init__(**kwargs)
File "/home/cimcon/Documents/Rajveer Rathod/CIMCopilot/chatwith datasheet/venv/lib/python3.10/site-packages/pydantic/v1/main.py", line 341, in __init__
    raise validation_error

this is an industry grade project, any assistance in this will be appreciated.