Initial version

.gitignore

@@ -0,0 +1,5 @@
+./logs
+__pychache__
+./tests
+.env
+./*.txt

AskJesus_RAG.py

@@ -0,0 +1,213 @@
+import openai
+import pandas as pd
+import os
+import logging
+
+from logging_utils import setup_logging_to_file, sanitize_filename, close_logging_handlers
+
+# support for the .env file
+from dotenv import load_dotenv
+load_dotenv()
+
+# ChromaDB's client library for Python
+import chromadb
+from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
+from chroma_datasets.utils import (
+    load_huggingface_dataset,
+    import_chroma_exported_hf_dataset
+)
+
+# LangChain's client library for Python
+import langchain
+from langchain.vectorstores import Chroma
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.chains import (
+    RetrievalQA,
+    LLMChain
+)
+from langchain.chat_models import ChatOpenAI
+from langchain.prompts import PromptTemplate
+from langchain.prompts.chat import (
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+)
+
+
+
+#
+# OpenAI
+#
+
+
+# Test that your OpenAI API key is correctly set as an environment variable
+if os.getenv("OPENAI_API_KEY") is not None:
+    openai.api_key = os.getenv("OPENAI_API_KEY")
+    print ("OPENAI_API_KEY is ready")
+else:
+    print ("OPENAI_API_KEY environment variable not found")
+
+# set up both gpt-3.5 and gpt-4 so we can compare them
+chat_gpt_temperature = os.getenv("CHAT_GPT_TEMPERATURE")
+
+# This code is used both in a private local deployment, with a local persisted ChromaDB
+# and on HuggingFace, by loading the ChromaDB from a dataset.
+# In either case, the ChromaDB is used to create a Chroma LangChain.
+private_local_deployemnt = os.getenv("PRIVATE_LOCAL_DEPLOYMENT") == "True"
+
+
+#
+# ChromaDB
+#
+
+# open a pre-existing ChromaDB collection of UB paragraphs from disk (created by a different process)
+chroma_embedding_function = OpenAIEmbeddingFunction(
+    openai.api_key,
+    model_name=os.getenv("EMBEDDING_MODEL")
+)
+
+if private_local_deployemnt :
+    # the entire UB is under UBVectorDB/entire_book
+    chroma_db_path = "../../Python/UBVectorDB/entire_book"
+    chroma_client = chromadb.PersistentClient(path=chroma_db_path)
+    chroma_collection_name = "entire_book_paragraph_content"
+
+    paragraph_content_collection = chroma_client.get_collection(
+        name=chroma_collection_name, 
+        embedding_function=chroma_embedding_function
+    )
+    print(f"\nChroma has opened the persisted collection {chroma_collection_name} at {chroma_db_path} with {paragraph_content_collection.count()} paragraphs.")
+else :
+    UB_paragraphs_dataset_name = os.getenv("UB_PARAGRAPH_DATASET_NAME")
+    UB_paragraphs_dataset = load_huggingface_dataset(UB_paragraphs_dataset_name)
+
+    #
+    # create a Chroma Collection from the HF dataset
+    #
+    chroma_client = chromadb.Client()
+    chroma_collection_name_from_HF = "entire_book_paragraph_content-from-HF"
+    
+
+    """
+    NOTE: this code works only on HF due to batch sizes.
+
+    ValueError: Batch size 14585 exceeds maximum batch size 166
+    """
+
+    paragraph_content_collection_from_HF = import_chroma_exported_hf_dataset(
+        chroma_client=chroma_client, 
+        dataset=UB_paragraphs_dataset['data'], 
+        collection_name=chroma_collection_name_from_HF,
+        embedding_function=chroma_embedding_function
+    )
+    print(paragraph_content_collection_from_HF.count())
+
+
+
+#
+# LangChain
+#
+
+
+# create the open-source embedding function
+langchain_embedding_function = OpenAIEmbeddings(
+    openai_api_key=openai.api_key
+)
+
+# Create a ChromaDB client to be used in LangChain
+langchain_chroma = Chroma(
+    client=chroma_client,
+    collection_name=chroma_collection_name if private_local_deployemnt else chroma_collection_name_from_HF,
+    embedding_function=langchain_embedding_function
+)
+print(f"\nLangChain has imported the collection.\nThere are {langchain_chroma._collection.count()} UB paragraphs.\n")
+
+
+# Use LangChain to run a similiraty query on the collection
+def similarity_test(question, k=20) :
+    docs = langchain_chroma.similarity_search(question, k)
+
+    print(f"\nSimilarity Search for: {question}\n")
+    #logging.info(f"\nSimilarity Search for: {question}\n")
+
+    for doc in docs:
+        print(f"{doc.metadata['Standard Reference']} {doc.page_content}\n")
+        #logging.info(f"{doc.metadata['Standard Reference']} {doc.page_content}\n")
+
+
+
+#
+# Define the LangChain RetrievalQA chains
+#
+similarity_k = int(os.getenv("SIMILARITY_K"))
+
+
+
+def run_question(question, system_message, gpt_model, use_RAG):
+    # Creating log filename based on first 50 characters of the question
+    log_filename = f"{sanitize_filename(question[:50])}.txt"
+
+    # Setting up logging to the file
+    setup_logging_to_file(log_filename)
+
+    print(f"Question: {question}\nSystem Message: {system_message}\nChatGPT model: {gpt_model}\nUse references: {use_RAG}\n")
+    #logging.info(f"Question: {question}\nSystem Message: {system_message}\nChatGPT model: {gpt_model}\nUse references: {use_RAG}\n")
+
+    if use_RAG is True :
+        response = run_retrievalQA_chains(question, system_message, gpt_model)
+    else :
+        response = run_regular_chain(question, system_message, gpt_model)
+
+    print(f"Results logged to file: {log_filename}\n\n")
+    close_logging_handlers()
+
+    return response
+
+
+def run_retrievalQA_chains(question, system_message, gpt_model):
+    result = ""
+
+    llm = ChatOpenAI(model_name=gpt_model, temperature=chat_gpt_temperature)
+
+    template = system_message + "Use the following pieces of context to answer the question at the end.\n{context}\nQuestion: {question}\Masterful and inspiring answer:"
+
+    QA_CHAIN_PROMPT = PromptTemplate.from_template(template)
+
+    qa_chain_with_prompt = RetrievalQA.from_chain_type(
+        llm,
+        retriever=langchain_chroma.as_retriever(search_kwargs={'k': similarity_k}),
+        chain_type_kwargs={"prompt": QA_CHAIN_PROMPT},
+        return_source_documents=True
+    )
+        
+    result = qa_chain_with_prompt({"query": question})
+
+    print(f"\n\nWith UB references (model: {gpt_model}, with {len(result['source_documents'])} references)\n\n{result['result']}\n\n")
+    #logging.info(f"\n\nWith UB references (model: {gpt_model}, with {len(result['source_documents'])} references)\n\n{result['result']}\n\n")
+
+    return result['result']    
+
+
+def run_regular_chain(question, system_message, gpt_model) : 
+    result = ""
+
+    llm = ChatOpenAI(model_name=gpt_model, temperature=chat_gpt_temperature)
+
+    template = system_message + "\nQuestion: {question}\Masterful and inspiring answer:"
+
+    # create AskJesus system message for non-RAG chains
+    human_message_prompt = HumanMessagePromptTemplate(
+        prompt=PromptTemplate(
+            template=template,
+            input_variables=["question"]
+        )
+    )
+    prompt_template = ChatPromptTemplate.from_messages([human_message_prompt])
+
+    # run chain, log to file and to console
+    chain = LLMChain(llm=llm, prompt=prompt_template)
+    result = chain.run(question)
+
+    print(f"\n\nWithout UB references (model: {gpt_model})\n\n{result}\n")
+    #logging.info(f"\n\nWithout UB references (model: {gpt_model})\n\n{result}\n")
+
+    return result

Tell me everything about Adam and Eve.txt

@@ -0,0 +1,2 @@
+HTTP Request: POST https://api.openai.com/v1/embeddings "HTTP/1.1 200 OK"
+HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"

Tell me everything about your relationship with yo.txt

@@ -0,0 +1,2 @@
+HTTP Request: POST https://api.openai.com/v1/embeddings "HTTP/1.1 200 OK"
+HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"

app.py

@@ -0,0 +1,140 @@
+#
+# AskJesus HF v0.32
+# Feb 22, 2024
+#
+#
+
+# Import the required libraries
+import os
+import gradio as gr
+
+# Import the LangChain and ChatOpenAI classes
+from langchain.chat_models import ChatOpenAI
+from langchain.prompts.chat import (
+    ChatPromptTemplate,
+    SystemMessagePromptTemplate,
+    HumanMessagePromptTemplate,
+)
+from langchain.schema import HumanMessage, SystemMessage
+
+
+# Import the required libraries
+from dotenv import load_dotenv
+load_dotenv()
+
+from social_sharing import send_email_mailchimp, send_to_airtable
+from AskJesus_RAG import run_question
+
+# This code is used both in a private local deployment, with a local persisted ChromaDB
+# and on HuggingFace, by loading the ChromaDB from a dataset.
+# In either case, the ChromaDB is used to create a Chroma LangChain.
+private_local_deployemnt = os.getenv("PRIVATE_LOCAL_DEPLOYMENT") == "True"
+
+
+#
+# ChatGPT SYSTEM MESSAGE and Model selection
+#
+current_system_message = os.getenv("CHAT_GPT_DEFAULT_SYSTEM_MESSAGE")
+current_gpt_model = os.getenv("CHAT_GPT_3_5_MODEL")
+
+# Use RAG for the answer generation
+current_RAG_option = True
+
+# Initialize an empty list to store the chat history
+chat_history = []
+
+with gr.Blocks(title=f"AskJesus Chatbot {os.getenv('ASKJESUS_CHATBOT_VERSION')}") as demo:
+    
+    # Gradio UI
+    with gr.Row():
+        msg = gr.Textbox(
+            label="Question:", 
+            placeholder="Enter question here",
+            scale=4
+        )
+
+    with gr.Row():
+        chatbot = gr.Chatbot(
+            label=f"AskJesus Chatbot {os.getenv('ASKJESUS_CHATBOT_VERSION')}",
+            scale=8
+        )
+        
+    with gr.Row():
+        
+        email_input = gr.Textbox(
+            label="Email:", 
+            placeholder="Enter your email here",
+            scale=8
+        )
+        send_email_button = gr.Button(
+            value="Send email",
+            variant="primary",
+            scale=1
+        )
+
+
+    def user(user_message, history):
+        # Append the user's message to the chat history
+        chat_history.append({"Question": user_message, "AskJesus chatbot": None})
+        return gr.update(value="", interactive=False), history + [[user_message, None]]
+
+    def bot(history):
+        
+        # Get a chat completion from the formatted messages and the current system message
+        global current_system_message
+
+        # assuming response is an str
+        bot_message = run_question(
+            question=history[-1][0], 
+            system_message=current_system_message, 
+            gpt_model=current_gpt_model,
+            use_RAG=current_RAG_option
+        )
+        
+        # Update the chat history with the bot's message
+        chat_history[-1]["AskJesus chatbot"] = bot_message
+
+        history[-1][1] = bot_message
+        yield history
+        
+        # Send the question and answer to Airtable
+        send_to_airtable(
+            history[-1][0], 
+            history[-1][1], 
+            current_system_message, 
+            current_gpt_model, 
+            current_RAG_option
+        )
+
+    def email_session(email):
+        if not email:
+            print("No email address provided. Cannot send email.")
+            raise gr.Error("Please provide email.")
+            return
+
+        # Convert the chat history to a string format
+        history_str = "\n".join([f"Question: {entry['Question']}\nAskJesus chatbot: {entry['AskJesus chatbot']}\n\n" for entry in chat_history])
+        send_email_mailchimp(email, history_str)
+
+    def email_last_qa(email):
+        if not email:
+            print("No email address provided. Cannot send email.")
+            raise gr.Error("Please provide email.")
+            return
+
+        # Convert the last question and answer to a string format
+        history_str = "\n".join([f"Question: {chat_history[-1]['Question']}\nAskJesus chatbot: {chat_history[-1]['AskJesus chatbot']}\n\n"])
+        if send_email_mailchimp(email, history_str) == True :
+            gr.Info("Email sent.")
+        else :
+            raise gr.Error("Error: email not sent.")
+
+    response = msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+        bot, chatbot, chatbot
+    )
+    response.then(lambda: gr.update(interactive=True), None, [msg], queue=False)
+    send_email_button.click(email_last_qa, [email_input])
+
+
+demo.queue()
+demo.launch(show_error=True)

logging_utils.py

@@ -0,0 +1,21 @@
+import logging
+
+def setup_logging_to_file(filename):
+    logging.basicConfig(
+        filename=filename, 
+        level=logging.INFO, 
+        #format='%(asctime)s - %(levelname)s - %(message)s'
+        format='%(message)s'
+
+    )
+
+
+def sanitize_filename(filename):
+    invalid_chars = '\/:*?"<>|'
+    return ''.join('_' if c in invalid_chars else c for c in filename)
+
+
+def close_logging_handlers():
+    for handler in logging.root.handlers[:]:
+        handler.close()
+        logging.root.removeHandler(handler)

requirements.txt

@@ -0,0 +1,4 @@
+openai
+langchain
+gradio
+dotenv

social_sharing.py

@@ -0,0 +1,92 @@
+#
+# Ask Jesus v0.3
+# Sep 28, 2023
+#
+
+import os
+import tweepy
+import requests  # To make API calls to Airtable
+
+
+#
+# Mandrill
+#
+import mailchimp_transactional as MailchimpTransactional
+from mailchimp_transactional.api_client import ApiClientError
+
+# NOTE: There is a Live or Test key
+mailchimp = MailchimpTransactional.Client(os.getenv("MAILCHIMP_LIVE_KEY"))
+
+#
+# Send all questions to an Airtable
+#
+
+def send_to_airtable(question, answer, current_system_message, current_gpt_model, current_RAG_option):
+    # Replace with your Airtable API URL and API Key
+    url = os.getenv("AIRTABLE_URL")
+    headers = {"Authorization": f"Bearer {os.getenv('AIRTABLE_PERSONAL_TOKEN')}"}
+    data = {
+        "fields": {
+            "question": question, 
+            "answer": answer, 
+            "system prompt":current_system_message, 
+            "chatbot version":os.getenv("ASKJESUS_CHATBOT_VERSION"),
+            "added UB references":str(current_RAG_option),
+            "gpt_model":current_gpt_model
+        }
+    }
+    requests.post(url, headers=headers, json=data)
+
+#
+# Send last Q&A to via email
+#
+
+def send_email_mailchimp(email, history_str):
+
+    # Email content
+    subject = "👉 A chatbot session from AskJesus"
+    #body = "Someone that cares about you share their AskJesus chatbot session with you:\n\n" + history_str + "\n\n Click here to try the AskJesus chatbot."
+
+    html_intro = "<html><body><p>Someone that cares about you shared their AskJesus chatbot session with you:</p>"
+    html_link_to_askjesus_cfu_page = f"<p>Click <a href={os.getenv('ASKJESUS_CFU_PAGE')}>here</a> to try the AskJesus chatbot."
+    html_link_to_matching_fund_cfu_page = f"<br/>AskJesus will always be free and ad-free. Will you pay-it-foward so that others can enjoy it? Click <a href={os.getenv('MATCHING_FUND_CFU_PAGE')}>here</a> to donate.</p></body></html>"
+
+    # Replace newline characters with HTML line breaks
+    history_html = history_str.replace("\n", "<br/>")
+
+    # Combine everything
+    body = html_intro + history_html + html_link_to_askjesus_cfu_page + html_link_to_matching_fund_cfu_page
+
+    message = {
+        "from_email": os.getenv("FROM_EMAIL"),
+        "subject": subject,
+        "html": body,
+        "to": [
+        {
+            "email": email,
+            "type": "to"
+        }
+            ]
+    }
+
+    try:
+        response = mailchimp.messages.send({"message":message})
+        print('Mailchimp API called successfully: {}'.format(response))
+        #print (message)
+        return True
+
+    except ApiClientError as error:
+        print('An exception occurred: {}'.format(error.text))
+        return False
+
+
+def send_tweet(tweet_link):
+   
+    try:
+        twitter_client.create_tweet(text=tweet_link)
+        print (f"Successfully tweeted the last Q&A. {tweet_link}")
+        return True
+    
+    except Exception as e:
+        print (f"Failed to tweet. Error: {e}")
+        return False