Update app.py

app.py

@@ -4,9 +4,6 @@ import logging
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.output_parsers import StrOutputParser
 from langchain_openai import ChatOpenAI
-from langchain_community.graphs import Neo4jGraph
-from typing import List, Tuple
-from pydantic import BaseModel, Field
 from langchain_core.messages import AIMessage, HumanMessage
 from langchain_core.runnables import (
     RunnableBranch,
@@ -26,168 +23,59 @@ import torchaudio
 from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
 import numpy as np
 import threading
-from langchain_community.vectorstores import Neo4jVector
 from langchain_openai import OpenAIEmbeddings
+from langchain_pinecone import PineconeVectorStore
+from langchain.chains import RetrievalQA
 
+embeddings = OpenAIEmbeddings(api_key=os.environ['OPENAI_API_KEY'])
+def initialize_gpt_model():
+    return ChatOpenAI(api_key=os.environ['OPENAI_API_KEY'], temperature=0, model='gpt-4o')
 
-#code for history
-conversational_memory = ConversationBufferWindowMemory(
-        memory_key='chat_history',
-        k=10,
-        return_messages=True
-    )
+gpt_model = initialize_gpt_model()
 
-# Setup Neo4j
-graph = Neo4jGraph(
-    url="neo4j+s://c62d0d35.databases.neo4j.io",
-    username="neo4j",
-    password="_x8f-_aAQvs2NB0x6s0ZHSh3W_y-HrENDbgStvsUCM0"
-)
 
+gpt_embeddings = OpenAIEmbeddings(api_key=os.environ['OPENAI_API_KEY'])
+gpt_vectorstore = PineconeVectorStore(index_name="radardata10312024", embedding=gpt_embeddings)
+gpt_retriever = gpt_vectorstore.as_retriever(search_kwargs={'k': 5})
 
-# directly show the graph resulting from the given Cypher query
-default_cypher = "MATCH (s)-[r:!MENTIONS]->(t) RETURN s,r,t LIMIT 50"
 
 
-vector_index = Neo4jVector.from_existing_graph(
-    OpenAIEmbeddings(openai_api_key="sk-PV6RlpmTifrWo_olwL1IR69J9v2e5AKe-Xfxs_Yf9VT3BlbkFJm-UJQx5RNyGpok9MM_DYSTmayn7y-lKLSBqXecEoYA"),
-    graph=graph,
-    search_type="hybrid",
-    node_label="Document",
-    text_node_properties=["text"],
-    embedding_node_property="embedding",
-)
+# Pinecone setup
+from pinecone import Pinecone
+pc = Pinecone(api_key=os.environ['PINECONE_API_KEY'])
 
-# Define entity extraction and retrieval functions
-class Entities(BaseModel):
-    names: List[str] = Field(
-        ..., description="All the person, organization, or business entities that appear in the text"
-    )
 
-prompt = ChatPromptTemplate.from_messages([
-    ("system", "You are extracting organization and person entities from the text."),
-    ("human", "Use the given format to extract information from the following input: {question}"),
-])
-
-chat_model = ChatOpenAI(temperature=0, model_name="gpt-4o", api_key=os.environ['OPENAI_API_KEY'])
-entity_chain = prompt | chat_model.with_structured_output(Entities)
-
-def remove_lucene_chars(input: str) -> str:
-    return input.translate(str.maketrans({
-        "\\": r"\\", "+": r"\+", "-": r"\-", "&": r"\&", "|": r"\|", "!": r"\!",
-        "(": r"\(", ")": r"\)", "{": r"\{", "}": r"\}", "[": r"\[", "]": r"\]",
-        "^": r"\^", "~": r"\~", "*": r"\*", "?": r"\?", ":": r"\:", '"': r'\"',
-        ";": r"\;", " ": r"\ "
-    }))
-
-def generate_full_text_query(input: str) -> str:
-    full_text_query = ""
-    words = [el for el in remove_lucene_chars(input).split() if el]
-    for word in words[:-1]:
-        full_text_query += f" {word}~2 AND"
-    full_text_query += f" {words[-1]}~2"
-    return full_text_query.strip()
-
-# Setup logging to a file to capture debug information
-logging.basicConfig(filename='neo4j_retrieval.log', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
-
-def structured_retriever(question: str) -> str:
-    result = ""
-    entities = entity_chain.invoke({"question": question})
-    for entity in entities.names:
-        response = graph.query(
-            """CALL db.index.fulltext.queryNodes('entity', $query, {limit:2})
-            YIELD node,score
-            CALL {
-              WITH node
-              MATCH (node)-[r:!MENTIONS]->(neighbor)
-              RETURN node.id + ' - ' + type(r) + ' -> ' + neighbor.id AS output
-              UNION ALL
-              WITH node
-              MATCH (node)<-[r:!MENTIONS]-(neighbor)
-              RETURN neighbor.id + ' - ' + type(r) + ' -> ' +  node.id AS output
-            }
-            RETURN output LIMIT 50
-            """,
-            {"query": generate_full_text_query(entity)},
-        )
-        result += "\n".join([el['output'] for el in response])
-    return result
-
-def retriever_neo4j(question: str):
-    print(f"Search query: {question}")
-    structured_data = structured_retriever(question)
-    unstructured_data = [el.page_content for el in vector_index.similarity_search(question)]
-    final_data = f"""Structured data:
-{structured_data}
-Unstructured data:
-{"#Document ". join(unstructured_data)}
-    """
-    return final_data
-
-# Setup for condensing the follow-up questions
-_template = """Given the following conversation and a follow-up question, rephrase the follow-up question to be a standalone question,
-in its original language.
-Chat History:
-{chat_history}
-Follow Up Input: {question}
-Standalone question:"""
-
-CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
-
-def _format_chat_history(chat_history: list[tuple[str, str]]) -> list:
-    buffer = []
-    for human, ai in chat_history:
-        buffer.append(HumanMessage(content=human))
-        buffer.append(AIMessage(content=ai))
-    return buffer
-
-_search_query = RunnableBranch(
-    # If input includes chat_history, we condense it with the follow-up question
-    (
-        RunnableLambda(lambda x: bool(x.get("chat_history"))).with_config(
-            run_name="HasChatHistoryCheck"
-        ),  # Condense follow-up question and chat into a standalone_question
-        RunnablePassthrough.assign(
-            chat_history=lambda x: _format_chat_history(x["chat_history"])
-        )
-        | CONDENSE_QUESTION_PROMPT
-        | ChatOpenAI(temperature=0,openai_api_key="sk-PV6RlpmTifrWo_olwL1IR69J9v2e5AKe-Xfxs_Yf9VT3BlbkFJm-UJQx5RNyGpok9MM_DYSTmayn7y-lKLSBqXecEoYA")
-        | StrOutputParser(),
-    ),
-    # Else, we have no chat history, so just pass through the question
-    RunnableLambda(lambda x : x["question"]),
-)
+index_name ="radardata10312024"
+vectorstore = PineconeVectorStore(index_name=index_name, embedding=embeddings)
+retriever = vectorstore.as_retriever(search_kwargs={'k': 5})
 
+chat_model = ChatOpenAI(api_key=os.environ['OPENAI_API_KEY'], temperature=0, model='gpt-4o')
 
-template = """I am a guide for Birmingham, Alabama. I can provide recommendations and insights about the city, including events and activities.
-Ask your question directly, and I'll provide a precise and quick,short and crisp response in a conversational way without any Greet.
-{context}
-Question: {question}
-Answer:"""
+#code for history
+conversational_memory = ConversationBufferWindowMemory(
+        memory_key='chat_history',
+        k=10,
+        return_messages=True
+    )
 
+template =f"""Hello there! As your friendly and knowledgeable guide here in Birmingham, Alabama.Give the short ,precise,crisp and straight-foreward response of maximum 2 sentences and dont greet. 
+{{context}}
+Question: {{question}}
+Helpful Answer:"""
 
-prompt = ChatPromptTemplate.from_template(template)
+QA_CHAIN_PROMPT= PromptTemplate(input_variables=["context", "question"], template=template)
 
-# Define the chain for Neo4j-based retrieval and response generation
-chain_neo4j = (
-    RunnableParallel(
-        {
-            "context": _search_query | retriever_neo4j,
-            "question": RunnablePassthrough(),
-        }
+def build_qa_chain(prompt_template):
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=chat_model,
+        chain_type="stuff",
+        retriever=retriever,
+        chain_type_kwargs={"prompt": prompt_template}
     )
-    | prompt
-    | chat_model
-    | StrOutputParser()
-)
+    return qa_chain  # Return the qa_chain object
 
-# Define the function to get the response
-def get_response(question):
-    try:
-        return chain_neo4j.invoke({"question": question})
-    except Exception as e:
-        return f"Error: {str(e)}"
+# Instantiate the QA Chain using the defined prompt template
+qa_chain = build_qa_chain(QA_CHAIN_PROMPT)
 
 # Define the function to clear input and output
 def clear_fields():
@@ -227,24 +115,31 @@ def generate_audio_elevenlabs(text):
 
 
 
+import time
+
+# Main function to handle mode selection with character-by-character streaming
 def handle_mode_selection(mode, chat_history, question):
     if mode == "Normal Chatbot":
-        # Append the user's question to chat history first
-        chat_history.append((question, ""))  # Placeholder for the bot's response
-        
-        # Stream the response and update chat history with each chunk
-        for response_chunk in chat_with_bot(chat_history):
-                chat_history[-1] = (question, response_chunk[-1][1])  # Update last entry with streamed response
-                yield chat_history, "", None  # Stream each chunk to display in the chatbot
-        yield chat_history, "", None  # Final yield to complete the response
+        chat_history.append((question, ""))  # Append user question with an empty response initially
+
+        # Get response from Pinecone using the qa_chain
+        response = qa_chain({"query": question, "context": ""})
+        response_text = response['result']
+
+        # Stream each character in the response text to the chat history
+        for i, char in enumerate(response_text):
+            chat_history[-1] = (question, chat_history[-1][1] + char)  # Update the last message
+            yield chat_history, "", None  # Yield updated chat history
+            time.sleep(0.05)  # Small delay to simulate streaming
 
     elif mode == "Voice to Voice Conversation":
-        # Voice to Voice mode: Stream the response text and then convert it to audio
-        response_text = get_response(question)  # Retrieve response text
-        audio_path = generate_audio_elevenlabs(response_text)  # Convert response to audio
+        response_text = qa_chain({"query": question, "context": ""})['result']
+        audio_path = generate_audio_elevenlabs(response_text)
         yield [], "", audio_path  # Only output the audio response without updating chatbot history
 
 
+
+
 # Function to add a user's message to the chat history and clear the input box
 def add_message(history, message):
     if message.strip():
@@ -279,14 +174,11 @@ def generate_audio_from_last_response(history):
 
 # Define example prompts
 examples = [
-    ["What are some popular events in Birmingham?"],
-    ["Who are the top players of the Crimson Tide?"],
-    ["Where can I find a hamburger?"],
-    ["What are some popular tourist attractions in Birmingham?"],
-    ["What are some good clubs in Birmingham?"],
-    ["Is there a farmer's market or craft fair in Birmingham, Alabama?"],
-    ["Are there any special holiday events or parades in Birmingham, Alabama, during December?"],
-    ["What are the best places to enjoy live music in Birmingham, Alabama?"]
+    ["what are the tree care services at alabama?"],
+    ["where from i studies undergrade in marketing from alabama?"],
+    ["what from i get tourism recreation center?"],
+    ["where from i will get a retail loan and from which institute?"],
+    ["where i will look for good dentist at alabama?"]
     
 ]