Mt Olympus Project

Architectural Design

Mt Olympus Project

Overview 

The Mount Olympus project is a multi-user interactive experience where users engage with AI-driven personas of Greek gods. These personas respond dynamically based on emotional cues and personalized user histories. The architecture leverages **Hume AI for emotional analysis**, **Python for orchestration and scripting**, and **Unity as a centralized hub** for managing scripts, assets, and cross-platform integration.

The key objective is to create a scalable, event-driven system that offers dynamic, emotionally responsive interactions, with each god’s behavior shaped by persistent conversational history. Unity serves as the backbone for organizing and executing scripts while allowing seamless integration with external APIs, including Hume AI, VR, and mobile platforms.

Core Components 

1. Hume AI – Emotional Analysis and Persona Management 
Hume AI plays a central role in analyzing user input and managing the emotional state of each god persona.

It also offers these design advantages:

 
Hume maintains a configuration template that establishes each god’s personality, voice, and initialization script. 
Assigned Voice: Custom voice configuration for each god. 
Initialization Script: Establishes persona’s backstory, behavior, and traits. 
Session Tokens: Used to track conversational history of interactions over time 

Emotional Analysis Workflow:

A User input (WAV file) is sent to Hume for emotional analysis. 
Hume returns emotional metadata (e.g., “angry,” “calm,” “excited”) along with context for the response. 
This data informs the behavior and tone of the AI persona’s response. 
Response Subroutines: Hume provides predefined responses for specific emotional states (e.g., anger management, calming routines) that can be tapped into for advanced interactions. 

2. Python – Orchestration Layer \ Context Envelop
The Python layer acts as the event manager, coordinating between Hume AI and Unity. 
– Audio Input Handling: Captures user input and sends it to Hume for processing. 
– Response Management: Receives emotional metadata from Hume and generates appropriate responses based on              the current context. 
– Scripting and Context Management: 
   – Python scripts manage the dynamic flow of interactions. 
   – Context envelopes track ongoing user interactions and ensure continuity across sessions. 
– Integration with Unity: Python communicates with Unity via JSON protocols, passing emotional data and response triggers. 

–Context Envelope: providing a hard stop point in the submission of prompts

3. Unity – Centralized Hub for Script Management and Cross-Platform Integration 
Unity is the core environment for cataloging, managing, and executing scripts while providing cross-platform compatibility.

 
Script Cataloging and Execution: 
– Unity serves as the central repository for all scripts related to the Mount Olympus project. 

– Scripts can be easily accessed, modified, and executed within Unity. 
Cross-Platform API Support: 
   – Unity’s extensive API ecosystem allows seamless integration with external platforms, including VR, iOS, Android, and  web-based systems. 
    -Alternative Visual Rendering Options: Unity offers robust support for real-time rendering, but we have also been exploring alternative solutions for visual and lip-syncing needs.

These include D-ID and ByteDance technologies, which provide more flexibility and innovation in character presentation.

—We currently do not envision using the Unity Game Space for visualizations

—The central use of UNITY is in script management and it’s robust access to a wide range of APIs

_{The development environment will focus on a combination of Python for backend orchestration and Unity for managing and testing scripts. Depending on the complexity, different tools will be required:} 
 

Python Development: Basic Python libraries will handle audio input, JSON data exchange, and integration with external APIs (Hume AI, D-ID). The setup can be managed using standard Python IDEs like **PyCharm** or **VSCode**, with minimal library maintenance beyond core dependencies. 
 

Unity as the Integration Hub: Unity probably will not be used for game-space purposes. Instead, it will be utilized for its robust API management. It also excels in script cataloging capabilities. Unity’s role is to act as the central repository for managing project elements and running integration tests. 
 

Testing Options: Initial development and testing can be performed locally using Python scripts and Unity’s Play mode for integration testing. For more advanced visual presentation and character rendering, external services like D-ID and ByteDance will be integrated for visual feedback and emotional expression. 

Data Flow 

1. User Interaction 
1. User speaks to a god persona. 
2. Audio is recorded and converted to a WAV file. 
3. WAV file is sent to Hume for emotional analysis. 
4. Hume returns emotional metadata and response context. 
5. Python orchestrates the response, triggering the appropriate Unity script 
6. The chosen visual engine generates the visual and vocal

rendering the god’s reaction with matching emotional expressions. 

7. User receives a dynamic, personalized response. 

2. JSON Protocol for Data Exchange 
– JSON is the primary protocol for between Python, Hume, and Unity. 
– Emotional metadata, response triggers, and session context are passed as structured JSON objects.

Key Design Considerations 

1. Event-Driven Architecture 
– The system is built around an event-driven model, where each interaction triggers a series of predefined actions. 
– This ensures scalable and responsive interactions, with minimal latency. 

2. Low-Code Approach 
– Emphasis on low-code development to reduce complexity and accelerate implementation. 
– Leveraging Unity’s extensive API support simplifies cross-platform deployment. 

3. Personalized User Experience 
– Each user’s interaction history is tracked through Hume’s session tokens. 
– The god personas adapt their responses based on prior interactions, creating a more immersive and personalized experience.


Conclusion 
This architecture combines the power of Hume AI’s emotional analysis. It also uses Python’s flexibility for orchestration. Unity’s robust script management and cross-platform capabilities further enhance it. By leveraging an event-driven, low-code approach, the Mount Olympus project offers a scale-able, dynamic environment for interactive storytelling.

The development environment will focus on lightweight and scalable tools, with flexibility to integrate new visual technologies such as D-ID or ByteDance for

enhanced character interaction. The next steps involve refining the Python orchestration layer. We will integrate Hume’s emotional subroutines. Unity’s role will expand as an integration and testing hub.