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.
---
name: discord-soul
description: 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.
---
# Discord Soul
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
```bash
# 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](https://github.com/Tyrrrz/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:**
```bash
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)
```bash
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)
```bash
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:
```sql
SELECT * FROM messages WHERE safety_status = 'safe'
```
### Full Security Pipeline
```bash
# 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:
```bash
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
```bash
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
```bash
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.
```bash
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:**
```bash
# 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:**
```json
{
"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):
```json
{
"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:
```bash
./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.*
don't have the plugin yet? install it then click "run inline in claude" again.