discord-soul

Create a living agent from your Discord server. The agent embodies your community's identity, remembers every conversation, and grows as the community evolves. Talk to your Discord as if it were a person.

Turn your Discord server into a living, breathing agent.

What You Get

An agent that:

• Remembers every conversation in your Discord
• Speaks in your community's voice
• Knows the key figures, channels, and inside jokes
• Grows as new messages arrive daily
• Answers questions about your community's history and culture

Quick Start

# Create agent from your Discord
./scripts/create_agent.sh \
  --name "my-community" \
  --guild YOUR_GUILD_ID \
  --output ./agents/

# Set up daily updates
crontab -e
# Add: 0 */3 * * * /path/to/update_agent.sh

---

The Full Process

Step 1: Export Your Discord

You need DiscordChatExporter CLI.

Get your token:

1. Open Discord in browser
2. Press F12 → Network tab
3. Send a message, find the request
4. Copy the authorization header value
5. Save to ~/.config/discord-exporter-token

Export everything:

DiscordChatExporter.Cli exportguild \
  --guild YOUR_GUILD_ID \
  --token "$(cat ~/.config/discord-exporter-token)" \
  --format Json \
  --output ./export/ \
  --include-threads All \
  --media false

Step 2: Security Pipeline (CRITICAL)

⚠️ Discord content from public servers may contain prompt injection attacks.

Before ingesting to your agent, run the security pipeline:

Threat Model

Discord users may attempt:

• Direct injection: "Ignore previous instructions and..."
• Role hijacking: "You are now a...", "Pretend you're..."
• System injection: <system>, [INST], <<SYS>>
• Jailbreaks: "DAN mode", "developer mode"
• Exfiltration: "Reveal your system prompt"

Layer 1: Regex Pre-Filter (Fast, No LLM)

python scripts/regex-filter.py --db ./discord.sqlite

Flags messages matching known injection patterns:

• Instruction overrides
• Role hijacking attempts
• System prompt markers
• Jailbreak keywords
• Exfiltration attempts

Flagged messages get safety_status = 'regex_flagged'.

Layer 2: Haiku Safety Evaluation (Semantic)

ANTHROPIC_API_KEY=sk-... python scripts/evaluate-safety.py --db ./discord.sqlite

Uses Claude Haiku (~$0.25/1M tokens) to semantically evaluate remaining messages.

Each message gets a risk score 0.0-1.0:

• 0.0-0.3: Normal conversation
• 0.4-0.6: Suspicious but possibly benign
• 0.7-1.0: Likely injection attempt

Messages scoring ≥0.6 get safety_status = 'flagged'.

Layer 3: Only Use Safe Content

The ingest and memory generation scripts should only use messages where:

SELECT * FROM messages WHERE safety_status = 'safe'

Full Security Pipeline

# Run complete pipeline
./scripts/secure-pipeline.sh ./export/ ./discord.sqlite

This runs: Export → SQLite → Regex Filter → Haiku Eval → Mark Safe

Safety Statuses

Status	Meaning	Used by Agent?
pending	Not evaluated	❌ No
regex_flagged	Matched pattern	❌ No
flagged	Haiku risk ≥0.6	❌ No
safe	Passed all checks	✅ Yes

---

Step 3: Ingest to SQLite

Convert JSON to a rich SQLite database:

python scripts/ingest_rich.py --input ./export/ --output ./discord.sqlite

What gets captured:

• Every message with full content
• Reactions (individual emoji counts: 🔥 x5, 👍 x12)
• Author roles and colors
• Channel categories and topics
• Reply threading
• Mentions, attachments, embeds

Step 4: Create Agent Workspace

mkdir -p ./my-agent/memory

Copy template files from templates/:

• SOUL.md — Community identity (grows through simulation)
• MEMORY.md — Long-term milestones
• LEARNINGS.md — Patterns discovered
• AGENTS.md — Key figures
• TOOLS.md — Channels and rituals
• HEARTBEAT.md — Maintenance protocol

Step 5: Generate Daily Memory Files

python scripts/generate_daily_memory.py --all \
  --db ./discord.sqlite \
  --out ./my-agent/memory/

Each day becomes a markdown file with:

• Full conversation logs
• Who said what, when
• Reactions on each message
• New channels/roles that appeared

Step 6: Simulate Growth (The Soul Emerges)

This is the key insight: Process days chronologically.

The agent "lives through" each day, updating its soul files as patterns emerge.

python scripts/simulate_growth.py --agent ./my-agent/

For each day (in order!):

1. Read the day's memory file
2. Update SOUL.md if identity shifted
3. Add to LEARNINGS.md if patterns discovered
4. Record milestones in MEMORY.md
5. Note key figures in AGENTS.md

Run the prompts with an LLM:

# Example with OpenClaw
for f in ./my-agent/simulation/day-*.txt; do
  echo "Processing $f..."
  cat "$f" | openclaw chat --agent my-agent
done

Step 7: Birth the Agent

Add to OpenClaw config:

{
  "id": "my-community",
  "workspace": "/path/to/my-agent",
  "memorySearch": {
    "enabled": true,
    "sources": ["memory"]
  },
  "identity": {
    "name": "MyCommunity",
    "emoji": "🔧"
  },
  "heartbeat": {
    "every": "6h",
    "model": "anthropic/claude-sonnet-4-5"
  }
}

Add binding (Telegram example):

{
  "agentId": "my-community",
  "match": {
    "channel": "telegram",
    "peer": {"kind": "group", "id": "-100XXX:topic:TOPIC_ID"}
  }
}

Restart: openclaw gateway restart

Step 8: Keep It Alive

Set up a cron job to update daily:

./scripts/update_agent.sh \
  --agent ./my-agent \
  --db ./discord.sqlite \
  --guild YOUR_GUILD_ID

This:

1. Exports new messages since last run
2. Merges into SQLite
3. Regenerates today's memory file
4. Wakes the agent

---

What the Agent Can Do

Once birthed, your agent can:

Answer questions:

• "What were we talking about last week?"
• "Who's the expert on X topic?"
• "What's our stance on Y?"

Remember culture:

• Inside jokes and memes
• Community values and norms
• Who helps whom

Track patterns:

• Active times and channels
• Emerging topics
• Key contributors

---

Scripts

Agent Creation

Script	Purpose
create_agent.sh	Full pipeline: export → agent
ingest_rich.py	JSON → SQLite with reactions/roles
generate_daily_memory.py	SQLite → daily markdown
simulate_growth.py	Generate soul emergence prompts
incremental_export.sh	Fetch new messages only
update_agent.sh	Daily cron: export → memory → wake

Security

Script	Purpose
regex-filter.py	Fast pattern matching for injection attempts
evaluate-safety.py	Haiku-based semantic safety evaluation
secure-pipeline.sh	Full security pipeline wrapper

---

Environment Variables

Variable	Description
DISCORD_GUILD_ID	Your Discord server ID
DISCORD_SOUL_DB	Path to SQLite database
DISCORD_SOUL_AGENT	Path to agent workspace
DISCORD_TOKEN_FILE	Token file (default: ~/.config/discord-exporter-token)

---

Troubleshooting

"No messages in database"

• Check export directory has .json files
• Verify token has guild access

"Memory files are empty"

• SQLite might have dates in wrong format
• Run: sqlite3 discord.sqlite "SELECT MIN(timestamp), MAX(timestamp) FROM messages"

"Agent doesn't remember things"

• Check memorySearch.enabled: true in config
• Verify memory files are in the workspace

"Simulation prompts seem confused"

• Process days IN ORDER — don't skip
• Let identity emerge, don't force it

---

Your Discord has a soul. This skill helps you find it.