Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,3 @@
+
+.idea/
+__pycache__/

README.md

@@ -1,12 +1,34 @@
 ---
-title: Llm Autobiography
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
+title: llm-autobiography
+app_file: chatgpt.py
 sdk: gradio
-sdk_version: 4.36.1
-app_file: app.py
-pinned: false
+sdk_version: 3.50.2
 ---
+#  Chatbot Frontend
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+## Prerequisites
+- Python 3.x
+- pip
+
+## Installation
+1. Clone the repository:
+   ```
+   git clone https://github.com/Zhuoxuan-Zhang/chatbot-ui.git
+   ```
+2. Navigate to the project directory:
+   ```
+   cd chatbot-ui
+   ```
+3. Install the required packages:
+   ```
+   pip install -r requirements.txt
+   ```
+
+## Running the Application
+Start the chatbot by running:
+```
+python chatgpt.py
+```
+
+## Usage
+- Open Chrome and visit `http://localhost:7860` to interact with the chatbot.

chatgpt.py

@@ -0,0 +1,337 @@
+import gradio as gr
+import whisper
+import asyncio
+import httpx
+import tempfile
+import aiohttp
+import os
+
+from interview_protocol import protocols as interview_protocols
+
+# Load the Whisper model for transcription
+model = whisper.load_model("base")
+
+# Your backend base URL
+base_url = "http://localhost:8080"
+
+# Function to get the method index based on selection
+def get_method_index(chapter, method):
+    all_methods = []
+    for chap in interview_protocols.values():
+        all_methods.extend(chap)
+    index = all_methods.index(method)
+    return index
+
+# Function to set the API key and settings on your backend
+async def set_api_key(api_key, chapter_name, topic_name, username):
+    url = f"{base_url}/api/set-key"
+    headers = {'Content-Type': 'application/json'}
+    data = {'api_key': api_key, 'chapter_name': chapter_name, 'topic_name': topic_name, 'username': username}
+    async with httpx.AsyncClient(timeout=20) as client:
+        try:
+            response = await client.post(url, json=data, headers=headers)
+            if response.status_code == 200:
+                return "API key and Interview Protocol set successfully."
+            else:
+                return f"Failed to set API key and Interview Protocol: {response.text}"
+        except asyncio.TimeoutError:
+            print("The request timed out")
+            return "Request timed out while setting API key."
+        except Exception as e:
+            return f"Error setting API key and Interview Protocol: {str(e)}"
+
+# Get a response from the backend
+async def get_backend_response(api_key, patient_prompt, protocol_index):
+    url = f"{base_url}/responses/doctor"
+    headers = {'Content-Type': 'application/json'}
+    data = {
+        'patient_prompt': patient_prompt,
+        'protocol_index': protocol_index  # Use the calculated index
+    }
+    async with httpx.AsyncClient(timeout=20) as client:
+        try:
+            response = await client.post(url, json=data, headers=headers)
+            if response.status_code == 200:
+                response_data = response.json()
+                return response_data
+            else:
+                return f"Failed to fetch response from backend: {response.text}"
+        except Exception as e:
+            return f"Error contacting backend service: {str(e)}"
+
+async def save_conversation_and_memory():
+    url = f"{base_url}/save/end_and_save"
+    headers = {'Content-Type': 'application/json'}
+    data = {}
+    async with httpx.AsyncClient(timeout=20) as client:
+        try:
+            response = await client.post(url, json=data, headers=headers)
+            if response.status_code == 200:
+                response_data = response.json()
+                return response_data.get('response', 'Saving Error!.')
+            else:
+                return f"Failed to save conversations and memory graph: {response.text}"
+        except Exception as e:
+            return f"Error contacting backend service: {str(e)}"
+
+# Function to get conversation histories from the backend
+async def get_conversation_histories(username):
+    url = f"{base_url}/save/download_conversations"
+    headers = {'Content-Type': 'application/json'}
+    data = {'username': username}
+    async with httpx.AsyncClient(timeout=20) as client:
+        try:
+            response = await client.post(url, json=data, headers=headers)
+            if response.status_code == 200:
+                conversation_data = response.json()
+                return conversation_data
+            else:
+                return []  # Return empty list if failed
+        except Exception as e:
+            return []
+
+# Function to download conversation histories as separate text files
+def download_conversations(username):
+    conversation_histories = asyncio.run(get_conversation_histories(username))
+    files = []
+    temp_dir = tempfile.mkdtemp()
+    for conversation_entry in conversation_histories:
+        file_name = conversation_entry.get('file_name', f"Conversation_{len(files)+1}.txt")
+        conversation = conversation_entry.get('conversation', [])
+        conversation_text = ""
+        for message_pair in conversation:
+            if isinstance(message_pair, list) and len(message_pair) == 2:
+                speaker, message = message_pair
+                conversation_text += f"{speaker.capitalize()}: {message}\n\n"
+            else:
+                # Handle unexpected data format
+                conversation_text += f"Unknown format: {message_pair}\n\n"
+        # Write each conversation to a file with the same file name as backend
+        temp_file_path = os.path.join(temp_dir, file_name)
+        with open(temp_file_path, 'w') as temp_file:
+            temp_file.write(conversation_text)
+        files.append(temp_file_path)
+    return files
+
+async def get_biography():
+    url = f"{base_url}/save/generate_autobiography"
+    headers = {'Content-Type': 'application/json'}
+    async with httpx.AsyncClient(timeout=20) as client:
+        try:
+            response = await client.get(url, headers=headers)
+            if response.status_code == 200:
+                biography_data = response.json()
+                biography_text = biography_data.get('biography', '')
+                return biography_text
+            else:
+                return "Failed to generate biography."
+        except Exception as e:
+            return f"Error contacting backend service: {str(e)}"
+
+# Function to download biography as a text file
+def download_biography():
+    biography_text = asyncio.run(get_biography())
+    if not biography_text or "Failed" in biography_text or "Error" in biography_text:
+        # Handle error messages
+        return gr.update(value=None, visible=False), biography_text  # Return the error message
+    # Write the biography to a temporary text file
+    with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as temp_file:
+        temp_file.write(biography_text)
+        temp_file_path = temp_file.name
+    return temp_file_path, "Biography generated successfully."
+
+def transcribe_audio(audio_file):
+    transcription = model.transcribe(audio_file)["text"]
+    return transcription
+
+def submit_text_and_respond(edited_text, api_key, chapter, method, history):
+    # Get the protocol index based on selection
+    protocol_index = get_method_index(chapter, method)
+    response = asyncio.run(get_backend_response(api_key, edited_text, protocol_index))
+    print('------')
+    print(response)
+    if isinstance(response, str):
+        # Handle error messages
+        history.append((edited_text, response))
+        return history, "", []
+    doctor_response = response['doctor_response']['response']
+    memory_event = response['memory_events']
+    history.append((edited_text, doctor_response))
+    # Update memory graph
+    memory_graph = update_memory_graph(memory_event)
+    return history, "", memory_graph  # Return memory_graph as output
+
+def set_api_key_button(api_key_input, chapter_name, topic_name, username_input):
+    message = asyncio.run(set_api_key(api_key_input, chapter_name, topic_name, username_input))
+    print(message)
+    return message, api_key_input  # Store the API key in state
+
+def save_conversation(state):
+    response = asyncio.run(save_conversation_and_memory())
+    return response
+
+def start_recording(audio_file):
+    if not audio_file:
+        return ""
+    try:
+        transcription = transcribe_audio(audio_file)
+        return transcription
+    except Exception as e:
+        return f"Failed to transcribe: {str(e)}"
+
+def update_methods(chapter):
+    return gr.update(choices=interview_protocols[chapter], value=interview_protocols[chapter][0])
+
+def update_memory_graph(memory_data):
+    # Process memory_data to display in the table
+    table_data = []
+    for node in memory_data:
+        table_data.append([
+            node.get('date', ''),
+            node.get('topic', ''),
+            node.get('event_description', ''),
+            node.get('people_involved', '')
+        ])
+    return table_data
+
+# Gradio interface setup
+with gr.Blocks() as app:
+    with gr.Row():
+        # Sidebar Column
+        with gr.Column(scale=1, min_width=250):
+            gr.Markdown("## Settings")
+            
+            with gr.Box():
+                gr.Markdown("### Interview Protocol")
+                # Chapter Selection
+                chapter_dropdown = gr.Dropdown(
+                    label="Select Chapter",
+                    choices=list(interview_protocols.keys()),
+                    value=list(interview_protocols.keys())[0],
+                )
+                # Topic Selection
+                method_dropdown = gr.Dropdown(
+                    label="Select Topic",
+                    choices=interview_protocols[chapter_dropdown.value],
+                    value=interview_protocols[chapter_dropdown.value][0],
+                )
+
+                # Update methods when chapter changes
+                chapter_dropdown.change(
+                    fn=update_methods,
+                    inputs=[chapter_dropdown],
+                    outputs=[method_dropdown]
+                )
+
+                # Update states when selections change
+                def update_chapter(chapter):
+                    return chapter
+
+                def update_method(method):
+                    return method
+
+                chapter_state = gr.State()
+                method_state = gr.State()
+
+                chapter_dropdown.change(
+                    fn=update_chapter,
+                    inputs=[chapter_dropdown],
+                    outputs=[chapter_state]
+                )
+
+                method_dropdown.change(
+                    fn=update_method,
+                    inputs=[method_dropdown],
+                    outputs=[method_state]
+                )
+
+            with gr.Box():
+                gr.Markdown("### User Information")
+                # Username input
+                username_input = gr.Textbox(
+                    label="Username", placeholder="Enter your username"
+                )
+                
+                # API Key Input
+                api_key_input = gr.Textbox(
+                    label="API Key", placeholder="Enter your API Key", type="password"
+                )
+
+            # Initialize Button
+            api_key_button = gr.Button("Initialize", variant="primary", size="large")
+            api_key_status = gr.Textbox(
+                label="Status", interactive=False, placeholder="Initialization status will appear here."
+            )
+
+            api_key_state = gr.State()
+
+            # Set API key and settings when the button is clicked
+            api_key_button.click(
+                fn=set_api_key_button,
+                inputs=[api_key_input, chapter_dropdown, method_dropdown, username_input],
+                outputs=[api_key_status, api_key_state]
+            )
+
+        # Main Content Column
+        with gr.Column(scale=3):
+            # Only the Chatbot in the first row to keep it larger
+            chatbot = gr.Chatbot(label="Chat with GPT", height=500)
+
+            with gr.Row():
+                transcription_box = gr.Textbox(
+                    label="Transcription (You can edit this)", lines=3
+                )
+                audio_input = gr.Audio(
+                    source="microphone", type="filepath", label="🎤 Record Audio"
+                )
+
+            with gr.Row():
+                submit_button = gr.Button("Submit", variant="primary", size="large")
+                save_conversation_button = gr.Button("End and Save Conversation", variant="secondary")
+                download_button = gr.Button("Download Conversations", variant="secondary")
+                download_biography_button = gr.Button("Download Biography", variant="secondary")  # New button
+
+            # Move the Memory Graph Table below the chatbot
+            memory_graph_table = gr.Dataframe(
+                headers=["Date", "Topic", "Description", "People Involved"],
+                datatype=["str", "str", "str", "str"],
+                interactive=False,
+                label="Memory Events",
+                max_rows=5
+            )
+
+            # Set up interactions
+            audio_input.change(
+                fn=start_recording,
+                inputs=[audio_input],
+                outputs=[transcription_box]
+            )
+
+            state = gr.State([])
+
+            submit_button.click(
+                submit_text_and_respond,
+                inputs=[transcription_box, api_key_state, chapter_dropdown, method_dropdown, state],
+                outputs=[chatbot, transcription_box, memory_graph_table]
+            )
+
+            download_button.click(
+                fn=download_conversations,
+                inputs=[username_input],
+                outputs=gr.Files()
+            )
+
+            # Set up the download biography button
+            download_biography_button.click(
+                fn=download_biography,
+                inputs=None,
+                outputs=[gr.File(label="Biography.txt"), gr.Textbox(visible=False)]
+            )
+
+            save_conversation_button.click(
+                fn=save_conversation,
+                inputs=[state],
+                outputs=None
+            )
+
+    app.launch(share=True)

gradio_app.py

@@ -0,0 +1,38 @@
+import openai
+import whisper
+from getpass import getpass
+from elevenlabs.client import ElevenLabs
+from elevenlabs import play
+
+import gradio as gr
+
+from typing import Optional
+
+openai_api_key = ''
+
+client = ElevenLabs(
+  api_key="" # Defaults to ELEVEN_API_KEY
+)
+
+def transcribe(audio):
+    file = open(audio, "rb")
+    
+    if file is None:
+        return ""
+    
+    with file as f:
+        t_text = openai.Audio.transcribe(
+        model="whisper-1",
+        file=f,
+        api_key=openai_api_key   
+        )
+    return t_text["text"]
+
+demo = gr.Interface(
+    title = 'Medical Scriber', 
+    fn=transcribe, 
+    inputs=[gr.Audio(source="microphone", type="filepath")],
+    outputs=["text"]
+    ).launch()
+
+demo.launch(debug=True)

interview_protocol.py

@@ -0,0 +1,21 @@
+protocols = {
+    "Life Chapters": ["Life As A Book"],
+    "Key Scenes in the Life Story": [
+        "High Point",
+        "Low Point",
+        "Turning Point",
+        "Positive Childhood Memory",
+        "Negative Childhood Memory",
+        "Vivid Adult Memory",
+        "Religious, Spiritual, or Mystical Experience",
+        "Wisdom Event"
+    ],
+    "Future": ["Next Chapter", "Dreams and Plans", "Life Project"],
+    "Challenges": ["Life Challenge", "Health", "Loss", "Failure or Regret"],
+    "Personal Ideology": [
+        "Religious and Ethical Values",
+        "Political and Social Values",
+        "Change, Development Of Religious And Political Views",
+        "Key Value"
+    ]
+}

requirements.txt

@@ -1 +1,106 @@
-huggingface_hub==0.22.2
+aiofiles==23.2.1
+aiohappyeyeballs==2.4.0
+aiohttp==3.10.5
+aiosignal==1.3.1
+altair==5.4.1
+annotated-types==0.7.0
+anyio==4.4.0
+async-timeout==4.0.3
+attrs==24.2.0
+blinker==1.8.2
+cachetools==5.5.0
+certifi==2024.8.30
+charset-normalizer==3.3.2
+click==8.1.7
+contourpy==1.3.0
+cycler==0.12.1
+distro==1.9.0
+elevenlabs==1.8.0
+exceptiongroup==1.2.2
+fastapi==0.114.1
+ffmpeg==1.4
+ffmpy==0.4.0
+filelock==3.16.0
+fonttools==4.53.1
+frozenlist==1.4.1
+fsspec==2024.9.0
+gitdb==4.0.11
+GitPython==3.1.43
+gradio==3.50.2
+gradio_client==0.6.1
+h11==0.14.0
+httpcore==1.0.5
+httpx==0.27.2
+huggingface-hub==0.24.6
+idna==3.8
+importlib_resources==6.4.5
+Jinja2==3.1.4
+jiter==0.5.0
+jsonschema==4.23.0
+jsonschema-specifications==2023.12.1
+kiwisolver==1.4.7
+llvmlite==0.43.0
+loguru==0.7.2
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.9.2
+mdurl==0.1.2
+more-itertools==10.5.0
+mpmath==1.3.0
+multidict==6.1.0
+narwhals==1.7.0
+networkx==3.3
+numba==0.60.0
+numpy==1.26.4
+openai==0.28.0
+openai-whisper==20231117
+orjson==3.10.7
+packaging==24.1
+pandas==2.2.2
+pillow==10.4.0
+protobuf==5.28.1
+pyarrow==17.0.0
+PyAudio==0.2.14
+pydantic==2.9.1
+pydantic_core==2.23.3
+pydeck==0.9.1
+pydub==0.25.1
+Pygments==2.18.0
+pyparsing==3.1.4
+python-dateutil==2.9.0.post0
+python-multipart==0.0.9
+pytz==2024.2
+PyYAML==6.0.2
+referencing==0.35.1
+regex==2024.9.11
+requests==2.32.3
+rich==13.8.1
+rpds-py==0.20.0
+ruff==0.6.4
+safetensors==0.4.5
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.16.0
+smmap==5.0.1
+sniffio==1.3.1
+starlette==0.38.5
+streamlit==1.38.0
+sympy==1.13.2
+tenacity==8.5.0
+tiktoken==0.7.0
+tokenizers==0.19.1
+toml==0.10.2
+tomlkit==0.12.0
+torch==2.4.1
+tornado==6.4.1
+tqdm==4.66.5
+transformers==4.44.2
+transforms==0.2.1
+typer==0.12.5
+typing_extensions==4.12.2
+tzdata==2024.1
+urllib3==2.2.2
+uvicorn==0.30.6
+webrtcvad==2.0.10
+websockets==11.0.3
+yarl==1.11.1