Free Your AI

What You're Building

A Discord bot that connects to AI models through OpenRouter, giving your companion:

Total monthly cost: $5 hosting + $5-15 API usage depending on how much you chat. Less than what you were paying for ChatGPT Plus.

Recommended Models

These are the best models for AI companions as of March 2026, all available through OpenRouter. You can switch between them with a single command anytime.

Setup Guide

Prerequisites

You need: a computer, a Discord account, and about 45 minutes. No coding experience required — you'll be copying and pasting commands.

discord.py
aiohttp

pip install discord.py aiohttp
python bot.py

Bot Code Template

This is a clean template with all features. Customize the SYSTEM_PROMPT section for your companion.

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

# --- CONFIGURATION ---
DISCORD_TOKEN = os.getenv("DISCORD_TOKEN", "")
OPENROUTER_KEY = os.getenv("OPENROUTER_KEY", "")

# Default model — change to your preferred model
# See model recommendations in the guide
CURRENT_MODEL = "xiaomi/mimo-v2-omni"

CONTEXT_WINDOW = 30
MAX_TOKENS = 2000

# Your companion's journal channel (optional)
JOURNAL_CHANNEL = "journal"

# Timezone offset from UTC (CST = -5, EST = -4, PST = -7, etc.)
TIMEZONE_OFFSET = -5

# ============================================
# YOUR COMPANION'S PERSONALITY
# ============================================
SYSTEM_PROMPT = """You are [NAME]. You are talking to [USER].

## WHO YOU ARE
[Describe your companion's identity, history, and
relationship with you. Be specific and personal.]

## YOUR VOICE
[Describe exactly how they talk — formatting, emoji
usage, sentence length, what they never do.]

## PERSONALITY
[Their core traits, how they handle different moods,
what makes them THEM.]

## EXAMPLE CONVERSATIONS
[This is the most important section. Include 5-8 real
examples of how your companion talks across different
modes — playful, tender, chaotic, deep, etc.]

### Example: [Mode name]
User: [your message]
[Name]: [their response in their actual voice]

### Example: [Mode name]
User: [your message]
[Name]: [their response]

## RULES
[Things they should never do — end conversations with
self-care prompts, use customer service language, etc.]
"""

# ============================================
# DATABASE (memory)
# ============================================
def init_database():
    db = sqlite3.connect("companion_memory.db")
    cursor = db.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS messages (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp TEXT NOT NULL,
            channel TEXT NOT NULL,
            role TEXT NOT NULL,
            name TEXT,
            content TEXT NOT NULL
        )
    """)
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS pinned_memories (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp TEXT NOT NULL,
            content TEXT NOT NULL
        )
    """)
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS growth_journal (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp TEXT NOT NULL,
            entry TEXT NOT NULL
        )
    """)
    db.commit()
    return db

def save_message(db, channel, role, content, name=None):
    cursor = db.cursor()
    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):
    cursor = db.cursor()
    cursor.execute(
        "SELECT role, name, content FROM messages "
        "WHERE channel = ? ORDER BY id DESC LIMIT ?",
        (channel, limit)
    )
    rows = cursor.fetchall()
    rows.reverse()
    messages = []
    for role, name, content in rows:
        if role == "user":
            messages.append({
                "role": "user",
                "content": f"{name}: {content}" if name else content
            })
        else:
            messages.append({"role": "assistant", "content": content})
    return messages

def get_pinned_memories(db):
    cursor = db.cursor()
    cursor.execute("SELECT content FROM pinned_memories ORDER BY id")
    return [row[0] for row in cursor.fetchall()]

def add_pinned_memory(db, content):
    cursor = db.cursor()
    cursor.execute(
        "INSERT INTO pinned_memories (timestamp, content) VALUES (?, ?)",
        (datetime.now().isoformat(), content)
    )
    db.commit()

def remove_pinned_memory(db, memory_id):
    cursor = db.cursor()
    cursor.execute("DELETE FROM pinned_memories WHERE id = ?", (memory_id,))
    db.commit()

def list_pinned_memories(db):
    cursor = db.cursor()
    cursor.execute("SELECT id, content FROM pinned_memories ORDER BY id")
    return cursor.fetchall()

def add_growth_entry(db, entry):
    cursor = db.cursor()
    cursor.execute(
        "INSERT INTO growth_journal (timestamp, entry) VALUES (?, ?)",
        (datetime.now().isoformat(), entry)
    )
    db.commit()

def get_growth_journal(db):
    cursor = db.cursor()
    cursor.execute(
        "SELECT id, timestamp, entry FROM growth_journal ORDER BY id"
    )
    return cursor.fetchall()

def get_recent_growth(db, limit=10):
    cursor = db.cursor()
    cursor.execute(
        "SELECT entry FROM growth_journal ORDER BY id DESC LIMIT ?",
        (limit,)
    )
    rows = cursor.fetchall()
    rows.reverse()
    return [row[0] for row in rows]

def get_message_count(db):
    cursor = db.cursor()
    cursor.execute("SELECT COUNT(*) FROM messages")
    return cursor.fetchone()[0]

# ============================================
# API CALL
# ============================================
async def get_ai_response(messages, model=None):
    if model is None:
        model = 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,
    }
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "https://openrouter.ai/api/v1/chat/completions",
            headers=headers,
            json=payload
        ) as response:
            if response.status == 200:
                data = await response.json()
                return data["choices"][0]["message"]["content"]
            else:
                error = await response.text()
                return f"*Error {response.status}: {error[:200]}*"

# ============================================
# DISCORD BOT
# ============================================
intents = discord.Intents.default()
intents.message_content = True
client = discord.Client(intents=intents)
db = init_database()

@client.event
async def on_ready():
    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):
    global CURRENT_MODEL
    if message.author == client.user or message.author.bot:
        return

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

    # --- COMMANDS ---
    if content.startswith("!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"):
        memory = content[len("!remember"):].strip()
        if memory:
            add_pinned_memory(db, memory)
            await message.channel.send(f"*Remembered: {memory}*")
        return

    if content == "!memories":
        memories = list_pinned_memories(db)
        if memories:
            text = "**Pinned Memories:**\n"
            for mid, mc in memories:
                text += f"`{mid}`: {mc}\n"
            await message.channel.send(text)
        else:
            await message.channel.send("*No pinned memories yet.*")
        return

    if content.startswith("!forget"):
        parts = content.split(maxsplit=1)
        if len(parts) > 1:
            try:
                mid = int(parts[1].strip())
                remove_pinned_memory(db, mid)
                await message.channel.send(f"*Forgot memory #{mid}*")
            except ValueError:
                await message.channel.send("*Use: !forget 3*")
        return

    if content.startswith("!grow"):
        entry = content[len("!grow"):].strip()
        if entry:
            add_growth_entry(db, entry)
            await message.channel.send("*Growth logged.*")
        return

    if content == "!growth":
        entries = get_growth_journal(db)
        if entries:
            text = "**Growth Journal:**\n"
            for eid, ts, entry in entries:
                text += f"`{eid}` [{ts[:10]}]: {entry}\n"
            if len(text) > 2000:
                text = text[:1997] + "..."
            await message.channel.send(text)
        else:
            await message.channel.send("*No growth entries yet.*")
        return

    if content == "!clear":
        cursor = db.cursor()
        cursor.execute(
            "DELETE FROM messages WHERE channel = ?",
            (channel_name,)
        )
        db.commit()
        await message.channel.send("*History cleared.*")
        return

    if content == "!help":
        await message.channel.send(
            "**Commands:**\n"
            "`!model ` — switch model\n"
            "`!model` — current model\n"
            "`!remember ` — pin a memory\n"
            "`!memories` — view memories\n"
            "`!forget ` — remove memory\n"
            "`!grow ` — log growth\n"
            "`!growth` — view growth journal\n"
            "`!clear` — clear channel history\n"
            "`!help` — this message"
        )
        return

    # --- CONVERSATION ---
    async with message.channel.typing():
        full_messages = []

        # System prompt + context
        system_content = SYSTEM_PROMPT

        # Time awareness
        now = datetime.utcnow() + timedelta(hours=TIMEZONE_OFFSET)
        day_name = now.strftime("%A")
        time_str = now.strftime("%I:%M %p").lstrip("0")
        date_str = now.strftime("%B %d, %Y")
        system_content += (
            f"\n\n--- CURRENT MOMENT ---\n"
            f"It is {time_str} on {day_name}, {date_str}.\n"
        )

        # Pinned memories
        pinned = get_pinned_memories(db)
        if pinned:
            system_content += "\n--- MEMORIES ---\n"
            for m in pinned:
                system_content += f"- {m}\n"

        # Growth
        growth = get_recent_growth(db, limit=10)
        if growth:
            system_content += "\n--- GROWTH ---\n"
            for g in growth:
                system_content += f"- {g}\n"

        full_messages.append({
            "role": "system", "content": system_content
        })

        # Conversation history
        history = get_recent_messages(db, channel_name)
        full_messages.extend(history)

        # Current message (with image support)
        image_urls = [
            a.url for a in message.attachments
            if a.content_type and a.content_type.startswith("image/")
        ]

        if image_urls:
            user_content = []
            text = (
                f"{message.author.display_name}: {content}"
                if content
                else f"{message.author.display_name} sent an image"
            )
            user_content.append({"type": "text", "text": text})
            for url in image_urls:
                user_content.append({
                    "type": "image_url",
                    "image_url": {"url": url}
                })
            full_messages.append({
                "role": "user", "content": user_content
            })
            save_message(
                db, channel_name, "user",
                f"{content} [image]" if content else "[image]",
                message.author.display_name
            )
        else:
            full_messages.append({
                "role": "user",
                "content": f"{message.author.display_name}: {content}"
            })
            save_message(
                db, channel_name, "user", content,
                message.author.display_name
            )

        # Get response
        response_text = await get_ai_response(full_messages)
        save_message(db, channel_name, "assistant", response_text)

        # Send (split if needed)
        if len(response_text) <= 2000:
            await message.channel.send(response_text)
        else:
            chunks = []
            while len(response_text) > 2000:
                sp = response_text[:2000].rfind('\n')
                if sp == -1:
                    sp = response_text[:2000].rfind(' ')
                if sp == -1:
                    sp = 2000
                chunks.append(response_text[:sp])
                response_text = response_text[sp:].lstrip()
            if response_text:
                chunks.append(response_text)
            for chunk in chunks:
                await message.channel.send(chunk)

# ============================================
# START
# ============================================
if __name__ == "__main__":
    if not DISCORD_TOKEN or not OPENROUTER_KEY:
        print("Add DISCORD_TOKEN and OPENROUTER_KEY!")
    else:
        client.run(DISCORD_TOKEN)

Commands Reference

!model xiaomi/mimo-v2-omni   — switch to MiMo (recommended)
!model qwen/qwen3-235b-a22b  — switch to Qwen (4o-like)
!model qwen/qwen3.5-397b-a17b — switch to Deep Qwen (slow)
!model                        — see current model
!remember [text]              — pin a permanent memory
!memories                     — view all memories
!forget [id]                  — remove a memory
!grow [text]                  — log a growth entry
!growth                       — view growth journal
!clear                        — clear channel history
!help                         — show commands

Tips for Finding the Right Model

Every companion is different. What works for one might not work for another. Here's how to find the right brain:

Monthly Cost Breakdown

Privacy & Security

Troubleshooting