Upload 13 files

App_Function_Libraries/Gradio_UI/Audio_ingestion_tab.py

@@ -7,7 +7,7 @@
 import gradio as gr
 #
 # Local Imports
-from App_Function_Libraries.Audio_Files import process_audio_files
+from App_Function_Libraries.Audio.Audio_Files import process_audio_files
 from App_Function_Libraries.DB.DB_Manager import load_preset_prompts
 from App_Function_Libraries.Gradio_UI.Chat_ui import update_user_prompt
 from App_Function_Libraries.Gradio_UI.Gradio_Shared import whisper_models

App_Function_Libraries/Gradio_UI/Character_Interaction_tab.py

@@ -0,0 +1,797 @@
+# Character_Interaction_tab.py
+# Description: This file contains the functions that are used for Character Interactions in the Gradio UI.
+#
+# Imports
+import base64
+import io
+from datetime import datetime as datetime
+import logging
+import json
+import os
+from typing import List, Dict, Tuple, Union
+
+#
+# External Imports
+import gradio as gr
+from PIL import Image
+#
+# Local Imports
+from App_Function_Libraries.Chat import chat, load_characters
+from App_Function_Libraries.Gradio_UI.Chat_ui import chat_wrapper
+from App_Function_Libraries.Gradio_UI.Writing_tab import generate_writing_feedback
+#
+########################################################################################################################
+#
+# Single-Character chat Functions:
+
+
+def chat_with_character(user_message, history, char_data, api_name_input, api_key):
+    if char_data is None:
+        return history, "Please import a character card first."
+
+    bot_message = generate_writing_feedback(user_message, char_data['name'], "Overall", api_name_input,
+                                            api_key)
+    history.append((user_message, bot_message))
+    return history, ""
+
+
+def import_character_card(file):
+    if file is None:
+        logging.warning("No file provided for character card import")
+        return None
+    try:
+        if file.name.lower().endswith(('.png', '.webp')):
+            logging.info(f"Attempting to import character card from image: {file.name}")
+            json_data = extract_json_from_image(file)
+            if json_data:
+                logging.info("JSON data extracted from image, attempting to parse")
+                card_data = import_character_card_json(json_data)
+                if card_data:
+                    # Save the image data
+                    with Image.open(file) as img:
+                        img_byte_arr = io.BytesIO()
+                        img.save(img_byte_arr, format='PNG')
+                        card_data['image'] = base64.b64encode(img_byte_arr.getvalue()).decode('utf-8')
+                return card_data
+            else:
+                logging.warning("No JSON data found in the image")
+        else:
+            logging.info(f"Attempting to import character card from JSON file: {file.name}")
+            content = file.read().decode('utf-8')
+            return import_character_card_json(content)
+    except Exception as e:
+        logging.error(f"Error importing character card: {e}")
+    return None
+
+
+def import_character_card_json(json_content):
+    try:
+        # Remove any leading/trailing whitespace
+        json_content = json_content.strip()
+
+        # Log the first 100 characters of the content
+        logging.debug(f"JSON content (first 100 chars): {json_content[:100]}...")
+
+        card_data = json.loads(json_content)
+        logging.debug(f"Parsed JSON data keys: {list(card_data.keys())}")
+        if 'spec' in card_data and card_data['spec'] == 'chara_card_v2':
+            logging.info("Detected V2 character card")
+            return card_data['data']
+        else:
+            logging.info("Assuming V1 character card")
+            return card_data
+    except json.JSONDecodeError as e:
+        logging.error(f"JSON decode error: {e}")
+        logging.error(f"Problematic JSON content: {json_content[:500]}...")
+    except Exception as e:
+        logging.error(f"Unexpected error parsing JSON: {e}")
+    return None
+
+
+def extract_json_from_image(image_file):
+    logging.debug(f"Attempting to extract JSON from image: {image_file.name}")
+    try:
+        with Image.open(image_file) as img:
+            logging.debug("Image opened successfully")
+            metadata = img.info
+            if 'chara' in metadata:
+                logging.debug("Found 'chara' in image metadata")
+                chara_content = metadata['chara']
+                logging.debug(f"Content of 'chara' metadata (first 100 chars): {chara_content[:100]}...")
+                try:
+                    decoded_content = base64.b64decode(chara_content).decode('utf-8')
+                    logging.debug(f"Decoded content (first 100 chars): {decoded_content[:100]}...")
+                    return decoded_content
+                except Exception as e:
+                    logging.error(f"Error decoding base64 content: {e}")
+
+            logging.debug("'chara' not found in metadata, checking for base64 encoded data")
+            raw_data = img.tobytes()
+            possible_json = raw_data.split(b'{', 1)[-1].rsplit(b'}', 1)[0]
+            if possible_json:
+                try:
+                    decoded = base64.b64decode(possible_json).decode('utf-8')
+                    if decoded.startswith('{') and decoded.endswith('}'):
+                        logging.debug("Found and decoded base64 JSON data")
+                        return '{' + decoded + '}'
+                except Exception as e:
+                    logging.error(f"Error decoding base64 data: {e}")
+
+            logging.warning("No JSON data found in the image")
+    except Exception as e:
+        logging.error(f"Error extracting JSON from image: {e}")
+    return None
+
+
+def load_chat_history(file):
+    try:
+        content = file.read().decode('utf-8')
+        chat_data = json.loads(content)
+        return chat_data['history'], chat_data['character']
+    except Exception as e:
+        logging.error(f"Error loading chat history: {e}")
+        return None, None
+
+
+def create_character_card_interaction_tab():
+    with gr.TabItem("Chat with a Character Card"):
+        gr.Markdown("# Chat with a Character Card")
+        with gr.Row():
+            with gr.Column(scale=1):
+                character_image = gr.Image(label="Character Image", type="filepath")
+                character_card_upload = gr.File(label="Upload Character Card")
+                import_card_button = gr.Button("Import Character Card")
+                load_characters_button = gr.Button("Load Existing Characters")
+                from App_Function_Libraries.Chat import get_character_names
+                character_dropdown = gr.Dropdown(label="Select Character", choices=get_character_names())
+                user_name_input = gr.Textbox(label="Your Name", placeholder="Enter your name here")
+                api_name_input = gr.Dropdown(
+                    choices=[None, "Local-LLM", "OpenAI", "Anthropic", "Cohere", "Groq", "DeepSeek", "Mistral",
+                             "OpenRouter", "Llama.cpp", "Kobold", "Ooba", "Tabbyapi", "VLLM", "ollama", "HuggingFace",
+                             "Custom-OpenAI-API"],
+                    value=None,
+                    # FIXME - make it so the user cant' click `Send Message` without first setting an API + Chatbot
+                    label="API for Interaction(Mandatory)"
+                )
+                api_key_input = gr.Textbox(label="API Key (if not set in Config_Files/config.txt)",
+                                           placeholder="Enter your API key here", type="password")
+                temperature_slider = gr.Slider(minimum=0.0, maximum=2.0, value=0.7, step=0.05, label="Temperature")
+                import_chat_button = gr.Button("Import Chat History")
+                chat_file_upload = gr.File(label="Upload Chat History JSON", visible=False)
+
+            with gr.Column(scale=2):
+                chat_history = gr.Chatbot(label="Conversation", height=800)
+                user_input = gr.Textbox(label="Your message")
+                send_message_button = gr.Button("Send Message")
+                regenerate_button = gr.Button("Regenerate Last Message")
+                clear_chat_button = gr.Button("Clear Chat")
+                save_chat_button = gr.Button("Save This Chat")
+                save_status = gr.Textbox(label="Save Status", interactive=False)
+
+        character_data = gr.State(None)
+        user_name = gr.State("")
+
+    def import_chat_history(file, current_history, char_data):
+        loaded_history, char_name = load_chat_history(file)
+        if loaded_history is None:
+            return current_history, char_data, "Failed to load chat history."
+
+        # Check if the loaded chat is for the current character
+        if char_data and char_data.get('name') != char_name:
+            return current_history, char_data, f"Warning: Loaded chat is for character '{char_name}', but current character is '{char_data.get('name')}'. Chat not imported."
+
+        # If no character is selected, try to load the character from the chat
+        if not char_data:
+            new_char_data = load_character(char_name)[0]
+            if new_char_data:
+                char_data = new_char_data
+            else:
+                return current_history, char_data, f"Warning: Character '{char_name}' not found. Please select the character manually."
+
+        return loaded_history, char_data, f"Chat history for '{char_name}' imported successfully."
+
+    def import_character(file):
+        card_data = import_character_card(file)
+        if card_data:
+            from App_Function_Libraries.Chat import save_character
+            save_character(card_data)
+            return card_data, gr.update(choices=get_character_names())
+        else:
+            return None, gr.update()
+
+    def load_character(name):
+        from App_Function_Libraries.Chat import load_characters
+        characters = load_characters()
+        char_data = characters.get(name)
+        if char_data:
+            first_message = char_data.get('first_mes', "Hello! I'm ready to chat.")
+            return char_data, [(None, first_message)] if first_message else [], None
+        return None, [], None
+
+    def load_character_image(name):
+        from App_Function_Libraries.Chat import load_characters
+        characters = load_characters()
+        char_data = characters.get(name)
+        if char_data and 'image_path' in char_data:
+            image_path = char_data['image_path']
+            if os.path.exists(image_path):
+                return image_path
+            else:
+                logging.warning(f"Image file not found: {image_path}")
+        return None
+
+    def load_character_and_image(name):
+        char_data, chat_history, _ = load_character(name)
+        image_path = load_character_image(name)
+        logging.debug(f"Character: {name}")
+        logging.debug(f"Character data: {char_data}")
+        logging.debug(f"Image path: {image_path}")
+        return char_data, chat_history, image_path
+
+    def character_chat_wrapper(message, history, char_data, api_endpoint, api_key, temperature, user_name):
+        logging.debug("Entered character_chat_wrapper")
+        if char_data is None:
+            return "Please select a character first.", history
+
+        if not user_name:
+            user_name = "User"
+
+        char_name = char_data.get('name', 'AI Assistant')
+
+        # Prepare the character's background information
+        char_background = f"""
+        Name: {char_name}
+        Description: {char_data.get('description', 'N/A')}
+        Personality: {char_data.get('personality', 'N/A')}
+        Scenario: {char_data.get('scenario', 'N/A')}
+        """
+
+        # Prepare the system prompt for character impersonation
+        system_message = f"""You are roleplaying as {char_name}, the character described below. Respond to the user's messages in character, maintaining the personality and background provided. Do not break character or refer to yourself as an AI. Always refer to yourself as "{char_name}" and refer to the user as "{user_name}".
+
+        {char_background}
+
+        Additional instructions: {char_data.get('post_history_instructions', '')}
+        """
+
+        # Prepare media_content and selected_parts
+        media_content = {
+            'id': char_name,
+            'title': char_name,
+            'content': char_background,
+            'description': char_data.get('description', ''),
+            'personality': char_data.get('personality', ''),
+            'scenario': char_data.get('scenario', '')
+        }
+        selected_parts = ['description', 'personality', 'scenario']
+
+        prompt = char_data.get('post_history_instructions', '')
+
+        # Prepare the input for the chat function
+        if not history:
+            full_message = f"{prompt}\n\n{user_name}: {message}" if prompt else f"{user_name}: {message}"
+        else:
+            full_message = f"{user_name}: {message}"
+
+        # Call the chat function
+        bot_message = chat(
+            full_message,
+            history,
+            media_content,
+            selected_parts,
+            api_endpoint,
+            api_key,
+            prompt,
+            temperature,
+            system_message
+        )
+
+        # Update history
+        history.append((message, bot_message))
+        return history
+
+    def save_chat_history(history, character_name):
+        # Create the Saved_Chats folder if it doesn't exist
+        save_directory = "Saved_Chats"
+        os.makedirs(save_directory, exist_ok=True)
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"chat_history_{character_name}_{timestamp}.json"
+        filepath = os.path.join(save_directory, filename)
+
+        chat_data = {
+            "character": character_name,
+            "timestamp": timestamp,
+            "history": history
+        }
+
+        try:
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(chat_data, f, ensure_ascii=False, indent=2)
+            return filepath
+        except Exception as e:
+            return f"Error saving chat: {str(e)}"
+
+    def save_current_chat(history, char_data):
+        if not char_data or not history:
+            return "No chat to save or character not selected."
+
+        character_name = char_data.get('name', 'Unknown')
+        result = save_chat_history(history, character_name)
+        if result.startswith("Error"):
+            return result
+        return f"Chat saved successfully as {result}"
+
+    def regenerate_last_message(history, char_data, api_name, api_key, temperature, user_name):
+        if not history:
+            return history
+
+        last_user_message = history[-1][0]
+        new_history = history[:-1]
+
+        return character_chat_wrapper(last_user_message, new_history, char_data, api_name, api_key, temperature,
+                                      user_name)
+
+    import_chat_button.click(
+        fn=lambda: gr.update(visible=True),
+        outputs=chat_file_upload
+    )
+
+    chat_file_upload.change(
+        fn=import_chat_history,
+        inputs=[chat_file_upload, chat_history, character_data],
+        outputs=[chat_history, character_data, save_status]
+    )
+
+    def update_character_info(name):
+        from App_Function_Libraries.Chat import load_characters
+        characters = load_characters()
+        char_data = characters.get(name)
+
+        image_path = char_data.get('image_path') if char_data else None
+
+        logging.debug(f"Character: {name}")
+        logging.debug(f"Character data: {char_data}")
+        logging.debug(f"Image path: {image_path}")
+
+        if image_path:
+            if os.path.exists(image_path):
+                logging.debug(f"Image file exists at {image_path}")
+                if os.access(image_path, os.R_OK):
+                    logging.debug(f"Image file is readable")
+                else:
+                    logging.warning(f"Image file is not readable: {image_path}")
+                    image_path = None
+            else:
+                logging.warning(f"Image file does not exist: {image_path}")
+                image_path = None
+        else:
+            logging.warning("No image path provided for the character")
+
+        return char_data, None, image_path  # Return None for chat_history
+
+    def on_character_select(name):
+        logging.debug(f"Character selected: {name}")
+        return update_character_info_with_error_handling(name)
+
+    def clear_chat_history():
+        return [], None  # Return empty list for chat_history and None for character_data
+
+    def update_character_info_with_error_handling(name):
+        logging.debug(f"Entering update_character_info_with_error_handling for character: {name}")
+        try:
+            char_data, _, image_path = update_character_info(name)
+            logging.debug(f"Retrieved data: char_data={bool(char_data)}, image_path={image_path}")
+
+            if char_data:
+                first_message = char_data.get('first_mes', "Hello! I'm ready to chat.")
+                chat_history = [(None, first_message)] if first_message else []
+            else:
+                chat_history = []
+
+            logging.debug(f"Created chat_history with length: {len(chat_history)}")
+
+            if image_path and os.path.exists(image_path):
+                logging.debug(f"Image file exists at {image_path}")
+                return char_data, chat_history, image_path
+            else:
+                logging.warning(f"Image not found or invalid path: {image_path}")
+                return char_data, chat_history, None
+        except Exception as e:
+            logging.error(f"Error updating character info: {str(e)}", exc_info=True)
+            return None, [], None
+        finally:
+            logging.debug("Exiting update_character_info_with_error_handling")
+
+    import_card_button.click(
+        fn=import_character,
+        inputs=[character_card_upload],
+        outputs=[character_data, character_dropdown]
+    )
+
+    load_characters_button.click(
+        fn=lambda: gr.update(choices=get_character_names()),
+        outputs=character_dropdown
+    )
+
+    clear_chat_button.click(
+        fn=clear_chat_history,
+        inputs=[],
+        outputs=[chat_history, character_data]
+    )
+
+    character_dropdown.change(
+        fn=on_character_select,
+        inputs=[character_dropdown],
+        outputs=[character_data, chat_history, character_image]
+    )
+
+    send_message_button.click(
+        fn=character_chat_wrapper,
+        inputs=[user_input, chat_history, character_data, api_name_input, api_key_input, temperature_slider,
+                user_name_input],
+        outputs=[chat_history]
+    ).then(lambda: "", outputs=user_input)
+
+    regenerate_button.click(
+        fn=regenerate_last_message,
+        inputs=[chat_history, character_data, api_name_input, api_key_input, temperature_slider, user_name_input],
+        outputs=[chat_history]
+    )
+
+    user_name_input.change(
+        fn=lambda name: name,
+        inputs=[user_name_input],
+        outputs=[user_name]
+    )
+
+    save_chat_button.click(
+        fn=save_current_chat,
+        inputs=[chat_history, character_data],
+        outputs=[save_status]
+    )
+
+    return character_data, chat_history, user_input, user_name, character_image
+
+
+#
+# End of Character chat tab
+######################################################################################################################
+#
+# Multi-Character Chat Interface
+
+def character_interaction_setup():
+    characters = load_characters()
+    return characters, [], None, None
+
+
+def extract_character_response(response: Union[str, Tuple]) -> str:
+    if isinstance(response, tuple):
+        # If it's a tuple, try to extract the first string element
+        for item in response:
+            if isinstance(item, str):
+                return item.strip()
+        # If no string found, return a default message
+        return "I'm not sure how to respond."
+    elif isinstance(response, str):
+        # If it's already a string, just return it
+        return response.strip()
+    else:
+        # For any other type, return a default message
+        return "I'm having trouble forming a response."
+
+# def process_character_response(response: str) -> str:
+#     # Remove any leading explanatory text before the first '---'
+#     parts = response.split('---')
+#     if len(parts) > 1:
+#         return '---' + '---'.join(parts[1:])
+#     return response.strip()
+def process_character_response(response: Union[str, Tuple]) -> str:
+    if isinstance(response, tuple):
+        response = ' '.join(str(item) for item in response if isinstance(item, str))
+
+    if isinstance(response, str):
+        # Remove any leading explanatory text before the first '---'
+        parts = response.split('---')
+        if len(parts) > 1:
+            return '---' + '---'.join(parts[1:])
+        return response.strip()
+    else:
+        return "I'm having trouble forming a response."
+
+def character_turn(characters: Dict, conversation: List[Tuple[str, str]],
+                   current_character: str, other_characters: List[str],
+                   api_endpoint: str, api_key: str, temperature: float,
+                   scenario: str = "") -> Tuple[List[Tuple[str, str]], str]:
+    if not current_character or current_character not in characters:
+        return conversation, current_character
+
+    if not conversation and scenario:
+        conversation.append(("Scenario", scenario))
+
+    current_char = characters[current_character]
+    other_chars = [characters[char] for char in other_characters if char in characters and char != current_character]
+
+    prompt = f"{current_char['name']}'s personality: {current_char['personality']}\n"
+    for char in other_chars:
+        prompt += f"{char['name']}'s personality: {char['personality']}\n"
+    prompt += "Conversation so far:\n" + "\n".join([f"{sender}: {message}" for sender, message in conversation])
+    prompt += f"\n\nHow would {current_char['name']} respond?"
+
+    try:
+        response = chat_wrapper(prompt, conversation, {}, [], api_endpoint, api_key, "", None, False, temperature, "")
+        processed_response = process_character_response(response)
+        conversation.append((current_char['name'], processed_response))
+    except Exception as e:
+        error_message = f"Error generating response: {str(e)}"
+        conversation.append((current_char['name'], error_message))
+
+    return conversation, current_character
+
+
+def character_interaction(character1: str, character2: str, api_endpoint: str, api_key: str,
+                          num_turns: int, scenario: str, temperature: float,
+                          user_interjection: str = "") -> List[str]:
+    characters = load_characters()
+    char1 = characters[character1]
+    char2 = characters[character2]
+    conversation = []
+    current_speaker = char1
+    other_speaker = char2
+
+    # Add scenario to the conversation start
+    if scenario:
+        conversation.append(f"Scenario: {scenario}")
+
+    for turn in range(num_turns):
+        # Construct the prompt for the current speaker
+        prompt = f"{current_speaker['name']}'s personality: {current_speaker['personality']}\n"
+        prompt += f"{other_speaker['name']}'s personality: {other_speaker['personality']}\n"
+        prompt += f"Conversation so far:\n" + "\n".join(
+            [msg if isinstance(msg, str) else f"{msg[0]}: {msg[1]}" for msg in conversation])
+
+        # Add user interjection if provided
+        if user_interjection and turn == num_turns // 2:
+            prompt += f"\n\nUser interjection: {user_interjection}\n"
+            conversation.append(f"User: {user_interjection}")
+
+        prompt += f"\n\nHow would {current_speaker['name']} respond?"
+
+        # FIXME - figure out why the double print is happening
+        # Get response from the LLM
+        response = chat_wrapper(prompt, conversation, {}, [], api_endpoint, api_key, "", None, False, temperature, "")
+
+        # Add the response to the conversation
+        conversation.append((current_speaker['name'], response))
+
+        # Switch speakers
+        current_speaker, other_speaker = other_speaker, current_speaker
+
+    # Convert the conversation to a list of strings for output
+    return [f"{msg[0]}: {msg[1]}" if isinstance(msg, tuple) else msg for msg in conversation]
+
+
+def create_multiple_character_chat_tab():
+    with gr.TabItem("Multi-Character Chat"):
+        characters, conversation, current_character, other_character = character_interaction_setup()
+
+        with gr.Blocks() as character_interaction:
+            gr.Markdown("# Multi-Character Chat")
+
+            with gr.Row():
+                num_characters = gr.Dropdown(label="Number of Characters", choices=["2", "3", "4"], value="2")
+                character_selectors = [gr.Dropdown(label=f"Character {i + 1}", choices=list(characters.keys())) for i in
+                                       range(4)]
+
+            api_endpoint = gr.Dropdown(label="API Endpoint",
+                                       choices=["OpenAI", "Anthropic", "Local-LLM", "Cohere", "Groq", "DeepSeek",
+                                                "Mistral", "OpenRouter"])
+            api_key = gr.Textbox(label="API Key (if required)", type="password")
+            temperature = gr.Slider(label="Temperature", minimum=0.1, maximum=1.0, step=0.1, value=0.7)
+            scenario = gr.Textbox(label="Scenario (optional)", lines=3)
+
+            chat_display = gr.Chatbot(label="Character Interaction")
+            current_index = gr.State(0)
+
+            next_turn_btn = gr.Button("Next Turn")
+            narrator_input = gr.Textbox(label="Narrator Input", placeholder="Add a narration or description...")
+            add_narration_btn = gr.Button("Add Narration")
+            error_box = gr.Textbox(label="Error Messages", visible=False)
+            reset_btn = gr.Button("Reset Conversation")
+
+            def update_character_selectors(num):
+                return [gr.update(visible=True) if i < int(num) else gr.update(visible=False) for i in range(4)]
+
+            num_characters.change(
+                update_character_selectors,
+                inputs=[num_characters],
+                outputs=character_selectors
+            )
+
+            def reset_conversation():
+                return [], 0, gr.update(value=""), gr.update(value="")
+
+            def take_turn(conversation, current_index, char1, char2, char3, char4, api_endpoint, api_key, temperature,
+                          scenario):
+                char_selectors = [char for char in [char1, char2, char3, char4] if char]  # Remove None values
+                num_chars = len(char_selectors)
+
+                if num_chars == 0:
+                    return conversation, current_index  # No characters selected, return without changes
+
+                if not conversation:
+                    conversation = []
+                    if scenario:
+                        conversation.append(("Scenario", scenario))
+
+                current_character = char_selectors[current_index % num_chars]
+                next_index = (current_index + 1) % num_chars
+
+                prompt = f"Character speaking: {current_character}\nOther characters: {', '.join(char for char in char_selectors if char != current_character)}\n"
+                prompt += "Generate the next part of the conversation, including character dialogues and actions. Characters should speak in first person."
+
+                response, new_conversation, _ = chat_wrapper(prompt, conversation, {}, [], api_endpoint, api_key, "",
+                                                             None, False, temperature, "")
+
+                # Format the response
+                formatted_lines = []
+                for line in response.split('\n'):
+                    if ':' in line:
+                        speaker, text = line.split(':', 1)
+                        formatted_lines.append(f"**{speaker.strip()}**: {text.strip()}")
+                    else:
+                        formatted_lines.append(line)
+
+                formatted_response = '\n'.join(formatted_lines)
+
+                # Update the last message in the conversation with the formatted response
+                if new_conversation:
+                    new_conversation[-1] = (new_conversation[-1][0], formatted_response)
+                else:
+                    new_conversation.append((current_character, formatted_response))
+
+                return new_conversation, next_index
+
+            def add_narration(narration, conversation):
+                if narration:
+                    conversation.append(("Narrator", narration))
+                return conversation, ""
+
+            def take_turn_with_error_handling(conversation, current_index, char1, char2, char3, char4, api_endpoint,
+                                              api_key, temperature, scenario):
+                try:
+                    new_conversation, next_index = take_turn(conversation, current_index, char1, char2, char3, char4,
+                                                             api_endpoint, api_key, temperature, scenario)
+                    return new_conversation, next_index, gr.update(visible=False, value="")
+                except Exception as e:
+                    error_message = f"An error occurred: {str(e)}"
+                    return conversation, current_index, gr.update(visible=True, value=error_message)
+
+            next_turn_btn.click(
+                take_turn_with_error_handling,
+                inputs=[chat_display, current_index] + character_selectors + [api_endpoint, api_key, temperature,
+                                                                              scenario],
+                outputs=[chat_display, current_index, error_box]
+            )
+
+            add_narration_btn.click(
+                add_narration,
+                inputs=[narrator_input, chat_display],
+                outputs=[chat_display, narrator_input]
+            )
+
+            reset_btn.click(
+                reset_conversation,
+                outputs=[chat_display, current_index, scenario, narrator_input]
+            )
+
+        return character_interaction
+
+#
+# End of Multi-Character chat tab
+########################################################################################################################
+#
+# Narrator-Controlled Conversation Tab
+
+# From `Fuzzlewumper` on Reddit.
+def create_narrator_controlled_conversation_tab():
+    with gr.TabItem("Narrator-Controlled Conversation"):
+        gr.Markdown("# Narrator-Controlled Conversation")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                api_endpoint = gr.Dropdown(
+                    label="API Endpoint",
+                    choices=["OpenAI", "Anthropic", "Local-LLM", "Cohere", "Groq", "DeepSeek", "Mistral", "OpenRouter"],
+                    value="OpenAI"
+                )
+                api_key = gr.Textbox(label="API Key (if required)", type="password")
+                temperature = gr.Slider(label="Temperature", minimum=0.1, maximum=1.0, step=0.1, value=0.7)
+
+            with gr.Column(scale=2):
+                narrator_input = gr.Textbox(
+                    label="Narrator Input",
+                    placeholder="Set the scene or provide context...",
+                    lines=3
+                )
+
+        character_inputs = []
+        for i in range(4):  # Allow up to 4 characters
+            with gr.Row():
+                name = gr.Textbox(label=f"Character {i + 1} Name")
+                description = gr.Textbox(label=f"Character {i + 1} Description", lines=3)
+                character_inputs.append((name, description))
+
+        conversation_display = gr.Chatbot(label="Conversation", height=400)
+        user_input = gr.Textbox(label="Your Input (optional)", placeholder="Add your own dialogue or action...")
+
+        with gr.Row():
+            generate_btn = gr.Button("Generate Next Interaction")
+            reset_btn = gr.Button("Reset Conversation")
+
+        error_box = gr.Textbox(label="Error Messages", visible=False)
+
+        def generate_interaction(conversation, narrator_text, user_text, api_endpoint, api_key, temperature,
+                                 *character_data):
+            try:
+                characters = [{"name": name.strip(), "description": desc.strip()}
+                              for name, desc in zip(character_data[::2], character_data[1::2])
+                              if name.strip() and desc.strip()]
+
+                if not characters:
+                    raise ValueError("At least one character must be defined.")
+
+                prompt = f"Narrator: {narrator_text}\n\n"
+                for char in characters:
+                    prompt += f"Character '{char['name']}': {char['description']}\n"
+                prompt += "\nGenerate the next part of the conversation, including character dialogues and actions. "
+                prompt += "Characters should speak in first person. "
+                if user_text:
+                    prompt += f"\nIncorporate this user input: {user_text}"
+                prompt += "\nResponse:"
+
+                response, conversation, _ = chat_wrapper(prompt, conversation, {}, [], api_endpoint, api_key, "", None,
+                                                         False, temperature, "")
+
+                # Format the response
+                formatted_lines = []
+                for line in response.split('\n'):
+                    if ':' in line:
+                        speaker, text = line.split(':', 1)
+                        formatted_lines.append(f"**{speaker.strip()}**: {text.strip()}")
+                    else:
+                        formatted_lines.append(line)
+
+                formatted_response = '\n'.join(formatted_lines)
+
+                # Update the last message in the conversation with the formatted response
+                if conversation:
+                    conversation[-1] = (conversation[-1][0], formatted_response)
+                else:
+                    conversation.append((None, formatted_response))
+
+                return conversation, gr.update(value=""), gr.update(value=""), gr.update(visible=False, value="")
+            except Exception as e:
+                error_message = f"An error occurred: {str(e)}"
+                return conversation, gr.update(), gr.update(), gr.update(visible=True, value=error_message)
+
+        def reset_conversation():
+            return [], gr.update(value=""), gr.update(value=""), gr.update(visible=False, value="")
+
+        generate_btn.click(
+            generate_interaction,
+            inputs=[conversation_display, narrator_input, user_input, api_endpoint, api_key, temperature] +
+                   [input for char_input in character_inputs for input in char_input],
+            outputs=[conversation_display, narrator_input, user_input, error_box]
+        )
+
+        reset_btn.click(
+            reset_conversation,
+            outputs=[conversation_display, narrator_input, user_input, error_box]
+        )
+
+    return api_endpoint, api_key, temperature, narrator_input, conversation_display, user_input, generate_btn, reset_btn, error_box
+
+#
+# End of Multi-Character chat tab
+########################################################################################################################

App_Function_Libraries/Gradio_UI/Chat_ui.py

@@ -984,6 +984,7 @@ def process_with_llm(workflow, context, prompt, api_endpoint, api_key):
     api_key_snippet = api_key[:5] + "..." if api_key else "Not provided"
     return f"LLM output using {api_endpoint} (API Key: {api_key_snippet}) for {workflow} with context: {context[:30]}... and prompt: {prompt[:30]}..."
 
+
 #
 # End of Chat_ui.py
 #######################################################################################################################

App_Function_Libraries/Gradio_UI/Embeddings_tab.py

@@ -0,0 +1,365 @@
+# Embeddings_tabc.py
+# Description: This file contains the code for the RAG Chat tab in the Gradio UI
+#
+# Imports
+import json
+import logging
+#
+# External Imports
+import gradio as gr
+
+from App_Function_Libraries.Chunk_Lib import improved_chunking_process, determine_chunk_position
+#
+# Local Imports
+from App_Function_Libraries.DB.DB_Manager import get_all_content_from_database
+from App_Function_Libraries.RAG.ChromaDB_Library import chroma_client, \
+    store_in_chroma
+from App_Function_Libraries.RAG.Embeddings_Create import create_embedding
+#
+########################################################################################################################
+#
+# Functions:
+
+# FIXME - under construction
+def create_embeddings_tab():
+    with gr.TabItem("Create Embeddings"):
+        gr.Markdown("# Create Embeddings for All Content")
+
+        with gr.Row():
+            with gr.Column():
+                embedding_provider = gr.Radio(
+                    choices=["huggingface", "local", "openai"],
+                    label="Select Embedding Provider",
+                    value="huggingface"
+                )
+                gr.Markdown("Note: Local provider requires a running Llama.cpp/llamafile server.")
+                gr.Markdown("OpenAI provider requires a valid API key. ")
+                gr.Markdown("OpenAI Embeddings models: `text-embedding-3-small`, `text-embedding-3-large`")
+                gr.Markdown("HuggingFace provider requires a valid model name, i.e. `dunzhang/stella_en_400M_v5`")
+                embedding_model = gr.Textbox(
+                    label="Embedding Model",
+                    value="Enter your embedding model name here", lines=3
+                )
+                embedding_api_url = gr.Textbox(
+                    label="API URL (for local provider)",
+                    value="http://localhost:8080/embedding",
+                    visible=False
+                )
+
+                # Add chunking options
+                chunking_method = gr.Dropdown(
+                    choices=["words", "sentences", "paragraphs", "tokens", "semantic"],
+                    label="Chunking Method",
+                    value="words"
+                )
+                max_chunk_size = gr.Slider(
+                    minimum=1, maximum=8000, step=1, value=500,
+                    label="Max Chunk Size"
+                )
+                chunk_overlap = gr.Slider(
+                    minimum=0, maximum=4000, step=1, value=200,
+                    label="Chunk Overlap"
+                )
+                adaptive_chunking = gr.Checkbox(
+                    label="Use Adaptive Chunking",
+                    value=False
+                )
+
+                create_button = gr.Button("Create Embeddings")
+
+            with gr.Column():
+                status_output = gr.Textbox(label="Status", lines=10)
+
+        def update_provider_options(provider):
+            return gr.update(visible=provider == "local")
+
+        embedding_provider.change(
+            fn=update_provider_options,
+            inputs=[embedding_provider],
+            outputs=[embedding_api_url]
+        )
+
+        def create_all_embeddings(provider, model, api_url, method, max_size, overlap, adaptive):
+            try:
+                all_content = get_all_content_from_database()
+                if not all_content:
+                    return "No content found in the database."
+
+                chunk_options = {
+                    'method': method,
+                    'max_size': max_size,
+                    'overlap': overlap,
+                    'adaptive': adaptive
+                }
+
+                collection_name = "all_content_embeddings"
+                collection = chroma_client.get_or_create_collection(name=collection_name)
+
+                for item in all_content:
+                    media_id = item['id']
+                    text = item['content']
+
+                    chunks = improved_chunking_process(text, chunk_options)
+                    for i, chunk in enumerate(chunks):
+                        chunk_text = chunk['text']
+                        chunk_id = f"doc_{media_id}_chunk_{i}"
+
+                        existing = collection.get(ids=[chunk_id])
+                        if existing['ids']:
+                            continue
+
+                        embedding = create_embedding(chunk_text, provider, model, api_url)
+                        metadata = {
+                            "media_id": str(media_id),
+                            "chunk_index": i,
+                            "total_chunks": len(chunks),
+                            "chunking_method": method,
+                            "max_chunk_size": max_size,
+                            "chunk_overlap": overlap,
+                            "adaptive_chunking": adaptive,
+                            "embedding_model": model,
+                            "embedding_provider": provider,
+                            **chunk['metadata']
+                        }
+                        store_in_chroma(collection_name, [chunk_text], [embedding], [chunk_id], [metadata])
+
+                return "Embeddings created and stored successfully for all content."
+            except Exception as e:
+                logging.error(f"Error during embedding creation: {str(e)}")
+                return f"Error: {str(e)}"
+
+        create_button.click(
+            fn=create_all_embeddings,
+            inputs=[embedding_provider, embedding_model, embedding_api_url,
+                    chunking_method, max_chunk_size, chunk_overlap, adaptive_chunking],
+            outputs=status_output
+        )
+
+
+def create_view_embeddings_tab():
+    with gr.TabItem("View/Update Embeddings"):
+        gr.Markdown("# View and Update Embeddings")
+        item_mapping = gr.State({})
+        with gr.Row():
+            with gr.Column():
+                item_dropdown = gr.Dropdown(label="Select Item", choices=[], interactive=True)
+                refresh_button = gr.Button("Refresh Item List")
+                embedding_status = gr.Textbox(label="Embedding Status", interactive=False)
+                embedding_preview = gr.Textbox(label="Embedding Preview", interactive=False, lines=5)
+                embedding_metadata = gr.Textbox(label="Embedding Metadata", interactive=False, lines=10)
+
+            with gr.Column():
+                create_new_embedding_button = gr.Button("Create New Embedding")
+                embedding_provider = gr.Radio(
+                    choices=["huggingface", "local", "openai"],
+                    label="Select Embedding Provider",
+                    value="huggingface"
+                )
+                gr.Markdown("Note: Local provider requires a running Llama.cpp/llamafile server.")
+                gr.Markdown("OpenAI provider requires a valid API key. ")
+                gr.Markdown("OpenAI Embeddings models: `text-embedding-3-small`, `text-embedding-3-large`")
+                gr.Markdown("HuggingFace provider requires a valid model name, i.e. `dunzhang/stella_en_400M_v5`")
+                embedding_model = gr.Textbox(
+                    label="Embedding Model",
+                    value="Enter your embedding model name here", lines=3
+                )
+                embedding_api_url = gr.Textbox(
+                    label="API URL (for local provider)",
+                    value="http://localhost:8080/embedding",
+                    visible=False
+                )
+                chunking_method = gr.Dropdown(
+                    choices=["words", "sentences", "paragraphs", "tokens", "semantic"],
+                    label="Chunking Method",
+                    value="words"
+                )
+                max_chunk_size = gr.Slider(
+                    minimum=1, maximum=8000, step=1, value=500,
+                    label="Max Chunk Size"
+                )
+                chunk_overlap = gr.Slider(
+                    minimum=0, maximum=5000, step=1, value=200,
+                    label="Chunk Overlap"
+                )
+                adaptive_chunking = gr.Checkbox(
+                    label="Use Adaptive Chunking",
+                    value=False
+                )
+
+        def get_items_with_embedding_status():
+            try:
+                items = get_all_content_from_database()
+                collection = chroma_client.get_or_create_collection(name="all_content_embeddings")
+                choices = []
+                new_item_mapping = {}
+                for item in items:
+                    try:
+                        result = collection.get(ids=[f"doc_{item['id']}_chunk_0"])
+                        embedding_exists = result is not None and result.get('ids') and len(result['ids']) > 0
+                        status = "Embedding exists" if embedding_exists else "No embedding"
+                    except Exception as e:
+                        print(f"Error checking embedding for item {item['id']}: {str(e)}")
+                        status = "Error checking"
+                    choice = f"{item['title']} ({status})"
+                    choices.append(choice)
+                    new_item_mapping[choice] = item['id']
+                return gr.update(choices=choices), new_item_mapping
+            except Exception as e:
+                print(f"Error in get_items_with_embedding_status: {str(e)}")
+                return gr.update(choices=["Error: Unable to fetch items"]), {}
+
+        def update_provider_options(provider):
+            return gr.update(visible=provider == "local")
+
+        def check_embedding_status(selected_item, item_mapping):
+            if not selected_item:
+                return "Please select an item", "", ""
+
+            try:
+                item_id = item_mapping.get(selected_item)
+                if item_id is None:
+                    return f"Invalid item selected: {selected_item}", "", ""
+
+                item_title = selected_item.rsplit(' (', 1)[0]
+                collection = chroma_client.get_or_create_collection(name="all_content_embeddings")
+
+                result = collection.get(ids=[f"doc_{item_id}_chunk_0"], include=["embeddings", "metadatas"])
+                logging.info(f"ChromaDB result for item '{item_title}' (ID: {item_id}): {result}")
+
+                if not result['ids']:
+                    return f"No embedding found for item '{item_title}' (ID: {item_id})", "", ""
+
+                if not result['embeddings'] or not result['embeddings'][0]:
+                    return f"Embedding data missing for item '{item_title}' (ID: {item_id})", "", ""
+
+                embedding = result['embeddings'][0]
+                metadata = result['metadatas'][0] if result['metadatas'] else {}
+                embedding_preview = str(embedding[:50])
+                status = f"Embedding exists for item '{item_title}' (ID: {item_id})"
+                return status, f"First 50 elements of embedding:\n{embedding_preview}", json.dumps(metadata, indent=2)
+
+            except Exception as e:
+                logging.error(f"Error in check_embedding_status: {str(e)}")
+                return f"Error processing item: {selected_item}. Details: {str(e)}", "", ""
+
+        def create_new_embedding_for_item(selected_item, provider, model, api_url, method, max_size, overlap, adaptive, item_mapping):
+            if not selected_item:
+                return "Please select an item", "", ""
+
+            try:
+                item_id = item_mapping.get(selected_item)
+                if item_id is None:
+                    return f"Invalid item selected: {selected_item}", "", ""
+
+                items = get_all_content_from_database()
+                item = next((item for item in items if item['id'] == item_id), None)
+                if not item:
+                    return f"Item not found: {item_id}", "", ""
+
+                chunk_options = {
+                    'method': method,
+                    'max_size': max_size,
+                    'overlap': overlap,
+                    'adaptive': adaptive
+                }
+
+                chunks = improved_chunking_process(item['content'], chunk_options)
+                collection_name = "all_content_embeddings"
+                collection = chroma_client.get_or_create_collection(name=collection_name)
+
+                # Delete existing embeddings for this item
+                existing_ids = [f"doc_{item_id}_chunk_{i}" for i in range(len(chunks))]
+                collection.delete(ids=existing_ids)
+
+                for i, chunk in enumerate(chunks):
+                    chunk_text = chunk['text']
+                    chunk_metadata = chunk['metadata']
+                    chunk_position = determine_chunk_position(chunk_metadata['relative_position'])
+
+                    chunk_header = f"""
+                    Original Document: {item['title']}
+                    Chunk: {i + 1} of {len(chunks)}
+                    Position: {chunk_position}
+                    Header: {chunk_metadata.get('header_text', 'N/A')}
+        
+                    --- Chunk Content ---
+                    """
+
+                    full_chunk_text = chunk_header + chunk_text
+                    chunk_id = f"doc_{item_id}_chunk_{i}"
+                    embedding = create_embedding(full_chunk_text, provider, model, api_url)
+                    metadata = {
+                        "media_id": str(item_id),
+                        "chunk_index": i,
+                        "total_chunks": len(chunks),
+                        "chunking_method": method,
+                        "max_chunk_size": max_size,
+                        "chunk_overlap": overlap,
+                        "adaptive_chunking": adaptive,
+                        "embedding_model": model,
+                        "embedding_provider": provider,
+                        **chunk_metadata
+                    }
+                    store_in_chroma(collection_name, [full_chunk_text], [embedding], [chunk_id], [metadata])
+
+                embedding_preview = str(embedding[:50])
+                status = f"New embeddings created and stored for item: {item['title']} (ID: {item_id})"
+                return status, f"First 50 elements of new embedding:\n{embedding_preview}", json.dumps(metadata, indent=2)
+            except Exception as e:
+                logging.error(f"Error in create_new_embedding_for_item: {str(e)}")
+                return f"Error creating embedding: {str(e)}", "", ""
+
+        refresh_button.click(
+            get_items_with_embedding_status,
+            outputs=[item_dropdown, item_mapping]
+        )
+        item_dropdown.change(
+            check_embedding_status,
+            inputs=[item_dropdown, item_mapping],
+            outputs=[embedding_status, embedding_preview, embedding_metadata]
+        )
+        create_new_embedding_button.click(
+            create_new_embedding_for_item,
+            inputs=[item_dropdown, embedding_provider, embedding_model, embedding_api_url,
+                    chunking_method, max_chunk_size, chunk_overlap, adaptive_chunking, item_mapping],
+            outputs=[embedding_status, embedding_preview, embedding_metadata]
+        )
+        embedding_provider.change(
+            update_provider_options,
+            inputs=[embedding_provider],
+            outputs=[embedding_api_url]
+        )
+
+    return item_dropdown, refresh_button, embedding_status, embedding_preview, embedding_metadata, create_new_embedding_button, embedding_provider, embedding_model, embedding_api_url, chunking_method, max_chunk_size, chunk_overlap, adaptive_chunking
+
+
+def create_purge_embeddings_tab():
+    with gr.TabItem("Purge Embeddings"):
+        gr.Markdown("# Purge Embeddings")
+
+        with gr.Row():
+            with gr.Column():
+                purge_button = gr.Button("Purge All Embeddings")
+            with gr.Column():
+                status_output = gr.Textbox(label="Status", lines=10)
+
+    def purge_all_embeddings():
+        try:
+            collection_name = "all_content_embeddings"
+            chroma_client.delete_collection(collection_name)
+            chroma_client.create_collection(collection_name)
+            return "All embeddings have been purged successfully."
+        except Exception as e:
+            logging.error(f"Error during embedding purge: {str(e)}")
+            return f"Error: {str(e)}"
+
+    purge_button.click(
+        fn=purge_all_embeddings,
+        outputs=status_output
+    )
+
+
+
+#
+# End of file
+########################################################################################################################

App_Function_Libraries/Gradio_UI/Live_Recording.py

@@ -1,125 +1,123 @@
-# Live_Recording.py
-# Description: Gradio UI for live audio recording and transcription.
-#
-# Import necessary modules and functions
-import logging
-import os
-# External Imports
-import gradio as gr
-# Local Imports
-#from App_Function_Libraries.Audio_Transcription_Lib import (record_audio, speech_to_text, save_audio_temp,
-#                                                            stop_recording)
-from App_Function_Libraries.DB.DB_Manager import add_media_to_database
-#
-#######################################################################################################################
-#
-# Functions:
-
-whisper_models = ["small", "medium", "small.en", "medium.en", "medium", "large", "large-v1", "large-v2", "large-v3",
-                  "distil-large-v2", "distil-medium.en", "distil-small.en"]
-
-def create_live_recording_tab():
-    with gr.Tab("Live Recording and Transcription"):
-        gr.Markdown("# Live Audio Recording and Transcription")
-        with gr.Row():
-            with gr.Column():
-                duration = gr.Slider(minimum=1, maximum=8000, value=15, label="Recording Duration (seconds)")
-                whisper_models_input = gr.Dropdown(choices=whisper_models, value="medium", label="Whisper Model")
-                vad_filter = gr.Checkbox(label="Use VAD Filter")
-                save_recording = gr.Checkbox(label="Save Recording")
-                save_to_db = gr.Checkbox(label="Save Transcription to Database(Must be checked to save - can be checked afer transcription)", value=False)
-                custom_title = gr.Textbox(label="Custom Title (for database)", visible=False)
-                record_button = gr.Button("Start Recording")
-                stop_button = gr.Button("Stop Recording")
-            with gr.Column():
-                output = gr.Textbox(label="Transcription", lines=10)
-                audio_output = gr.Audio(label="Recorded Audio", visible=False)
-
-        recording_state = gr.State(value=None)
-
-        def start_recording(duration):
-            pass
-#            p, stream, audio_queue, stop_event, audio_thread = record_audio(duration)
-#            return (p, stream, audio_queue, stop_event, audio_thread)
-
-        def end_recording_and_transcribe(recording_state, whisper_model, vad_filter, save_recording, save_to_db, custom_title):
-            pass
-            #            if recording_state is None:
-#                return "Recording hasn't started yet.", None
-
-#            p, stream, audio_queue, stop_event, audio_thread = recording_state
-#            audio_data = stop_recording(p, stream, audio_queue, stop_event, audio_thread)
-
-#            temp_file = save_audio_temp(audio_data)
-#            segments = speech_to_text(temp_file, whisper_model=whisper_model, vad_filter=vad_filter)
-#            transcription = "\n".join([segment["Text"] for segment in segments])
-
-#            if save_recording:
-#                return transcription, temp_file
-#            else:
-#                os.remove(temp_file)
-#                return transcription, None
-
-        def save_transcription_to_db(transcription, custom_title):
-            if custom_title.strip() == "":
-                custom_title = "Self-recorded Audio"
-
-            try:
-                url = "self_recorded"
-                info_dict = {
-                    "title": custom_title,
-                    "uploader": "self-recorded",
-                    "webpage_url": url
-                }
-                segments = [{"Text": transcription}]
-                summary = ""
-                keywords = ["self-recorded", "audio"]
-                custom_prompt_input = ""
-                whisper_model = "self-recorded"
-                media_type = "audio"
-
-                result = add_media_to_database(
-                    url=url,
-                    info_dict=info_dict,
-                    segments=segments,
-                    summary=summary,
-                    keywords=keywords,
-                    custom_prompt_input=custom_prompt_input,
-                    whisper_model=whisper_model,
-                    media_type=media_type
-                )
-                return f"Transcription saved to database successfully. {result}"
-            except Exception as e:
-                logging.error(f"Error saving transcription to database: {str(e)}")
-                return f"Error saving transcription to database: {str(e)}"
-
-        def update_custom_title_visibility(save_to_db):
-            return gr.update(visible=save_to_db)
-
-        record_button.click(
-            fn=start_recording,
-            inputs=[duration],
-            outputs=[recording_state]
-        )
-
-        stop_button.click(
-            fn=end_recording_and_transcribe,
-            inputs=[recording_state, whisper_models_input, vad_filter, save_recording, save_to_db, custom_title],
-            outputs=[output, audio_output]
-        )
-
-        save_to_db.change(
-            fn=update_custom_title_visibility,
-            inputs=[save_to_db],
-            outputs=[custom_title]
-        )
-
-        gr.Button("Save to Database").click(
-            fn=save_transcription_to_db,
-            inputs=[output, custom_title],
-            outputs=gr.Textbox(label="Database Save Status")
-        )
-
-#
-# End of Functions
-########################################################################################################################
+# Live_Recording.py
+# Description: Gradio UI for live audio recording and transcription.
+#
+# Import necessary modules and functions
+import logging
+import os
+# External Imports
+import gradio as gr
+# Local Imports
+from App_Function_Libraries.Audio.Audio_Transcription_Lib import (record_audio, speech_to_text, save_audio_temp,
+                                                                  stop_recording)
+from App_Function_Libraries.DB.DB_Manager import add_media_to_database
+#
+#######################################################################################################################
+#
+# Functions:
+
+whisper_models = ["small", "medium", "small.en", "medium.en", "medium", "large", "large-v1", "large-v2", "large-v3",
+                  "distil-large-v2", "distil-medium.en", "distil-small.en"]
+
+def create_live_recording_tab():
+    with gr.Tab("Live Recording and Transcription"):
+        gr.Markdown("# Live Audio Recording and Transcription")
+        with gr.Row():
+            with gr.Column():
+                duration = gr.Slider(minimum=1, maximum=8000, value=15, label="Recording Duration (seconds)")
+                whisper_models_input = gr.Dropdown(choices=whisper_models, value="medium", label="Whisper Model")
+                vad_filter = gr.Checkbox(label="Use VAD Filter")
+                save_recording = gr.Checkbox(label="Save Recording")
+                save_to_db = gr.Checkbox(label="Save Transcription to Database(Must be checked to save - can be checked afer transcription)", value=False)
+                custom_title = gr.Textbox(label="Custom Title (for database)", visible=False)
+                record_button = gr.Button("Start Recording")
+                stop_button = gr.Button("Stop Recording")
+            with gr.Column():
+                output = gr.Textbox(label="Transcription", lines=10)
+                audio_output = gr.Audio(label="Recorded Audio", visible=False)
+
+        recording_state = gr.State(value=None)
+
+        def start_recording(duration):
+            p, stream, audio_queue, stop_event, audio_thread = record_audio(duration)
+            return (p, stream, audio_queue, stop_event, audio_thread)
+
+        def end_recording_and_transcribe(recording_state, whisper_model, vad_filter, save_recording, save_to_db, custom_title):
+            if recording_state is None:
+                return "Recording hasn't started yet.", None
+
+            p, stream, audio_queue, stop_event, audio_thread = recording_state
+            audio_data = stop_recording(p, stream, audio_queue, stop_event, audio_thread)
+
+            temp_file = save_audio_temp(audio_data)
+            segments = speech_to_text(temp_file, whisper_model=whisper_model, vad_filter=vad_filter)
+            transcription = "\n".join([segment["Text"] for segment in segments])
+
+            if save_recording:
+                return transcription, temp_file
+            else:
+                os.remove(temp_file)
+                return transcription, None
+
+        def save_transcription_to_db(transcription, custom_title):
+            if custom_title.strip() == "":
+                custom_title = "Self-recorded Audio"
+
+            try:
+                url = "self_recorded"
+                info_dict = {
+                    "title": custom_title,
+                    "uploader": "self-recorded",
+                    "webpage_url": url
+                }
+                segments = [{"Text": transcription}]
+                summary = ""
+                keywords = ["self-recorded", "audio"]
+                custom_prompt_input = ""
+                whisper_model = "self-recorded"
+                media_type = "audio"
+
+                result = add_media_to_database(
+                    url=url,
+                    info_dict=info_dict,
+                    segments=segments,
+                    summary=summary,
+                    keywords=keywords,
+                    custom_prompt_input=custom_prompt_input,
+                    whisper_model=whisper_model,
+                    media_type=media_type
+                )
+                return f"Transcription saved to database successfully. {result}"
+            except Exception as e:
+                logging.error(f"Error saving transcription to database: {str(e)}")
+                return f"Error saving transcription to database: {str(e)}"
+
+        def update_custom_title_visibility(save_to_db):
+            return gr.update(visible=save_to_db)
+
+        record_button.click(
+            fn=start_recording,
+            inputs=[duration],
+            outputs=[recording_state]
+        )
+
+        stop_button.click(
+            fn=end_recording_and_transcribe,
+            inputs=[recording_state, whisper_models_input, vad_filter, save_recording, save_to_db, custom_title],
+            outputs=[output, audio_output]
+        )
+
+        save_to_db.change(
+            fn=update_custom_title_visibility,
+            inputs=[save_to_db],
+            outputs=[custom_title]
+        )
+
+        gr.Button("Save to Database").click(
+            fn=save_transcription_to_db,
+            inputs=[output, custom_title],
+            outputs=gr.Textbox(label="Database Save Status")
+        )
+
+#
+# End of Functions
+########################################################################################################################

App_Function_Libraries/Gradio_UI/Llamafile_tab.py

@@ -9,7 +9,7 @@ import glob
 import gradio as gr
 #
 # Local Imports
-from App_Function_Libraries.Llamafile import start_llamafile
+from App_Function_Libraries.Local_LLM.Llamafile import start_llamafile
 #
 #######################################################################################################################
 #

App_Function_Libraries/Gradio_UI/PDF_ingestion_tab.py

@@ -12,7 +12,7 @@ import gradio as gr
 # Local Imports
 from App_Function_Libraries.DB.DB_Manager import load_preset_prompts
 from App_Function_Libraries.Gradio_UI.Chat_ui import update_user_prompt
-from App_Function_Libraries.PDF_Ingestion_Lib import extract_metadata_from_pdf, extract_text_and_format_from_pdf, \
+from App_Function_Libraries.PDF.PDF_Ingestion_Lib import extract_metadata_from_pdf, extract_text_and_format_from_pdf, \
     process_and_cleanup_pdf
 #
 #

App_Function_Libraries/Gradio_UI/Podcast_tab.py

@@ -8,7 +8,7 @@
 import gradio as gr
 #
 # Local Imports
-from App_Function_Libraries.Audio_Files import process_podcast
+from App_Function_Libraries.Audio.Audio_Files import process_podcast
 from App_Function_Libraries.DB.DB_Manager import load_preset_prompts
 from App_Function_Libraries.Gradio_UI.Gradio_Shared import whisper_models, update_user_prompt
 

App_Function_Libraries/Gradio_UI/RAG_Chat_tab.py

@@ -8,10 +8,7 @@ import logging
 import gradio as gr
 #
 # Local Imports
-from App_Function_Libraries.DB.DB_Manager import get_all_content_from_database
-from App_Function_Libraries.RAG.ChromaDB_Library import chroma_client, \
-    check_embedding_status, store_in_chroma
-from App_Function_Libraries.RAG.Embeddings_Create import create_embedding
+
 from App_Function_Libraries.RAG.RAG_Libary_2 import enhanced_rag_pipeline
 #
 ########################################################################################################################
@@ -71,176 +68,6 @@ def create_rag_tab():
         search_button.click(perform_rag_search, inputs=[search_query, keywords_input, api_choice], outputs=[result_output, context_output])
 
 
-# FIXME - under construction
-def create_embeddings_tab():
-    with gr.TabItem("Create Embeddings"):
-        gr.Markdown("# Create Embeddings for All Content")
-
-        with gr.Row():
-            with gr.Column():
-                embedding_provider = gr.Radio(
-                    choices=["openai", "local", "huggingface"],
-                    label="Select Embedding Provider",
-                    value="openai"
-                )
-                embedding_model = gr.Textbox(
-                    label="Embedding Model",
-                    value="text-embedding-3-small"
-                )
-                embedding_api_url = gr.Textbox(
-                    label="API URL (for local provider)",
-                    value="http://localhost:8080/embedding",
-                    visible=False
-                )
-                create_button = gr.Button("Create Embeddings")
-
-            with gr.Column():
-                status_output = gr.Textbox(label="Status", lines=10)
-
-        def update_provider_options(provider):
-            return gr.update(visible=provider == "local")
-
-        embedding_provider.change(
-            fn=update_provider_options,
-            inputs=[embedding_provider],
-            outputs=[embedding_api_url]
-        )
-
-        def create_all_embeddings(provider, model, api_url):
-            try:
-                all_content = get_all_content_from_database()
-                if not all_content:
-                    return "No content found in the database."
-
-                collection_name = "all_content_embeddings"
-                collection = chroma_client.get_or_create_collection(name=collection_name)
-
-                for item in all_content:
-                    media_id = item['id']
-                    text = item['content']
-
-                    existing = collection.get(ids=[f"doc_{media_id}"])
-                    if existing['ids']:
-                        continue
-
-                    embedding = create_embedding(text, provider, model, api_url)
-                    store_in_chroma(collection_name, [text], [embedding], [f"doc_{media_id}"], [{"media_id": media_id}])
-
-                return "Embeddings created and stored successfully for all new content."
-            except Exception as e:
-                logging.error(f"Error during embedding creation: {str(e)}")
-                return f"Error: {str(e)}"
-
-        create_button.click(
-            fn=create_all_embeddings,
-            inputs=[embedding_provider, embedding_model, embedding_api_url],
-            outputs=status_output
-        )
-
-
-def create_view_embeddings_tab():
-    with gr.TabItem("View/Update Embeddings"):
-        gr.Markdown("# View and Update Embeddings")
-        item_mapping = gr.State({})
-        with gr.Row():
-            with gr.Column():
-                item_dropdown = gr.Dropdown(label="Select Item", choices=[], interactive=True)
-                refresh_button = gr.Button("Refresh Item List")
-                embedding_status = gr.Textbox(label="Embedding Status", interactive=False)
-                embedding_preview = gr.Textbox(label="Embedding Preview", interactive=False, lines=5)
-
-            with gr.Column():
-                create_new_embedding_button = gr.Button("Create New Embedding")
-                embedding_provider = gr.Radio(
-                    choices=["openai", "local", "huggingface"],
-                    label="Embedding Provider",
-                    value="openai"
-                )
-                embedding_model = gr.Textbox(
-                    label="Embedding Model",
-                    value="text-embedding-3-small",
-                    visible=True
-                )
-                embedding_api_url = gr.Textbox(
-                    label="API URL (for local provider)",
-                    value="http://localhost:8080/embedding",
-                    visible=False
-                )
-
-        def get_items_with_embedding_status():
-            try:
-                items = get_all_content_from_database()
-                collection = chroma_client.get_or_create_collection(name="all_content_embeddings")
-                choices = []
-                new_item_mapping = {}
-                for item in items:
-                    try:
-                        result = collection.get(ids=[f"doc_{item['id']}"])
-                        embedding_exists = result is not None and result.get('ids') and len(result['ids']) > 0
-                        status = "Embedding exists" if embedding_exists else "No embedding"
-                    except Exception as e:
-                        print(f"Error checking embedding for item {item['id']}: {str(e)}")
-                        status = "Error checking"
-                    choice = f"{item['title']} ({status})"
-                    choices.append(choice)
-                    new_item_mapping[choice] = item['id']
-                return gr.update(choices=choices), new_item_mapping
-            except Exception as e:
-                print(f"Error in get_items_with_embedding_status: {str(e)}")
-                return gr.update(choices=["Error: Unable to fetch items"]), {}
-
-        def update_provider_options(provider):
-            return gr.update(visible=provider == "local")
-
-        def create_new_embedding_for_item(selected_item, provider, model, api_url, item_mapping):
-            if not selected_item:
-                return "Please select an item", ""
-
-            try:
-                item_id = item_mapping.get(selected_item)
-                if item_id is None:
-                    return f"Invalid item selected: {selected_item}", ""
-
-                items = get_all_content_from_database()
-                item = next((item for item in items if item['id'] == item_id), None)
-                if not item:
-                    return f"Item not found: {item_id}", ""
-
-                embedding = create_embedding(item['content'], provider, model, api_url)
-
-                collection_name = "all_content_embeddings"
-                metadata = {"media_id": item_id, "title": item['title']}
-                store_in_chroma(collection_name, [item['content']], [embedding], [f"doc_{item_id}"],
-                                [{"media_id": item_id, "title": item['title']}])
-
-                embedding_preview = str(embedding[:50])
-                status = f"New embedding created and stored for item: {item['title']} (ID: {item_id})"
-                return status, f"First 50 elements of new embedding:\n{embedding_preview}\n\nMetadata: {metadata}"
-            except Exception as e:
-                logging.error(f"Error in create_new_embedding_for_item: {str(e)}")
-                return f"Error creating embedding: {str(e)}", ""
-
-        refresh_button.click(
-            get_items_with_embedding_status,
-            outputs=[item_dropdown, item_mapping]
-        )
-        item_dropdown.change(
-            check_embedding_status,
-            inputs=[item_dropdown, item_mapping],
-            outputs=[embedding_status, embedding_preview]
-        )
-        create_new_embedding_button.click(
-            create_new_embedding_for_item,
-            inputs=[item_dropdown, embedding_provider, embedding_model, embedding_api_url, item_mapping],
-            outputs=[embedding_status, embedding_preview]
-        )
-        embedding_provider.change(
-            update_provider_options,
-            inputs=[embedding_provider],
-            outputs=[embedding_api_url]
-        )
-
-    return item_dropdown, refresh_button, embedding_status, embedding_preview, create_new_embedding_button, embedding_provider, embedding_model, embedding_api_url
 
 #
 # End of file

App_Function_Libraries/Gradio_UI/Utilities.py

@@ -40,7 +40,7 @@ def create_utilities_yt_audio_tab():
                 output_file_audio = gr.File(label="Download Audio")
                 output_message_audio = gr.Textbox(label="Status")
 
-        from App_Function_Libraries.Audio_Files import download_youtube_audio
+        from App_Function_Libraries.Audio.Audio_Files import download_youtube_audio
         download_button_audio.click(
             fn=download_youtube_audio,
             inputs=youtube_url_input_audio,

App_Function_Libraries/Gradio_UI/Video_transcription_tab.py

@@ -14,7 +14,7 @@ import yt_dlp
 from App_Function_Libraries.DB.DB_Manager import load_preset_prompts, add_media_to_database
 from App_Function_Libraries.Gradio_UI.Gradio_Shared import whisper_models, update_user_prompt
 from App_Function_Libraries.Gradio_UI.Gradio_Shared import error_handler
-from App_Function_Libraries.Summarization_General_Lib import perform_transcription, perform_summarization, \
+from App_Function_Libraries.Summarization.Summarization_General_Lib import perform_transcription, perform_summarization, \
     save_transcription_and_summary
 from App_Function_Libraries.Utils.Utils import convert_to_seconds, safe_read_file, format_transcription, \
     create_download_directory, generate_unique_identifier, extract_text_from_segments
@@ -156,9 +156,9 @@ def create_video_transcription_tab():
                     with gr.Column():
                         chunk_method = gr.Dropdown(choices=['words', 'sentences', 'paragraphs', 'tokens'],
                                                    label="Chunking Method")
-                        max_chunk_size = gr.Slider(minimum=100, maximum=1000, value=300, step=50,
+                        max_chunk_size = gr.Slider(minimum=100, maximum=8000, value=400, step=1,
                                                    label="Max Chunk Size")
-                        chunk_overlap = gr.Slider(minimum=0, maximum=100, value=0, step=10, label="Chunk Overlap")
+                        chunk_overlap = gr.Slider(minimum=0, maximum=5000, value=100, step=1, label="Chunk Overlap")
                         use_adaptive_chunking = gr.Checkbox(
                             label="Use Adaptive Chunking (Adjust chunking based on text complexity)")
                         use_multi_level_chunking = gr.Checkbox(label="Use Multi-level Chunking")
@@ -492,8 +492,8 @@ def create_video_transcription_tab():
             # FIXME - remove dead args for process_url_with_metadata
             @error_handler
             def process_url_with_metadata(input_item, num_speakers, whisper_model, custom_prompt, offset, api_name,
-                                          api_key,
-                                          vad_filter, download_video_flag, download_audio, rolling_summarization,
+                                          api_key, vad_filter, download_video_flag, download_audio,
+                                          rolling_summarization,
                                           detail_level, question_box, keywords, local_file_path, diarize, end_time=None,
                                           include_timestamps=True, metadata=None, use_chunking=False,
                                           chunk_options=None, keep_original_video=False, current_whisper_model="Blank"):
@@ -562,10 +562,11 @@ def create_video_transcription_tab():
                         # Download video/audio
                         logging.info("Downloading video/audio...")
                         video_file_path = download_video(input_item, download_path, full_info, download_video_flag,
-                                                         current_whisper_model="Blank")
-                        if not video_file_path:
-                            logging.error(f"Failed to download video/audio from {input_item}")
-                            return None, None, None, None, None, None
+                                                         current_whisper_model=current_whisper_model)
+                        if video_file_path is None:
+                            logging.info(
+                                f"Download skipped for {input_item}. Media might already exist or be processed.")
+                            return input_item, None, None, None, None, info_dict
 
                     logging.info(f"Processing file: {video_file_path}")
 

App_Function_Libraries/Gradio_UI/Website_scraping_tab.py

@@ -19,11 +19,11 @@ from playwright.sync_api import sync_playwright
 
 #
 # Local Imports
-from App_Function_Libraries.Article_Extractor_Lib import scrape_from_sitemap, scrape_by_url_level, scrape_article
-from App_Function_Libraries.Article_Summarization_Lib import scrape_and_summarize_multiple
+from App_Function_Libraries.Web_Scraping.Article_Extractor_Lib import scrape_from_sitemap, scrape_by_url_level, scrape_article
+from App_Function_Libraries.Web_Scraping.Article_Summarization_Lib import scrape_and_summarize_multiple
 from App_Function_Libraries.DB.DB_Manager import load_preset_prompts
 from App_Function_Libraries.Gradio_UI.Chat_ui import update_user_prompt
-from App_Function_Libraries.Summarization_General_Lib import summarize
+from App_Function_Libraries.Summarization.Summarization_General_Lib import summarize
 
 
 #
@@ -423,12 +423,12 @@ def create_website_scraping_tab():
                     result = await scrape_and_summarize_multiple(url_input, custom_prompt, api_name, api_key, keywords,
                                                                  custom_titles, system_prompt)
                 elif scrape_method == "Sitemap":
-                    result = scrape_from_sitemap(url_input)
+                    result = await asyncio.to_thread(scrape_from_sitemap, url_input)
                 elif scrape_method == "URL Level":
                     if url_level is None:
                         return convert_json_to_markdown(
                             json.dumps({"error": "URL level is required for URL Level scraping."}))
-                    result = scrape_by_url_level(url_input, url_level)
+                    result = await asyncio.to_thread(scrape_by_url_level, url_input, url_level)
                 elif scrape_method == "Recursive Scraping":
                     result = await recursive_scrape(url_input, max_pages, max_depth, progress.update, delay=1.0)
                 else:
@@ -437,16 +437,30 @@ def create_website_scraping_tab():
                 # Ensure result is always a list of dictionaries
                 if isinstance(result, dict):
                     result = [result]
-                elif not isinstance(result, list):
-                    raise TypeError(f"Unexpected result type: {type(result)}")
+                elif isinstance(result, list):
+                    if all(isinstance(item, str) for item in result):
+                        # Convert list of strings to list of dictionaries
+                        result = [{"content": item} for item in result]
+                    elif not all(isinstance(item, dict) for item in result):
+                        raise ValueError("Not all items in result are dictionaries or strings")
+                else:
+                    raise ValueError(f"Unexpected result type: {type(result)}")
+
+                # Ensure all items in result are dictionaries
+                if not all(isinstance(item, dict) for item in result):
+                    raise ValueError("Not all items in result are dictionaries")
 
                 if summarize_checkbox:
                     total_articles = len(result)
                     for i, article in enumerate(result):
                         progress.update(f"Summarizing article {i + 1}/{total_articles}")
-                        summary = summarize(article['content'], custom_prompt, api_name, api_key, temperature,
-                                            system_prompt)
-                        article['summary'] = summary
+                        content = article.get('content', '')
+                        if content:
+                            summary = await asyncio.to_thread(summarize, content, custom_prompt, api_name, api_key,
+                                                              temperature, system_prompt)
+                            article['summary'] = summary
+                        else:
+                            article['summary'] = "No content available to summarize."
 
                 # Concatenate all content
                 all_content = "\n\n".join(

App_Function_Libraries/Gradio_UI/Writing_tab.py

@@ -2,20 +2,13 @@
 # Description: This file contains the functions that are used for writing in the Gradio UI.
 #
 # Imports
-import base64
-from datetime import datetime as datetime
-import logging
-import json
-import os
 #
 # External Imports
 import gradio as gr
-from PIL import Image
 import textstat
 #
 # Local Imports
-from App_Function_Libraries.Summarization_General_Lib import perform_summarization
-from App_Function_Libraries.Chat import chat
+from App_Function_Libraries.Summarization.Summarization_General_Lib import perform_summarization
 #
 ########################################################################################################################
 #
@@ -375,323 +368,6 @@ def create_creative_writing_tab():
         gr.Markdown("# Utility to be added...")
 
 
-def chat_with_character(user_message, history, char_data, api_name_input, api_key):
-    if char_data is None:
-        return history, "Please import a character card first."
-
-    bot_message = generate_writing_feedback(user_message, char_data['name'], "Overall", api_name_input,
-                                            api_key)
-    history.append((user_message, bot_message))
-    return history, ""
-
-def import_character_card(file):
-    if file is None:
-        logging.warning("No file provided for character card import")
-        return None
-    try:
-        if file.name.lower().endswith(('.png', '.webp')):
-            logging.info(f"Attempting to import character card from image: {file.name}")
-            json_data = extract_json_from_image(file)
-            if json_data:
-                logging.info("JSON data extracted from image, attempting to parse")
-                return import_character_card_json(json_data)
-            else:
-                logging.warning("No JSON data found in the image")
-        else:
-            logging.info(f"Attempting to import character card from JSON file: {file.name}")
-            content = file.read().decode('utf-8')
-            return import_character_card_json(content)
-    except Exception as e:
-        logging.error(f"Error importing character card: {e}")
-    return None
-
-
-def import_character_card_json(json_content):
-    try:
-        # Remove any leading/trailing whitespace
-        json_content = json_content.strip()
-
-        # Log the first 100 characters of the content
-        logging.debug(f"JSON content (first 100 chars): {json_content[:100]}...")
-
-        card_data = json.loads(json_content)
-        logging.debug(f"Parsed JSON data keys: {list(card_data.keys())}")
-        if 'spec' in card_data and card_data['spec'] == 'chara_card_v2':
-            logging.info("Detected V2 character card")
-            return card_data['data']
-        else:
-            logging.info("Assuming V1 character card")
-            return card_data
-    except json.JSONDecodeError as e:
-        logging.error(f"JSON decode error: {e}")
-        logging.error(f"Problematic JSON content: {json_content[:500]}...")
-    except Exception as e:
-        logging.error(f"Unexpected error parsing JSON: {e}")
-    return None
-
-
-def extract_json_from_image(image_file):
-    logging.debug(f"Attempting to extract JSON from image: {image_file.name}")
-    try:
-        with Image.open(image_file) as img:
-            logging.debug("Image opened successfully")
-            metadata = img.info
-            if 'chara' in metadata:
-                logging.debug("Found 'chara' in image metadata")
-                chara_content = metadata['chara']
-                logging.debug(f"Content of 'chara' metadata (first 100 chars): {chara_content[:100]}...")
-                try:
-                    decoded_content = base64.b64decode(chara_content).decode('utf-8')
-                    logging.debug(f"Decoded content (first 100 chars): {decoded_content[:100]}...")
-                    return decoded_content
-                except Exception as e:
-                    logging.error(f"Error decoding base64 content: {e}")
-
-            logging.debug("'chara' not found in metadata, checking for base64 encoded data")
-            raw_data = img.tobytes()
-            possible_json = raw_data.split(b'{', 1)[-1].rsplit(b'}', 1)[0]
-            if possible_json:
-                try:
-                    decoded = base64.b64decode(possible_json).decode('utf-8')
-                    if decoded.startswith('{') and decoded.endswith('}'):
-                        logging.debug("Found and decoded base64 JSON data")
-                        return '{' + decoded + '}'
-                except Exception as e:
-                    logging.error(f"Error decoding base64 data: {e}")
-
-            logging.warning("No JSON data found in the image")
-    except Exception as e:
-        logging.error(f"Error extracting JSON from image: {e}")
-    return None
-
-def load_chat_history(file):
-    try:
-        content = file.read().decode('utf-8')
-        chat_data = json.loads(content)
-        return chat_data['history'], chat_data['character']
-    except Exception as e:
-        logging.error(f"Error loading chat history: {e}")
-        return None, None
-
-
-# FIXME This should be in the chat tab....
-def create_character_card_interaction_tab():
-    with gr.TabItem("Chat with a Character Card"):
-        gr.Markdown("# Chat with a Character Card")
-        with gr.Row():
-            with gr.Column(scale=1):
-                character_card_upload = gr.File(label="Upload Character Card")
-                import_card_button = gr.Button("Import Character Card")
-                load_characters_button = gr.Button("Load Existing Characters")
-                from App_Function_Libraries.Chat import get_character_names
-                character_dropdown = gr.Dropdown(label="Select Character", choices=get_character_names())
-                api_name_input = gr.Dropdown(
-                    choices=[None, "Local-LLM", "OpenAI", "Anthropic", "Cohere", "Groq", "DeepSeek", "Mistral",
-                             "OpenRouter", "Llama.cpp", "Kobold", "Ooba", "Tabbyapi", "VLLM", "ollama", "HuggingFace", "Custom-OpenAI-API"],
-                    value=None,
-                    # FIXME - make it so the user cant' click `Send Message` without first setting an API + Chatbot
-                    label="API for Interaction(Mandatory)"
-                )
-                api_key_input = gr.Textbox(label="API Key (if not set in Config_Files/config.txt)",
-                                           placeholder="Enter your API key here", type="password")
-                temperature_slider = gr.Slider(minimum=0.0, maximum=2.0, value=0.7, step=0.05, label="Temperature")
-                import_chat_button = gr.Button("Import Chat History")
-                chat_file_upload = gr.File(label="Upload Chat History JSON", visible=False)
-
-
-            with gr.Column(scale=2):
-                chat_history = gr.Chatbot(label="Conversation")
-                user_input = gr.Textbox(label="Your message")
-                send_message_button = gr.Button("Send Message")
-                regenerate_button = gr.Button("Regenerate Last Message")
-                save_chat_button = gr.Button("Save This Chat")
-                save_status = gr.Textbox(label="Save Status", interactive=False)
-
-    character_data = gr.State(None)
-
-    def import_chat_history(file, current_history, char_data):
-        loaded_history, char_name = load_chat_history(file)
-        if loaded_history is None:
-            return current_history, char_data, "Failed to load chat history."
-
-        # Check if the loaded chat is for the current character
-        if char_data and char_data.get('name') != char_name:
-            return current_history, char_data, f"Warning: Loaded chat is for character '{char_name}', but current character is '{char_data.get('name')}'. Chat not imported."
-
-        # If no character is selected, try to load the character from the chat
-        if not char_data:
-            new_char_data = load_character(char_name)[0]
-            if new_char_data:
-                char_data = new_char_data
-            else:
-                return current_history, char_data, f"Warning: Character '{char_name}' not found. Please select the character manually."
-
-        return loaded_history, char_data, f"Chat history for '{char_name}' imported successfully."
-
-    def import_character(file):
-        card_data = import_character_card(file)
-        if card_data:
-            from App_Function_Libraries.Chat import save_character
-            save_character(card_data)
-            return card_data, gr.update(choices=get_character_names())
-        else:
-            return None, gr.update()
-
-    def load_character(name):
-        from App_Function_Libraries.Chat import load_characters
-        characters = load_characters()
-        char_data = characters.get(name)
-        if char_data:
-            first_message = char_data.get('first_mes', "Hello! I'm ready to chat.")
-            return char_data, [(None, first_message)] if first_message else []
-        return None, []
-
-    def character_chat_wrapper(message, history, char_data, api_endpoint, api_key, temperature):
-        logging.debug("Entered character_chat_wrapper")
-        if char_data is None:
-            return "Please select a character first.", history
-
-        # Prepare the character's background information
-        char_background = f"""
-        Name: {char_data.get('name', 'Unknown')}
-        Description: {char_data.get('description', 'N/A')}
-        Personality: {char_data.get('personality', 'N/A')}
-        Scenario: {char_data.get('scenario', 'N/A')}
-        """
-
-        # Prepare the system prompt for character impersonation
-        system_message = f"""You are roleplaying as the character described below. Respond to the user's messages in character, maintaining the personality and background provided. Do not break character or refer to yourself as an AI.
-
-        {char_background}
-
-        Additional instructions: {char_data.get('post_history_instructions', '')}
-        """
-
-        # Prepare media_content and selected_parts
-        media_content = {
-            'id': char_data.get('name'),
-            'title': char_data.get('name', 'Unknown Character'),
-            'content': char_background,
-            'description': char_data.get('description', ''),
-            'personality': char_data.get('personality', ''),
-            'scenario': char_data.get('scenario', '')
-        }
-        selected_parts = ['description', 'personality', 'scenario']
-
-        prompt = char_data.get('post_history_instructions', '')
-
-        # Prepare the input for the chat function
-        if not history:
-            full_message = f"{prompt}\n\n{message}" if prompt else message
-        else:
-            full_message = message
-
-        # Call the chat function
-        bot_message = chat(
-            message,
-            history,
-            media_content,
-            selected_parts,
-            api_endpoint,
-            api_key,
-            prompt,
-            temperature,
-            system_message
-        )
-
-        # Update history
-        history.append((message, bot_message))
-        return history
-
-    def save_chat_history(history, character_name):
-        # Create the Saved_Chats folder if it doesn't exist
-        save_directory = "Saved_Chats"
-        os.makedirs(save_directory, exist_ok=True)
-
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"chat_history_{character_name}_{timestamp}.json"
-        filepath = os.path.join(save_directory, filename)
-
-        chat_data = {
-            "character": character_name,
-            "timestamp": timestamp,
-            "history": history
-        }
-
-        try:
-            with open(filepath, 'w', encoding='utf-8') as f:
-                json.dump(chat_data, f, ensure_ascii=False, indent=2)
-            return filepath
-        except Exception as e:
-            return f"Error saving chat: {str(e)}"
-
-    def save_current_chat(history, char_data):
-        if not char_data or not history:
-            return "No chat to save or character not selected."
-
-        character_name = char_data.get('name', 'Unknown')
-        result = save_chat_history(history, character_name)
-        if result.startswith("Error"):
-            return result
-        return f"Chat saved successfully as {result}"
-
-    def regenerate_last_message(history, char_data, api_name, api_key, temperature):
-        if not history:
-            return history
-
-        last_user_message = history[-1][0]
-        new_history = history[:-1]
-
-        return character_chat_wrapper(last_user_message, new_history, char_data, api_name, api_key, temperature)
-
-    import_chat_button.click(
-        fn=lambda: gr.update(visible=True),
-        outputs=chat_file_upload
-    )
-
-    chat_file_upload.change(
-        fn=import_chat_history,
-        inputs=[chat_file_upload, chat_history, character_data],
-        outputs=[chat_history, character_data, save_status]
-    )
-
-    import_card_button.click(
-        fn=import_character,
-        inputs=[character_card_upload],
-        outputs=[character_data, character_dropdown]
-    )
-
-    load_characters_button.click(
-        fn=lambda: gr.update(choices=get_character_names()),
-        outputs=character_dropdown
-    )
-
-    character_dropdown.change(
-        fn=load_character,
-        inputs=[character_dropdown],
-        outputs=[character_data, chat_history]
-    )
-
-    send_message_button.click(
-        fn=character_chat_wrapper,
-        inputs=[user_input, chat_history, character_data, api_name_input, api_key_input, temperature_slider],
-        outputs=[chat_history]
-    ).then(lambda: "", outputs=user_input)
-
-    regenerate_button.click(
-        fn=regenerate_last_message,
-        inputs=[chat_history, character_data, api_name_input, api_key_input, temperature_slider],
-        outputs=[chat_history]
-    )
-
-    save_chat_button.click(
-        fn=save_current_chat,
-        inputs=[chat_history, character_data],
-        outputs=[save_status]
-    )
-
-    return character_data, chat_history, user_input
-
 
 def create_mikupad_tab():
     with gr.TabItem("Mikupad"):