Update app.py

app.py

@@ -1,41 +1,19 @@
 import gradio as gr
 import os
 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,
-    RunnableLambda,
-    RunnablePassthrough,
-    RunnableParallel,
-)
-from langchain_core.prompts.prompt import PromptTemplate
 import requests
 import tempfile
-from langchain.memory import ConversationBufferWindowMemory
-import time
-import logging
-from langchain.chains import ConversationChain
 import torch
-import torchaudio
-from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
 import numpy as np
-import threading
-
-
-#code for history
-conversational_memory = ConversationBufferWindowMemory(
-        memory_key='chat_history',
-        k=10,
-        return_messages=True
-    )
+from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
+from langchain_community.graphs import Neo4jGraph
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_openai import ChatOpenAI
+from pydantic import BaseModel, Field
+from typing import List
+import time
 
-# Setup Neo4j
+# Neo4j Setup
 graph = Neo4jGraph(
     url="neo4j+s://6457770f.databases.neo4j.io",
     username="neo4j",
@@ -72,9 +50,6 @@ def generate_full_text_query(input: str) -> str:
     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})
@@ -98,77 +73,6 @@ def structured_retriever(question: str) -> str:
         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"]),
-)
-
-
-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:"""
-
-
-qa_prompt = ChatPromptTemplate.from_template(template)
-
-# Define the chain for Neo4j-based retrieval and response generation
-chain_neo4j = (
-    RunnableParallel(
-        {
-            "context": _search_query | retriever_neo4j,
-            "question": RunnablePassthrough(),
-        }
-    )
-    | qa_prompt
-    | chat_model
-    | StrOutputParser()
-)
-
-# 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)}"
-
-# Define the function to clear input and output
-def clear_fields():
-    return [],"",None
-
 # Function to generate audio with Eleven Labs TTS
 def generate_audio_elevenlabs(text):
     XI_API_KEY = os.environ['ELEVENLABS_API']
@@ -195,79 +99,11 @@ def generate_audio_elevenlabs(text):
                 if chunk:
                     f.write(chunk)
             audio_path = f.name
-        logging.debug(f"Audio saved to {audio_path}")
         return audio_path  # Return audio path for automatic playback
     else:
         logging.error(f"Error generating audio: {response.text}")
         return None
 
-def handle_mode_selection(mode, chat_history, question):
-    if mode == "Normal Chatbot":
-        # Normal chatbot mode: Show the response in the chatbot output
-        response = get_response(question)
-        chat_history.append((question, response))
-        return chat_history, "", None
-        
-    elif mode == "Voice to Voice Conversation":
-        # Voice to Voice mode: Generate the response using Eleven Labs and return audio without showing text
-        response = get_response(question)  # Get the response text (can be omitted if not needed for debugging)
-        audio_path = generate_audio_elevenlabs(response)  # Convert the response to audio
-        #chat_history.append((question, "[Voice Response]"))  # Log that a voice response was generated (optional)
-        chat_history.append(("[Voice Input]", "[Voice Response]"))
-        return chat_history, "", audio_path
-
-
-# Function to add a user's message to the chat history and clear the input box
-def add_message(history, message):
-    if message.strip():
-        history.append((message, ""))  # Add the user's message to the chat history only if it's not empty
-    return history, ""  # Clear the input box
-   
-# Define function to generate a streaming response
-def chat_with_bot(messages):
-    user_message = messages[-1][0]  # Get the last user message (input)
-    messages[-1] = (user_message, "")  # Prepare the placeholder for the bot's response
-    
-    response = get_response(user_message)
-    
-
-    
-    # Simulate streaming response by iterating over each character in the response
-    for character in response:
-        messages[-1] = (user_message, messages[-1][1] + character)
-        yield messages  # Stream each character
-        time.sleep(0.05)  # Adjust delay as needed for real-time effect
-
-    yield messages  # Final yield to ensure the full response is displayed
-
-
-# Function to generate audio with Eleven Labs TTS from the last bot response
-def generate_audio_from_last_response(history):
-    # Get the most recent bot response from the chat history
-    if history and len(history) > 0:
-        recent_response = history[-1][1]  # The second item in the tuple is the bot response text
-        if recent_response:
-            return generate_audio_elevenlabs(recent_response)
-    return None
-
-# 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?"]
-    
-]
-
-# Function to insert the prompt into the textbox when clicked
-def insert_prompt(current_text, prompt):
-    return prompt[0] if prompt else current_text
-
-
 # Define the ASR model with Whisper
 model_id = 'openai/whisper-large-v3'
 device = "cuda:0" if torch.cuda.is_available() else "cpu"
@@ -288,137 +124,72 @@ pipe_asr = pipeline(
     return_timestamps=True
 )
 
-# Define the function to reset the state after 10 seconds
-def auto_reset_state():
-    time.sleep(5)
-    return None, ""  # Reset the state and clear input text
-
-
-def transcribe_function(stream, new_chunk):
+# Function to handle audio input, transcribe, fetch from Neo4j, and generate audio response
+def transcribe_and_respond(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
-
     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
+    # Transcribe the audio using Whisper
     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
+    question = result.get("text", "")
 
+    # Retrieve information from Neo4j
+    response_text = structured_retriever(question) if question else "I didn't understand the question."
+    
+    # Convert the response to audio using Eleven Labs TTS
+    audio_path = generate_audio_elevenlabs(response_text) if response_text else None
 
+    return stream, question, audio_path
 
-# Define the function to clear the state and input text
+# Function to clear the transcription state
 def clear_transcription_state():
-    return None, ""
-
-
+    return None, "", None
 
+# Define the Gradio interface with only audio input and output
 with gr.Blocks(theme="rawrsor1/Everforest") as demo:
-    chatbot = gr.Chatbot([], elem_id="RADAR", bubble_full_width=False)
-    with gr.Row():
-        with gr.Column():
-            mode_selection = gr.Radio(
-                choices=["Normal Chatbot", "Voice to Voice Conversation"],
-                label="Mode Selection",
-                value="Normal Chatbot"
-            )
-    with gr.Row():
-        with gr.Column():
-            question_input = gr.Textbox(label="Ask a Question", placeholder="Type your question here...")
-            audio_input = gr.Audio(sources=["microphone"], streaming=True, type='numpy', every=0.1, label="Speak to Ask")
-            submit_voice_btn = gr.Button("Submit Voice")
-
-        with gr.Column():
-            audio_output = gr.Audio(label="Audio", type="filepath", autoplay=True, interactive=False)
-    
-    with gr.Row():
-        with gr.Column():
-            get_response_btn = gr.Button("Get Response")
-        with gr.Column():
-            clear_state_btn = gr.Button("Clear State")
-        with gr.Column():
-            generate_audio_btn = gr.Button("Generate Audio")
-        with gr.Column():
-            clean_btn = gr.Button("Clean")
-
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("<h1 style='color: red;'>Example Prompts</h1>", elem_id="Example-Prompts")
-            gr.Examples(examples=examples, fn=insert_prompt, inputs=question_input, outputs=question_input, api_name="api_insert_example")
-
-  
-    # Define interactions for the Get Response button
-    get_response_btn.click(
-        fn=handle_mode_selection,
-        inputs=[mode_selection, chatbot, question_input],
-        outputs=[chatbot, question_input, audio_output],
-        api_name="api_add_message_on_button_click"
-    ).then(fn=chat_with_bot, inputs=[chatbot], outputs=chatbot,api_name="api_ask_retriever_on_button_click")
-
-    question_input.submit(
-        fn=handle_mode_selection,
-        inputs=[mode_selection, chatbot, question_input],
-        outputs=[chatbot, question_input, audio_output],
-        api_name="api_add_message_on_enter"
-    ).then(fn=chat_with_bot, inputs=[chatbot], outputs=chatbot,api_name="api_ask_retriever_on_enter")
-
+        audio_input = gr.Audio(
+            sources=["microphone"],
+            streaming=True,
+            type='numpy',
+            every=0.1,
+            label="Speak to Ask"
+        )
+        audio_output = gr.Audio(
+            label="Audio Response",
+            type="filepath",
+            autoplay=True,
+            interactive=False
+        )
     
-    submit_voice_btn.click(
-        fn=handle_mode_selection,
-        inputs=[mode_selection, chatbot, question_input],
-        outputs=[chatbot, question_input, audio_output],
-        api_name="api_voice_to_voice_translation"
-    )
-
-    # Speech-to-Text functionality
+    # Speech-to-Text to TTS functionality with Neo4j retrieval
     state = gr.State()
     audio_input.stream(
-        transcribe_function,
+        transcribe_and_respond,
         inputs=[state, audio_input],
-        outputs=[state, question_input],
-        api_name="api_voice_to_text"
-    )
-    
-    generate_audio_btn.click(
-        fn=generate_audio_from_last_response,
-        inputs=chatbot,
-        outputs=audio_output,
-        api_name="api_generate_text_to_audio"
-    )
-    
-    clean_btn.click(
-        fn=clear_fields,
-        inputs=[],
-        outputs=[chatbot, question_input, audio_output],
-        api_name="api_clear_textbox"
+        outputs=[state, audio_output],
+        api_name="api_voice_to_neo4j_response"
     )
 
     # Clear state interaction
-    clear_state_btn.click(
+    gr.Button("Clear State").click(
         fn=clear_transcription_state,
-        outputs=[question_input, state],
-        api_name="api_clean_state_transcription"
+        outputs=[state, audio_output],
+        api_name="api_clean_state"
     )
 
 # Launch the Gradio interface
-demo.launch(show_error=True,share=True)
+demo.launch(show_error=True, share=True)