Update app.py

app.py

@@ -5,37 +5,18 @@ 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 typing import List
 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
+from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
 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
 
+# 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')
 
-#code for history
-conversational_memory = ConversationBufferWindowMemory(
-        memory_key='chat_history',
-        k=10,
-        return_messages=True
-    )
-
-# Setup Neo4j
+# Setup Neo4j connection
 graph = Neo4jGraph(
     url="neo4j+s://c62d0d35.databases.neo4j.io",
     username="neo4j",
@@ -48,12 +29,12 @@ class Entities(BaseModel):
         ..., description="All the person, organization, or business entities that appear in the text"
     )
 
+# Define prompt and model for entity extraction
+chat_model = ChatOpenAI(temperature=0, model_name="gpt-4", api_key=os.environ['OPENAI_API_KEY'])
 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:
@@ -72,10 +53,7 @@ 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:
+def retrieve_data_from_neo4j(question: str) -> str:
     result = ""
     entities = entity_chain.invoke({"question": question})
     for entity in entities.names:
@@ -86,10 +64,6 @@ def structured_retriever(question: str) -> str:
               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
             """,
@@ -98,164 +72,23 @@ 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']
     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
-    }
-    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
-        }
-    }
+    headers = {"Accept": "application/json", "xi-api-key": XI_API_KEY}
+    data = {"text": str(text), "model_id": "eleven_multilingual_v2", "voice_settings": {"stability": 1.0}}
     response = requests.post(tts_url, headers=headers, json=data, stream=True)
     if response.ok:
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as f:
             for chunk in response.iter_content(chunk_size=1024):
                 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":
-        # 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
-
-    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
-        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():
-        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 a placeholder for the bot's response
-    
-    response = get_response(user_message)  # Assume `get_response` is a generator function
-    
-    # Stream each character in the response and update the history progressively
-    for character in response:
-        messages[-1] = (user_message, messages[-1][1] + character)
-        yield messages  # Stream each updated chunk
-        time.sleep(0.05)  # Adjust delay as needed for real-time effect
-
-    yield messages  # Final yield to complete the response
-
-
-    
-# 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 f.name
     return None
 
-
-
-# Define the ASR model with Whisper
+# ASR model setup using 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
@@ -271,120 +104,37 @@ pipe_asr = pipeline(
     chunk_length_s=15,
     batch_size=16,
     torch_dtype=torch_dtype,
-    device=device,
-    return_timestamps=True
+    device=device
 )
 
-# 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):
-    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
+# Function to handle audio input, transcription, and Neo4j response generation
+def transcribe_and_respond(audio):
+    # Transcribe audio input
+    audio_data = {"array": audio["data"], "sampling_rate": audio["sample_rate"]}
+    transcription = pipe_asr(audio_data)["text"]
+    logging.debug(f"Transcription: {transcription}")
 
-    # Process the audio data for transcription
-    result = pipe_asr({"array": stream, "sampling_rate": sr}, return_timestamps=False)
-    full_text = result.get("text", "")
+    # Retrieve data from Neo4j based on transcription
+    response_text = retrieve_data_from_neo4j(transcription)
+    logging.debug(f"Neo4j Response: {response_text}")
 
-    # Start a thread to reset the state after 10 seconds
-    threading.Thread(target=auto_reset_state).start()
+    # Convert response to audio
+    return generate_audio_elevenlabs(response_text)
 
-    return stream, full_text, full_text
-
-
-
-# Define the function to clear the state and input text
-def clear_transcription_state():
-    return None, ""
-
-
-
-with gr.Blocks(theme="rawrsor1/Everforest") as demo:
-    # Hide the chatbot component by setting `visible=False`
-    chatbot = gr.Chatbot([], elem_id="RADAR", bubble_full_width=False, visible=False)
-    
-    with gr.Row():
-        with gr.Column():
-            # Hide the "Normal Chatbot" radio button by removing it or setting `visible=False`
-            mode_selection = gr.Radio(
-                choices=["Voice to Voice Conversation"],  # Removed "Normal Chatbot" option
-                label="Mode Selection",
-                value="Voice to Voice Conversation",
-                visible=False  # Hide the mode selection entirely
-            )
-    # Remaining code unchanged
-    with gr.Row():
-        with gr.Column():
-            question_input = gr.Textbox(label="Ask a Question", placeholder="Type your question here...",visible=False)
-            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)
+# Define Gradio interface
+with gr.Blocks() as demo:
+    audio_input = gr.Audio(source="microphone", type="numpy", label="Speak to Ask")  # Removed streaming mode for manual submission
+    audio_output = gr.Audio(label="Response", type="filepath", autoplay=True, interactive=False)
     
-    with gr.Row():
-        
-        with gr.Column():
-            clear_state_btn = gr.Button("Clear State")
-        
-        with gr.Column():
-            clean_btn = gr.Button("Clean")
-
-    
-  
-    # Adjust the interactions for the Get Response button
-    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
-    state = gr.State()
-    audio_input.stream(
-        transcribe_function,
-        inputs=[state, audio_input],
-        outputs=[state, question_input],
-        api_name="api_voice_to_text"
-    )    
+    # "Submit Audio" button
+    submit_button = gr.Button("Submit Audio")
     
-    
-    
-    clean_btn.click(
-        fn=clear_fields,
-        inputs=[],
-        outputs=[chatbot, question_input, audio_output],
-        api_name="api_clear_textbox"
-    )
-
-    # Clear state interaction
-    clear_state_btn.click(
-        fn=clear_transcription_state,
-        outputs=[question_input, state],
-        api_name="api_clean_state_transcription"
+    # Link the button to trigger response generation after clicking
+    submit_button.click(
+        fn=transcribe_and_respond,
+        inputs=audio_input,
+        outputs=audio_output
     )
 
-# Launch the Gradio interface
+# Launch Gradio interface
 demo.launch(show_error=True, share=True)