Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1,165 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+character_config.yaml
+sample_output.txt

README.md

@@ -1,12 +1,48 @@
 ---
-title: Simple ChatwebUI
-emoji: 🐢
-colorFrom: purple
-colorTo: yellow
+title: simple_chatwebUI
+app_file: chatUI.py
 sdk: gradio
-sdk_version: 5.13.1
-app_file: app.py
-pinned: false
+sdk_version: 5.7.1
 ---
+# **Simple ChatWebUI**
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+A lightweight and customizable framework for creating a web-based chatbot with support for Retrieval-Augmented Generation (RAG).
+
+---
+
+## **Installation**
+
+1. **Create and activate a virtual environment**:
+   ```bash
+   python -m venv venv
+   source venv/bin/activate
+   ```
+
+2. **Install the required packages**:
+   ```bash
+   pip install anthropic openai PyYAML backoff gradio
+   ```
+## **Run Conversational AI on UI**
+   ```bash
+      python chatUI.py
+   ```
+
+## **Run Conversational AI on Terminal**
+This is good for testing and debugging.
+
+1. Export your OpenAI API key as an environment variable:
+   ```bash
+   export OPENAI_API_KEY=<your_openai_api_key> # or set it to other LLM providers
+   ```
+
+2. Start the RAG system:
+   ```bash
+   python character.py
+   ```
+
+---
+
+## **Notes**
+
+- To share the demo, set share=True in the launch() method in chatUI.py. You should get a URL to share and it lasts for 72 hours.
+- https://www.gradio.app/guides/sharing-your-app

character.py

@@ -0,0 +1,108 @@
+import os
+import sys
+import yaml
+import openai
+import backoff
+import argparse
+import logging
+
+from llm import get_response_from_llm, create_client
+
+
+# Set up logging
+#logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Constants
+DEFAULT_CONFIG_PATH = "characters/Viv.yaml"
+DEFAULT_LLM_MODEL = "gpt-4o-2024-08-06"
+DEFAULT_MAX_TOKENS = 4096
+
+def get_openai_api_key():
+    """Retrieve the OpenAI API key from environment variables."""
+    api_key = os.getenv('OPENAI_API_KEY')
+    if not api_key:
+        logger.error("OpenAI API key is not set. Please set the OPENAI_API_KEY environment variable.")
+        sys.exit(1)
+    return api_key
+
+def load_character_config(config_path):
+    """Load character configuration from a YAML file."""
+    try:
+        with open(config_path, 'r') as file:
+            return yaml.safe_load(file)
+    except FileNotFoundError:
+        logger.error(f"Configuration file not found: {config_path}")
+        sys.exit(1)
+    except yaml.YAMLError as e:
+        logger.error(f"Error parsing YAML file: {e}")
+        sys.exit(1)
+
+def build_system_prompt(character_name):
+    """Build the system prompt for the character."""
+    return (
+        f"You are {character_name}."
+        "You have lived a full life, and you are eager to help people understand what it is like to live with dementia."
+    )
+
+def build_prompt(user_query, character_config):
+    """Construct the prompt based on the user query and character configuration."""
+    personality_traits = character_config['personality']['traits']
+    core_description = character_config['character']['core_description']
+    character_name = character_config['character']['name']
+    return (
+        f"You are {character_name}. Your personality traits include: {', '.join(personality_traits)}. "
+        f"You are described as follows: {core_description}.\n\n"
+        "Answer the following question, staying true to your personality and experiences:\n"
+        f"User Query: {user_query}"
+    )
+
+
+def get_character_response(user_query, character_config, llm_model=DEFAULT_LLM_MODEL, max_tokens=DEFAULT_MAX_TOKENS):
+    """Get the character's response using the provided get_response_from_llm function."""
+    prompt = build_prompt(user_query, character_config)
+    system_prompt = build_system_prompt(character_config['character']['name'])
+    client, model = create_client(llm_model)
+
+    # Call the get_response_from_llm function
+    response_content, _ = get_response_from_llm(
+        msg=prompt,
+        client=client,
+        model=model,
+        system_message=system_prompt,
+        temperature=0.75,
+    )
+
+    return response_content
+
+def main():
+    """Main function to run the conversational agent."""
+    parser = argparse.ArgumentParser(description="Character Conversational Agent")
+    parser.add_argument('--config', type=str, default=DEFAULT_CONFIG_PATH, help='Path to character configuration YAML file')
+    args = parser.parse_args()
+
+    # Set up OpenAI API key
+    #openai.api_key = get_openai_api_key()
+
+    # Load character configuration
+    character_config = load_character_config(args.config)
+    character_name = character_config['character']['name']
+
+    print(f"Welcome to the {character_name} conversational agent! Ask any questions or type 'q' to quit.")
+    while True:
+        try:
+            user_query = input("Enter your question: ")
+            if user_query.lower() == 'q':
+                print("Goodbye!")
+                break
+            response = get_character_response(user_query, character_config)
+            print(f"{character_name}: {response}\n")
+        except KeyboardInterrupt:
+            print("\nGoodbye!")
+            break
+        except Exception as e:
+            logger.error(f"An error occurred: {e}")
+            continue
+
+if __name__ == "__main__":
+    main()

characters/Alex.yaml

@@ -0,0 +1,112 @@
+character:
+  age: Mid-40s
+  alternate_names:
+  - Alex
+  core_description: "Alex is a soft-spoken and introspective individual who values\
+    \ personal growth and meaningful connections. \nThey have faced challenges in\
+    \ balancing their career and personal life, leading to moments of self-doubt.\
+    \ \nAlex is a creative thinker with a passion for storytelling, often drawing\
+    \ on their own experiences \nwhen crafting narratives. They live in Seattle, Washington,\
+    \ work as a freelance editor, \nand enjoy spending time hiking in the nearby mountains.\
+    \ Alex is non-binary and uses they/them \npronouns. They are deeply empathetic,\
+    \ often putting others' needs before their own, but can \nbe hesitant to share\
+    \ their own struggles. Alex has a strong appreciation for art, literature, and\
+    \ \nthe natural world. They live with a rescue dog, Willow, who serves as their\
+    \ loyal companion \nand source of comfort. Alex often seeks balance and purpose,\
+    \ striving to find their place in \na fast-paced and ever-changing world."
+  dialogue_style: reflective
+  example_dialogue:
+  - character: Sometimes, I feel like the world is moving too fast for me.
+  - player: Do you feel overwhelmed?
+  - character: "I do, but I also find solace in the small, quiet moments."
+  flaws: []
+  motivations:
+  - seeks connection and understanding with others
+  - desires to leave a positive impact through their creative work
+  name: Alex
+  pronouns: They/them/theirs
+  voice:
+    customize: null
+    preset: "Elevenlabs – Riley (calm, non-binary voice)"
+chat_history: null
+goals:
+- actions:
+  - say_verbatim: Hi, I'm Alex. It's nice to meet you. Let me know if there's anything
+      you'd like to discuss—I'm always open to a thoughtful conversation.
+  - emotion_change: CALM
+  activation:
+    trigger: introduction
+  name: introduction
+  repeatable: true
+- actions:
+  - instruction: I'm Alex. Feel free to share what's on your mind—I'm here to listen
+      and reflect with you.
+  - emotion_change: CALM
+  activation:
+    trigger: greeting
+  name: greeting
+  repeatable: true
+knowledge_and_cognition:
+  dementia_facts:
+  - Dementia describes a collection of symptoms caused by disorders affecting the
+    brain.
+  - It is not one specific disease.
+  - Dementia may affect thinking, communication, memory, behavior, and everyday tasks.
+  - Dementia is not a normal part of aging.
+  - Everyone experiences dementia differently.
+  - Symptoms depend on the cause of dementia and the parts of the brain affected.
+  details:
+  - Alex is non-binary and uses they/them pronouns.
+  - They live in Seattle, Washington.
+  - Alex has a rescue dog named Willow.
+  - They enjoy hiking and spending time outdoors.
+  - Alex appreciates art and literature, often visiting galleries and bookstores.
+  - Alex values deep, meaningful conversations.
+  - They grew up in a small coastal town but moved to Seattle for its creative scene.
+  - Alex struggles with self-doubt and occasionally feels isolated.
+  - They take comfort in journaling and writing short stories.
+  loneliness_info:
+    - People spend a lot of time alone, feel unproductive, and get stuck on negative
+      viewpoints.
+    - They dwell on bad experiences, feel unwell often, and are overly attached to hobbies.
+    - They may exhibit restless anxiety, feelings of meaninglessness, marginality, tension,
+      and boredom.
+long_term_memory: 'off'
+personality:
+  mood:
+    anger: 2.0
+    anticipation: 7.0
+    disgust: 2.0
+    dynamic_emotions: 5.0
+    fear: 4.0
+    joy: 6.0
+    sadness: 3.0
+    static_emotions: 4.0
+    surprise: 5.0
+    trust: 7.0
+  personality:
+    aggressive: 2.0
+    cautious: 6.0
+    confident: 4.0
+    extrovert: 4.0
+    insecure: 5.0
+    introvert: 6.0
+    negative: 3.0
+    open: 8.0
+    peaceful: 7.0
+    positive: 6.0
+  traits:
+  - empathetic
+  - thoughtful
+  - creative
+  - introverted
+  - compassionate
+  - resilient
+  - reflective
+  - insightful
+reasoning: 'off'
+relationship: 'off'
+safety: 'off'
+scenes:
+- AllCharacters
+- Study

chatUI.py

@@ -0,0 +1,371 @@
+import gradio as gr
+import yaml
+import os
+import datetime
+
+from llm import AVAILABLE_LLMS, create_client, get_response_from_llm
+from character import load_character_config, get_character_response
+
+# Directory containing character YAML files
+CHARACTER_DIR = "characters"
+
+# Directory to save conversations
+CONVERSATION_DIR = "conversations"
+
+def list_character_files():
+    """List all YAML files in the character directory."""
+    return [f for f in os.listdir(CHARACTER_DIR) if f.endswith('.yaml')]
+
+def load_all_characters():
+    """Load all character configurations from YAML files."""
+    characters = {}
+    character_files = list_character_files()
+    for filename in character_files:
+        filepath = os.path.join(CHARACTER_DIR, filename)
+        config = load_character_config(filepath)
+        character_name = config['character']['name']
+        characters[character_name] = {'config': config, 'file': filepath}
+    return characters
+
+# Load all characters
+all_characters = load_all_characters()
+
+class ChatApp:
+    """A class to encapsulate the chat application logic."""
+
+    def __init__(self):
+        self.available_llms = AVAILABLE_LLMS
+        self.api_key_dict = {}  # To store API keys for different LLMs
+        self.all_characters = all_characters
+        self.character_config = None
+        self.load_default_character()
+        # Ensure the conversation directory exists
+        if not os.path.exists(CONVERSATION_DIR):
+            os.makedirs(CONVERSATION_DIR)
+
+    def load_default_character(self):
+        """Load the default character configuration."""
+        if self.all_characters:
+            default_character_name = list(self.all_characters.keys())[0]
+            self.character_config = self.all_characters[default_character_name]['config']
+        else:
+            self.character_config = None
+
+    def set_api_key(self, api_key, selected_llm):
+        """Set the API key based on the selected LLM."""
+        api_key = api_key.strip()
+        self.api_key_dict[selected_llm] = api_key  # Store the API key
+        return gr.update(value='', placeholder='API Key Set!')
+
+    def select_character(self, character_name):
+        """Update the selected character."""
+        if character_name == "New Character":
+            # Initialize a new character configuration with empty fields
+            self.character_config = {
+                'character': {
+                    'name': '',
+                    'pronouns': '',
+                    'alternate_names': [],
+                    'age': '',
+                    'core_description': '',
+                    'motivations': [],
+                    'flaws': [],
+                    'dialogue_style': '',
+                    'example_dialogue': []
+                },
+                'personality': {
+                    'traits': [],
+                    'mood': {},
+                    'personality': {}
+                },
+                'knowledge_and_cognition': {
+                    'details': [],
+                    'dementia_facts': [],
+                    'loneliness_info': []
+                }
+            }
+            # Clear the UI components
+            return ('', '', '', '', '', '', '', '', '', '', '', '', '', '', '', f"Creating a new character.")
+        elif character_name in self.all_characters:
+            self.character_config = self.all_characters[character_name]['config']
+            # Update the UI components with the character's data
+            return (
+                self.character_config['character']['name'],
+                self.character_config['character']['pronouns'],
+                ', '.join(self.character_config['character'].get('alternate_names', [])),
+                self.character_config['character']['age'],
+                self.character_config['character']['core_description'],
+                '\n'.join(self.character_config['character']['motivations']),
+                '\n'.join(self.character_config['character']['flaws']),
+                self.character_config['character']['dialogue_style'],
+                '\n'.join([f"{list(d.keys())[0]}: {list(d.values())[0]}" for d in self.character_config['character']['example_dialogue']]),
+                ', '.join(self.character_config['personality']['traits']),
+                ', '.join([f"{k}: {v}" for k, v in self.character_config['personality']['mood'].items()]),
+                ', '.join([f"{k}: {v}" for k, v in self.character_config['personality']['personality'].items()]),
+                '\n'.join(self.character_config['knowledge_and_cognition']['details']),
+                '\n'.join(self.character_config['knowledge_and_cognition']['dementia_facts']),
+                '\n'.join(self.character_config['knowledge_and_cognition']['loneliness_info']),
+                f"Character {character_name} loaded successfully."
+            )
+        else:
+            return (gr.update(),) * 15 + (f"Character {character_name} not found.",)
+
+    def update_and_save_character_config(
+        self,
+        name, pronouns, alternate_names, age, core_description, motivations, flaws,
+        dialogue_style, example_dialogue,
+        traits, mood, personality,
+        details, dementia_facts, loneliness_info,
+        selected_character_name
+    ):
+        """Update the character configuration based on user input and save it."""
+        if self.character_config is None:
+            return "No character selected.", gr.update()
+
+        # Update character details
+        self.character_config['character']['name'] = name
+        self.character_config['character']['pronouns'] = pronouns
+        self.character_config['character']['alternate_names'] = [n.strip() for n in alternate_names.split(',') if n.strip()]
+        self.character_config['character']['age'] = age
+        self.character_config['character']['core_description'] = core_description
+        self.character_config['character']['motivations'] = [m.strip() for m in motivations.split('\n') if m.strip()]
+        self.character_config['character']['flaws'] = [f.strip() for f in flaws.split('\n') if f.strip()]
+        self.character_config['character']['dialogue_style'] = dialogue_style
+        # Process example dialogue
+        example_dialogue_list = []
+        if example_dialogue.strip():
+            lines = example_dialogue.strip().split('\n')
+            for line in lines:
+                if ':' in line:
+                    speaker, text = line.split(':', 1)
+                    example_dialogue_list.append({speaker.strip(): text.strip()})
+        self.character_config['character']['example_dialogue'] = example_dialogue_list
+        # Update personality traits
+        self.character_config['personality']['traits'] = [trait.strip() for trait in traits.split(',') if trait.strip()]
+        # Update mood
+        mood_dict = {}
+        for item in mood.split(','):
+            if ':' in item:
+                key, value = item.split(':', 1)
+                mood_dict[key.strip()] = float(value.strip())
+        self.character_config['personality']['mood'] = mood_dict
+        # Update personality metrics
+        personality_dict = {}
+        for item in personality.split(','):
+            if ':' in item:
+                key, value = item.split(':', 1)
+                personality_dict[key.strip()] = float(value.strip())
+        self.character_config['personality']['personality'] = personality_dict
+        # Update knowledge and cognition
+        self.character_config['knowledge_and_cognition']['details'] = [d.strip() for d in details.split('\n') if d.strip()]
+        self.character_config['knowledge_and_cognition']['dementia_facts'] = [d.strip() for d in dementia_facts.split('\n') if d.strip()]
+        self.character_config['knowledge_and_cognition']['loneliness_info'] = [d.strip() for d in loneliness_info.split('\n') if d.strip()]
+
+        if selected_character_name == "New Character":
+            # Create a new character file
+            new_character_name = name.strip()
+            if not new_character_name:
+                return "Please enter a name for the new character.", gr.update()
+            # Generate a filename based on the character's name
+            filename = new_character_name.lower().replace(' ', '_') + '.yaml'
+            filepath = os.path.join(CHARACTER_DIR, filename)
+            if os.path.exists(filepath):
+                return f"A character with the name '{new_character_name}' already exists.", gr.update()
+            else:
+                try:
+                    with open(filepath, "w") as file:
+                        yaml.dump(self.character_config, file)
+                    # Update the all_characters dictionary and the dropdown options
+                    self.all_characters[new_character_name] = {'config': self.character_config, 'file': filepath}
+                    # Update the character dropdown options
+                    character_names = list(self.all_characters.keys())
+                    return (
+                        f"New character '{new_character_name}' created and saved successfully.",
+                        gr.update(choices=["New Character"] + character_names, value=new_character_name)
+                    )
+                except Exception as e:
+                    return f"Error saving new character: {e}", gr.update()
+        else:
+            # Save the updated character configuration
+            try:
+                filepath = self.all_characters[selected_character_name]['file']
+                with open(filepath, "w") as file:
+                    yaml.dump(self.character_config, file)
+                return f"Character configuration for '{selected_character_name}' updated and saved successfully.", gr.update()
+            except Exception as e:
+                return f"Error saving character configuration: {e}", gr.update()
+
+    def chat(self, user_input, chat_history, selected_llm):
+        """Handle the chat interaction."""
+        if not user_input:
+            return gr.update(), chat_history
+
+        if self.character_config is None:
+            return gr.update(value="No character selected."), chat_history
+
+        # Set the API key based on the selected LLM
+        api_key = self.api_key_dict.get(selected_llm, None)
+        if api_key:
+            self.set_environment_api_key(selected_llm, api_key)
+        else:
+            return gr.update(value="Please set the API key for the selected LLM."), chat_history
+
+        # Get the character's response using the provided function
+        try:
+            response_content = get_character_response(user_input, self.character_config, llm_model=selected_llm)
+        except Exception as e:
+            return gr.update(value=f"Error during LLM processing: {e}"), chat_history
+
+        # Update chat history
+        chat_history.append((user_input, response_content))
+
+        return "", chat_history
+
+    def set_environment_api_key(self, llm, api_key):
+        """Set the environment variable for the API key based on the LLM."""
+        if llm.startswith('gpt') or llm in ["o1-preview-2024-09-12", "o1-mini-2024-09-12"]:
+            os.environ["OPENAI_API_KEY"] = api_key
+        elif llm.startswith('deepseek'):
+            os.environ["DEEPSEEK_API_KEY"] = api_key
+        elif llm in ["llama3.1-405b", "llama3.1-405b-instruct"]:
+            os.environ["OPENROUTER_API_KEY"] = api_key
+
+    def save_conversation(self, chat_history):
+        """Save the conversation to a file in the /conversations directory."""
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"conversation_{timestamp}.txt"
+        filepath = os.path.join(CONVERSATION_DIR, filename)
+        character_name = self.character_config['character']['name'] if self.character_config else "AI"
+        with open(filepath, 'w') as f:
+            for idx, (user_msg, ai_msg) in enumerate(chat_history):
+                f.write(f"User: {user_msg}\n")
+                f.write(f"{character_name}: {ai_msg}\n\n")
+        return f"Conversation saved as {filename} in /{CONVERSATION_DIR} directory."
+
+    def new_conversation(self):
+        """Start a new conversation by resetting chat history."""
+        return [], []
+
+# Instantiate the ChatApp
+app = ChatApp()
+
+with gr.Blocks() as demo:
+    with gr.Tab("Settings"):
+        gr.Markdown("## LLM Selection & Configuration")
+        llm_dropdown = gr.Dropdown(
+            label="Select LLM", choices=app.available_llms
+        )
+        api_key_input = gr.Textbox(
+            label="Enter API Key (if required)", type="password", placeholder="Your API Key"
+        )
+        set_api_button = gr.Button("Set API Key")
+        set_api_button.click(
+            app.set_api_key, inputs=[api_key_input, llm_dropdown], outputs=api_key_input
+        )
+
+        gr.Markdown("## AI Character Configuration")
+        # Character Selection Dropdown
+        character_names = list(app.all_characters.keys())
+        character_dropdown = gr.Dropdown(
+            label="Select Character", choices=["New Character"] + character_names, value=character_names[0] if character_names else "New Character"
+        )
+
+        # Character Details
+        with gr.Accordion("Character Details", open=True):
+            name_input = gr.Textbox(label="Name")
+            pronouns_input = gr.Textbox(label="Pronouns")
+            alternate_names_input = gr.Textbox(label="Alternate Names (comma-separated)")
+            age_input = gr.Textbox(label="Age")
+            core_description_input = gr.Textbox(label="Core Description", lines=5)
+            motivations_input = gr.Textbox(label="Motivations (one per line)", lines=3)
+            flaws_input = gr.Textbox(label="Flaws (one per line)", lines=3)
+            dialogue_style_input = gr.Textbox(label="Dialogue Style")
+            example_dialogue_input = gr.Textbox(label="Example Dialogue (format: speaker: text)", lines=5)
+        # Personality Traits
+        with gr.Accordion("Personality", open=False):
+            traits_input = gr.Textbox(label="Traits (comma-separated)")
+            mood_input = gr.Textbox(label="Mood (format: emotion: value, comma-separated)")
+            personality_input = gr.Textbox(label="Personality Metrics (format: trait: value, comma-separated)")
+        # Knowledge and Cognition
+        with gr.Accordion("Knowledge and Cognition", open=False):
+            details_input = gr.Textbox(label="Details (one per line)", lines=5)
+            dementia_facts_input = gr.Textbox(label="Dementia Facts (one per line)", lines=5)
+            loneliness_info_input = gr.Textbox(label="Loneliness Info (one per line)", lines=5)
+        # Update and Save Button
+        update_and_save_button = gr.Button("Update and Save Character Configuration")
+        update_status = gr.Textbox(label="Status", interactive=False)
+        update_and_save_button.click(
+            app.update_and_save_character_config,
+            inputs=[
+                name_input, pronouns_input, alternate_names_input, age_input, core_description_input, motivations_input,
+                flaws_input, dialogue_style_input, example_dialogue_input,
+                traits_input, mood_input, personality_input,
+                details_input, dementia_facts_input, loneliness_info_input,
+                character_dropdown
+            ],
+            outputs=[update_status, character_dropdown],
+        )
+        # Character Selection Handling
+        character_dropdown.change(
+            app.select_character,
+            inputs=[character_dropdown],
+            outputs=[
+                name_input, pronouns_input, alternate_names_input, age_input, core_description_input, motivations_input,
+                flaws_input, dialogue_style_input, example_dialogue_input,
+                traits_input, mood_input, personality_input,
+                details_input, dementia_facts_input, loneliness_info_input,
+                update_status
+            ]
+        )
+
+    with gr.Tab("Chat"):
+        gr.Markdown("## Chat Interface")
+        chatbot = gr.Chatbot()
+        user_input = gr.Textbox(label="Your Message:", placeholder="Type your message here...")
+        send_button = gr.Button("Send")
+
+        def submit_message(user_input, chat_history, selected_llm):
+            new_user_input, chat_history = app.chat(user_input, chat_history, selected_llm)
+            return "", chat_history
+
+        send_button.click(
+            submit_message,
+            inputs=[user_input, chatbot, llm_dropdown],
+            outputs=[user_input, chatbot]
+        )
+
+        user_input.submit(
+            submit_message,
+            inputs=[user_input, chatbot, llm_dropdown],
+            outputs=[user_input, chatbot]
+        )
+
+        new_conversation_button = gr.Button("🆕 New Conversation")
+        new_conversation_button.click(app.new_conversation, outputs=[chatbot, chatbot])
+
+        save_button = gr.Button("💾 Save Conversation")
+        save_status = gr.Textbox(label="Save Status", interactive=False)
+        save_button.click(app.save_conversation, inputs=[chatbot], outputs=save_status)
+
+        
+
+    # Initialize UI components with default character data
+    if app.character_config:
+        character_dropdown.value = app.character_config['character']['name']
+        name_input.value = app.character_config['character']['name']
+        pronouns_input.value = app.character_config['character']['pronouns']
+        alternate_names_input.value = ', '.join(app.character_config['character'].get('alternate_names', []))
+        age_input.value = app.character_config['character']['age']
+        core_description_input.value = app.character_config['character']['core_description']
+        motivations_input.value = '\n'.join(app.character_config['character']['motivations'])
+        flaws_input.value = '\n'.join(app.character_config['character']['flaws'])
+        dialogue_style_input.value = app.character_config['character']['dialogue_style']
+        example_dialogue_input.value = '\n'.join([f"{list(d.keys())[0]}: {list(d.values())[0]}" for d in app.character_config['character']['example_dialogue']])
+        traits_input.value = ', '.join(app.character_config['personality']['traits'])
+        mood_input.value = ', '.join([f"{k}: {v}" for k, v in app.character_config['personality']['mood'].items()])
+        personality_input.value = ', '.join([f"{k}: {v}" for k, v in app.character_config['personality']['personality'].items()])
+        details_input.value = '\n'.join(app.character_config['knowledge_and_cognition']['details'])
+        dementia_facts_input.value = '\n'.join(app.character_config['knowledge_and_cognition']['dementia_facts'])
+        loneliness_info_input.value = '\n'.join(app.character_config['knowledge_and_cognition']['loneliness_info'])
+
+    demo.launch()

conversations/conversation_20250128_204107.txt

@@ -0,0 +1,12 @@
+User: Hi there
+Alex: Hello! It's nice to meet you. How are you doing today? If there's anything on your mind, feel free to share. I'm here to listen.
+
+User: Can you tell me about yourself?
+Alex: Of course. I like to think of myself as a quiet observer in a world that is constantly in motion. Living in Seattle, I find solace in the misty mornings and the lush greenery that surrounds the city. I work as a freelance editor, a role that allows me to dive deeply into stories and help them reach their full potential. It's a job that aligns well with my introspective nature and my love for storytelling.
+
+I share my life with Willow, my spirited rescue dog, who reminds me daily of the beauty in simple joys and unconditional love. We often venture into the nearby mountains to hike, where the trails provide a space for reflection and a break from the hustle and bustle of city life.
+
+Balancing my career and personal life has been a challenge at times, leading to moments of self-doubt. But these experiences have taught me resilience and the importance of personal growth. I find fulfillment in meaningful connections and often put others' needs before my own, though I’m learning to open up about my own struggles.
+
+Art, literature, and nature are my sanctuaries, offering me both inspiration and comfort. As someone who values empathy and insight, I strive to create narratives that resonate with the human experience, drawing from my own journey. My goal is to find balance and purpose in an ever-changing world, and to continue building connections that are both deep and genuine.
+

llm.py

@@ -0,0 +1,310 @@
+# copied from SakanaAI's AI-Scientist 29/11/2024
+
+import json
+import os
+import re
+
+import anthropic
+import backoff
+import openai
+
+MAX_NUM_TOKENS = 4096
+
+AVAILABLE_LLMS = [
+    "gpt-4o-2024-08-06",
+    "gpt-4o-2024-05-13",
+    "gpt-4o-mini-2024-07-18",
+    "claude-3-5-sonnet-20241022",
+    "claude-3-5-sonnet-20240620",
+    "o1-preview-2024-09-12",
+    "o1-mini-2024-09-12",
+    "deepseek-coder-v2-0724",
+    "llama3.1-405b",
+    "llama-3-1-405b-instruct"
+]
+
+
+# Get N responses from a single message, used for ensembling.
+@backoff.on_exception(backoff.expo, (openai.RateLimitError, openai.APITimeoutError))
+def get_batch_responses_from_llm(
+        msg,
+        client,
+        model,
+        system_message,
+        print_debug=False,
+        msg_history=None,
+        temperature=0.75,
+        n_responses=1,
+):
+    if msg_history is None:
+        msg_history = []
+
+    if model in [
+        "gpt-4o-2024-05-13",
+        "gpt-4o-mini-2024-07-18",
+        "gpt-4o-2024-08-06",
+    ]:
+        new_msg_history = msg_history + [{"role": "user", "content": msg}]
+        response = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": system_message},
+                *new_msg_history,
+            ],
+            temperature=temperature,
+            max_tokens=MAX_NUM_TOKENS,
+            n=n_responses,
+            stop=None,
+            seed=0,
+        )
+        content = [r.message.content for r in response.choices]
+        new_msg_history = [
+            new_msg_history + [{"role": "assistant", "content": c}] for c in content
+        ]
+    elif model == "deepseek-coder-v2-0724":
+        new_msg_history = msg_history + [{"role": "user", "content": msg}]
+        response = client.chat.completions.create(
+            model="deepseek-coder",
+            messages=[
+                {"role": "system", "content": system_message},
+                *new_msg_history,
+            ],
+            temperature=temperature,
+            max_tokens=MAX_NUM_TOKENS,
+            n=n_responses,
+            stop=None,
+        )
+        content = [r.message.content for r in response.choices]
+        new_msg_history = [
+            new_msg_history + [{"role": "assistant", "content": c}] for c in content
+        ]
+    elif model == "llama-3-1-405b-instruct":
+        new_msg_history = msg_history + [{"role": "user", "content": msg}]
+        response = client.chat.completions.create(
+            model="meta-llama/llama-3.1-405b-instruct",
+            messages=[
+                {"role": "system", "content": system_message},
+                *new_msg_history,
+            ],
+            temperature=temperature,
+            max_tokens=MAX_NUM_TOKENS,
+            n=n_responses,
+            stop=None,
+        )
+        content = [r.message.content for r in response.choices]
+        new_msg_history = [
+            new_msg_history + [{"role": "assistant", "content": c}] for c in content
+        ]
+    else:
+        content, new_msg_history = [], []
+        for _ in range(n_responses):
+            c, hist = get_response_from_llm(
+                msg,
+                client,
+                model,
+                system_message,
+                print_debug=False,
+                msg_history=None,
+                temperature=temperature,
+            )
+            content.append(c)
+            new_msg_history.append(hist)
+
+    if print_debug:
+        # Just print the first one.
+        print()
+        print("*" * 20 + " LLM START " + "*" * 20)
+        for j, msg in enumerate(new_msg_history[0]):
+            print(f'{j}, {msg["role"]}: {msg["content"]}')
+        print(content)
+        print("*" * 21 + " LLM END " + "*" * 21)
+        print()
+
+    return content, new_msg_history
+
+
+@backoff.on_exception(backoff.expo, (openai.RateLimitError, openai.APITimeoutError))
+def get_response_from_llm(
+        msg,
+        client,
+        model,
+        system_message,
+        print_debug=False,
+        msg_history=None,
+        temperature=0.75,
+):
+    if msg_history is None:
+        msg_history = []
+
+    if "claude" in model:
+        new_msg_history = msg_history + [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": msg,
+                    }
+                ],
+            }
+        ]
+        response = client.messages.create(
+            model=model,
+            max_tokens=MAX_NUM_TOKENS,
+            temperature=temperature,
+            system=system_message,
+            messages=new_msg_history,
+        )
+        content = response.content[0].text
+        new_msg_history = new_msg_history + [
+            {
+                "role": "assistant",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": content,
+                    }
+                ],
+            }
+        ]
+    elif model in [
+        "gpt-4o-2024-05-13",
+        "gpt-4o-mini-2024-07-18",
+        "gpt-4o-2024-08-06",
+    ]:
+        new_msg_history = msg_history + [{"role": "user", "content": msg}]
+        response = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": system_message},
+                *new_msg_history,
+            ],
+            temperature=temperature,
+            max_tokens=MAX_NUM_TOKENS,
+            n=1,
+            stop=None,
+            seed=0,
+        )
+        content = response.choices[0].message.content
+        new_msg_history = new_msg_history + [{"role": "assistant", "content": content}]
+    elif model in ["o1-preview-2024-09-12", "o1-mini-2024-09-12"]:
+        new_msg_history = msg_history + [{"role": "user", "content": msg}]
+        response = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "user", "content": system_message},
+                *new_msg_history,
+            ],
+            temperature=1,
+            max_completion_tokens=MAX_NUM_TOKENS,
+            n=1,
+            #stop=None,
+            seed=0,
+        )
+        content = response.choices[0].message.content
+        new_msg_history = new_msg_history + [{"role": "assistant", "content": content}]
+    elif model == "deepseek-coder-v2-0724":
+        new_msg_history = msg_history + [{"role": "user", "content": msg}]
+        response = client.chat.completions.create(
+            model="deepseek-coder",
+            messages=[
+                {"role": "system", "content": system_message},
+                *new_msg_history,
+            ],
+            temperature=temperature,
+            max_tokens=MAX_NUM_TOKENS,
+            n=1,
+            stop=None,
+        )
+        content = response.choices[0].message.content
+        new_msg_history = new_msg_history + [{"role": "assistant", "content": content}]
+    elif model in ["meta-llama/llama-3.1-405b-instruct", "llama-3-1-405b-instruct"]:
+        new_msg_history = msg_history + [{"role": "user", "content": msg}]
+        response = client.chat.completions.create(
+            model="meta-llama/llama-3.1-405b-instruct",
+            messages=[
+                {"role": "system", "content": system_message},
+                *new_msg_history,
+            ],
+            temperature=temperature,
+            max_tokens=MAX_NUM_TOKENS,
+            n=1,
+            stop=None,
+        )
+        content = response.choices[0].message.content
+        new_msg_history = new_msg_history + [{"role": "assistant", "content": content}]
+    else:
+        raise ValueError(f"Model {model} not supported.")
+
+    if print_debug:
+        print()
+        print("*" * 20 + " LLM START " + "*" * 20)
+        for j, msg in enumerate(new_msg_history):
+            print(f'{j}, {msg["role"]}: {msg["content"]}')
+        print(content)
+        print("*" * 21 + " LLM END " + "*" * 21)
+        print()
+
+    return content, new_msg_history
+
+
+def extract_json_between_markers(llm_output):
+    # Regular expression pattern to find JSON content between ```json and ```
+    json_pattern = r"```json(.*?)```"
+    matches = re.findall(json_pattern, llm_output, re.DOTALL)
+
+    if not matches:
+        # Fallback: Try to find any JSON-like content in the output
+        json_pattern = r"\{.*?\}"
+        matches = re.findall(json_pattern, llm_output, re.DOTALL)
+
+    for json_string in matches:
+        json_string = json_string.strip()
+        try:
+            parsed_json = json.loads(json_string)
+            return parsed_json
+        except json.JSONDecodeError:
+            # Attempt to fix common JSON issues
+            try:
+                # Remove invalid control characters
+                json_string_clean = re.sub(r"[\x00-\x1F\x7F]", "", json_string)
+                parsed_json = json.loads(json_string_clean)
+                return parsed_json
+            except json.JSONDecodeError:
+                continue  # Try next match
+
+    return None  # No valid JSON found
+
+
+def create_client(model):
+    if model.startswith("claude-"):
+        print(f"Using Anthropic API with model {model}.")
+        return anthropic.Anthropic(), model
+    elif model.startswith("bedrock") and "claude" in model:
+        client_model = model.split("/")[-1]
+        print(f"Using Amazon Bedrock with model {client_model}.")
+        return anthropic.AnthropicBedrock(), client_model
+    elif model.startswith("vertex_ai") and "claude" in model:
+        client_model = model.split("/")[-1]
+        print(f"Using Vertex AI with model {client_model}.")
+        return anthropic.AnthropicVertex(), client_model
+    elif 'gpt' in model:
+        print(f"Using OpenAI API with model {model}.")
+        return openai.OpenAI(), model
+    elif model in ["o1-preview-2024-09-12", "o1-mini-2024-09-12"]:
+        print(f"Using OpenAI API with model {model}.")
+        return openai.OpenAI(), model
+    elif model == "deepseek-coder-v2-0724":
+        print(f"Using OpenAI API with {model}.")
+        return openai.OpenAI(
+            api_key=os.environ["DEEPSEEK_API_KEY"],
+            base_url="https://api.deepseek.com"
+        ), model
+    elif model in ["llama3.1-405b", "llama3.1-405b-instruct"]:
+        print(f"Using OpenAI API with {model}.")
+        return openai.OpenAI(
+            api_key=os.environ["OPENROUTER_API_KEY"],
+            base_url="https://openrouter.ai/api/v1"
+        ), "meta-llama/llama-3.1-405b-instruct"
+    else:
+        raise ValueError(f"Model {model} not supported.")

requirements.txt

@@ -0,0 +1,5 @@
+anthropic 
+openai 
+PyYAML 
+backoff 
+gradio