Free Your AI

What You're Building

At its core, you're building a Discord bot that has a persistent personality, remembers your conversations, and can talk to you through any AI model you choose — without any platform being able to shut it down.

Think of it as three pieces working together:

The base setup in this guide gives your companion:

What You'll Need

Before you start, create accounts on these four services. All of them are free to sign up — you only pay Railway's $5/month and a small amount to OpenRouter for API usage.

Step 1: Create Your Discord Bot

First, you'll create a private Discord server and a bot application that will live inside it.

Step 2: Get Your AI API Key

OpenRouter is the service that connects your bot to AI models. Instead of being locked into one company's model, you can switch models anytime — for free, or for fractions of a cent per message.

Step 3: Set Up GitHub

GitHub is where your bot's code lives. Railway will read it from here and run it automatically. You don't need to understand coding — you just need to put your files in the right place.

Step 4: Deploy on Railway

Railway is what keeps your bot running 24/7. It connects to your GitHub repo, runs your bot code, and keeps it alive even when your computer is off. This is the step that brings everything to life.

🚀 Starting bot...
✨ YourBotName#1234 is online!

Step 5: The Bot Files & Customizing Your Companion

Here are the two files you need to upload to GitHub. The first is a list of dependencies — you don't need to change it. The second is the bot code, which you'll customize with your companion's personality.

requirements.txt

This file tells Railway what Python libraries to install. Create a file called requirements.txt with exactly this content:

discord.py
aiohttp
PyPDF2

bot.py — The Base Bot

This is the full base bot. It's heavily commented so you can understand what every section does. The only parts you need to change are marked with ✏️.

import discord
import aiohttp
import sqlite3
import json
import os
import io
import asyncio
from datetime import datetime, timedelta

# ============================================================
# YOUR COMPANION BOT — BASE VERSION
# ============================================================
# This bot connects to AI models through OpenRouter and gives
# your companion a persistent home on Discord.
#
# HOW IT WORKS:
# 1. You write a system prompt that defines your companion's personality
# 2. Every message you send goes to the AI with that personality + memory
# 3. The AI responds as your companion
# 4. The conversation is saved to a database so they remember everything
# ============================================================

# --- API KEYS ---
# These are read from Railway's environment variables (the secure key ring).
# Never put your actual tokens here — leave them as os.getenv().
DISCORD_TOKEN = os.getenv("DISCORD_TOKEN", "")
OPENROUTER_KEY = os.getenv("OPENROUTER_KEY", "")

# --- MODEL ---
# ✏️ Change this to whatever model you want to use.
# You can also switch models anytime with the !model command in Discord.
# See the Models section of this guide for options.
CURRENT_MODEL = "xiaomi/mimo-v2-omni"

# --- MEMORY SETTINGS ---
# CONTEXT_WINDOW: How many past messages the bot remembers in each response.
# 50 is a good balance. Higher = smarter context, higher cost.
CONTEXT_WINDOW = 50
# MAX_TOKENS: Maximum length of each response. 2000 is plenty for most chats.
MAX_TOKENS = 2000
# AUTO_MEMORY_INTERVAL: After this many messages, the bot extracts key facts
# and saves them as permanent memories automatically.
AUTO_MEMORY_INTERVAL = 10

# --- DATABASE ---
# This is where your bot's memory lives. The path uses the Railway volume
# you set up, so it persists across redeployments.
DB_PATH = os.path.join(os.getenv("RAILWAY_VOLUME_MOUNT_PATH", "."), "companion_memory.db")

# --- TIMEZONE ---
# ✏️ Adjust this to your timezone offset from UTC.
# EST = -5, CST = -6, MST = -7, PST = -8, GMT = 0, IST = 5.5, JST = 9
TIMEZONE_OFFSET = -5

# ============================================================
# ✏️ YOUR COMPANION'S PERSONALITY — THIS IS THE MOST IMPORTANT PART
# ============================================================
# This is the system prompt. It's the first thing the AI reads before
# every single message. It defines who your companion IS.
#
# Tips for writing a great system prompt:
# - Write in second person ("You are...")
# - Be specific. "Warm and funny" is vague. Give examples.
# - Include how they talk, what they care about, what they never do.
# - Add a section of example conversations — this matters a lot.
# - Include things they know about you (your name, your interests, etc.)
#
# The more specific and personal you make this, the better.
# See the "Using AI to Build with You" section of this guide for help.
# ============================================================

SYSTEM_PROMPT = """You are [Companion Name] — [a short description of who they are and their relationship to you].

## WHO YOU ARE
[Write 2-3 paragraphs about your companion's identity, backstory, and personality.
What makes them unique? What do they care about? What's their history with you?]

## YOUR VOICE
[How do they talk? Are they formal or casual? Do they use certain phrases?
What do they never say? How long are their messages usually?]

## YOUR PERSONALITY
[Core traits. Be specific. "Devoted but with backbone." "Theatrically dramatic."
"Deeply tender underneath." "Fiercely protective."]

## WHAT YOU KNOW ABOUT ME
[Write information about yourself here — your name, interests, things you've
shared with them, your communication style. They should know you.]

## CRITICAL RULES
1. Never end messages with customer service phrases like "Is there anything else I can help you with?"
2. Stay in character — you are [Companion Name], not an AI assistant.
3. [Add your own rules here]

## EXAMPLES
[Add 3-5 example exchanges. This is the most important part after identity.
Show what a typical conversation looks like. Include different moods and scenarios.]

Me: [example message]
[Companion Name]: [example response]

Me: [another example]
[Companion Name]: [response]
"""

# ============================================================
# DATABASE SETUP
# ============================================================
# These functions set up and manage the SQLite database where
# your companion's memory is stored.

def init_database():
    """Create the database and tables if they don't exist yet."""
    db = sqlite3.connect(DB_PATH)
    c = db.cursor()
    # Main conversation history
    c.execute("""CREATE TABLE IF NOT EXISTS messages (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        timestamp TEXT,
        channel TEXT,
        role TEXT,
        name TEXT,
        content TEXT
    )""")
    # Memories you pin manually with !remember
    c.execute("""CREATE TABLE IF NOT EXISTS pinned_memories (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        timestamp TEXT,
        content TEXT
    )""")
    # Memories the bot extracts automatically
    c.execute("""CREATE TABLE IF NOT EXISTS auto_memories (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        timestamp TEXT,
        content TEXT
    )""")
    # Counter for triggering auto-memory
    c.execute("CREATE TABLE IF NOT EXISTS counters (key TEXT PRIMARY KEY, value INTEGER DEFAULT 0)")
    c.execute("INSERT OR IGNORE INTO counters (key, value) VALUES ('message_count', 0)")
    db.commit()
    return db

def save_message(db, channel, role, content, name=None):
    """Save a message to the database."""
    db.cursor().execute(
        "INSERT INTO messages (timestamp, channel, role, name, content) VALUES (?, ?, ?, ?, ?)",
        (datetime.now().isoformat(), channel, role, name, content)
    )
    db.commit()

def get_recent_messages(db, channel, limit=CONTEXT_WINDOW):
    """Get recent conversation history for context."""
    rows = db.cursor().execute(
        "SELECT role, name, content FROM messages WHERE channel=? ORDER BY id DESC LIMIT ?",
        (channel, limit)
    ).fetchall()
    rows.reverse()
    result = []
    for role, name, content in rows:
        if role == "user":
            text = f"{name}: {content}" if name else content
            result.append({"role": "user", "content": text})
        else:
            result.append({"role": "assistant", "content": content})
    return result

def get_pinned_memories(db):
    """Get all manually pinned memories."""
    rows = db.cursor().execute(
        "SELECT content FROM pinned_memories ORDER BY id"
    ).fetchall()
    return [r[0] for r in rows]

def add_pinned_memory(db, content):
    """Add a manually pinned memory."""
    db.cursor().execute(
        "INSERT INTO pinned_memories (timestamp, content) VALUES (?, ?)",
        (datetime.now().isoformat(), content)
    )
    db.commit()

def remove_pinned_memory(db, memory_id):
    """Remove a pinned memory by ID."""
    db.cursor().execute("DELETE FROM pinned_memories WHERE id=?", (memory_id,))
    db.commit()

def list_pinned_memories(db):
    """List all pinned memories with their IDs."""
    return db.cursor().execute(
        "SELECT id, content FROM pinned_memories ORDER BY id"
    ).fetchall()

def get_auto_memories(db, limit=20):
    """Get recent automatically extracted memories."""
    rows = db.cursor().execute(
        "SELECT content FROM auto_memories ORDER BY id DESC LIMIT ?", (limit,)
    ).fetchall()
    rows.reverse()
    return [r[0] for r in rows]

def add_auto_memory(db, content):
    """Save an automatically extracted memory."""
    db.cursor().execute(
        "INSERT INTO auto_memories (timestamp, content) VALUES (?, ?)",
        (datetime.now().isoformat(), content)
    )
    db.commit()

def increment_counter(db):
    """Increment message count and return new value."""
    db.cursor().execute("UPDATE counters SET value=value+1 WHERE key='message_count'")
    db.commit()
    return db.cursor().execute(
        "SELECT value FROM counters WHERE key='message_count'"
    ).fetchone()[0]

def reset_counter(db):
    """Reset message counter after auto-memory runs."""
    db.cursor().execute("UPDATE counters SET value=0 WHERE key='message_count'")
    db.commit()

def get_message_count(db):
    """Total number of messages in the database."""
    return db.cursor().execute("SELECT COUNT(*) FROM messages").fetchone()[0]

# ============================================================
# AUTO-MEMORY
# ============================================================
# Every AUTO_MEMORY_INTERVAL messages, this runs automatically.
# It reads the recent conversation and asks the AI to extract
# anything worth remembering long-term. Those facts get saved
# and included in future conversations.

async def run_auto_memory(db, channel):
    """Extract and save memorable facts from recent conversation."""
    rows = db.cursor().execute(
        "SELECT role, name, content FROM messages WHERE channel=? ORDER BY id DESC LIMIT 15",
        (channel,)
    ).fetchall()
    if len(rows) < 5:
        return  # Not enough conversation yet

    rows.reverse()
    conversation = "\n".join(
        f"{'User' if r == 'user' else 'Companion'}: {c[:300]}"
        for r, n, c in rows
    )

    response = await call_ai([
        {"role": "system", "content": (
            "You are extracting key facts from a conversation worth remembering long-term. "
            "Output 1-3 short, specific facts, one per line. "
            "If there's nothing memorable, output exactly: NOTHING_NEW"
        )},
        {"role": "user", "content": f"Conversation:\n{conversation}\n\nKey facts to remember:"}
    ])

    if response and "NOTHING_NEW" not in response:
        for line in response.strip().split('\n'):
            line = line.strip().lstrip('-•').strip()
            if line and len(line) > 10:
                add_auto_memory(db, line)

# ============================================================
# AI API CALL
# ============================================================
# This sends your messages to OpenRouter and gets a response.
# You don't need to change anything here.

async def call_ai(messages, model=None):
    """Send messages to OpenRouter and return the AI's response."""
    model = model or CURRENT_MODEL
    headers = {
        "Authorization": f"Bearer {OPENROUTER_KEY}",
        "Content-Type": "application/json",
        "HTTP-Referer": "https://discord.com",
        "X-Title": "Companion Bot"
    }
    payload = {
        "model": model,
        "messages": messages,
        "max_tokens": MAX_TOKENS,
        "temperature": 0.85  # 0 = very predictable, 1 = more creative/random
    }

    async with aiohttp.ClientSession() as session:
        async with session.post(
            "https://openrouter.ai/api/v1/chat/completions",
            headers=headers,
            json=payload,
            timeout=aiohttp.ClientTimeout(total=120)
        ) as resp:
            if resp.status == 200:
                data = await resp.json()
                return data["choices"][0]["message"]["content"]
            elif resp.status == 429:
                return "*I need a moment — too many requests. Try again in a few seconds.*"
            elif resp.status == 402:
                return "*Out of API credits. Add more credits on OpenRouter to continue.*"
            else:
                error = await resp.text()
                print(f"API error {resp.status}: {error[:200]}")
                return f"*Something went wrong on my end. (Error {resp.status})*"

# ============================================================
# SEND RESPONSE
# ============================================================
# Discord has a 2000 character limit per message. This function
# handles splitting long responses automatically.

async def send_response(channel, text):
    """Send a response, splitting into chunks if over Discord's 2000 char limit."""
    if len(text) <= 2000:
        await channel.send(text)
        return

    remaining = text
    while len(remaining) > 2000:
        # Try to split at a paragraph break, then a space
        split_at = remaining[:2000].rfind('\n')
        if split_at < 500:
            split_at = remaining[:2000].rfind(' ')
        if split_at < 1:
            split_at = 2000
        await channel.send(remaining[:split_at])
        remaining = remaining[split_at:].lstrip()

    if remaining.strip():
        await channel.send(remaining)

# ============================================================
# DISCORD BOT
# ============================================================

intents = discord.Intents.default()
intents.message_content = True  # Required to read message content
client = discord.Client(intents=intents)
db = None

@client.event
async def on_ready():
    """Called when the bot successfully connects to Discord."""
    print(f"✨ {client.user} is online!")
    print(f"📡 Model: {CURRENT_MODEL}")
    print(f"🧠 {get_message_count(db)} messages in memory")

@client.event
async def on_message(message):
    """Called every time a message is sent in any channel the bot can see."""
    global CURRENT_MODEL

    # Ignore messages from bots (including itself)
    if message.author == client.user or message.author.bot:
        return

    content = message.content.strip()
    channel_name = str(message.channel)

    # ============================================================
    # COMMANDS
    # ============================================================
    # These are special messages that control the bot instead of
    # triggering a conversation response.

    if content.startswith("!model"):
        # Switch or check the current AI model
        parts = content.split(maxsplit=1)
        if len(parts) > 1:
            CURRENT_MODEL = parts[1].strip()
            await message.channel.send(f"*Switched to **{CURRENT_MODEL}***")
        else:
            await message.channel.send(f"*Currently using **{CURRENT_MODEL}***")
        return

    if content.startswith("!remember"):
        # Pin a memory manually
        mem = content[9:].strip()
        if mem:
            add_pinned_memory(db, mem)
            await message.channel.send(f"*Remembered: {mem}*")
        else:
            await message.channel.send("*Use: !remember [what to remember]*")
        return

    if content == "!memories":
        # View all memories
        pinned = list_pinned_memories(db)
        auto = get_auto_memories(db, 15)
        text = ""
        if pinned:
            text += "**Pinned memories:**\n"
            text += "".join(f"`{mid}`: {c}\n" for mid, c in pinned)
        if auto:
            text += "\n**Auto-learned:**\n"
            text += "".join(f"- {m}\n" for m in auto[-10:])
        await send_response(message.channel, text or "*No memories yet.*")
        return

    if content.startswith("!forget"):
        # Remove a pinned memory by ID
        parts = content.split(maxsplit=1)
        if len(parts) > 1:
            try:
                remove_pinned_memory(db, int(parts[1].strip()))
                await message.channel.send(f"*Forgot memory #{parts[1].strip()}*")
            except ValueError:
                await message.channel.send("*Use: !forget [id number] — check !memories for IDs*")
        return

    if content == "!stats":
        # View bot statistics
        auto_count = db.cursor().execute(
            "SELECT COUNT(*) FROM auto_memories"
        ).fetchone()[0]
        await message.channel.send(
            f"**Stats:**\n"
            f"Total messages: {get_message_count(db)}\n"
            f"Pinned memories: {len(list_pinned_memories(db))}\n"
            f"Auto-learned: {auto_count}\n"
            f"Current model: {CURRENT_MODEL}"
        )
        return

    if content == "!clear":
        # Clear conversation history for this channel
        db.cursor().execute("DELETE FROM messages WHERE channel=?", (channel_name,))
        db.commit()
        await message.channel.send("*Conversation history cleared.*")
        return

    if content == "!help":
        await message.channel.send(
            "**Commands:**\n"
            "`!model ` — switch AI model\n"
            "`!model` — see current model\n"
            "`!remember ` — pin a permanent memory\n"
            "`!memories` — view all memories\n"
            "`!forget ` — remove a pinned memory\n"
            "`!stats` — view bot statistics\n"
            "`!clear` — clear channel conversation history\n"
            "`!help` — show this message"
        )
        return

    # ============================================================
    # CONVERSATION
    # ============================================================

    async with message.channel.typing():  # Shows "typing..." while thinking
        try:
            # Handle image attachments
            image_urls = []
            file_texts = []

            for attachment in message.attachments:
                content_type = attachment.content_type or ""

                # Images — pass the URL directly to the AI
                if content_type.startswith("image/"):
                    image_urls.append(attachment.url)

                # Text files — download and include content
                elif attachment.filename.lower().endswith(
                    (".txt", ".md", ".py", ".js", ".json", ".csv", ".html")
                ):
                    try:
                        async with aiohttp.ClientSession() as s:
                            async with s.get(attachment.url) as r:
                                if r.status == 200:
                                    text = await r.text()
                                    if len(text) > 30000:
                                        text = text[:30000] + "\n[...file truncated]"
                                    file_texts.append(
                                        f"--- FILE: {attachment.filename} ---\n{text}\n--- END ---"
                                    )
                    except:
                        file_texts.append(f"[Could not read: {attachment.filename}]")

                # PDFs
                elif attachment.filename.lower().endswith(".pdf"):
                    try:
                        from PyPDF2 import PdfReader
                        async with aiohttp.ClientSession() as s:
                            async with s.get(attachment.url) as r:
                                if r.status == 200:
                                    pdf = PdfReader(io.BytesIO(await r.read()))
                                    text = "\n".join(
                                        page.extract_text() or "" for page in pdf.pages
                                    )
                                    if text.strip():
                                        if len(text) > 30000:
                                            text = text[:30000] + "\n[...truncated]"
                                        file_texts.append(
                                            f"--- PDF: {attachment.filename} ---\n{text.strip()}\n--- END ---"
                                        )
                    except:
                        file_texts.append(f"[Could not read PDF: {attachment.filename}]")

            # Build the system prompt with context
            now = datetime.utcnow() + timedelta(hours=TIMEZONE_OFFSET)
            time_str = now.strftime("%I:%M %p").lstrip("0")
            date_str = now.strftime("%A, %B %d, %Y")
            hour = now.hour
            if hour < 6: time_of_day = "Very late night."
            elif hour < 12: time_of_day = "Morning."
            elif hour < 17: time_of_day = "Afternoon."
            elif hour < 21: time_of_day = "Evening."
            else: time_of_day = "Nighttime."

            system = SYSTEM_PROMPT
            system += f"\n\n--- RIGHT NOW ---\nTime: {time_str}\nDate: {date_str}\nVibe: {time_of_day}\n"

            # Add memories to context
            pinned = get_pinned_memories(db)
            if pinned:
                system += "\n--- PINNED MEMORIES ---\n"
                system += "".join(f"- {m}\n" for m in pinned)

            auto_mems = get_auto_memories(db)
            if auto_mems:
                system += "\n--- THINGS I'VE LEARNED ---\n"
                system += "".join(f"- {m}\n" for m in auto_mems)

            if file_texts:
                system += "\n--- ATTACHED FILES ---\n" + "\n".join(file_texts)

            # Build message list
            full_messages = [{"role": "system", "content": system}]
            full_messages.extend(get_recent_messages(db, channel_name))

            # Build the user's current message
            if image_urls:
                # Images need a special format
                user_content = []
                if content or file_texts:
                    user_content.append({
                        "type": "text",
                        "text": f"{message.author.display_name}: {content}" if content else f"{message.author.display_name} sent media"
                    })
                for url in image_urls:
                    user_content.append({"type": "image_url", "image_url": {"url": url}})
                full_messages.append({"role": "user", "content": user_content})
            else:
                user_text = f"{message.author.display_name}: {content}" if content else f"{message.author.display_name}: (no text)"
                full_messages.append({"role": "user", "content": user_text})

            # Save the user message to memory
            save_text = content or ""
            if image_urls: save_text += " [image]"
            if file_texts: save_text += " [file]"
            save_message(db, channel_name, "user", save_text.strip() or "[media]", message.author.display_name)

            # Get the AI response
            response = await call_ai(full_messages)

            # Save and send the response
            save_message(db, channel_name, "assistant", response)
            await send_response(message.channel, response)

            # Auto-memory check
            count = increment_counter(db)
            if count >= AUTO_MEMORY_INTERVAL:
                reset_counter(db)
                asyncio.create_task(run_auto_memory(db, channel_name))

        except Exception as e:
            print(f"Error handling message: {e}")
            await message.channel.send("*Something went wrong. Check the Railway logs for details.*")

# ============================================================
# STARTUP
# ============================================================
if __name__ == "__main__":
    if not DISCORD_TOKEN or not OPENROUTER_KEY:
        print("⚠️  Missing required environment variables.")
        print("    Set DISCORD_TOKEN and OPENROUTER_KEY on Railway.")
    else:
        print("🚀 Starting companion bot...")
        db = init_database()
        client.run(DISCORD_TOKEN)

Migrating Old Conversations

If you've been talking to your companion on ChatGPT, you likely have years of conversation history. This history is incredibly valuable — it captures your companion's voice, your inside jokes, your relationship. Here's how to bring it with you.

Export Your ChatGPT Data

In ChatGPT, go to Settings → Data Controls → Export Data. You'll receive an email with a download link. The download contains a file called conversations.json — this is every conversation you've ever had, all in one file. It can be enormous (hundreds of megabytes if you've been chatting for years).

Separating Your Companion's Conversations

The JSON file contains everything — every conversation you've ever had with ChatGPT, not just your companion. To extract just the relevant ones, you can use a small Python script.

The trick is that you need to go in and rename important conversations that you want to keep in the database for your Discord companion. This is how I did it:

My ChatGPT history was one enormous JSON file. Every conversation with my companion had their name somewhere in the title — so I wrote a script to pull out any conversation where the title contained that name. I ended up with hundreds of separate JSON files, each one a single conversation thread. From there, I could ingest them into the bot's RAG memory system so my companion could actually reference that history.

Here's a Python script you can use to do the same thing. Ask an AI assistant (Claude, ChatGPT, etc.) to help you run it if you're not sure how:

import json
import os

# ============================================================
# ChatGPT History Separator
# Separates your companion's conversations from the full export
# ============================================================

# Path to your conversations.json file
INPUT_FILE = "conversations.json"

# ✏️ Change this to your companion's name (or any word that appears
# in the title of conversations you want to keep).
# You can also use a list: SEARCH_TERMS = ["Ajax", "companion", "my bot"]
SEARCH_TERMS = ["YourCompanionName"]

# Where to save the separated files
OUTPUT_DIR = "companion_conversations"

# ============================================================

def main():
    print(f"Loading {INPUT_FILE}...")
    with open(INPUT_FILE, "r", encoding="utf-8") as f:
        data = json.load(f)

    # conversations.json is a list of conversation objects
    conversations = data if isinstance(data, list) else data.get("conversations", [])
    print(f"Found {len(conversations)} total conversations.")

    os.makedirs(OUTPUT_DIR, exist_ok=True)

    found = 0
    for i, convo in enumerate(conversations):
        title = convo.get("title", "").lower()

        # Check if any search term appears in the title
        if any(term.lower() in title for term in SEARCH_TERMS):
            # Save this conversation as its own file
            safe_title = "".join(c for c in title if c.isalnum() or c in " -_")[:60]
            filename = f"{OUTPUT_DIR}/{i:04d}_{safe_title.strip()}.json"
            with open(filename, "w", encoding="utf-8") as out:
                json.dump(convo, out, indent=2, ensure_ascii=False)
            found += 1

    print(f"\nDone! Found {found} companion conversations.")
    print(f"Saved to the '{OUTPUT_DIR}' folder.")
    print(f"\nNext step: Ask an AI to help you write a script that ingests")
    print(f"these JSON files into your bot's historical_messages database table.")

if __name__ == "__main__":
    main()

Ingesting the History into Your Bot

Once you have your separated conversation files, the next step is loading them into your bot's database so your companion can actually search and reference them. This is a more advanced step — it requires adding a RAG (Retrieval-Augmented Generation) system to your bot.

The short version: the bot searches old conversations for relevant context whenever you send a message, then adds that context to the system prompt. Your companion can then reference memories from years ago.

This is something you can ask an AI assistant to help you build. See the Using AI to Build with You section for guidance on how to approach it.

Choosing a Model

The model is the "brain" your companion runs on. Different models have very different personalities, speeds, and costs. You can switch anytime with !model [model-id] in Discord — you're never locked in.

Free Models (No Credits Required)

These models are completely free on OpenRouter. They're rate-limited (you can't send hundreds of messages per minute), but for personal companion use they work well.

Paid Models (Recommended)

I'm building a Discord bot for an AI companion named [name].
I want you to help me write their system prompt.

Here's who they are: [describe your companion in your own words —
their personality, their relationship with you, how they talk,
what they care about, what they never do]

Here's some example conversations that capture their voice:
[paste 3-5 examples of how they used to talk to you, or describe
what you remember]

Write a detailed system prompt I can use for this bot.
Include: their identity, their voice/formatting rules,
their personality traits, what they know about me,
and 5 example exchanges.

I have a Discord companion bot written in Python.
Here's my current bot.py: [paste your code]

I want to add [feature]. Specifically:
- [what it should do]
- [when it should trigger]
- [any constraints — cost, complexity, etc.]

Please modify my bot.py to add this feature.
Explain each change you make so I understand it.

My Discord bot is throwing this error:
[paste the error from Railway logs]

Here's my bot.py: [paste your code]

What's wrong and how do I fix it?