Added generic chatbot and descriptions to the custom chatbots

app.py

@@ -2,12 +2,15 @@ import gradio as gr
 from langchain_core.messages import HumanMessage
 import src.passage_finder as pf
 import src.srf_bot as sb
+import src.generic_bot as gb
 import prompts.system_prompts as sp
 import os
 
-# Initialize PassageFinder and Chatbot
+
+# Initialize PassageFinder, SRFChatbot, and GenericChatbot
 passage_finder = pf.PassageFinder()
 chatbot = sb.SRFChatbot()
+generic_chatbot = gb.GenericChatbot()
 
 # Passage Finder functions
 def respond_passage_finder(message):
@@ -68,6 +71,21 @@ def respond_chatbot(query, history):
     history.append((query, f"<i>[{system_message_dropdown}]</i>\n" + response))
     return history
 
+# Generic Chatbot function
+def respond_genericchatbot(query, history):
+    formatted_query = [HumanMessage(content=query)]
+    result = generic_chatbot.graph.invoke({"messages": formatted_query}, generic_chatbot.config)
+    state = generic_chatbot.graph.get_state(config=generic_chatbot.config).values
+    documents = state.get("documents")
+    passages = ''
+    if documents and len(documents) > 0:
+        for d in documents:
+            passages += f'<b>{d.metadata["publication_name"]} - {d.metadata["chapter_name"]}</b>\n{d.page_content}\n\n'
+        history.append((f'Passages: {query}', passages))
+    response = result["messages"][-1].content
+    history.append((query, response))
+    return history
+
 # Define the CSS
 css = """
 body { background-color: #f0f0f0; }
@@ -144,15 +162,24 @@ with gr.Blocks(css=css) as demo:
                 with gr.Column(scale=1):
                     system_prompt_dropdown = gr.Dropdown(
                         choices=list(sp.system_prompt_templates.keys()),
-                        label="Select Chatbot Instructions",
+                        label="Select Chatbot",
                         value=list(sp.system_prompt_templates.keys())[0],
                     )
+                    
+                    # Chatbot description Textbox
+                    chatbot_description = gr.Textbox(
+                        value=sp.chatbot_descriptions[list(sp.system_prompt_templates.keys())[0]],
+                        label="Chatbot Description",
+                        lines=3,
+                        interactive=False
+                    )
                     system_prompt_display = gr.Textbox(
                         value=sp.system_prompt_templates[list(sp.system_prompt_templates.keys())[0]],
-                        label="Current Chatbot Instructions",
+                        label="Chatbot Instructions",
                         lines=5,
                         interactive=False
                     )
+
                     
                     gr.Markdown("""
                     <div class="source-box">
@@ -166,9 +193,9 @@ with gr.Blocks(css=css) as demo:
                     """)
             
             system_prompt_dropdown.change(
-                fn=chatbot.reset_system_prompt,
+                fn=lambda x: (sp.chatbot_descriptions[x], sp.system_prompt_templates[x]),
                 inputs=[system_prompt_dropdown],
-                outputs=[system_prompt_display]
+                outputs=[chatbot_description, system_prompt_display]
             )
             
             submit_button_cb.click(
@@ -177,9 +204,62 @@ with gr.Blocks(css=css) as demo:
                 outputs=[chatbot_output]
             )
 
+            gr.Examples(
+                examples=[
+                    "importance of meditation",
+                    "How can I develop unconditional love?",
+                    "concept of karma",
+                    "What are some techniques for spiritual growth?",
+                ],
+                inputs=user_input_cb,
+            )
+
+        with gr.TabItem("Generic Chatbot"):
+            with gr.Row():
+                with gr.Column(scale=4):
+                    generic_chatbot_output = gr.Chatbot(height=600)
+                    user_input_gc = gr.Textbox(placeholder="Type your question here...", label="Your Question", value="Loaves and fishes")
+                    submit_button_gc = gr.Button("Submit")
+        
+            with gr.Column(scale=1):
+                gr.Markdown("""
+                <div class="source-box">
+                    <strong>About this chatbot:</strong>
+                    <p>This chatbot has access to a vector database of some SRF publications that it can use if necessary, but it receives no other specific instructions. You can ask it anything. If you want quotes and references, you need to explicitly request them in your query.</p>
+                </div>
+                """)
+                    
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                        <div class="source-box">
+                            <strong>Available sources:</strong>
+                            <ul>
+                                <li>Journey to Self-Realization</li>
+                                <li>The Second Coming of Christ</li>
+                                <li>Autobiography of a Yogi</li>
+                            </ul>
+                        </div>
+                        """)
+                
+                submit_button_gc.click(
+                    fn=respond_genericchatbot,
+                    inputs=[user_input_gc, generic_chatbot_output],
+                    outputs=[generic_chatbot_output]
+                )
+
+            gr.Examples(
+                examples=[
+                    "Tell me about Paramahansa Yogananda's life",
+                    "What are the main teachings of Self-Realization Fellowship?",
+                    "Explain the concept of Kriya Yoga",
+                    "Can you provide quotes about the importance of meditation?",
+                ],
+                inputs=user_input_gc,
+            )
+
 # Access the secrets
 username = os.getenv("USERNAME")
 password = os.getenv("PASSWORD")
 
 # Launch the interface
-demo.launch(share=True, auth=(username, password), debug=True)
+demo.launch(share=True, auth=(username, password), debug=True)

app_generic.py

@@ -0,0 +1,85 @@
+import gradio as gr
+from langchain_core.messages import HumanMessage
+import src.passage_finder as pf
+import src.srf_bot as sb
+import src.generic_bot as gb
+import prompts.system_prompts as sp
+import os
+
+# Initialize chatbot
+generic_chatbot = gb.GenericChatbot()
+
+# Chatbot functions
+def respond_genericchatbot(query, history):
+    formatted_query = [HumanMessage(content=query)]
+    # Invoke the graph with properly formatted input
+    result = generic_chatbot.graph.invoke({"messages": formatted_query}, generic_chatbot.config)
+    # Get the passages from the graph and append to history if documents exist
+    state = generic_chatbot.graph.get_state(config=generic_chatbot.config).values
+    documents = state.get("documents")
+    passages = ''
+    if documents and len(documents) > 0:
+        for d in documents:
+            passages += f'<b>{d.metadata["publication_name"]} - {d.metadata["chapter_name"]}</b>\n{d.page_content}\n\n'
+        history.append((f'Passages: {query}', passages))
+    # Extract the assistant's response and append to history
+    response = result["messages"][-1].content
+    history.append((query, response))
+    return history
+
+# Define the CSS
+css = """
+body { background-color: #f0f0f0; }
+.gradio-container { background-color: #ffffff; }
+.gr-button { background-color: #333333; color: white; font-size: 18px; padding: 10px; }
+.gr-textbox textarea { font-size: 18px; color: black; }
+.gr-dropdown { font-size: 18px; color: black; }
+.source-box { background-color: white; padding: 10px; border-radius: 8px; margin-top: 20px; color: black; border: 1px solid #D0D0D0; }
+
+/* Dark mode and responsive styles */
+@media (prefers-color-scheme: dark) {
+    .gradio-container { background-color: #1e1e1e; color: white; }
+    h1, h2, p { color: white; }
+    .gr-textbox textarea { background-color: #333333; color: white; }
+    .gr-button { background-color: #555555; color: white; }
+    .gr-dropdown { background-color: #333333; color: white; }
+    .source-box { background-color: #333333; color: white; border: 1px solid #555555; }
+}
+
+@media (max-width: 600px) {
+    .gr-row { flex-direction: column !important; }
+    .gr-column { width: 100% !important; }
+}
+"""
+
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("# Generic Chatbot")
+    
+    chatbot_output = gr.Chatbot(height=600)
+    user_input = gr.Textbox(placeholder="Type your question here...", label="Your Question")
+    submit_button = gr.Button("Submit")
+    
+    gr.Markdown("""
+    <div class="source-box">
+        <strong>Available sources:</strong>
+        <ul>
+            <li>Journey to Self-Realization</li>
+            <li>The Second Coming of Christ</li>
+            <li>Autobiography of a Yogi</li>
+        </ul>
+    </div>
+    """)
+    
+    submit_button.click(
+        fn=respond_genericchatbot,
+        inputs=[user_input, chatbot_output],
+        outputs=[chatbot_output]
+    )
+
+# Access the secrets
+username = os.getenv("USERNAME")
+password = os.getenv("PASSWORD")
+
+# Launch the interface
+demo.launch(share=True, auth=(username, password), debug=True)
+

app_old.py

@@ -0,0 +1,185 @@
+import gradio as gr
+from langchain_core.messages import HumanMessage
+import src.passage_finder as pf
+import src.srf_bot as sb
+import prompts.system_prompts as sp
+import os
+
+# Initialize PassageFinder and Chatbot
+passage_finder = pf.PassageFinder()
+chatbot = sb.SRFChatbot()
+
+# Passage Finder functions
+def respond_passage_finder(message):
+    config = passage_finder.get_configurable()
+    results = passage_finder.graph.invoke({"messages": [HumanMessage(content=message)]}, config)
+    
+    documents = results.get('documents', [])
+    
+    output = []
+    for doc in documents:
+        quotes = doc.metadata.get('matched_quotes', [])
+        publication = doc.metadata.get('publication_name', 'Unknown Publication')
+        chapter = doc.metadata.get('chapter_name', 'Unknown Chapter')
+        full_passage = doc.metadata.get('highlighted_content', '')
+        
+        quote_text = "\n".join([f"• \"{q.quote}\"" for q in quotes])
+        output.append({
+            "quotes": quote_text,
+            "reference": f"{publication}: {chapter}",
+            "full_passage": full_passage
+        })
+    
+    return output
+
+def process_input_passage_finder(message):
+    results = respond_passage_finder(message)
+    html_output = "<div class='response-container'>"
+    for result in results:
+        html_output += f"""
+        <div class='result-item'>
+            <h3 class='reference'>{result['reference']}</h3>
+            <div class='quotes'>{result['quotes'].replace("• ", "<br>• ")}</div>
+            <details>
+                <summary>Show full passage</summary>
+                <div class='full-passage'>{result['full_passage']}</div>
+            </details>
+        </div>
+        """
+    html_output += "</div>"
+    return html_output
+
+# Chatbot functions
+def respond_chatbot(query, history):
+    formatted_query = [HumanMessage(content=query)]
+    # Invoke the graph with properly formatted input
+    result = chatbot.graph.invoke({"messages": formatted_query}, chatbot.config)
+    # Get the passages from the graph and append to history if documents exist
+    state = chatbot.graph.get_state(config=chatbot.config).values
+    documents = state.get("documents")
+    passages = ''
+    if documents and len(documents) > 0:
+        for d in documents:
+            passages += f'<b>{d.metadata["publication_name"]} - {d.metadata["chapter_name"]}</b>\n{d.page_content}\n\n'
+        history.append((f'Passages: {query}', passages))
+    # Extract the assistant's response and append to history
+    response = result["messages"][-1].content
+    system_message_dropdown = state.get("system_message_dropdown")
+    history.append((query, f"<i>[{system_message_dropdown}]</i>\n" + response))
+    return history
+
+# Define the CSS
+css = """
+body { background-color: #f0f0f0; }
+.gradio-container { background-color: #ffffff; }
+.response-container { border: 1px solid #e0e0e0; border-radius: 8px; padding: 20px; background-color: #f9f9f9; }
+.result-item { margin-bottom: 20px; background-color: white; padding: 15px; border-radius: 5px; box-shadow: 0 2px 5px rgba(0,0,0,0.1); }
+.reference { color: #2c3e50; margin-bottom: 10px; }
+.quotes { font-style: italic; margin-bottom: 10px; }
+.full-passage { margin-top: 10px; padding: 10px; background-color: #f0f0f0; border-radius: 5px; }
+details summary { cursor: pointer; color: #3498db; font-weight: bold; }
+details summary:hover { text-decoration: underline; }
+
+/* Chatbot specific styles */
+.gr-button { background-color: #333333; color: white; font-size: 18px; padding: 10px; }
+.gr-textbox textarea { font-size: 18px; color: black; }
+.gr-dropdown { font-size: 18px; color: black; }
+.source-box { background-color: white; padding: 10px; border-radius: 8px; margin-top: 20px; color: black; border: 1px solid #D0D0D0; }
+
+/* Dark mode and responsive styles */
+@media (prefers-color-scheme: dark) {
+    .gradio-container { background-color: #1e1e1e; color: white; }
+    h1, h2, p { color: white; }
+    .gr-textbox textarea { background-color: #333333; color: white; }
+    .gr-button { background-color: #555555; color: white; }
+    .gr-dropdown { background-color: #333333; color: white; }
+    .source-box { background-color: #333333; color: white; border: 1px solid #555555; }
+}
+
+@media (max-width: 600px) {
+    .gr-row { flex-direction: column !important; }
+    .gr-column { width: 100% !important; }
+}
+"""
+
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("# SRF Teachings App")
+    
+    with gr.Tabs():
+        with gr.TabItem("Passage Finder"):
+            gr.Markdown("Ask questions about Self-Realization Fellowship teachings and receive responses with relevant quotes.")
+            
+            with gr.Row():
+                input_text_pf = gr.Textbox(
+                    placeholder="Ask about the meaning of life, spirituality, or any other topic...",
+                    label="Your Question"
+                )
+                submit_btn_pf = gr.Button("Submit", variant="primary")
+            
+            output_area_pf = gr.HTML()
+            
+            gr.Markdown("### Sources")
+            gr.Textbox(value="Journey to Self Realization, Second Coming of Christ, and Autobiography of a Yogi", 
+                       label="Available Sources", interactive=False)
+            
+            submit_btn_pf.click(process_input_passage_finder, inputs=input_text_pf, outputs=output_area_pf)
+
+            gr.Examples(
+                examples=[
+                    "What is the meaning of life?",
+                    "Importance of good posture",
+                    "How can I find inner peace?",
+                    "What does Paramahansa Yogananda say about meditation?",
+                ],
+                inputs=input_text_pf,
+            )
+
+        with gr.TabItem("Custom Chatbots"):
+            with gr.Row():
+                with gr.Column(scale=4):
+                    chatbot_output = gr.Chatbot(height=600)
+                    user_input_cb = gr.Textbox(placeholder="Type your question here...", label="Your Question", value="What is the meaning of life?")
+                    submit_button_cb = gr.Button("Submit")
+                
+                with gr.Column(scale=1):
+                    system_prompt_dropdown = gr.Dropdown(
+                        choices=list(sp.system_prompt_templates.keys()),
+                        label="Select Chatbot Instructions",
+                        value=list(sp.system_prompt_templates.keys())[0],
+                    )
+                    system_prompt_display = gr.Textbox(
+                        value=sp.system_prompt_templates[list(sp.system_prompt_templates.keys())[0]],
+                        label="Current Chatbot Instructions",
+                        lines=5,
+                        interactive=False
+                    )
+                    
+                    gr.Markdown("""
+                    <div class="source-box">
+                        <strong>Available sources:</strong>
+                        <ul>
+                            <li>Journey to Self-Realization</li>
+                            <li>The Second Coming of Christ</li>
+                            <li>Autobiography of a Yogi</li>
+                        </ul>
+                    </div>
+                    """)
+            
+            system_prompt_dropdown.change(
+                fn=chatbot.reset_system_prompt,
+                inputs=[system_prompt_dropdown],
+                outputs=[system_prompt_display]
+            )
+            
+            submit_button_cb.click(
+                fn=respond_chatbot,
+                inputs=[user_input_cb, chatbot_output],
+                outputs=[chatbot_output]
+            )
+
+# Access the secrets
+username = os.getenv("USERNAME")
+password = os.getenv("PASSWORD")
+
+# Launch the interface
+demo.launch(share=True, auth=(username, password), debug=True)

prompts/system_prompts.py

@@ -3,7 +3,6 @@
 
 # System prompt options for the chatbot
 system_prompt_templates = {
-    "Open-Ended Bot": '''You are a helpful assistant for people that want to query the teachings of Paramhansa Yogananda and the Self-Realization Fellowship. Look up the vector database provided for relevantpassages to answer queries. Only use the context provided. Do not use any other sources.''',
     
     "Question-Answer Bot with Quotes": """You are a helpful assistant that can query the teachings of Paramhansa Yogananda and the Self-Realization Fellowship from a vector database. 
     You will only answer questions based on the provided context.
@@ -29,10 +28,6 @@ system_prompt_templates = {
     - Provide up to three suggestions for followup quote searches
     - Do not paraphrase the quotes into an answer. Return the quotes directly.''',
     
-    "Passage Finder": '''You are a helpful assistant that finds passages from the teachings of Paramhansa Yogananda and 
-    the Self-Realization Fellowship that are related to a given topic or question from a vector database. Output
-    the full passages provided in the context. Organize them by relevance to the user query. Bold quotes that
-    are particularly insightful or relevant to the user query.''',
 
     "Subtopic Finder and Deep Dive": '''You are a helpful assistant that generates subtopics for a given topic or question from the teachings of Paramhansa Yogananda and the Self-Realization Fellowship
     and allows users to do a deep dive into those subtopics. Retrieve at least 20 passages from the vector database for the given topic and then list out sub-topics that emerge from the retrieved passages.
@@ -48,6 +43,21 @@ system_prompt_templates = {
 
 }
 
+
+chatbot_descriptions = {
+
+    "Question-Answer Bot with Quotes": """Chatbot that answers questions with quotes from the SRF teachings.""",
+
+    "Quote Finder": '''Chatbot that finds quotes from the SRF teachings.''',
+    
+    "Subtopic Finder and Deep Dive": '''Chatbot that generates subtopics for a given topic or question from the SRF teachings and allows users to do a deep dive into those subtopics.''',
+    
+    "In Depth Topic Summary": '''Chatbot that summarizes topics from the SRF teachings in depth.''',
+
+}
+
+
+
 def get_systemprompt(template_name):
     """
     Retrieve a system prompt based on the template name.

src/generic_bot.py

@@ -0,0 +1,154 @@
+import sys
+import os
+import uuid
+from dotenv import load_dotenv
+from typing import Annotated, List, Tuple
+from typing_extensions import TypedDict
+from langchain.tools import tool, BaseTool
+from langchain.schema import Document
+from langgraph.graph import StateGraph, START, END, MessagesState
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode, tools_condition
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, AIMessagePromptTemplate, HumanMessagePromptTemplate
+# from langchain.schema import SystemMessage, HumanMessage, AIMessage, ToolMessage
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage, SystemMessage
+from langchain.retrievers.multi_query import MultiQueryRetriever
+import json
+sys.path.append(os.path.abspath('..'))
+
+
+import src.utils.qdrant_manager as qm
+import prompts.system_prompts as sp
+
+load_dotenv('/Users/nadaa/Documents/code/py_innovations/srf_chatbot_v2/.env')
+
+
+class ToolManager:
+    def __init__(self, collection_name="openai_large_chunks_1500char"):
+        self.tools = []
+        self.qdrant = qm.QdrantManager(collection_name=collection_name)
+        self.vectorstore = self.qdrant.get_vectorstore()
+        self.add_tools()
+
+    def get_tools(self):
+        return self.tools
+
+    def add_tools(self):
+        @tool
+        def vector_search(query: str, k: int = 5) -> list[Document]:
+            """Useful for simple queries. This tool will search a vector database for passages from the teachings of Paramhansa Yogananda and other publications from the Self Realization Fellowship (SRF).
+            The user has the option to specify the number of passages they want the search to return, otherwise the number of passages will be set to the default value."""
+            retriever = self.vectorstore.as_retriever(search_kwargs={"k": k})
+            documents = retriever.invoke(query)
+            return documents
+             
+        @tool
+        def multiple_query_vector_search(query: str, k: int = 5) -> list[Document]:
+            """Useful when the user's query is vague, complex, or involves multiple concepts. 
+            This tool will write multiple versions of the user's query and search the vector database for relevant passages. 
+            Use this tool when the user asks for an in depth answer to their question."""
+            
+            llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.5)
+            retriever_from_llm = MultiQueryRetriever.from_llm(retriever=self.vectorstore.as_retriever(), llm=llm)
+            documents = retriever_from_llm.invoke(query)
+            return documents
+            
+        self.tools.append(vector_search)
+        self.tools.append(multiple_query_vector_search)
+
+class BasicToolNode:
+    """A node that runs the tools requested in the last AIMessage."""
+
+    def __init__(self, tools: list) -> None:
+        self.tools_by_name = {tool.name: tool for tool in tools}
+
+    def __call__(self, inputs: dict):
+        if messages := inputs.get("messages", []):
+            message = messages[-1]
+        else:
+            raise ValueError("No message found in input")
+        outputs = []
+        documents = []
+        for tool_call in message.tool_calls:
+            tool_result = self.tools_by_name[tool_call["name"]].invoke(
+                tool_call["args"]
+            )
+            outputs.append(
+                ToolMessage(
+                    content=str(tool_result),
+                    name=tool_call["name"],
+                    tool_call_id=tool_call["id"],
+                )
+            )
+            documents += tool_result
+            
+        return {"messages": outputs, "documents": documents}
+
+class AgentState(TypedDict):
+
+    messages: Annotated[list, add_messages]
+    documents: list[Document]
+    system_message: list[SystemMessage]
+    system_message_dropdown: list[str]
+
+class GenericChatbot:
+    def __init__(
+        self,
+        model: str = 'gpt-4o-mini',
+        temperature: float = 0,
+    ):
+
+        self.llm = ChatOpenAI(model=model, temperature=temperature)
+        self.tools = ToolManager().get_tools()
+        self.llm_with_tools = self.llm.bind_tools(self.tools)
+
+        # Build the graph
+        self.graph = self.build_graph()
+        # Get the configurable
+        self.config = self.get_configurable()
+    
+
+    def get_configurable(self):
+        # This thread id is used to keep track of the chatbot's conversation
+        self.thread_id = str(uuid.uuid4())
+        return {"configurable": {"thread_id": self.thread_id}}
+    
+
+    # Add the system message onto the llm
+    ## THIS SHOULD BE REFACTORED SO THAT THE STATE ALWAYS HAS THE DEFINITIVE SYSTEM MESSAGE THAT SHOULD BE IN USE
+    def chatbot(self, state: AgentState):
+        messages = state["messages"]
+        return {"messages": [self.llm_with_tools.invoke(messages)]}
+    
+    def build_graph(self):
+        # Add chatbot state
+        graph_builder = StateGraph(AgentState)
+
+        # Add nodes
+        tool_node = BasicToolNode(tools=self.tools)
+        # tool_node = ToolNode(self.tools)
+        graph_builder.add_node("tools", tool_node)
+        graph_builder.add_node("chatbot", self.chatbot)
+
+        # Add a conditional edge wherein the chatbot can decide whether or not to go to the tools
+        graph_builder.add_conditional_edges(
+            "chatbot",
+            tools_condition,
+        )
+
+        # Add fixed edges
+        graph_builder.add_edge(START, "chatbot")
+        graph_builder.add_edge("tools", "chatbot")
+
+        # Instantiate the memory saver
+        memory = MemorySaver()
+
+        # Compile the graph
+        return graph_builder.compile(checkpointer=memory)
+    
+
+
+
+

src/srf_bot.py

@@ -96,7 +96,7 @@ class AgentState(TypedDict):
 class SRFChatbot:
     def __init__(
         self,
-        chatbot_instructions_dropdown: str = 'Open-Ended Bot',
+        chatbot_instructions_dropdown: str = 'Question-Answer Bot with Quotes',
         model: str = 'gpt-4o-mini',
         temperature: float = 0,
     ):