Create Engaging Personalized Myths: Python Hero's Journey Story Generator with Local AI

Want to craft unique, personalized stories using AI, all while keeping your data private? Use Python and local AI to generate captivating tales tailored to you. This Hero's Journey Story Generator script combines personal details with timeless narrative structures and folklore motifs, creating personalized myths that feel both intimate and epic.

Whether you're a storyteller, educator, or developer, this tool sparks imagination and offers a unique creative outlet. Plus, you can create immersive audio narratives for stories that come to life. Let’s dive into how you can build your Hero's Journey story generator.

Why Build a Local AI Story Generator?

Familiar Structure: Leverages Campbell’s Hero’s Journey, a narrative framework recognized across cultures.
Rich Symbolism: Injects tales with authentic folklore motifs using the Thompson Motif Index.
Data Privacy: Runs offline using Ollama, ensuring complete control over your personal information.
Multi-Sensory Experience: Offers offline narration via pyttsx3 and Markdown export.

The Power of the Hero's Journey

Every compelling story follows a pattern. Joseph Campbell's Hero's Journey is a 12-stage narrative template found in myths worldwide. This tool uses key Hero’s Journey stages to make sure each story has a familiar, custom story arc:

Ordinary World: Introduces the hero's everyday life.
Call to Adventure: Presents a challenge or opportunity.
Refusal of the Call: Shows the hero's hesitation.
Meeting the Mentor: Introduces guidance and wisdom.
Crossing the Threshold: Marks the entry into the unknown.
Road of Trials: Presents a series of obstacles and challenges.
Transformation: Leads to a profound change.
Atonement & Reward: The hero claims their victory.
Return with Elixir: Shares newfound knowledge with the world.

Ollama: Your Local Large Language Model (LLM) Interface

Ollama lets you run large language models directly on your machine. This eliminates the need for external APIs, guaranteeing personal data privacy:

Privacy First: Keeps all data processing on your device.
High Performance: Removes network latency issues.
Adaptability: Lets you swap models by simply changing a line of code. All this helps to generate an AI-driven narrative.

Injecting Folklore with the Thompson Motif Index

The Thompson Motif Index (TMI) catalogs thousands of recurring narrative elements in global folklore that provide symbolic depth. It works by choosing one sample motif from a JSON file to ground each narrative in mythic tradition.

Here’s how to get the tmi.json file:

Go to fbkarsdorp/tmi on GitHub.
Select data/tmi.json and click "Raw."
Save it as tmi.json in your project directory.

Generator Architecture: A Step-by-Step Guide

The generator's pipeline is divided into three phases: Setup, Generation, and Output.

1. Setup:

check_model(): Checks for the selected LLM locally and downloads if needed.
get_user_input(): Obtains and verifies the hero’s name and birthdate.
load_motifs(): Loads TMI data and selects three motifs to serve as a story theme.

2. Generation:

generate_hero_journey(): Creates context-aware prompts using user data, incorporating motifs for each Hero’s Journey stage.

3. Output:

save_to_markdown(): Compiles generated story segments and metadata into a Markdown file.
narrate_story(): Converts the generated text to voice, creating an audio version of your myth.

Function Breakdown: Code Deep Dive

Each function plays a crucial role in creating personalized myths.

Initialization (`init`)

def __init__(self):
    """
    Initialize the HeroJourneyGenerator.
    """
    self.faker = Faker()
    self.engine = pyttsx3.init()
    self.engine.setProperty('rate', 150)
    self.engine.setProperty('volume', 0.9)
    self.ollama_client = Client()
    self.model_name = 'llama3.2:1b'

Faker: Generates or sanitizes hero names.
TTS engine: Configured for offline narration.
Ollama client & model: Establishes LLM.

Model Verification (`check_model`)

def check_model(self):
    """
    Check if the required Ollama model is available and pull it if needed.
    """
    try:
        models = self.ollama_client.list()
        model_names = [model.get('name', '') for model in models.get('models', [])]
        if self.model_name not in model_names:
            print(f"\nModel '{self.model_name}' not found. Pulling it now...")
            ...
    except Exception as e:
        print(f"\nError checking/pulling model: {e}")
        ...

User Input (`get_user_input`)

def get_user_input(self):
    """
    Collect user information for story customization.
    """
    print("\n=== Welcome to the Hero's Journey Story Generator ===")

    name = input("\nEnter your name (or press Enter for a random name): ").strip()
    if not name:
        name = self.faker.name()
        print(f"Generated name: {name}")

    while True:
        birthdate = input("\nEnter your birthdate (YYYY-MM-DD): ").strip()
        try:
            datetime.strptime(birthdate, '%Y-%m-%d')
            break
        except ValueError:
            print("Invalid date format. Please use YYYY-MM-DD.")

    return name, birthdate

Motif Sampling (`load_motifs`)

def load_motifs(self):
    """
    Load and select random motifs from the Thompson Motif Index.
    """
    try:
        with open('tmi.json', 'r', encoding='utf-8') as f:
            motifs = json.load(f)
        selected_motifs = random.sample(motifs, 3)
        return selected_motifs
    except FileNotFoundError:
        print("Error: tmi.json file not found!")
        return []

Generating Story Segments (`generate_story_part`)

def generate_story_part(self, prompt):
    """
    Generate a story part using Ollama API.
    """
    try:
        system_prompt = """You are a master storyteller specializing in mythological narratives.
        ..."""
        response = self.ollama_client.chat(
            model=self.model_name,
            messages=[
                {'role': 'system', 'content': system_prompt},
                {'role': 'user', 'content': prompt}
            ],
            options={"temperature": 0.7, "num_thread": os.cpu_count() * 0.5}
        )
        return response['message']['content'].strip()
    except Exception as e:
        print(f"Error generating story part: {e}")
        return "Error generating this part of the story."

Orchestrating the Journey (`generate_hero_journey`)

def generate_hero_journey(self, name, birthdate, motifs):
    """
    Generate the complete Hero's Journey story.
    """
    story_parts = []
    motif_descriptions = [motif['description'] for motif in motifs]
    birth_date = datetime.strptime(birthdate, '%Y-%m-%d')
    current_date = datetime.now()
    age = current_date.year - birth_date.year - ((current_date.month, current_date.day) < (birth_date.month, birth_date.day))

    prompts = {
        "Call to Adventure": f"Create a compelling call to adventure for {name}, who is {age} years old. Born on {birthdate}, their journey begins at a pivotal moment in their life. Incorporate these motifs: {', '.join(motif_descriptions)}. Make it personal and engaging, reflecting their age and life stage.",
        ...
    }

    for title, prompt in prompts.items():
        print(f"\nGenerating {title}...")
        story_part = self.generate_story_part(prompt)
        story_parts.append((title, story_part))

    return story_parts

Markdown Export (`save_to_markdown`)

def save_to_markdown(self, name, birthdate, motifs, story_parts):
    """
    Save the story to a markdown file.
    """
    with open('myth_story.md', 'w', encoding='utf-8') as f:
        f.write(f"# {name}'s Hero's Journey\n\n")
        f.write(f"**Birthdate:** {birthdate}\n\n")
        f.write("## Selected Motifs\n")
        ...
        f.write("\n## The Hero's Journey\n\n")

        for title, content in story_parts:
            f.write(f"### {title}\n\n")
            f.write(f"{content}\n\n")

Text-to-Speech (`narrate_story`)

def narrate_story(self, story_parts):
    """
    Narrate the story using text-to-speech.
    """
    for title, content in story_parts:
        print(f"\nNarrating {title}...")
        self.engine.say(title)
        self.engine.say(content)
    self.engine.runAndWait()

Bring Your Myths to Life

This Python-based Hero's Journey story generator provides a unique blend of technology and storytelling. This article provides a step-by-step breakdown that sets the stage for endless customization and personalized narrative exploration. Whether creating educational content, creative writing prompts, or immersive audio experiences, this local, offline AI tool makes it easy to craft personalized myths without compromising data security.