Update app.py

app.py

@@ -28,156 +28,63 @@ import numpy as np
 import threading
 
 
-# Setup Neo4j connection
+# Setup Neo4j
 graph = Neo4jGraph(
     url="neo4j+s://6457770f.databases.neo4j.io",
     username="neo4j",
     password="Z10duoPkKCtENuOukw3eIlvl0xJWKtrVSr-_hGX1LQ4"
 )
 
-# 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"
-    )
-
-entity_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 = entity_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):
-    structured_data = structured_retriever(question)
-    logging.debug(f"Structured data: {structured_data}")
-    return structured_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(
-    (
-        RunnableLambda(lambda x: bool(x.get("chat_history"))).with_config(
-            run_name="HasChatHistoryCheck"
-        ),
-        RunnablePassthrough.assign(
-            chat_history=lambda x: _format_chat_history(x["chat_history"])
-        )
-        | CONDENSE_QUESTION_PROMPT
-        | ChatOpenAI(temperature=0, api_key=os.environ['OPENAI_API_KEY'])
-        | StrOutputParser(),
-    ),
-    RunnableLambda(lambda x: x["question"]),
-)
-
-
+# Define a prompt template for generating responses
 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:"""
 
+Data:
+{context}
 
+User's question: {question}
+Answer:"""
 qa_prompt = ChatPromptTemplate.from_template(template)
 
-# Define the chain for Neo4j-based retrieval and response generation
-chain_neo4j = (
-    RunnableParallel(
-        {
-            "context": RunnableLambda(lambda x: retriever_neo4j(x["question"])),
-            "question": RunnablePassthrough(),
-        }
+# Chat model configuration
+chat_model = ChatOpenAI(temperature=0, model_name="gpt-4o", api_key=os.environ['OPENAI_API_KEY'])
+
+# Function to generate a query for Neo4j and retrieve information
+def generate_full_text_query(input: str) -> str:
+    return " ".join([f"{word}~2" for word in input.split()])
+
+def retrieve_from_neo4j(question: str) -> str:
+    query = generate_full_text_query(question)
+    response = graph.query(
+        """CALL db.index.fulltext.queryNodes('entity', $query, {limit:2})
+        YIELD node, score
+        RETURN node.name AS name, node.description AS description LIMIT 5""",
+        {"query": query}
     )
-    | ChatPromptTemplate.from_template("Answer: {context} Question: {question}")
-    | chat_model
-    | StrOutputParser()
-)
+    context = "\n".join([f"{el['name']}: {el['description']}" for el in response])
+    return context
 
-# Define the function to query Neo4j and get a response
+# Function to generate the response using the prompt template and Neo4j data
 def get_response(question):
     try:
-        return chain_neo4j.invoke({"question": question})
+        context = retrieve_from_neo4j(question)
+        prompt = qa_prompt.format_prompt(context=context, question=question)
+        response = chat_model(prompt.to_string())
+        return response
     except Exception as e:
         return f"Error: {str(e)}"
 
-
-
 # Function to generate audio with Eleven Labs TTS
 def generate_audio_elevenlabs(text):
     XI_API_KEY = os.environ['ELEVENLABS_API']
     VOICE_ID = 'ehbJzYLQFpwbJmGkqbnW'
     tts_url = f"https://api.elevenlabs.io/v1/text-to-speech/{VOICE_ID}/stream"
-    headers = {
-        "Accept": "application/json",
-        "xi-api-key": XI_API_KEY
-    }
+    headers = {"Accept": "application/json", "xi-api-key": XI_API_KEY}
     data = {
         "text": str(text),
         "model_id": "eleven_multilingual_v2",
-        "voice_settings": {
-            "stability": 1.0,
-            "similarity_boost": 0.0,
-            "style": 0.60,
-            "use_speaker_boost": False
-        }
+        "voice_settings": {"stability": 1.0, "similarity_boost": 0.0}
     }
     response = requests.post(tts_url, headers=headers, json=data, stream=True)
     if response.ok:
@@ -190,7 +97,7 @@ def generate_audio_elevenlabs(text):
     else:
         return None
 
-# Define ASR model for speech-to-text
+# Define the ASR model with Whisper
 model_id = 'openai/whisper-large-v3'
 device = "cuda:0" if torch.cuda.is_available() else "cpu"
 torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
@@ -203,79 +110,34 @@ pipe_asr = pipeline(
     tokenizer=processor.tokenizer,
     feature_extractor=processor.feature_extractor,
     max_new_tokens=128,
-    chunk_length_s=5,  # Process audio in 5-second chunks
+    chunk_length_s=15,
     batch_size=16,
     torch_dtype=torch_dtype,
     device=device,
-    return_timestamps=False
+    return_timestamps=True
 )
 
-# Function to handle audio transcription in real-time
-def transcribe_function(stream, new_chunk):
-    try:
-        sr, y = new_chunk[0], new_chunk[1]
-    except TypeError:
-        print(f"Error chunk structure: {type(new_chunk)}, content: {new_chunk}")
-        return stream, "", None
-
-    # Ensure y is not empty and is at least 1-dimensional
-    if y is None or len(y) == 0:
-        return stream, "", None
-
+# Define the function to transcribe audio and generate a response
+def transcribe_and_respond(audio):
+    sr, y = audio[0], audio[1]
     y = y.astype(np.float32)
     max_abs_y = np.max(np.abs(y))
     if max_abs_y > 0:
         y = y / max_abs_y
-
-    # Ensure stream is also at least 1-dimensional before concatenation
-    if stream is not None and len(stream) > 0:
-        stream = np.concatenate([stream, y])
-    else:
-        stream = y
-
-    # Process the audio data for transcription
-    result = pipe_asr({"array": stream, "sampling_rate": sr}, return_timestamps=False)
-    full_text = result.get("text", "")
-
-    # Start a thread to reset the state after 10 seconds
-    threading.Thread(target=auto_reset_state).start()
-
-    return stream, full_text, full_text
-
-# Define the Gradio interface
-with gr.Blocks(theme="rawrsor1/Everforest") as demo:
-    audio_input = gr.Audio(sources=["microphone"], type='numpy', streaming=True, label="Speak to Ask")
-    transcription_textbox = gr.Textbox(label="Transcription", interactive=False)
-    submit_voice_btn = gr.Button("Submit Voice")
-    clear_state_btn = gr.Button("Clear State")
-    audio_output = gr.Audio(label="Response Audio", type="filepath", autoplay=True, interactive=False)
-
-    # Initialize the stream as an empty array for the first input
-    stream = np.array([])
-
-    # Update the transcription text in real-time as the user speaks
-    audio_input.stream(
-        fn=lambda new_chunk: transcribe_function(stream, new_chunk),
-        inputs=audio_input,
-        outputs=[None, transcription_textbox, transcription_textbox]
-    )
+    result = pipe_asr({"array": y, "sampling_rate": sr}, return_timestamps=False)
+    text = result.get("text", "")
+    response = get_response(text)
+    audio_path = generate_audio_elevenlabs(response)
+    return audio_path
+
+with gr.Blocks() as demo:
+    audio_input = gr.Audio(sources=["microphone"], streaming=False, type='numpy', label="Speak to Ask")
+    audio_output = gr.Audio(label="Audio", type="filepath", autoplay=True, interactive=False)
     
-    # Placeholder function for handling submission
-    def handle_submit(text):
-        # Placeholder function, could trigger response generation or other actions
-        return f"You submitted: {text}"
-
-    # Handle the submission of the final transcribed text
-    submit_voice_btn.click(
-        fn=handle_submit,
-        inputs=transcription_textbox,
-        outputs=transcription_textbox
-    )
-    
-    # Interaction for Clear State Button
-    clear_state_btn.click(
-        fn=lambda: "",
-        outputs=transcription_textbox
+    audio_input.change(
+        fn=transcribe_and_respond,
+        inputs=audio_input,
+        outputs=audio_output,
     )
 
 # Launch the Gradio interface