Upload 13 files

App_Function_Libraries/Gradio_UI/Arxiv_tab.py

@@ -0,0 +1,230 @@
+# Arxiv_tab.py
+# Description: This file contains the Gradio UI for searching, browsing, and ingesting arXiv papers.
+#
+# Imports
+import tempfile
+from datetime import datetime
+import requests
+
+from App_Function_Libraries.PDF.PDF_Ingestion_Lib import extract_text_and_format_from_pdf
+#
+# Local Imports
+from App_Function_Libraries.Third_Party.Arxiv import convert_xml_to_markdown, fetch_arxiv_xml, parse_arxiv_feed, \
+    build_query_url, ARXIV_PAGE_SIZE, fetch_arxiv_pdf_url
+from App_Function_Libraries.DB.DB_Manager import add_media_with_keywords
+#
+import gradio as gr
+#
+#####################################################################################################
+#
+# Functions:
+
+def create_arxiv_tab():
+    with gr.TabItem("Arxiv Search & Ingest"):
+        gr.Markdown("# arXiv Search, Browse, Download, and Ingest")
+        gr.Markdown("#### Thank you to arXiv for use of its open access interoperability.")
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Search Inputs
+                with gr.Row():
+                    with gr.Column():
+                        search_query = gr.Textbox(label="Search Query", placeholder="e.g., machine learning")
+                        author_filter = gr.Textbox(label="Author", placeholder="e.g., John Doe")
+                        year_filter = gr.Number(label="Year", precision=0)
+                        search_button = gr.Button("Search")
+
+            with gr.Column(scale=2):
+                # Pagination Controls
+                    paper_selector = gr.Radio(label="Select a Paper", choices=[], interactive=True)
+                    prev_button = gr.Button("Previous Page")
+                    next_button = gr.Button("Next Page")
+                    page_info = gr.Textbox(label="Page", value="1", interactive=False)
+
+        # Ingestion Section
+        with gr.Row():
+            with gr.Column():
+                # Paper Details View
+                paper_view = gr.Markdown(label="Paper Details")
+                arxiv_keywords = gr.Textbox(label="Additional Keywords (comma-separated)",
+                                            placeholder="e.g., AI, Deep Learning")
+                ingest_button = gr.Button("Ingest Selected Paper")
+                ingest_result = gr.Textbox(label="Ingestion Result", interactive=False)
+
+        # Define States for Pagination and Selection
+        state = gr.State(value={"start": 0, "current_page": 1, "last_query": None, "entries": []})
+        selected_paper_id = gr.State(value=None)
+
+        def search_arxiv(query, author, year):
+            start = 0
+            url = build_query_url(query, author, year, start)
+            try:
+                response = requests.get(url)
+                response.raise_for_status()
+            except requests.exceptions.RequestException as e:
+                return gr.update(value=[]), gr.update(value=f"**Error:** {str(e)}"), state.value
+
+            entries = parse_arxiv_feed(response.text)
+            state.value = {"start": start, "current_page": 1, "last_query": (query, author, year), "entries": entries}
+            if not entries:
+                return gr.update(value=[]), "No results found.", state.value
+
+            # Update the dropdown with paper titles for selection
+            titles = [entry['title'] for entry in entries]
+            return gr.update(choices=titles), "1", state.value
+
+        # Dead code? FIXME
+        def handle_pagination(direction):
+            current_state = state.value
+            query, author, year = current_state["last_query"]
+            new_page = current_state["current_page"] + direction
+            if new_page < 1:
+                new_page = 1
+            start = (new_page - 1) * ARXIV_PAGE_SIZE
+            url = build_query_url(query, author, year, start)
+            try:
+                response = requests.get(url)
+                response.raise_for_status()
+            except requests.exceptions.RequestException as e:
+                return gr.update(), gr.update()
+
+            entries = parse_arxiv_feed(response.text)
+            if entries:
+                current_state["start"] = start
+                current_state["current_page"] = new_page
+                current_state["entries"] = entries
+                state.value = current_state
+
+                # Update the dropdown with paper titles for the new page
+                titles = [entry['title'] for entry in entries]
+                return gr.update(choices=titles), str(new_page)
+            else:
+                # If no entries, do not change the page
+                return gr.update(), gr.update()
+
+        def load_selected_paper(selected_title):
+            if not selected_title:
+                return "Please select a paper to view."
+
+            # Find the selected paper from state
+            for entry in state.value["entries"]:
+                if entry['title'] == selected_title:
+                    paper_id = entry['id']
+                    break
+            else:
+                return "Paper not found."
+
+            try:
+                # Fetch the PDF URL and download the full-text
+                pdf_url = fetch_arxiv_pdf_url(paper_id)
+                response = requests.get(pdf_url)
+                response.raise_for_status()
+
+                # Save the PDF temporarily
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_pdf:
+                    temp_pdf.write(response.content)
+                    temp_pdf_path = temp_pdf.name
+
+                # Convert PDF to markdown using your PDF ingestion function
+                full_text_markdown = extract_text_and_format_from_pdf(temp_pdf_path)
+
+                selected_paper_id.value = paper_id
+                return full_text_markdown
+            except Exception as e:
+                return f"Error loading full paper: {str(e)}"
+
+        def process_and_ingest_arxiv_paper(paper_id, additional_keywords):
+            try:
+                if not paper_id:
+                    return "Please select a paper to ingest."
+
+                # Fetch the PDF URL
+                pdf_url = fetch_arxiv_pdf_url(paper_id)
+
+                # Download the PDF
+                response = requests.get(pdf_url)
+                response.raise_for_status()
+
+                # Save the PDF temporarily
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_pdf:
+                    temp_pdf.write(response.content)
+                    temp_pdf_path = temp_pdf.name
+
+                # Convert PDF to markdown using your PDF ingestion function
+                markdown_text = extract_text_and_format_from_pdf(temp_pdf_path)
+
+                # Fetch metadata from arXiv to get title, authors, and categories
+                xml_content = fetch_arxiv_xml(paper_id)
+                _, title, authors, categories = convert_xml_to_markdown(xml_content)
+
+                # Prepare the arXiv paper URL for access/download
+                paper_url = f"https://arxiv.org/abs/{paper_id}"
+
+                # Prepare the keywords for ingestion
+                keywords = f"arxiv,{','.join(categories)}"
+                if additional_keywords:
+                    keywords += f",{additional_keywords}"
+
+                # Ingest full paper markdown content
+                add_media_with_keywords(
+                    url=paper_url,
+                    title=title,
+                    media_type='document',
+                    content=markdown_text,  # Full paper content in markdown
+                    keywords=keywords,
+                    prompt='No prompt for arXiv papers',
+                    summary='Full arXiv paper ingested from PDF',
+                    transcription_model='None',
+                    author=', '.join(authors),
+                    ingestion_date=datetime.now().strftime('%Y-%m-%d')
+                )
+
+                # Return success message with paper title and authors
+                return f"arXiv paper '{title}' by {', '.join(authors)} ingested successfully."
+            except Exception as e:
+                # Return error message if anything goes wrong
+                return f"Error processing arXiv paper: {str(e)}"
+
+        # Event Handlers
+        # Connect Search Button
+        search_button.click(
+            fn=search_arxiv,
+            inputs=[search_query, author_filter, year_filter],
+            outputs=[paper_selector, page_info, state],
+            queue=True
+        )
+
+        # Connect Next Button
+        next_button.click(
+            fn=lambda: handle_pagination(1),
+            inputs=None,
+            outputs=[paper_selector, page_info],
+            queue=True
+        )
+
+        # Connect Previous Button
+        prev_button.click(
+            fn=lambda: handle_pagination(-1),
+            inputs=None,
+            outputs=[paper_selector, page_info],
+            queue=True
+        )
+
+        # When the user selects a paper in the Dropdown
+        paper_selector.change(
+            fn=load_selected_paper,
+            inputs=paper_selector,
+            outputs=paper_view,
+            queue=True
+        )
+
+        # Connect Ingest Button
+        ingest_button.click(
+            fn=process_and_ingest_arxiv_paper,
+            inputs=[selected_paper_id, arxiv_keywords],
+            outputs=ingest_result,
+            queue=True
+        )
+
+#
+# End of File
+#####################################################################################################

App_Function_Libraries/Gradio_UI/Character_Chat_tab.py

@@ -0,0 +1,1318 @@
+# Character_Interaction_Library_3.py
+# Description: Library for character card import functions
+#
+# Imports
+import re
+import uuid
+from datetime import datetime
+import json
+import logging
+import io
+import base64
+from typing import Dict, Any, Optional, List, Tuple, Union, cast
+#
+# External Imports
+from PIL import Image
+import gradio as gr
+#
+# Local Imports
+from App_Function_Libraries.Chat import chat
+from App_Function_Libraries.DB.Character_Chat_DB import (
+    add_character_card,
+    get_character_cards,
+    get_character_card_by_id,
+    add_character_chat,
+    get_character_chats,
+    get_character_chat_by_id,
+    update_character_chat,
+    delete_character_chat,
+    delete_character_card,
+    update_character_card, search_character_chats,
+)
+from App_Function_Libraries.Utils.Utils import sanitize_user_input
+#
+############################################################################################################
+#
+# Functions:
+
+
+#################################################################################
+#
+# Placeholder functions:
+
+def replace_placeholders(text: str, char_name: str, user_name: str) -> str:
+    """
+    Replace placeholders in the given text with appropriate values.
+
+    Args:
+        text (str): The text containing placeholders.
+        char_name (str): The name of the character.
+        user_name (str): The name of the user.
+
+    Returns:
+        str: The text with placeholders replaced.
+    """
+    replacements = {
+        '{{char}}': char_name,
+        '{{user}}': user_name,
+        '{{random_user}}': user_name  # Assuming random_user is the same as user for simplicity
+    }
+
+    for placeholder, value in replacements.items():
+        text = text.replace(placeholder, value)
+
+    return text
+
+def replace_user_placeholder(history, user_name):
+    """
+    Replaces all instances of '{{user}}' in the chat history with the actual user name.
+
+    Args:
+        history (list): The current chat history as a list of tuples (user_message, bot_message).
+        user_name (str): The name entered by the user.
+
+    Returns:
+        list: Updated chat history with placeholders replaced.
+    """
+    if not user_name:
+        user_name = "User"  # Default name if none provided
+
+    updated_history = []
+    for user_msg, bot_msg in history:
+        # Replace in user message
+        if user_msg:
+            user_msg = user_msg.replace("{{user}}", user_name)
+        # Replace in bot message
+        if bot_msg:
+            bot_msg = bot_msg.replace("{{user}}", user_name)
+        updated_history.append((user_msg, bot_msg))
+    return updated_history
+
+#
+# End of Placeholder functions
+#################################################################################
+
+def import_character_card(file):
+    if file is None:
+        return None, gr.update(), "No file provided for character card import"
+
+    try:
+        if file.name.lower().endswith(('.png', '.webp')):
+            json_data = extract_json_from_image(file)
+            if not json_data:
+                return None, gr.update(), "No JSON data found in the image."
+        elif file.name.lower().endswith('.json'):
+            with open(file.name, 'r', encoding='utf-8') as f:
+                json_data = f.read()
+        else:
+            return None, gr.update(), "Unsupported file type. Please upload a PNG/WebP image or a JSON file."
+
+        card_data = import_character_card_json(json_data)
+        if not card_data:
+            return None, gr.update(), "Failed to parse character card JSON."
+
+        # Save image data for PNG/WebP files
+        if file.name.lower().endswith(('.png', '.webp')):
+            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')
+
+        # Save character card to database
+        character_id = add_character_card(card_data)
+        if character_id:
+            characters = get_character_cards()
+            character_names = [char['name'] for char in characters]
+            return card_data, gr.update(
+                choices=character_names), f"Character card '{card_data['name']}' imported successfully."
+        else:
+            return None, gr.update(), f"Failed to save character card '{card_data.get('name', 'Unknown')}'. It may already exist."
+    except Exception as e:
+        logging.error(f"Error importing character card: {e}")
+        return None, gr.update(), f"Error importing character card: {e}"
+
+def import_character_card_json(json_content: str) -> Optional[Dict[str, Any]]:
+    try:
+        json_content = json_content.strip()
+        card_data = json.loads(json_content)
+
+        if 'spec' in card_data and card_data['spec'] == 'chara_card_v2':
+            logging.info("Detected V2 character card")
+            return parse_v2_card(card_data)
+        else:
+            logging.info("Assuming V1 character card")
+            return parse_v1_card(card_data)
+    except json.JSONDecodeError as e:
+        logging.error(f"JSON decode error: {e}")
+    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.warning("'chara' not found in metadata, attempting to find JSON data in image bytes")
+            # Alternative method to extract embedded JSON from image bytes if metadata is not available
+            img_byte_arr = io.BytesIO()
+            img.save(img_byte_arr, format='PNG')
+            img_bytes = img_byte_arr.getvalue()
+            img_str = img_bytes.decode('latin1')  # Use 'latin1' to preserve byte values
+
+            # Search for JSON-like structures in the image bytes
+            json_start = img_str.find('{')
+            json_end = img_str.rfind('}')
+            if json_start != -1 and json_end != -1 and json_end > json_start:
+                possible_json = img_str[json_start:json_end+1]
+                try:
+                    json.loads(possible_json)
+                    logging.debug("Found JSON data in image bytes")
+                    return possible_json
+                except json.JSONDecodeError:
+                    logging.debug("No valid JSON found in image bytes")
+
+            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 process_chat_history(chat_history: List[Tuple[str, str]], char_name: str, user_name: str) -> List[Tuple[str, str]]:
+    """
+    Process the chat history to replace placeholders in both user and character messages.
+
+    Args:
+        chat_history (List[Tuple[str, str]]): The chat history.
+        char_name (str): The name of the character.
+        user_name (str): The name of the user.
+
+    Returns:
+        List[Tuple[str, str]]: The processed chat history.
+    """
+    processed_history = []
+    for user_msg, char_msg in chat_history:
+        if user_msg:
+            user_msg = replace_placeholders(user_msg, char_name, user_name)
+        if char_msg:
+            char_msg = replace_placeholders(char_msg, char_name, user_name)
+        processed_history.append((user_msg, char_msg))
+    return processed_history
+
+def parse_v2_card(card_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    try:
+        # Validate spec_version
+        if card_data.get('spec_version') != '2.0':
+            logging.warning(f"Unsupported V2 spec version: {card_data.get('spec_version')}")
+            return None
+
+        data = card_data['data']
+
+        # Ensure all required fields are present
+        required_fields = ['name', 'description', 'personality', 'scenario', 'first_mes', 'mes_example']
+        for field in required_fields:
+            if field not in data:
+                logging.error(f"Missing required field in V2 card: {field}")
+                return None
+
+        # Handle new V2 fields
+        parsed_data = {
+            'name': data['name'],
+            'description': data['description'],
+            'personality': data['personality'],
+            'scenario': data['scenario'],
+            'first_mes': data['first_mes'],
+            'mes_example': data['mes_example'],
+            'creator_notes': data.get('creator_notes', ''),
+            'system_prompt': data.get('system_prompt', ''),
+            'post_history_instructions': data.get('post_history_instructions', ''),
+            'alternate_greetings': data.get('alternate_greetings', []),
+            'tags': data.get('tags', []),
+            'creator': data.get('creator', ''),
+            'character_version': data.get('character_version', ''),
+            'extensions': data.get('extensions', {})
+        }
+
+        # Handle character_book if present
+        if 'character_book' in data:
+            parsed_data['character_book'] = parse_character_book(data['character_book'])
+
+        return parsed_data
+    except KeyError as e:
+        logging.error(f"Missing key in V2 card structure: {e}")
+    except Exception as e:
+        logging.error(f"Error parsing V2 card: {e}")
+    return None
+
+def parse_v1_card(card_data: Dict[str, Any]) -> Dict[str, Any]:
+    # Ensure all required V1 fields are present
+    required_fields = ['name', 'description', 'personality', 'scenario', 'first_mes', 'mes_example']
+    for field in required_fields:
+        if field not in card_data:
+            logging.error(f"Missing required field in V1 card: {field}")
+            raise ValueError(f"Missing required field in V1 card: {field}")
+
+    # Convert V1 to V2 format
+    v2_data: Dict[str, Union[str, List[str], Dict[str, Any]]] = {
+        'name': card_data['name'],
+        'description': card_data['description'],
+        'personality': card_data['personality'],
+        'scenario': card_data['scenario'],
+        'first_mes': card_data['first_mes'],
+        'mes_example': card_data['mes_example'],
+        'creator_notes': cast(str, card_data.get('creator_notes', '')),
+        'system_prompt': cast(str, card_data.get('system_prompt', '')),
+        'post_history_instructions': cast(str, card_data.get('post_history_instructions', '')),
+        'alternate_greetings': cast(List[str], card_data.get('alternate_greetings', [])),
+        'tags': cast(List[str], card_data.get('tags', [])),
+        'creator': cast(str, card_data.get('creator', '')),
+        'character_version': cast(str, card_data.get('character_version', '')),
+        'extensions': {}
+    }
+
+    # Move any non-standard V1 fields to extensions
+    for key, value in card_data.items():
+        if key not in v2_data:
+            v2_data['extensions'][key] = value
+
+    return v2_data
+
+def extract_character_id(choice: str) -> int:
+    """Extract the character ID from the dropdown selection string."""
+    return int(choice.split('(ID: ')[1].rstrip(')'))
+
+def load_character_wrapper(character_id: int, user_name: str) -> Tuple[Dict[str, Any], List[Tuple[Optional[str], str]], Optional[Image.Image]]:
+    """Wrapper function to load character and image using the extracted ID."""
+    char_data, chat_history, img = load_character_and_image(character_id, user_name)
+    return char_data, chat_history, img
+
+def parse_character_book(book_data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Parse the character book data from a V2 character card.
+
+    Args:
+        book_data (Dict[str, Any]): The raw character book data from the character card.
+
+    Returns:
+        Dict[str, Any]: The parsed and structured character book data.
+    """
+    parsed_book = {
+        'name': book_data.get('name', ''),
+        'description': book_data.get('description', ''),
+        'scan_depth': book_data.get('scan_depth'),
+        'token_budget': book_data.get('token_budget'),
+        'recursive_scanning': book_data.get('recursive_scanning', False),
+        'extensions': book_data.get('extensions', {}),
+        'entries': []
+    }
+
+    for entry in book_data.get('entries', []):
+        parsed_entry = {
+            'keys': entry['keys'],
+            'content': entry['content'],
+            'extensions': entry.get('extensions', {}),
+            'enabled': entry['enabled'],
+            'insertion_order': entry['insertion_order'],
+            'case_sensitive': entry.get('case_sensitive', False),
+            'name': entry.get('name', ''),
+            'priority': entry.get('priority'),
+            'id': entry.get('id'),
+            'comment': entry.get('comment', ''),
+            'selective': entry.get('selective', False),
+            'secondary_keys': entry.get('secondary_keys', []),
+            'constant': entry.get('constant', False),
+            'position': entry.get('position')
+        }
+        parsed_book['entries'].append(parsed_entry)
+
+    return parsed_book
+
+def load_character_and_image(character_id: int, user_name: str) -> Tuple[Optional[Dict[str, Any]], List[Tuple[Optional[str], str]], Optional[Image.Image]]:
+    """
+    Load a character and its associated image based on the character ID.
+
+    Args:
+        character_id (int): The ID of the character to load.
+        user_name (str): The name of the user, used for placeholder replacement.
+
+    Returns:
+        Tuple[Optional[Dict[str, Any]], List[Tuple[Optional[str], str]], Optional[Image.Image]]:
+        A tuple containing the character data, chat history, and character image (if available).
+    """
+    try:
+        char_data = get_character_card_by_id(character_id)
+        if not char_data:
+            logging.warning(f"No character data found for ID: {character_id}")
+            return None, [], None
+
+        # Replace placeholders in character data
+        for field in ['first_mes', 'mes_example', 'scenario', 'description', 'personality']:
+            if field in char_data:
+                char_data[field] = replace_placeholders(char_data[field], char_data['name'], user_name)
+
+        # Replace placeholders in first_mes
+        first_mes = char_data.get('first_mes', "Hello! I'm ready to chat.")
+        first_mes = replace_placeholders(first_mes, char_data['name'], user_name)
+
+        chat_history = [(None, first_mes)] if first_mes else []
+
+        img = None
+        if char_data.get('image'):
+            try:
+                image_data = base64.b64decode(char_data['image'])
+                img = Image.open(io.BytesIO(image_data)).convert("RGBA")
+            except Exception as e:
+                logging.error(f"Error processing image for character '{char_data['name']}': {e}")
+
+        return char_data, chat_history, img
+
+    except Exception as e:
+        logging.error(f"Error in load_character_and_image: {e}")
+        return None, [], None
+
+def load_chat_and_character(chat_id: int, user_name: str) -> Tuple[Optional[Dict[str, Any]], List[Tuple[str, str]], Optional[Image.Image]]:
+    """
+    Load a chat and its associated character, including the character image and process templates.
+
+    Args:
+        chat_id (int): The ID of the chat to load.
+        user_name (str): The name of the user.
+
+    Returns:
+        Tuple[Optional[Dict[str, Any]], List[Tuple[str, str]], Optional[Image.Image]]:
+        A tuple containing the character data, processed chat history, and character image (if available).
+    """
+    try:
+        # Load the chat
+        chat = get_character_chat_by_id(chat_id)
+        if not chat:
+            logging.warning(f"No chat found with ID: {chat_id}")
+            return None, [], None
+
+        # Load the associated character
+        character_id = chat['character_id']
+        char_data = get_character_card_by_id(character_id)
+        if not char_data:
+            logging.warning(f"No character found for chat ID: {chat_id}")
+            return None, chat['chat_history'], None
+
+        # Process the chat history
+        processed_history = process_chat_history(chat['chat_history'], char_data['name'], user_name)
+
+        # Load the character image
+        img = None
+        if char_data.get('image'):
+            try:
+                image_data = base64.b64decode(char_data['image'])
+                img = Image.open(io.BytesIO(image_data)).convert("RGBA")
+            except Exception as e:
+                logging.error(f"Error processing image for character '{char_data['name']}': {e}")
+
+        # Process character data templates
+        for field in ['first_mes', 'mes_example', 'scenario', 'description', 'personality']:
+            if field in char_data:
+                char_data[field] = replace_placeholders(char_data[field], char_data['name'], user_name)
+
+        return char_data, processed_history, img
+
+    except Exception as e:
+        logging.error(f"Error in load_chat_and_character: {e}")
+        return None, [], None
+
+
+def load_chat_history(file):
+    try:
+        content = file.read().decode('utf-8')
+        chat_data = json.loads(content)
+
+        # Extract history and character name from the loaded data
+        history = chat_data.get('history') or chat_data.get('messages')
+        character_name = chat_data.get('character') or chat_data.get('character_name')
+
+        if not history or not character_name:
+            logging.error("Chat history or character name missing in the imported file.")
+            return None, None
+
+        return history, character_name
+    except Exception as e:
+        logging.error(f"Error loading chat history: {e}")
+        return None, None
+
+####################################################
+#
+# Gradio tabs
+
+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="pil")
+                character_card_upload = gr.File(
+                    label="Upload Character Card (PNG, WEBP, JSON)",
+                    file_types=[".png", ".webp", ".json"]
+                )
+                import_card_button = gr.Button("Import Character Card")
+                load_characters_button = gr.Button("Load Existing Characters")
+                character_dropdown = gr.Dropdown(label="Select Character", choices=[])
+                user_name_input = gr.Textbox(label="Your Name", placeholder="Enter your name here")
+                api_name_input = gr.Dropdown(
+                    choices=[
+                        "Local-LLM", "OpenAI", "Anthropic", "Cohere", "Groq", "DeepSeek", "Mistral",
+                        "OpenRouter", "Llama.cpp", "Kobold", "Ooba", "Tabbyapi", "VLLM", "ollama", "HuggingFace",
+                        "Custom-OpenAI-API"
+                    ],
+                    value="HuggingFace",
+                    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=True)
+
+                # Chat History Import and Search
+                gr.Markdown("## Search and Load Existing Chats")
+                chat_search_query = gr.Textbox(
+                    label="Search Chats",
+                    placeholder="Enter chat name or keywords to search"
+                )
+                chat_search_button = gr.Button("Search Chats")
+                chat_search_dropdown = gr.Dropdown(label="Search Results", choices=[], visible=False)
+                load_chat_button = gr.Button("Load Selected Chat", visible=False)
+
+                # Checkbox to Decide Whether to Save Chats by Default
+                auto_save_checkbox = gr.Checkbox(label="Save chats automatically", value=True)
+                chat_media_name = gr.Textbox(label="Custom Chat Name (optional)", visible=True)
+                save_chat_history_to_db = gr.Button("Save Chat History to Database")
+                save_status = gr.Textbox(label="Save Status", interactive=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_snapshot_button = gr.Button("Save Chat Snapshot")
+                update_chat_dropdown = gr.Dropdown(label="Select Chat to Update", choices=[], visible=False)
+                load_selected_chat_button = gr.Button("Load Selected Chat", visible=False)
+                update_chat_button = gr.Button("Update Selected Chat", visible=False)
+
+        # States
+        character_data = gr.State(None)
+        user_name = gr.State("")
+        selected_chat_id = gr.State(None)  # To track the selected chat for updates
+
+        # Callback Functions
+
+        def search_existing_chats(query):
+            results, message = search_character_chats(query)
+            if results:
+                # Format search results for dropdown
+                formatted_results = [
+                    f"{chat['conversation_name']} (ID: {chat['id']})" for chat in results
+                ]
+            else:
+                formatted_results = []
+            return formatted_results, message
+
+        def load_selected_chat_from_search(selected_chat, user_name):
+            if not selected_chat:
+                return None, [], None, "No chat selected."
+
+            try:
+                chat_id_match = re.search(r'\(ID:\s*(\d+)\)', selected_chat)
+                if not chat_id_match:
+                    return None, [], None, "Invalid chat selection format."
+
+                chat_id = int(chat_id_match.group(1))
+
+                # Use the new function to load chat and character data
+                char_data, chat_history, img = load_chat_and_character(chat_id, user_name)
+
+                if not char_data:
+                    return None, [], None, "Failed to load character data for the selected chat."
+
+                return char_data, chat_history, img, f"Chat '{selected_chat}' loaded successfully."
+            except Exception as e:
+                logging.error(f"Error loading selected chat: {e}")
+                return None, [], None, f"Error loading chat: {e}"
+
+
+        def import_chat_history(file, current_history, char_data, user_name_val):
+            """
+            Imports chat history from a file, replacing '{{user}}' with the actual user name.
+
+            Args:
+                file (file): The uploaded chat history file.
+                current_history (list): The current chat history.
+                char_data (dict): The current character data.
+                user_name_val (str): The user's name.
+
+            Returns:
+                tuple: Updated chat history, updated character data, and a status message.
+            """
+            loaded_history, char_name = load_chat_history(file)
+            if loaded_history is None:
+                return current_history, char_data, "Failed to load chat history."
+
+            # Replace '{{user}}' in the loaded chat history
+            loaded_history = replace_user_placeholder(loaded_history, user_name_val)
+
+            # 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}', "
+                    f"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:
+                characters = get_character_cards()
+                character = next((char for char in characters if char['name'] == char_name), None)
+                if character:
+                    char_data = character
+                    # Replace '{{user}}' in the first_message if necessary
+                    if character.get('first_message'):
+                        character['first_message'] = character['first_message'].replace("{{user}}",
+                                                                                        user_name_val if user_name_val else "User")
+                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 load_character(name):
+            characters = get_character_cards()
+            character = next((char for char in characters if char['name'] == name), None)
+            if character:
+                first_message = character.get('first_message', "Hello! I'm ready to chat.")
+                return character, [(None, first_message)] if first_message else [], None
+            return None, [], None
+
+        def load_character_image(name):
+            character = next((char for char in get_character_cards() if char['name'] == name), None)
+            if character and 'image' in character and character['image']:
+                try:
+                    # Decode the base64 image
+                    image_data = base64.b64decode(character['image'])
+                    # Load as PIL Image
+                    img = Image.open(io.BytesIO(image_data)).convert("RGBA")
+                    return img
+                except Exception as e:
+                    logging.error(f"Error loading image for character '{name}': {e}")
+                    return None
+            return None
+
+        def character_chat_wrapper(
+                message, history, char_data, api_endpoint, api_key,
+                temperature, user_name_val, auto_save
+        ):
+            if not char_data:
+                return history, "Please select a character first."
+
+            user_name_val = user_name_val or "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
+            system_message = f"""You are roleplaying as {char_name}. {char_data.get('system_prompt', '')}"""
+
+            # Prepare chat context
+            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', '')
+
+            # Sanitize and format user message
+            user_message = sanitize_user_input(message)
+            user_message = replace_placeholders(user_message, char_name, user_name_val)
+            full_message = f"{user_name_val}: {user_message}"
+
+            # Generate bot response
+            bot_message = chat(
+                full_message,
+                history,
+                media_content,
+                selected_parts,
+                api_endpoint,
+                api_key,
+                prompt,
+                temperature,
+                system_message
+            )
+
+            # Replace placeholders in bot message
+            bot_message = replace_placeholders(bot_message, char_name, user_name_val)
+
+            # Update history
+            history.append((user_message, bot_message))
+
+            # Auto-save if enabled
+            save_status = ""
+            if auto_save:
+                character_id = char_data.get('id')
+                if character_id:
+                    conversation_name = f"Auto-saved chat {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+                    add_character_chat(character_id, conversation_name, history)
+                    save_status = "Chat auto-saved."
+                else:
+                    save_status = "Character ID not found; chat not saved."
+
+            return history, save_status
+
+        def save_chat_history_to_db_wrapper(
+            chat_history, conversation_id, media_content,
+            chat_media_name, char_data, auto_save
+        ):
+            if not char_data or not chat_history:
+                return "No character or chat history available.", ""
+
+            character_id = char_data.get('id')
+            if not character_id:
+                return "Character ID not found.", ""
+
+            conversation_name = chat_media_name or f"Chat {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+            chat_id = add_character_chat(character_id, conversation_name, chat_history)
+            if chat_id:
+                return f"Chat saved successfully with ID {chat_id}.", ""
+            else:
+                return "Failed to save chat.", ""
+
+        def update_character_info(name):
+            return load_character_and_image(name, user_name.value)
+
+        def on_character_select(name, user_name_val):
+            logging.debug(f"Character selected: {name}")
+            char_data, chat_history, img = load_character_and_image(name, user_name_val)
+            return char_data, chat_history, img
+
+        def clear_chat_history(char_data, user_name_val):
+            """
+            Clears the chat history and initializes it with the character's first message,
+            replacing the '{{user}}' placeholder with the actual user name.
+
+            Args:
+                char_data (dict): The current character data.
+                user_name_val (str): The user's name.
+
+            Returns:
+                tuple: Updated chat history and the unchanged char_data.
+            """
+            if char_data and 'first_message' in char_data and char_data['first_message']:
+                # Replace '{{user}}' in the first_message
+                first_message = char_data['first_message'].replace("{{user}}",
+                                                                   user_name_val if user_name_val else "User")
+                # Initialize chat history with the updated first_message
+                return [(None, first_message)], char_data
+            else:
+                # If no first_message is defined, simply clear the chat
+                return [], char_data
+
+        def regenerate_last_message(
+                history, char_data, api_endpoint, api_key,
+                temperature, user_name_val, auto_save
+        ):
+            """
+            Regenerates the last bot message by removing it and resending the corresponding user message.
+
+            Args:
+                history (list): The current chat history as a list of tuples (user_message, bot_message).
+                char_data (dict): The current character data.
+                api_endpoint (str): The API endpoint to use for the LLM.
+                api_key (str): The API key for authentication.
+                temperature (float): The temperature setting for the LLM.
+                user_name_val (str): The user's name.
+                auto_save (bool): Flag indicating whether to auto-save the chat.
+
+            Returns:
+                tuple: Updated chat history and a save status message.
+            """
+            if not history:
+                return history, "No messages to regenerate."
+
+            last_entry = history[-1]
+            last_user_message, last_bot_message = last_entry
+
+            # Check if the last bot message exists
+            if last_bot_message is None:
+                return history, "The last message is not from the bot."
+
+            # Remove the last bot message
+            new_history = history[:-1]
+
+            # Resend the last user message to generate a new bot response
+            if not last_user_message:
+                return new_history, "No user message to regenerate the bot response."
+
+            # Prepare the character's background information
+            char_name = char_data.get('name', 'AI Assistant')
+            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_val}".
+
+            {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
+            full_message = f"{user_name_val}: {last_user_message}" if last_user_message else f"{user_name_val}: "
+
+            # Call the chat function to get a new bot message
+            bot_message = chat(
+                full_message,
+                new_history,
+                media_content,
+                selected_parts,
+                api_endpoint,
+                api_key,
+                prompt,
+                temperature,
+                system_message
+            )
+
+            # Append the new bot message to the history
+            new_history.append((last_user_message, bot_message))
+
+            # Auto-save if enabled
+            if auto_save:
+                character_id = char_data.get('id')
+                if character_id:
+                    conversation_name = f"Auto-saved chat {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+                    add_character_chat(character_id, conversation_name, new_history)
+                    save_status = "Chat auto-saved."
+                else:
+                    save_status = "Character ID not found; chat not saved."
+            else:
+                save_status = ""
+
+            return new_history, save_status
+
+        def toggle_chat_file_upload():
+            return gr.update(visible=True)
+
+        def save_untracked_chat_action(history, char_data):
+            if not char_data or not history:
+                return "No chat to save or character not selected."
+
+            character_id = char_data.get('id')
+            if not character_id:
+                return "Character ID not found."
+
+            conversation_name = f"Snapshot {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+            chat_id = add_character_chat(character_id, conversation_name, history, is_snapshot=True)
+            if chat_id:
+                return f"Chat snapshot saved successfully with ID {chat_id}."
+            else:
+                return "Failed to save chat snapshot."
+
+        def select_chat_for_update():
+            # Fetch all chats for the selected character
+            if character_data.value:
+                character_id = character_data.value.get('id')
+                if character_id:
+                    chats = get_character_chats(character_id)
+                    chat_choices = [
+                        f"{chat['conversation_name']} (ID: {chat['id']})" for chat in chats
+                    ]
+                    return gr.update(choices=chat_choices), None
+            return gr.update(choices=[]), "No character selected."
+
+        def load_selected_chat(chat_selection):
+            if not chat_selection:
+                return [], "No chat selected."
+
+            try:
+                chat_id = int(chat_selection.split('(ID: ')[1].rstrip(')'))
+                chat = get_character_chat_by_id(chat_id)
+                if chat:
+                    history = chat['chat_history']
+                    selected_chat_id.value = chat_id  # Update the selected_chat_id state
+                    return history, f"Loaded chat '{chat['conversation_name']}' successfully."
+                else:
+                    return [], "Chat not found."
+            except Exception as e:
+                logging.error(f"Error loading selected chat: {e}")
+                return [], f"Error loading chat: {e}"
+
+        def update_chat(chat_id, updated_history):
+            success = update_character_chat(chat_id, updated_history)
+            if success:
+                return "Chat updated successfully."
+            else:
+                return "Failed to update chat."
+
+        # Define States for conversation_id and media_content, which are required for saving chat history
+        conversation_id = gr.State(str(uuid.uuid4()))
+        media_content = gr.State({})
+
+        # Button Callbacks
+
+        import_card_button.click(
+            fn=import_character_card,
+            inputs=[character_card_upload],
+            outputs=[character_data, character_dropdown, save_status]
+        )
+
+        load_characters_button.click(
+            fn=lambda: gr.update(choices=[f"{char['name']} (ID: {char['id']})" for char in get_character_cards()]),
+            outputs=character_dropdown
+        )
+
+        # FIXME user_name_val = validate_user_name(user_name_val)
+        clear_chat_button.click(
+            fn=clear_chat_history,
+            inputs=[character_data, user_name_input],
+            outputs=[chat_history, character_data]
+        )
+
+        character_dropdown.change(
+            fn=extract_character_id,
+            inputs=[character_dropdown],
+            outputs=character_data
+        ).then(
+            fn=load_character_wrapper,
+            inputs=[character_data, user_name_input],
+            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,
+                auto_save_checkbox
+            ],
+            outputs=[chat_history, save_status]
+        ).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,
+                auto_save_checkbox
+            ],
+            outputs=[chat_history, save_status]
+        )
+
+        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]
+        )
+
+        save_chat_history_to_db.click(
+            fn=save_chat_history_to_db_wrapper,
+            inputs=[
+                chat_history,
+                conversation_id,
+                media_content,
+                chat_media_name,
+                character_data,
+                auto_save_checkbox  # Pass the auto_save state
+            ],
+            outputs=[conversation_id, save_status]
+        )
+
+        # Populate the update_chat_dropdown based on selected character
+        character_dropdown.change(
+            fn=select_chat_for_update,
+            inputs=[],
+            outputs=[update_chat_dropdown, save_status]
+        )
+
+        load_selected_chat_button.click(
+            fn=load_selected_chat,
+            inputs=[update_chat_dropdown],
+            outputs=[chat_history, save_status]
+        )
+
+        save_snapshot_button.click(
+            fn=save_untracked_chat_action,
+            inputs=[chat_history, character_data],
+            outputs=save_status
+        )
+
+        update_chat_button.click(
+            fn=update_chat,
+            inputs=[selected_chat_id, chat_history],
+            outputs=save_status
+        )
+
+        # Search Chats
+        chat_search_button.click(
+            fn=search_existing_chats,
+            inputs=[chat_search_query],
+            outputs=[chat_search_dropdown, save_status]
+        ).then(
+            fn=lambda choices, msg: gr.update(choices=choices, visible=True) if choices else gr.update(visible=False),
+            inputs=[chat_search_dropdown, save_status],
+            outputs=[chat_search_dropdown]
+        )
+
+        # Load Selected Chat from Search
+        load_chat_button.click(
+            fn=load_selected_chat_from_search,
+            inputs=[chat_search_dropdown, user_name_input],
+            outputs=[character_data, chat_history, character_image, save_status]
+        )
+
+        # Show Load Chat Button when a chat is selected
+        chat_search_dropdown.change(
+            fn=lambda selected: gr.update(visible=True) if selected else gr.update(visible=False),
+            inputs=[chat_search_dropdown],
+            outputs=[load_chat_button]
+        )
+
+
+        return character_data, chat_history, user_input, user_name, character_image
+
+
+def create_character_chat_mgmt_tab():
+    with gr.TabItem("Chat Management"):
+        gr.Markdown("# Chat Management")
+
+        with gr.Row():
+            # Search Section
+            with gr.Column(scale=1):
+                gr.Markdown("## Search Conversations or Characters")
+                search_query = gr.Textbox(label="Search Conversations or Characters", placeholder="Enter search keywords")
+                search_button = gr.Button("Search")
+                search_results = gr.Dropdown(label="Search Results", choices=[], visible=False)
+                search_status = gr.Markdown("", visible=True)
+
+            # Select Character and Chat Section
+            with gr.Column(scale=1):
+                gr.Markdown("## Select Character and Associated Chats")
+                characters = get_character_cards()
+                character_choices = [f"{char['name']} (ID: {char['id']})" for char in characters]
+                select_character = gr.Dropdown(label="Select Character", choices=character_choices, interactive=True)
+                select_chat = gr.Dropdown(label="Select Chat", choices=[], visible=False, interactive=True)
+                load_chat_button = gr.Button("Load Selected Chat", visible=False)
+
+        with gr.Row():
+            conversation_list = gr.Dropdown(label="Select Conversation or Character", choices=[])
+            conversation_mapping = gr.State({})
+
+        with gr.Tabs():
+            with gr.TabItem("Edit"):
+                chat_content = gr.TextArea(label="Chat/Character Content (JSON)", lines=20, max_lines=50)
+                save_button = gr.Button("Save Changes")
+                delete_button = gr.Button("Delete Conversation/Character", variant="stop")
+
+            with gr.TabItem("Preview"):
+                chat_preview = gr.HTML(label="Chat/Character Preview")
+        result_message = gr.Markdown("")
+
+        # Callback Functions
+
+        def search_conversations_or_characters(query):
+            if not query.strip():
+                return gr.update(choices=[], visible=False), "Please enter a search query."
+
+            try:
+                # Search Chats using FTS5
+                chat_results, chat_message = search_character_chats(query)
+
+                # Format chat results
+                formatted_chat_results = [
+                    f"Chat: {chat['conversation_name']} (ID: {chat['id']})" for chat in chat_results
+                ]
+
+                # Search Characters using substring match
+                characters = get_character_cards()
+                filtered_characters = [
+                    char for char in characters
+                    if query.lower() in char['name'].lower()
+                ]
+                formatted_character_results = [
+                    f"Character: {char['name']} (ID: {char['id']})" for char in filtered_characters
+                ]
+
+                # Combine results
+                all_choices = formatted_chat_results + formatted_character_results
+                mapping = {choice: conv['id'] for choice, conv in zip(formatted_chat_results, chat_results)}
+                mapping.update({choice: char['id'] for choice, char in zip(formatted_character_results, filtered_characters)})
+
+                if all_choices:
+                    return gr.update(choices=all_choices, visible=True), f"Found {len(all_choices)} result(s) matching '{query}'."
+                else:
+                    return gr.update(choices=[], visible=False), f"No results found for '{query}'."
+
+            except Exception as e:
+                logging.error(f"Error during search: {e}")
+                return gr.update(choices=[], visible=False), f"Error occurred during search: {e}"
+
+        def load_conversation_or_character(selected, conversation_mapping):
+            if not selected or selected not in conversation_mapping:
+                return "", "<p>No selection made.</p>"
+
+            selected_id = conversation_mapping[selected]
+            if selected.startswith("Chat:"):
+                chat = get_character_chat_by_id(selected_id)
+                if chat:
+                    json_content = json.dumps({
+                        "conversation_id": chat['id'],
+                        "conversation_name": chat['conversation_name'],
+                        "messages": chat['chat_history']
+                    }, indent=2)
+
+                    html_preview = create_chat_preview_html(chat['chat_history'])
+                    return json_content, html_preview
+            elif selected.startswith("Character:"):
+                character = get_character_card_by_id(selected_id)
+                if character:
+                    json_content = json.dumps({
+                        "id": character['id'],
+                        "name": character['name'],
+                        "description": character['description'],
+                        "personality": character['personality'],
+                        "scenario": character['scenario'],
+                        "post_history_instructions": character['post_history_instructions'],
+                        "first_mes": character['first_mes'],
+                        "mes_example": character['mes_example'],
+                        "creator_notes": character.get('creator_notes', ''),
+                        "system_prompt": character.get('system_prompt', ''),
+                        "tags": character.get('tags', []),
+                        "creator": character.get('creator', ''),
+                        "character_version": character.get('character_version', ''),
+                        "extensions": character.get('extensions', {})
+                    }, indent=2)
+
+                    html_preview = create_character_preview_html(character)
+                    return json_content, html_preview
+
+            return "", "<p>Unable to load the selected item.</p>"
+
+        def validate_content(selected, content):
+            try:
+                data = json.loads(content)
+                if selected.startswith("Chat:"):
+                    assert "conversation_id" in data and "messages" in data
+                elif selected.startswith("Character:"):
+                    assert "id" in data and "name" in data
+                return True, data
+            except Exception as e:
+                return False, f"Invalid JSON: {e}"
+
+        def save_conversation_or_character(selected, conversation_mapping, content):
+            if not selected or selected not in conversation_mapping:
+                return "Please select an item to save.", "<p>No changes made.</p>"
+
+            is_valid, result = validate_content(selected, content)
+            if not is_valid:
+                return f"Error: {result}", "<p>No changes made due to validation error.</p>"
+
+            selected_id = conversation_mapping[selected]
+
+            if selected.startswith("Chat:"):
+                success = update_character_chat(selected_id, result['messages'])
+                return ("Chat updated successfully." if success else "Failed to update chat."), ("<p>Chat updated.</p>" if success else "<p>Failed to update chat.</p>")
+            elif selected.startswith("Character:"):
+                success = update_character_card(selected_id, result)
+                return ("Character updated successfully." if success else "Failed to update character."), ("<p>Character updated.</p>" if success else "<p>Failed to update character.</p>")
+
+            return "Unknown item type.", "<p>No changes made.</p>"
+
+        def delete_conversation_or_character(selected, conversation_mapping):
+            if not selected or selected not in conversation_mapping:
+                return "Please select an item to delete.", "<p>No changes made.</p>", gr.update(choices=[])
+
+            selected_id = conversation_mapping[selected]
+
+            if selected.startswith("Chat:"):
+                success = delete_character_chat(selected_id)
+            elif selected.startswith("Character:"):
+                success = delete_character_card(selected_id)
+            else:
+                return "Unknown item type.", "<p>No changes made.</p>", gr.update()
+
+            if success:
+                updated_choices = [choice for choice in conversation_mapping.keys() if choice != selected]
+                conversation_mapping.value.pop(selected, None)
+                return f"{selected.split(':')[0]} deleted successfully.", f"<p>{selected.split(':')[0]} deleted.</p>", gr.update(choices=updated_choices)
+            else:
+                return f"Failed to delete {selected.split(':')[0].lower()}.", f"<p>Failed to delete {selected.split(':')[0].lower()}.</p>", gr.update()
+
+        def populate_chats(character_selection):
+            if not character_selection:
+                return gr.update(choices=[], visible=False), "Please select a character first."
+
+            try:
+                character_id = int(character_selection.split('(ID: ')[1].rstrip(')'))
+                chats = get_character_chats(character_id=character_id)
+
+                if not chats:
+                    return gr.update(choices=[], visible=False), f"No chats found for the selected character."
+
+                formatted_chats = [f"{chat['conversation_name']} (ID: {chat['id']})" for chat in chats]
+                return gr.update(choices=formatted_chats, visible=True), f"Found {len(formatted_chats)} chat(s)."
+            except Exception as e:
+                logging.error(f"Error populating chats: {e}")
+                return gr.update(choices=[], visible=False), f"Error occurred: {e}"
+
+        def load_chat_from_character(selected_chat):
+            if not selected_chat:
+                return "", "<p>No chat selected.</p>"
+
+            try:
+                chat_id = int(selected_chat.split('(ID: ')[1].rstrip(')'))
+                chat = get_character_chat_by_id(chat_id)
+                if not chat:
+                    return "", "<p>Selected chat not found.</p>"
+
+                json_content = json.dumps({
+                    "conversation_id": chat['id'],
+                    "conversation_name": chat['conversation_name'],
+                    "messages": chat['chat_history']
+                }, indent=2)
+
+                html_preview = create_chat_preview_html(chat['chat_history'])
+                return json_content, html_preview
+            except Exception as e:
+                logging.error(f"Error loading chat: {e}")
+                return "", f"<p>Error loading chat: {e}</p>"
+
+        def create_chat_preview_html(chat_history):
+            html_preview = "<div style='max-height: 500px; overflow-y: auto;'>"
+            for user_msg, bot_msg in chat_history:
+                user_style = "background-color: #e6f3ff; padding: 10px; border-radius: 5px; margin-bottom: 5px;"
+                bot_style = "background-color: #f0f0f0; padding: 10px; border-radius: 5px; margin-bottom: 10px;"
+                html_preview += f"<div style='{user_style}'><strong>User:</strong> {user_msg}</div>"
+                html_preview += f"<div style='{bot_style}'><strong>Bot:</strong> {bot_msg}</div>"
+            html_preview += "</div>"
+            return html_preview
+
+        def create_character_preview_html(character):
+            return f"""
+            <div>
+                <h2>{character['name']}</h2>
+                <p><strong>Description:</strong> {character['description']}</p>
+                <p><strong>Personality:</strong> {character['personality']}</p>
+                <p><strong>Scenario:</strong> {character['scenario']}</p>
+                <p><strong>First Message:</strong> {character['first_mes']}</p>
+                <p><strong>Example Message:</strong> {character['mes_example']}</p>
+                <p><strong>Post History Instructions:</strong> {character['post_history_instructions']}</p>
+                <p><strong>System Prompt:</strong> {character.get('system_prompt', 'N/A')}</p>
+                <p><strong>Tags:</strong> {', '.join(character.get('tags', []))}</p>
+                <p><strong>Creator:</strong> {character.get('creator', 'N/A')}</p>
+                <p><strong>Version:</strong> {character.get('character_version', 'N/A')}</p>
+            </div>
+            """
+
+        # Register Callback Functions with Gradio Components
+        search_button.click(
+            fn=search_conversations_or_characters,
+            inputs=[search_query],
+            outputs=[search_results, search_status]
+        )
+
+        search_results.change(
+            fn=load_conversation_or_character,
+            inputs=[search_results, conversation_mapping],
+            outputs=[chat_content, chat_preview]
+        )
+
+        save_button.click(
+            fn=save_conversation_or_character,
+            inputs=[conversation_list, conversation_mapping, chat_content],
+            outputs=[result_message, chat_preview]
+        )
+
+        delete_button.click(
+            fn=delete_conversation_or_character,
+            inputs=[conversation_list, conversation_mapping],
+            outputs=[result_message, chat_preview, conversation_list]
+        )
+
+        select_character.change(
+            fn=populate_chats,
+            inputs=[select_character],
+            outputs=[select_chat, search_status]
+        )
+
+        select_chat.change(
+            fn=load_chat_from_character,
+            inputs=[select_chat],
+            outputs=[chat_content, chat_preview]
+        )
+
+        load_chat_button.click(
+            fn=load_chat_from_character,
+            inputs=[select_chat],
+            outputs=[chat_content, chat_preview]
+        )
+
+        return (
+            search_query, search_button, search_results, search_status,
+            select_character, select_chat, load_chat_button,
+            conversation_list, conversation_mapping,
+            chat_content, save_button, delete_button,
+            chat_preview, result_message
+        )

App_Function_Libraries/Gradio_UI/Character_interaction_tab.py

@@ -0,0 +1,838 @@
+# 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
+import uuid
+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, save_chat_history_to_db_wrapper
+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
+
+
+# FIXME - deprecated keeping until sure no longer needed
+# 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=["Local-LLM", "OpenAI", "Anthropic", "Cohere", "Groq", "DeepSeek", "Mistral",
+#                              "OpenRouter", "Llama.cpp", "Kobold", "Ooba", "Tabbyapi", "VLLM", "ollama", "HuggingFace",
+#                              "Custom-OpenAI-API"],
+#                     value="HuggingFace",
+#                     # 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")
+#                 chat_media_name = gr.Textbox(label="Custom Chat Name(optional)", visible=True)
+#                 save_chat_history_to_db = gr.Button("Save Chat History to DataBase")
+#                 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")
+#
+#     # Define States for conversation_id and media_content, which are required for saving chat history
+#     conversation_id = gr.State(str(uuid.uuid4()))
+#     media_content = gr.State({})
+#
+#     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]
+#     )
+#
+#     # FIXME - Implement saving chat history to database; look at Chat_UI.py for reference
+#     save_chat_history_to_db.click(
+#         save_chat_history_to_db_wrapper,
+#         inputs=[chat_history, conversation_id, media_content, chat_media_name],
+#         outputs=[conversation_id, gr.Textbox(label="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=["Local-LLM", "OpenAI", "Anthropic", "Cohere", "Groq", "DeepSeek",
+                                                "Mistral",
+                                                "OpenRouter", "Llama.cpp", "Kobold", "Ooba", "Tabbyapi", "VLLM",
+                                                "ollama", "HuggingFace",
+                                                "Custom-OpenAI-API"],
+                                        value="HuggingFace")
+            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")
+            chat_media_name = gr.Textbox(label="Custom Chat Name(optional)", visible=True)
+            save_chat_history_to_db = gr.Button("Save Chat History to DataBase")
+
+            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)
+
+            # Define States for conversation_id and media_content, which are required for saving chat history
+            media_content = gr.State({})
+            conversation_id = gr.State(str(uuid.uuid4()))
+
+            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]
+            )
+
+        # FIXME - Implement saving chat history to database; look at Chat_UI.py for reference
+        save_chat_history_to_db.click(
+            save_chat_history_to_db_wrapper,
+            inputs=[chat_display, conversation_id, media_content, chat_media_name],
+            outputs=[conversation_id, gr.Textbox(label="Save Status")]
+        )
+
+        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=["Local-LLM", "OpenAI", "Anthropic", "Cohere", "Groq", "DeepSeek", "Mistral",
+                             "OpenRouter", "Llama.cpp", "Kobold", "Ooba", "Tabbyapi", "VLLM", "ollama", "HuggingFace",
+                             "Custom-OpenAI-API"],
+                    value="HuggingFace"
+                )
+                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")
+            chat_media_name = gr.Textbox(label="Custom Chat Name(optional)", visible=True)
+            save_chat_history_to_db = gr.Button("Save Chat History to DataBase")
+
+        error_box = gr.Textbox(label="Error Messages", visible=False)
+
+        # Define States for conversation_id and media_content, which are required for saving chat history
+        conversation_id = gr.State(str(uuid.uuid4()))
+        media_content = gr.State({})
+
+        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]
+        )
+
+        # FIXME - Implement saving chat history to database; look at Chat_UI.py for reference
+        save_chat_history_to_db.click(
+            save_chat_history_to_db_wrapper,
+            inputs=[conversation_display, conversation_id, media_content, chat_media_name],
+            outputs=[conversation_id, gr.Textbox(label="Save Status")]
+        )
+
+
+    return api_endpoint, api_key, temperature, narrator_input, conversation_display, user_input, generate_btn, reset_btn, error_box
+
+#
+# End of Narrator-Controlled Conversation tab
+########################################################################################################################

App_Function_Libraries/Gradio_UI/Chat_Workflows.py

@@ -23,7 +23,6 @@ with json_path.open('r') as f:
     workflows = json.load(f)
 
 
-# FIXME - broken Completely. Doesn't work.
 def chat_workflows_tab():
     with gr.TabItem("Chat Workflows"):
         gr.Markdown("# Workflows using LLMs")

App_Function_Libraries/Gradio_UI/Chat_ui.py

@@ -64,10 +64,23 @@ def get_system_prompt(preset_name):
     return prompts["system_prompt"]
 
 def clear_chat():
-    # Return empty list for chatbot and None for conversation_id
+    """
+    Return empty list for chatbot and None for conversation_id
+    @return:
+    """
     return gr.update(value=[]), None
 
 
+def clear_chat_single():
+    """
+    Clears the chatbot and chat history.
+
+    Returns:
+        list: Empty list for chatbot messages.
+        list: Empty list for chat history.
+    """
+    return [], []
+
 # FIXME - add additional features....
 def chat_wrapper(message, history, media_content, selected_parts, api_endpoint, api_key, custom_prompt, conversation_id,
                  save_conversation, temperature, system_prompt, max_tokens=None, top_p=None, frequency_penalty=None,
@@ -214,7 +227,7 @@ def create_chat_interface():
                                                  value="You are a helpful AI assitant",
                                                  lines=3,
                                                  visible=False)
-            with gr.Column():
+            with gr.Column(scale=2):
                 chatbot = gr.Chatbot(height=600, elem_classes="chatbot-container")
                 msg = gr.Textbox(label="Enter your message")
                 submit = gr.Button("Submit")
@@ -653,57 +666,128 @@ def create_chat_interface_four():
         overflow-y: auto;
     }
     """
+
     with gr.TabItem("Four Independent API Chats"):
         gr.Markdown("# Four Independent API Chat Interfaces")
 
         with gr.Row():
             with gr.Column():
-                preset_prompt = gr.Dropdown(label="Select Preset Prompt", choices=load_preset_prompts(), visible=True)
-                user_prompt = gr.Textbox(label="Modify Prompt", lines=3, value=".")
+                preset_prompt = gr.Dropdown(
+                    label="Select Preset Prompt",
+                    choices=load_preset_prompts(),
+                    visible=True
+                )
+                user_prompt = gr.Textbox(
+                    label="Modify Prompt",
+                    lines=3
+                )
             with gr.Column():
                 gr.Markdown("Scroll down for the chat windows...")
+
         chat_interfaces = []
-        for row in range(2):
-            with gr.Row():
-                for col in range(2):
-                    i = row * 2 + col
-                    with gr.Column():
-                        gr.Markdown(f"### Chat Window {i + 1}")
-                        api_endpoint = gr.Dropdown(label=f"API Endpoint {i + 1}",
-                                                   choices=["Local-LLM", "OpenAI", "Anthropic", "Cohere", "Groq",
-                                                            "DeepSeek", "Mistral", "OpenRouter", "Llama.cpp", "Kobold",
-                                                            "Ooba",
-                                                            "Tabbyapi", "VLLM", "ollama", "HuggingFace"])
-                        api_key = gr.Textbox(label=f"API Key {i + 1} (if required)", type="password")
-                        temperature = gr.Slider(label=f"Temperature {i + 1}", minimum=0.0, maximum=1.0, step=0.05,
-                                                value=0.7)
-                        chatbot = gr.Chatbot(height=400, elem_classes="chat-window")
-                        msg = gr.Textbox(label=f"Enter your message for Chat {i + 1}")
-                        submit = gr.Button(f"Submit to Chat {i + 1}")
-
-                        chat_interfaces.append({
-                            'api_endpoint': api_endpoint,
-                            'api_key': api_key,
-                            'temperature': temperature,
-                            'chatbot': chatbot,
-                            'msg': msg,
-                            'submit': submit,
-                            'chat_history': gr.State([])
-                        })
 
-        preset_prompt.change(update_user_prompt, inputs=preset_prompt, outputs=user_prompt)
+        def create_single_chat_interface(index, user_prompt_component):
+            """
+            Creates a single chat interface with its own set of components and event bindings.
+
+            Parameters:
+                index (int): The index of the chat interface.
+                user_prompt_component (gr.Textbox): The user prompt textbox component.
+
+            Returns:
+                dict: A dictionary containing all components of the chat interface.
+            """
+            with gr.Column():
+                gr.Markdown(f"### Chat Window {index + 1}")
+                api_endpoint = gr.Dropdown(
+                    label=f"API Endpoint {index + 1}",
+                    choices=[
+                        "Local-LLM", "OpenAI", "Anthropic", "Cohere", "Groq",
+                        "DeepSeek", "Mistral", "OpenRouter", "Llama.cpp", "Kobold",
+                        "Ooba", "Tabbyapi", "VLLM", "ollama", "HuggingFace"
+                    ]
+                )
+                api_key = gr.Textbox(
+                    label=f"API Key {index + 1} (if required)",
+                    type="password"
+                )
+                temperature = gr.Slider(
+                    label=f"Temperature {index + 1}",
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.05,
+                    value=0.7
+                )
+                chatbot = gr.Chatbot(height=400, elem_classes="chat-window")
+                msg = gr.Textbox(label=f"Enter your message for Chat {index + 1}")
+                submit = gr.Button(f"Submit to Chat {index + 1}")
+                clear_chat_button = gr.Button(f"Clear Chat {index + 1}")
+
+                # State to maintain chat history
+                chat_history = gr.State([])
+
+                # Append to chat_interfaces list
+                chat_interfaces.append({
+                    'api_endpoint': api_endpoint,
+                    'api_key': api_key,
+                    'temperature': temperature,
+                    'chatbot': chatbot,
+                    'msg': msg,
+                    'submit': submit,
+                    'clear_chat_button': clear_chat_button,
+                    'chat_history': chat_history
+                })
+
+        # # Create four chat interfaces
+        # for i in range(4):
+        #     create_single_chat_interface(i, user_prompt)
+
+        # Create four chat interfaces arranged in a 2x2 grid
+        with gr.Row():
+            for i in range(2):
+                with gr.Column():
+                    for j in range(2):
+                        create_single_chat_interface(i * 2 + j, user_prompt)
+
+
+        # Update user_prompt based on preset_prompt selection
+        preset_prompt.change(
+            fn=update_user_prompt,
+            inputs=preset_prompt,
+            outputs=user_prompt
+        )
 
         def chat_wrapper_single(message, chat_history, api_endpoint, api_key, temperature, user_prompt):
             logging.debug(f"Chat Wrapper Single - Message: {message}, Chat History: {chat_history}")
+
+            # Call chat_wrapper with the new signature and the additional parameters
             new_msg, new_history, _ = chat_wrapper(
-                message, chat_history, {}, [],  # Empty media_content and selected_parts
-                api_endpoint, api_key, user_prompt, None,  # No conversation_id
-                False,  # Not saving conversation
-                temperature=temperature, system_prompt=""
+                message,
+                chat_history,
+                {},  # Empty media_content
+                [],  # Empty selected_parts
+                api_endpoint,
+                api_key,
+                user_prompt,  # custom_prompt
+                None,  # conversation_id
+                False,  # save_conversation
+                temperature,  # temperature
+                system_prompt="",  # system_prompt
+                max_tokens=None,  # Additional parameters with default None values
+                top_p=None,
+                frequency_penalty=None,
+                presence_penalty=None,
+                stop_sequence=None
             )
-            chat_history.append((message, new_msg))
+            # Only append to history if the new message was successful (i.e., no error in API response)
+            if "API request failed" not in new_msg:
+                chat_history.append((message, new_msg))
+            else:
+                logging.error(f"API request failed: {new_msg}")
+
             return "", chat_history, chat_history
 
+        # Attach click events for each chat interface
         for interface in chat_interfaces:
             logging.debug(f"Chat Interface - Clicked Submit for Chat {interface['chatbot']}"),
             interface['submit'].click(
@@ -723,6 +807,13 @@ def create_chat_interface_four():
                 ]
             )
 
+            # Bind the clear chat button
+            interface['clear_chat_button'].click(
+                clear_chat_single,
+                inputs=[],
+                outputs=[interface['chatbot'], interface['chat_history']]
+            )
+
 
 def chat_wrapper_single(message, chat_history, chatbot, api_endpoint, api_key, temperature, media_content,
                         selected_parts, conversation_id, save_conversation, user_prompt):

App_Function_Libraries/Gradio_UI/Embeddings_tab.py

@@ -193,6 +193,10 @@ def create_view_embeddings_tab():
                     label="Select API for Contextualized Embeddings",
                     value="OpenAI"
                 )
+                use_contextual_embeddings = gr.Checkbox(
+                    label="Use Contextual Embeddings",
+                    value=True
+                )
                 contextual_api_key = gr.Textbox(label="API Key", lines=1)
 
         def get_items_with_embedding_status():
@@ -251,7 +255,8 @@ def create_view_embeddings_tab():
                 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, contextual_api_choice=None):
+        def create_new_embedding_for_item(selected_item, provider, model, api_url, method, max_size, overlap, adaptive,
+                                          item_mapping, use_contextual, contextual_api_choice=None):
             if not selected_item:
                 return "Please select an item", "", ""
 
@@ -290,10 +295,14 @@ def create_view_embeddings_tab():
                     chunk_metadata = chunk['metadata']
                     if chunk_count == 0:
                         chunk_count = 1
-                    # Generate contextual summary
-                    logging.debug(f"Generating contextual summary for chunk {chunk_count}")
-                    context = situate_context(contextual_api_choice, item['content'], chunk_text)
-                    contextualized_text = f"{chunk_text}\n\nContextual Summary: {context}"
+                    if use_contextual:
+                        # Generate contextual summary
+                        logging.debug(f"Generating contextual summary for chunk {chunk_count}")
+                        context = situate_context(contextual_api_choice, item['content'], chunk_text)
+                        contextualized_text = f"{chunk_text}\n\nContextual Summary: {context}"
+                    else:
+                        contextualized_text = chunk_text
+                        context = None
 
                     chunk_id = f"doc_{item_id}_chunk_{i}"
                     metadata = {
@@ -307,6 +316,7 @@ def create_view_embeddings_tab():
                         "embedding_model": model,
                         "embedding_provider": provider,
                         "original_text": chunk_text,
+                        "use_contextual_embeddings": use_contextual,
                         "contextual_summary": context,
                         **chunk_metadata
                     }
@@ -323,8 +333,17 @@ def create_view_embeddings_tab():
                 # Store in Chroma
                 store_in_chroma(collection_name, texts, embeddings, ids, metadatas)
 
+                # Create a preview of the first embedding
                 embedding_preview = str(embeddings[0][:50]) if embeddings else "No embeddings created"
-                status = f"New contextual embeddings created and stored for item: {item['title']} (ID: {item_id})"
+
+                # Return status message
+                status = f"New embeddings created and stored for item: {item['title']} (ID: {item_id})"
+
+                # Add contextual summaries to status message if enabled
+                if use_contextual:
+                    status += " (with contextual summaries)"
+
+                # Return status message, embedding preview, and metadata
                 return status, f"First 50 elements of new embedding:\n{embedding_preview}", json.dumps(metadatas[0], indent=2)
             except Exception as e:
                 logging.error(f"Error in create_new_embedding_for_item: {str(e)}")
@@ -342,7 +361,8 @@ def create_view_embeddings_tab():
         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, contextual_api_choice],
+                    chunking_method, max_chunk_size, chunk_overlap, adaptive_chunking, item_mapping,
+                    use_contextual_embeddings, contextual_api_choice],
             outputs=[embedding_status, embedding_preview, embedding_metadata]
         )
         embedding_provider.change(
@@ -351,7 +371,10 @@ def create_view_embeddings_tab():
             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
+    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,
+            use_contextual_embeddings, contextual_api_choice, contextual_api_key)
 
 
 def create_purge_embeddings_tab():

App_Function_Libraries/Gradio_UI/Gradio_Shared.py

@@ -153,11 +153,12 @@ def update_user_prompt(preset_name):
         # Return a dictionary with all details
         return {
             "title": details[0],
-            "details": details[1],
-            "system_prompt": details[2],
-            "user_prompt": details[3] if len(details) > 3 else ""
+            "author": details[1],
+            "details": details[2],
+            "system_prompt": details[3],
+            "user_prompt": details[4] if len(details) > 3 else "",
         }
-    return {"title": "", "details": "", "system_prompt": "", "user_prompt": ""}
+    return {"title": "", "details": "", "system_prompt": "", "user_prompt": "", "author": ""}
 
 def browse_items(search_query, search_type):
     if search_type == 'Keyword':

App_Function_Libraries/Gradio_UI/Media_edit.py

@@ -211,6 +211,7 @@ def create_prompt_edit_tab():
 
             with gr.Column():
                 title_input = gr.Textbox(label="Title", placeholder="Enter the prompt title")
+                author_input = gr.Textbox(label="Author", placeholder="Enter the prompt's author", lines=3)
                 description_input = gr.Textbox(label="Description", placeholder="Enter the prompt description", lines=3)
                 system_prompt_input = gr.Textbox(label="System Prompt", placeholder="Enter the system prompt", lines=3)
                 user_prompt_input = gr.Textbox(label="User Prompt", placeholder="Enter the user prompt", lines=3)
@@ -225,7 +226,7 @@ def create_prompt_edit_tab():
 
         add_prompt_button.click(
             fn=add_or_update_prompt,
-            inputs=[title_input, description_input, system_prompt_input, user_prompt_input],
+            inputs=[title_input, author_input, description_input, system_prompt_input, user_prompt_input],
             outputs=add_prompt_output
         )
 
@@ -233,7 +234,7 @@ def create_prompt_edit_tab():
         prompt_dropdown.change(
             fn=load_prompt_details,
             inputs=[prompt_dropdown],
-            outputs=[title_input, description_input, system_prompt_input, user_prompt_input]
+            outputs=[title_input, author_input, system_prompt_input, user_prompt_input]
         )
 
 
@@ -251,6 +252,7 @@ def create_prompt_clone_tab():
 
             with gr.Column():
                 title_input = gr.Textbox(label="Title", placeholder="Enter the prompt title")
+                author_input = gr.Textbox(label="Author", placeholder="Enter the prompt's author", lines=3)
                 description_input = gr.Textbox(label="Description", placeholder="Enter the prompt description", lines=3)
                 system_prompt_input = gr.Textbox(label="System Prompt", placeholder="Enter the system prompt", lines=3)
                 user_prompt_input = gr.Textbox(label="User Prompt", placeholder="Enter the user prompt", lines=3)
@@ -268,7 +270,7 @@ def create_prompt_clone_tab():
         prompt_dropdown.change(
             fn=load_prompt_details,
             inputs=[prompt_dropdown],
-            outputs=[title_input, description_input, system_prompt_input, user_prompt_input]
+            outputs=[title_input, author_input, description_input, system_prompt_input, user_prompt_input]
         )
 
         def prepare_for_cloning(selected_prompt):

App_Function_Libraries/Gradio_UI/PDF_ingestion_tab.py

@@ -26,7 +26,7 @@ def create_pdf_ingestion_tab():
         gr.Markdown("# Ingest PDF Files and Extract Metadata")
         with gr.Row():
             with gr.Column():
-                pdf_file_input = gr.File(label="Uploaded PDF File", file_types=[".pdf"], visible=False)
+                pdf_file_input = gr.File(label="Uploaded PDF File", file_types=[".pdf"], visible=True)
                 pdf_upload_button = gr.UploadButton("Click to Upload PDF", file_types=[".pdf"])
                 pdf_title_input = gr.Textbox(label="Title (Optional)")
                 pdf_author_input = gr.Textbox(label="Author (Optional)")

App_Function_Libraries/Gradio_UI/Prompt_Suggestion_tab.py

@@ -0,0 +1,136 @@
+# Description: Gradio UI for Creating and Testing new Prompts
+#
+# Imports
+import gradio as gr
+
+from App_Function_Libraries.Chat import chat
+from App_Function_Libraries.DB.SQLite_DB import add_or_update_prompt
+from App_Function_Libraries.Prompt_Engineering.Prompt_Engineering import generate_prompt, test_generated_prompt
+
+
+#
+# Local Imports
+
+#
+########################################################################################################################
+#
+# Functions
+
+# Gradio tab for prompt suggestion and testing
+def create_prompt_suggestion_tab():
+    with gr.TabItem("Prompt Suggestion/Creation"):
+        gr.Markdown("# Generate and Test AI Prompts with the Metaprompt Approach")
+
+        with gr.Row():
+            with gr.Column():
+                # Task and variable inputs
+                task_input = gr.Textbox(label="Task Description",
+                                        placeholder="E.g., Draft an email responding to a customer complaint")
+                variables_input = gr.Textbox(label="Variables (comma-separated)",
+                                             placeholder="E.g., CUSTOMER_COMPLAINT, COMPANY_NAME")
+
+                # API-related inputs
+                api_name_input = gr.Dropdown(
+                    choices=["OpenAI", "Cohere", "Groq", "DeepSeek", "Mistral", "OpenRouter", "Llama.cpp",
+                             "Kobold", "Ooba", "Tabbyapi", "VLLM", "ollama", "HuggingFace", "Custom-OpenAI-API"],
+                    label="API Provider",
+                    value="OpenAI"  # Default selection
+                )
+
+                api_key_input = gr.Textbox(label="API Key", placeholder="Enter your API key (if required)",
+                                           type="password")
+
+                # Temperature slider for controlling randomness of generation
+                temperature_input = gr.Slider(minimum=0, maximum=1, step=0.01, value=0.7, label="Temperature")
+
+                # Button to generate the prompt
+                generate_prompt_button = gr.Button("Generate Prompt")
+
+            with gr.Column():
+                # Output for the generated prompt
+                generated_prompt_output = gr.Textbox(label="Generated Prompt", interactive=False)
+                # FIXME - figure this out
+                # copy_button = gr.HTML("""
+                # <button onclick="copyToClipboard()">Copy</button>
+                # <script>
+                #     function copyToClipboard() {
+                #         const textBox = document.querySelector('textarea'); // Select the textarea
+                #         textBox.select(); // Select the text
+                #         document.execCommand('copy'); // Copy it to clipboard
+                #         alert('Copied to clipboard!');
+                #     }
+                # </script>
+                # """)
+        # Section to test the generated prompt
+        with gr.Row():
+            with gr.Column():
+                # Input to test the prompt with variable values
+                variable_values_input = gr.Textbox(label="Variable Values (comma-separated)",
+                                                   placeholder="Enter variable values in order, comma-separated")
+                test_prompt_button = gr.Button("Test Generated Prompt")
+            with gr.Column():
+                # Output for the test result
+                test_output = gr.Textbox(label="Test Output", interactive=False)
+
+        # Section to save the generated prompt to the database
+        with gr.Row():
+            with gr.Column():
+                prompt_title_input = gr.Textbox(label="Prompt Title", placeholder="Enter a title for this prompt")
+                prompt_author_input = gr.Textbox(label="Author",
+                                                 placeholder="Enter the author's name")  # New author field
+                prompt_description_input = gr.Textbox(label="Prompt Description", placeholder="Enter a description", lines=3)
+                save_prompt_button = gr.Button("Save Prompt to Database")
+                save_prompt_output = gr.Textbox(label="Save Prompt Output", interactive=False)
+
+        # Callback function to generate prompt
+        def on_generate_prompt(api_name, api_key, task, variables, temperature):
+            # Generate the prompt using the metaprompt approach and API
+            generated_prompt = generate_prompt(api_name, api_key, task, variables, temperature)
+            return generated_prompt
+
+        # Callback function to test the generated prompt
+        def on_test_prompt(api_name, api_key, generated_prompt, variable_values, temperature):
+            # Test the prompt by filling in variable values
+            test_result = test_generated_prompt(api_name, api_key, generated_prompt, variable_values, temperature)
+            return test_result
+
+        # Callback function to save the generated prompt to the database
+        def on_save_prompt(title, author, description, generated_prompt):
+            if not title or not generated_prompt:
+                return "Error: Title and generated prompt are required."
+
+            # Add the generated prompt to the database
+            result = add_or_update_prompt(title, author, description, system_prompt="", user_prompt=generated_prompt, keywords=None)
+            return result
+
+        # Connect the button to the function that generates the prompt
+        generate_prompt_button.click(
+            fn=on_generate_prompt,
+            inputs=[api_name_input, api_key_input, task_input, variables_input, temperature_input],
+            outputs=[generated_prompt_output]
+        )
+
+        # Connect the button to the function that tests the generated prompt
+        test_prompt_button.click(
+            fn=on_test_prompt,
+            inputs=[api_name_input, api_key_input, generated_prompt_output, variable_values_input, temperature_input],
+            outputs=[test_output]
+        )
+
+        # Connect the save button to the function that saves the prompt to the database
+        save_prompt_button.click(
+            fn=on_save_prompt,
+            inputs=[prompt_title_input, prompt_author_input, prompt_description_input, generated_prompt_output],
+            outputs=[save_prompt_output]
+        )
+
+# Example chat function based on your API structure
+def chat_api_call(api_endpoint, api_key, input_data, prompt, temp, system_message=None):
+    # Here you will call your chat function as defined previously
+    response = chat(message=input_data, history=[], media_content={}, selected_parts=[],
+                    api_endpoint=api_endpoint, api_key=api_key, prompt=prompt, temperature=temp,
+                    system_message=system_message)
+    return response
+#
+# End of Functions
+########################################################################################################################

App_Function_Libraries/Gradio_UI/RAG_QA_Chat_tab.py

@@ -58,6 +58,7 @@ def create_rag_qa_chat_tab():
                     label="Select API for RAG",
                     value="OpenAI"
                 )
+                use_query_rewriting = gr.Checkbox(label="Use Query Rewriting", value=True)
 
             with gr.Column(scale=2):
                 chatbot = gr.Chatbot(height=500)
@@ -105,11 +106,12 @@ def create_rag_qa_chat_tab():
         loading_indicator = gr.HTML(visible=False)
 
         def rag_qa_chat_wrapper(message, history, context_source, existing_file, search_results, file_upload,
-                                convert_to_text, keywords, api_choice):
+                                convert_to_text, keywords, api_choice, use_query_rewriting):
             try:
                 logging.info(f"Starting rag_qa_chat_wrapper with message: {message}")
                 logging.info(f"Context source: {context_source}")
                 logging.info(f"API choice: {api_choice}")
+                logging.info(f"Query rewriting: {'enabled' if use_query_rewriting else 'disabled'}")
 
                 # Show loading indicator
                 yield history, "", gr.update(visible=True)
@@ -118,14 +120,14 @@ def create_rag_qa_chat_tab():
                 api_choice = api_choice.value if isinstance(api_choice, gr.components.Dropdown) else api_choice
                 logging.info(f"Resolved API choice: {api_choice}")
 
-                # Only rephrase the question if it's not the first query
-                if len(history) > 0:
+                # Only rephrase the question if it's not the first query and query rewriting is enabled
+                if len(history) > 0 and use_query_rewriting:
                     rephrased_question = rephrase_question(history, message, api_choice)
                     logging.info(f"Original question: {message}")
                     logging.info(f"Rephrased question: {rephrased_question}")
                 else:
                     rephrased_question = message
-                    logging.info(f"First question, no rephrasing: {message}")
+                    logging.info(f"Using original question: {message}")
 
                 if context_source == "All Files in the Database":
                     # Use the enhanced_rag_pipeline to search the entire database
@@ -189,8 +191,11 @@ def create_rag_qa_chat_tab():
                 logging.info(
                     f"Response received from rag_qa_chat: {response[:100]}...")
 
-                # Add the original question to the history
-                new_history[-1] = (message, new_history[-1][1])
+                # Safely update history
+                if new_history:
+                    new_history[-1] = (message, new_history[-1][1])
+                else:
+                    new_history = [(message, response)]
 
                 gr.Info("Response generated successfully")
                 logging.info("rag_qa_chat_wrapper completed successfully")
@@ -210,6 +215,7 @@ def create_rag_qa_chat_tab():
 
         def rephrase_question(history, latest_question, api_choice):
             # Thank you https://www.reddit.com/r/LocalLLaMA/comments/1fi1kex/multi_turn_conversation_and_rag/
+            logging.info("RAG QnA: Rephrasing question")
             conversation_history = "\n".join([f"User: {h[0]}\nAssistant: {h[1]}" for h in history[:-1]])
             prompt = f"""You are a helpful assistant. Given the conversation history and the latest question, resolve any ambiguous references in the latest question.
 
@@ -223,6 +229,7 @@ def create_rag_qa_chat_tab():
 
             # Use the selected API to generate the rephrased question
             rephrased_question = generate_answer(api_choice, prompt, "")
+            logging.info(f"Rephrased question: {rephrased_question}")
             return rephrased_question.strip()
 
         def perform_search(query):
@@ -241,14 +248,14 @@ def create_rag_qa_chat_tab():
         submit.click(
             rag_qa_chat_wrapper,
             inputs=[msg, chatbot, context_source, existing_file, search_results, file_upload,
-                    convert_to_text, keywords, api_choice],
+                    convert_to_text, keywords, api_choice, use_query_rewriting],
             outputs=[chatbot, msg, loading_indicator]
         )
 
         clear_chat.click(clear_chat_history, outputs=[chatbot, msg])
 
     return (context_source, existing_file, search_query, search_button, search_results, file_upload,
-            convert_to_text, keywords, api_choice, chatbot, msg, submit, clear_chat)
+            convert_to_text, keywords, api_choice, use_query_rewriting, chatbot, msg, submit, clear_chat)
 
 def convert_file_to_text(file_path):
     """Convert various file types to plain text."""

App_Function_Libraries/Gradio_UI/Video_transcription_tab.py

@@ -112,14 +112,13 @@ def create_video_transcription_tab():
                              "OpenRouter",
                              "Llama.cpp", "Kobold", "Ooba", "Tabbyapi", "VLLM", "ollama", "HuggingFace", "Custom-OpenAI-API"],
                     value=None, label="API Name (Mandatory)")
-                api_key_input = gr.Textbox(label="API Key (Mandatory)", placeholder="Enter your API key here",
+                api_key_input = gr.Textbox(label="API Key (Optional - Set in Config.txt)", placeholder="Enter your API key here",
                                            type="password")
                 keywords_input = gr.Textbox(label="Keywords", placeholder="Enter keywords here (comma-separated)",
                                             value="default,no_keyword_set")
                 batch_size_input = gr.Slider(minimum=1, maximum=10, value=1, step=1,
                                              label="Batch Size (Number of videos to process simultaneously)")
-                timestamp_option = gr.Radio(choices=["Include Timestamps", "Exclude Timestamps"],
-                                            value="Include Timestamps", label="Timestamp Option")
+                timestamp_option = gr.Checkbox(label="Include Timestamps", value=True)
                 keep_original_video = gr.Checkbox(label="Keep Original Video", value=False)
                 # First, create a checkbox to toggle the chunking options
                 chunking_options_checkbox = gr.Checkbox(label="Show Chunking Options", value=False)
@@ -304,7 +303,7 @@ def create_video_transcription_tab():
                                     start_seconds, api_name, api_key,
                                     False, False, False, False, 0.01, None, keywords, None, diarize,
                                     end_time=end_seconds,
-                                    include_timestamps=(timestamp_option == "Include Timestamps"),
+                                    include_timestamps=timestamp_option,
                                     metadata=video_metadata,
                                     use_chunking=chunking_options_checkbox,
                                     chunk_options=chunk_options,

App_Function_Libraries/Gradio_UI/View_DB_Items_tab.py

@@ -3,7 +3,6 @@
 #
 # Imports
 import html
-import sqlite3
 #
 # External Imports
 import gradio as gr
@@ -13,8 +12,6 @@ from App_Function_Libraries.DB.DB_Manager import view_database, get_all_document
     fetch_paginated_data, fetch_item_details, get_latest_transcription, list_prompts, fetch_prompt_details, \
     load_preset_prompts
 from App_Function_Libraries.DB.SQLite_DB import get_document_version
-from App_Function_Libraries.Utils.Utils import get_database_path, format_text_with_line_breaks
-#
 #
 ####################################################################################################
 #
@@ -46,7 +43,7 @@ def create_prompt_view_tab():
                 for prompt_name in prompts:
                     details = fetch_prompt_details(prompt_name)
                     if details:
-                        title, _, _, _, _ = details
+                        title, _, _, _, _, _ = details
                         author = "Unknown"  # Assuming author is not stored in the current schema
                         table_html += f"<tr><td style='border: 1px solid black; padding: 8px;'>{html.escape(title)}</td><td style='border: 1px solid black; padding: 8px;'>{html.escape(author)}</td></tr>"
                         prompt_choices.append((title, title))  # Using title as both label and value
@@ -77,20 +74,27 @@ def create_prompt_view_tab():
         def display_selected_prompt(prompt_name):
             details = fetch_prompt_details(prompt_name)
             if details:
-                title, description, system_prompt, user_prompt, keywords = details
+                title, author, description, system_prompt, user_prompt, keywords = details
+                # Handle None values by converting them to empty strings
+                description = description or ""
+                system_prompt = system_prompt or ""
+                user_prompt = user_prompt or ""
+                author = author or "Unknown"
+                keywords = keywords or ""
+
                 html_content = f"""
                 <div style="border: 1px solid #ddd; padding: 10px; margin-bottom: 20px;">
-                    <h3>{html.escape(title)}</h3>
-                    <p><strong>Description:</strong> {html.escape(description or '')}</p>
+                    <h3>{html.escape(title)}</h3> <h4>by {html.escape(author)}</h4>
+                    <p><strong>Description:</strong> {html.escape(description)}</p>
                     <div style="margin-top: 10px;">
                         <strong>System Prompt:</strong>
-                        <pre style="white-space: pre-wrap; word-wrap: break-word;">{html.escape(system_prompt or '')}</pre>
+                        <pre style="white-space: pre-wrap; word-wrap: break-word;">{html.escape(system_prompt)}</pre>
                     </div>
                     <div style="margin-top: 10px;">
                         <strong>User Prompt:</strong>
-                        <pre style="white-space: pre-wrap; word-wrap: break-word;">{html.escape(user_prompt or '')}</pre>
+                        <pre style="white-space: pre-wrap; word-wrap: break-word;">{html.escape(user_prompt)}</pre>
                     </div>
-                    <p><strong>Keywords:</strong> {html.escape(keywords or '')}</p>
+                    <p><strong>Keywords:</strong> {html.escape(keywords)}</p>
                 </div>
                 """
                 return html_content
@@ -123,110 +127,6 @@ def create_prompt_view_tab():
             inputs=[prompt_selector],
             outputs=[selected_prompt_display]
         )
-# def create_prompt_view_tab():
-#     with gr.TabItem("View Prompt Database"):
-#         gr.Markdown("# View Prompt Database Entries")
-#         with gr.Row():
-#             with gr.Column():
-#                 entries_per_page = gr.Dropdown(choices=[10, 20, 50, 100], label="Entries per Page", value=10)
-#                 page_number = gr.Number(value=1, label="Page Number", precision=0)
-#                 view_button = gr.Button("View Page")
-#                 next_page_button = gr.Button("Next Page")
-#                 previous_page_button = gr.Button("Previous Page")
-#                 pagination_info = gr.Textbox(label="Pagination Info", interactive=False)
-#             with gr.Column():
-#                 results_display = gr.HTML()
-#
-#         # FIXME - SQL functions to be moved to DB_Manager
-#
-#         def view_database(page, entries_per_page):
-#             offset = (page - 1) * entries_per_page
-#             try:
-#                 with sqlite3.connect(get_database_path('prompts.db')) as conn:
-#                     cursor = conn.cursor()
-#                     cursor.execute('''
-#                         SELECT p.name, p.details, p.system, p.user, GROUP_CONCAT(k.keyword, ', ') as keywords
-#                         FROM Prompts p
-#                         LEFT JOIN PromptKeywords pk ON p.id = pk.prompt_id
-#                         LEFT JOIN Keywords k ON pk.keyword_id = k.id
-#                         GROUP BY p.id
-#                         ORDER BY p.name
-#                         LIMIT ? OFFSET ?
-#                     ''', (entries_per_page, offset))
-#                     prompts = cursor.fetchall()
-#
-#                     cursor.execute('SELECT COUNT(*) FROM Prompts')
-#                     total_prompts = cursor.fetchone()[0]
-#
-#                 results = ""
-#                 for prompt in prompts:
-#                     # Escape HTML special characters and replace newlines with <br> tags
-#                     title = html.escape(prompt[0]).replace('\n', '<br>')
-#                     details = html.escape(prompt[1] or '').replace('\n', '<br>')
-#                     system_prompt = html.escape(prompt[2] or '')
-#                     user_prompt = html.escape(prompt[3] or '')
-#                     keywords = html.escape(prompt[4] or '').replace('\n', '<br>')
-#
-#                     results += f"""
-#                     <div style="border: 1px solid #ddd; padding: 10px; margin-bottom: 20px;">
-#                         <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 10px;">
-#                             <div><strong>Title:</strong> {title}</div>
-#                             <div><strong>Details:</strong> {details}</div>
-#                         </div>
-#                         <div style="margin-top: 10px;">
-#                             <strong>User Prompt:</strong>
-#                             <pre style="white-space: pre-wrap; word-wrap: break-word;">{user_prompt}</pre>
-#                         </div>
-#                         <div style="margin-top: 10px;">
-#                             <strong>System Prompt:</strong>
-#                             <pre style="white-space: pre-wrap; word-wrap: break-word;">{system_prompt}</pre>
-#                         </div>
-#                         <div style="margin-top: 10px;">
-#                             <strong>Keywords:</strong> {keywords}
-#                         </div>
-#                     </div>
-#                     """
-#
-#                 total_pages = (total_prompts + entries_per_page - 1) // entries_per_page
-#                 pagination = f"Page {page} of {total_pages} (Total prompts: {total_prompts})"
-#
-#                 return results, pagination, total_pages
-#             except sqlite3.Error as e:
-#                 return f"<p>Error fetching prompts: {e}</p>", "Error", 0
-#
-#         def update_page(page, entries_per_page):
-#             results, pagination, total_pages = view_database(page, entries_per_page)
-#             next_disabled = page >= total_pages
-#             prev_disabled = page <= 1
-#             return results, pagination, page, gr.update(interactive=not next_disabled), gr.update(
-#                 interactive=not prev_disabled)
-#
-#         def go_to_next_page(current_page, entries_per_page):
-#             next_page = current_page + 1
-#             return update_page(next_page, entries_per_page)
-#
-#         def go_to_previous_page(current_page, entries_per_page):
-#             previous_page = max(1, current_page - 1)
-#             return update_page(previous_page, entries_per_page)
-#
-#         view_button.click(
-#             fn=update_page,
-#             inputs=[page_number, entries_per_page],
-#             outputs=[results_display, pagination_info, page_number, next_page_button, previous_page_button]
-#         )
-#
-#         next_page_button.click(
-#             fn=go_to_next_page,
-#             inputs=[page_number, entries_per_page],
-#             outputs=[results_display, pagination_info, page_number, next_page_button, previous_page_button]
-#         )
-#
-#         previous_page_button.click(
-#             fn=go_to_previous_page,
-#             inputs=[page_number, entries_per_page],
-#             outputs=[results_display, pagination_info, page_number, next_page_button, previous_page_button]
-#         )
-
 
 def format_as_html(content, title):
     escaped_content = html.escape(content)