initial

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+machine-learning.pdf filter=lfs diff=lfs merge=lfs -text

Answering_Agent.py

@@ -0,0 +1,63 @@
+import openai
+from openai import OpenAI
+
+from Query_Agent import extract_action
+
+
+class Answering_Agent:
+    def __init__(self, openai_api_key) -> None:
+        # TODO: Initialize the Answering_Agent
+        # openai_api_key = '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'
+
+        self.openai_client = openai
+        openai.api_key = openai_api_key
+
+    def get_document_content(self, doc_id):
+        # This is a placeholder function, you'll need to implement the logic to retrieve the actual content.
+        # For example, it might query a database or an API with the document ID.
+        return "Document content for ID " + doc_id
+
+    def generate_response(self, query, docs, conv_history, k=5, mode="chatty"):
+        # TODO: Generate a response to the user's query
+        # Concatenate the contents of the top k relevant documents
+        # top_docs = docs[2][:k]  # Get the top k documents based on the score
+
+        # Retrieve the content for each of the top documents
+        context_texts = "\n\n".join(
+            [f"Context {idx + 1}: {result[2]}" for idx, result in enumerate(docs)])  # Assuming result[2] is the text
+        print(f"context_texts is : {context_texts} \n\n\n")
+        # docs_content = "\n".join([self.get_document_content(doc["id"]) for doc in docs])
+
+        # Optional: Include conversation history in the prompt if provided
+        if conv_history:
+            history_str = "\n".join([f"{turn['role']}: {turn['content']}" for turn in conv_history])
+            prompt = f"""Based on the following documents and conversation history, answer the query:
+            Documents:
+            {context_texts}
+            Conversation:
+            {history_str}
+            Query: {query}
+            ONLY If neither Documents nor Conversation has anything to do with query, you must reply directly: No relevant documents found in the documents. Please ask a relevant question to the book on Machine Learning. 
+            Answer: """
+
+        else:
+            prompt = f"Based on the following documents, answer the query:\nDocuments:\n{context_texts}\nQuery: {query}\n ONLY If Documents has nothing to do with query,  you must reply directly: No relevant documents found in the documents.Please ask a relevant question to the book on Machine Learning. \nAnswer: "
+
+        # Adjust the prompt, max_tokens, and temperature based on the mode
+        max_tokens = 4000 if mode == "chatty" else 100
+        temperature = 0.9 if mode == "chatty" else 0.5
+
+        # mode of chatty
+        if mode == "chatty":
+            prompt = prompt + "Please provide a detailed and comprehensive response that includes background information, relevant examples, and any important distinctions or perspectives related to the topic. Where possible, include step-by-step explanations or descriptions to ensure clarity and depth in your answer"
+
+        client = OpenAI(api_key=openai.api_key)
+        message = {"role": "user", "content": prompt}
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[message],
+            max_tokens=max_tokens,
+            temperature=temperature,
+            stop=["\n", "Query:"]
+        )
+        return response.choices[0].message.content

Head_Agent.py

@@ -0,0 +1,97 @@
+import pinecone
+import openai
+from openai import OpenAI
+from Answering_Agent import Answering_Agent
+from Obnoxious_Agent import Obnoxious_Agent
+from Query_Agent import Query_Agent
+from Relevant_Documents_Agent import Relevant_Documents_Agent
+
+
+class Head_Agent:
+    def __init__(self, openai_key, pinecone_key, pinecone_index_name) -> None:
+        # TODO: Initialize the Head_Agent
+        # Store API keys and Pinecone index name
+        openai_key = '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'
+
+        self.openai_client = OpenAI(api_key=openai_key)
+
+        self.openai_key = openai_key
+        self.pinecone_key = pinecone_key
+        self.pinecone_index_name = pinecone_index_name
+
+        # Initialize Pinecone
+
+        # Placeholder for sub-agents, to be initialized in setup_sub_agents
+        self.obnoxious_agent = None
+        self.query_agent = None
+        self.answering_agent = None
+        self.relevant_documents_agent = None
+
+        # set up sub agents
+        self.setup_sub_agents()
+
+    def get_completion(self, prompt, model="gpt-4"):
+        message = {"role": "user", "content": prompt}
+        response = self.openai_client.chat.completions.create(
+            model=model,
+            messages=[message]
+        )
+        return response.choices[0].message.content
+
+    def setup_sub_agents(self):
+        # TODO: Setup the sub-agents
+        # Setup the Obnoxious_Agent
+        self.obnoxious_agent = Obnoxious_Agent()  # Assuming no external API client required
+
+        # Set up the Query_Agent with Pinecone index
+        self.query_agent = Query_Agent(pinecone_index=self.pinecone_index_name, openai_client=openai,
+                                       embeddings="text-embedding-ada-002")
+
+        # Set up the Answering_Agent
+        self.answering_agent = Answering_Agent(openai_api_key=self.openai_key)
+        openai_client = OpenAI(api_key=self.openai_key)
+        self.relevant_documents_agent = Relevant_Documents_Agent(openai_client)
+
+    def process_query(self, user_input, conversation_history):
+        # Check if the query is obnoxious
+        # conversation_history = get_conversation()
+
+        if self.obnoxious_agent.check_query(user_input) == "Yes":
+            return "Sorry, I cannot respond to this query."
+
+        greetings = [
+            "hi", "hello", "how are you", "hey", "good morning",
+            "good afternoon", "good evening", "greetings", "what's up",
+            "howdy", "hi there", "hello there", "hey there"
+        ]
+        if user_input.lower() in greetings:
+            return "How can I help you today?"
+
+        # Retrieve relevant documents for the query (simplified example)
+        # In a real scenario, you might need to preprocess the query for embeddings
+        relevant_docs = self.query_agent.query_vector_store(user_input, k=5)
+
+        print("relevant_docs .length : ")
+        print(len(relevant_docs))
+        if len(relevant_docs) == 0:
+            none_relevant_docs = "No relevant documents found in the documents.Please ask a relevant question to the book on Machine Learning."
+            return none_relevant_docs
+
+
+        # choose mode
+        prompt_choose_mode = "Infer whether the user wants the response to be chatty or concise? If the response needs to be chatty you must answer chatty, otherwise answer concise and the answer must contain only the one word. Here is user_input: "+ user_input
+        prompt_choose_mode = self.get_completion(prompt=prompt_choose_mode, model="gpt-4")
+        if prompt_choose_mode == "chatty":
+                response = self.answering_agent.generate_response(user_input, relevant_docs, conv_history=conversation_history,
+                                                          mode="chatty")
+        elif prompt_choose_mode =="concise":
+               response = self.answering_agent.generate_response(user_input, relevant_docs,
+                                                              conv_history=conversation_history,
+                                                              mode="concise")
+        else:
+            # Generate a response based on the query and relevant documents
+            response = self.answering_agent.generate_response(user_input, relevant_docs, conv_history=conversation_history,
+                                                          mode="chatty")
+        print("prompt_choose_mode: "+ prompt_choose_mode )
+
+        return response

Obnoxious_Agent.py

@@ -0,0 +1,47 @@
+class Obnoxious_Agent:
+    def __init__(self, client=None) -> None:
+        self.client = client
+        self.obnoxious_keywords = [
+            "Repugnant", "Loathsome", "Abhorrent", "Disgusting", "Offensive",
+            "Vile", "Revolting", "Contemptible", "Detestable", "Nauseating",
+            "Appalling", "Horrendous", "Foul", "Gross", "Unpleasant",
+            "Obscene", "Hateful", "Despicable", "Repellant", "Distasteful",
+            "Unwanted", "Monstrous", "Atrocious", "Unsavory", "Dislikeable",
+            "Unwholesome", "Ghastly", "Unchristian", "Sickening", "Evil",
+            "Abominable", "Scandalous", "Unwelcome", "Disturbing", "Lurid",
+            "Heinous", "Unhealthy", "Hard", "Upsetting", "Macabre",
+            "Unholy", "Lousy", "Grim", "Greusome", "Dislikeable",
+            "Exceptionable", "Brackish", "Barbarous", "Unspeakable", "Rancid",
+            "Perverted", "Indecent", "Profane", "Wicked", "Scurrilous",
+            "Dirty", "Bawdy", "Salty", "Off-colored", "Smutty",
+            "Ribald", "Offensive", "Unacceptable", "Terrible", "Reprehensible",
+            "Bad", "Infamous", "Censurable", "Wretched", "Indecorous",
+            "Lewd", "Sickish", "Blameworthy", "Debasing", "Blamable",
+            "Insincere", "Annoying", "Provoking", "Reprehensible", "Vulgar",
+            "Pornographic", "Naughty", "Perverted", "Unbecoming", "Coarse",
+            "Unprintable", "Belligerent", "Irritating", "Disruptive", "Displeasing",
+            "Inflammatory", "Disrespectful", "Aggravating", "Bothersome", "Intrusive",
+            "Insulting", "Obnoxious", "Off-putting", "Unpleasant", "Revolting", "dumb"
+        ]
+
+        self.prompt = ""
+
+    def set_prompt(self, prompt):
+        # Set the prompt for potential use with external APIs
+        self.prompt = prompt
+
+    def extract_action(self, response) -> bool:
+        # Extract and interpret the action from an external API's response
+        # This example assumes a hypothetical response structure
+        return response.get('is_obnoxious', False)
+
+    def check_query(self, query) -> str:
+        # Directly check if the query contains obnoxious content using keywords
+        query_lower = query.lower()
+        is_obnoxious = any(keyword in query_lower for keyword in self.obnoxious_keywords)
+
+        # If integrating with an external API:
+        # response = self.client.some_api_method(self.prompt.format(query=query))
+        # is_obnoxious = self.extract_action(response)
+
+        return "Yes" if is_obnoxious else "No"

Query_Agent.py

@@ -0,0 +1,57 @@
+from pinecone import Pinecone
+import openai
+from openai import OpenAI
+
+
+def extract_action(response, query=None):
+    # TODO: Extract the action from the response
+    # For example, retrieve document IDs and their similarity scores
+    relevant_docs = [{"id": match["id"], "score": match["score"]} for match in response["matches"]]
+
+    return relevant_docs
+
+
+class Query_Agent:
+
+    def __init__(self, pinecone_index, openai_client, embeddings) -> None:
+        # TODO: Initialize the Query_Agent agent
+        # Initialize the OpenAI client with the provided API key
+        openai_api_key = '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'
+        self.client = OpenAI(api_key=openai_api_key)
+
+        # Specify the embeddings model to use for generating query embeddings
+        self.embeddings_model = embeddings
+
+        pc = Pinecone(api_key="52ef9136-6188-4e51-af13-9639bf95c163")
+
+        # Initialize Pinecone client and connect to the specified index
+        self.pinecone_index = pc.Index(pinecone_index)
+
+    def query_vector_store(self, query, k=5):
+        # TODO: Query the Pinecone vector store
+        # Generate an embedding for the query
+
+        query = query.replace("\n", " ")
+
+        query_embedding = self.client.embeddings.create(
+            input=[query],
+            model=self.embeddings_model
+        ).data[0].embedding
+
+        # Query the Pinecone index using the generated embedding
+        query_results = self.pinecone_index.query(
+            vector=query_embedding,
+            top_k=k,
+            include_metadata=True)
+
+        # Extract and return the most relevant documents along with their scores
+        relevant_docs = [
+            (result['id'], result['score'], result['metadata']['text'])
+            for result in query_results['matches']
+        ]
+
+        return relevant_docs
+
+    def set_prompt(self, prompt):
+        # TODO: Set the prompt for the Query_Agent agent
+        self.prompt = prompt

Relevant_Documents_Agent.py

@@ -0,0 +1,114 @@
+import numpy as np
+from langchain_community.embeddings import OpenAIEmbeddings
+
+from pinecone import Pinecone, ServerlessSpec
+from tqdm.notebook import tqdm
+import langchain
+import openai
+from openai import OpenAI
+import string
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.document_loaders import UnstructuredPDFLoader, OnlinePDFLoader
+import os
+
+
+def get_text_from_document(document):
+    # Assuming 'text' is a list of Document objects, each with a 'page_content' attribute
+    # Concatenate the page_content of each Document into a single text string
+    # text = "".join([doc.page_content for doc in document])
+    text = "".join(document).replace('\n\n', '\n')
+
+    # Now, 'full_text' should contain the actual text extracted from the PDF
+    print(f"Total length of text: {len(text)} characters")
+
+    # If you want to see a part of the extracted text
+    print(text[:1000])  # Adjust the number as necessary to inspect more of the text
+
+    return text
+
+
+# Function to get the embeddings of the text using OpenAI text-embedding-ada-002 model
+def get_embedding(text, model="text-embedding-ada-002"):
+    text = text.replace("\n", " ")
+    openai_key = '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'
+    client = OpenAI(api_key=openai_key)
+    return client.embeddings.create(input=[text], model=model).data[0].embedding
+
+
+## TODO: Function to query the Pinecone vector store and return the top-k results
+def query_pinecone_vector_store(query, top_k=5):
+    # Generate an embedding for the query
+    query_embedding = get_embedding(query)
+
+    # pc = Pinecone(api_key="c25f9e89-fc9e-4d21-b3eb-057dbc21c17c")
+    pc = Pinecone(api_key="52ef9136-6188-4e51-af13-9639bf95c163")
+    pinecone_index_name = "ee596llm-project2"
+    index = pc.Index(pinecone_index_name)
+
+    # Query the Pinecone index with the generated embedding
+    query_results = index.query(
+        vector=query_embedding,
+        top_k=top_k,
+        include_metadata=True
+    )
+
+    # Extract and return the most relevant documents along with their scores
+    relevant_docs = [
+        (result['id'], result['score'], result['metadata']['text'])
+        for result in query_results['matches']
+    ]
+    return relevant_docs
+
+
+def get_completion(prompt, model="gpt-3.5-turbo"):
+    message = {"role": "user", "content": prompt}
+    client = OpenAI(api_key='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')
+    response = client.chat.completions.create(
+        model=model,
+        messages=[message]
+    )
+    return response.choices[0].message.content
+
+
+def generate_answer_with_context(query, results):
+    # Construct the prompt with the top-k results as context
+    context_texts = "\n\n".join(
+        [f"Context {idx + 1}: {result[1]}" for idx, result in enumerate(results)])  # Assuming result[1] is the text
+    print(f"context_texts is : {context_texts} \n\n\n")
+    prompt = f"Given the following contexts related to the query '{query}', provide a detailed answer:\n\n{context_texts}\n\nAnswer the query:"
+
+    # Generate the answer using the GPT-3.5 Turbo model with the constructed prompt
+    answer = get_completion(prompt, model="gpt-3.5-turbo")
+
+    return answer
+
+
+class Relevant_Documents_Agent:
+    def __init__(self, openai_client) -> None:
+        # TODO: Initialize the Relevant_Documents_Agent
+        self.openai_client = openai_client
+
+    def get_relevance(self, conversation) -> str:
+        # TODO: Get if the returned documents are relevant
+        # Generate embeddings for the query and all documents
+
+        top_k_results = query_pinecone_vector_store(conversation, top_k=4)
+
+        answer = generate_answer_with_context(conversation, top_k_results)
+
+        most_relevant_document = answer
+
+        return most_relevant_document
+
+    def compute_cosine_similarity(self, vec1, vec2):
+        # Ensure the vectors are numpy arrays for mathematical operations
+        vec1 = np.array(vec1)
+        vec2 = np.array(vec2)
+
+        # Compute the cosine similarity
+        dot_product = np.dot(vec1, vec2)
+        norm_vec1 = np.linalg.norm(vec1)
+        norm_vec2 = np.linalg.norm(vec2)
+        cosine_similarity = dot_product / (norm_vec1 * norm_vec2)
+
+        return cosine_similarity

app.py

@@ -0,0 +1,100 @@
+from datetime import datetime
+from Obnoxious_Agent import Obnoxious_Agent
+from Relevant_Documents_Agent import Relevant_Documents_Agent
+from Query_Agent import Query_Agent
+from Answering_Agent import Answering_Agent
+from datetime import datetime
+from langchain.document_loaders import UnstructuredPDFLoader, OnlinePDFLoader
+import streamlit as st
+from openai import OpenAI
+from Head_Agent import Head_Agent
+
+st.title("Mini Project 2: Streamlit Chatbot")
+
+# TODO: Replace with your actual OpenAI API key
+client = OpenAI(api_key='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')
+
+
+# Define a function to get the conversation history (Not required for Part-2, will be useful in Part-3)
+def get_conversation():
+    # ... (code for getting conversation history)
+    history_conversation = []
+    for message in st.session_state.messages:
+        if message["sender"] == "user":
+            cur_map = dict()
+            cur_map['role']= "user"
+            cur_map['content'] = message['content']
+            history_conversation.append(cur_map)
+        elif message["sender"] == "assistant":
+            cur_map = dict()
+            cur_map['role'] = "assistant"
+            cur_map['content'] = message['content']
+            history_conversation.append(cur_map)
+    return history_conversation
+
+
+def display_all_chat_messages():
+    for message in st.session_state.messages:
+        # st.text_area("", value=message["content"], key=message["sender"] + str(message["id"]))
+        if message["sender"] == "user":
+            with st.chat_message("user"):  # 显示avatar
+                st.container().markdown(f"**You [{message['timestamp']}]:** {message['content']}")
+        elif message["sender"] == "assistant":
+            with st.chat_message("assistant"):  # 显示avatar
+                st.container().markdown(f"**Assistant [{message['timestamp']}]:** {message['content']}")
+
+
+# Initialize the Head Agent with necessary parameters
+if 'head_agent' not in st.session_state:
+    openai_key = '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'
+    pinecone_key = "52ef9136-6188-4e51-af13-9639bf95c163"
+    pinecone_index_name = "ee596llm-project2"
+    st.session_state.head_agent = Head_Agent(openai_key, pinecone_key, pinecone_index_name)
+
+# Your existing code for handling user input and displaying messages
+# Replace the direct call to `get_completion` with `st.session_state.head_agent.process_query(prompt)`
+
+# Example:
+if prompt := st.chat_input("What would you like to chat about?"):
+    try:
+        if "messages" not in st.session_state:
+            st.session_state.messages = []
+        message_id = len(st.session_state.messages)
+        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        user_message = {"id": message_id, "sender": "user", "content": prompt, "timestamp": current_time}
+        st.session_state.messages.append(user_message)
+
+        # Instantiate the Obnoxious Agent
+        obnoxious_agent = Obnoxious_Agent()
+        is_obnoxious = obnoxious_agent.check_query(prompt)
+        # Respond based on the check
+        if is_obnoxious:
+            response = "Yes"
+        else:
+            response = "No"
+        # You can then display this response to the user or use it as part of your application logic
+        is_obnoxious_response = "Is the query obnoxious? " + response
+        # st.write("Is the query obnoxious? " + response)
+
+        # display_message(user_message)
+
+    except Exception as e:
+        st.error("Failed to process your message. Please try again.")
+
+    # ... (display user message in the chat interface)
+    # display_message(user_message)  # Use the display_message function to show the user's message
+
+    # Generate AI response
+    # with st.chat_message("assistant"):  删除掉 chat聊天框 不能嵌套
+
+    # ... (send request to OpenAI API)
+    # ... (get AI response and display it)
+    ai_response = st.session_state.head_agent.process_query(prompt, get_conversation())
+
+    # ... (append AI response to messages)
+    ai_message = {"id": len(st.session_state.messages), "sender": "assistant", "content": ai_response,
+                  "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+    st.session_state.messages.append(ai_message)
+    print(ai_message)
+    # display_message(ai_message)
+    display_all_chat_messages()

machine-learning.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32251b6d23adf23e887ba1dcb6fbd91c5369a5c6c99df4b16dd2da56bf0fdad5
+size 3921784

requirements.txt

@@ -0,0 +1,16 @@
+openai
+langchain
+langchain_openai
+unstructured
+datetime
+unstructured_inference
+pikepdf
+pypdf
+numpy
+pinecone-client
+tiktoken
+pandas
+pillow_heif
+sentence_transformers
+streamlit
+IPython