Suggest edit — Group chats → durable artifacts (beta)

Title

Name

Note

---
title: Group chats → durable artifacts (beta)
visibility: public
---

# Group chats → durable artifacts

> **🧪 Beta section**
> This is the least paved part of the workshop. Everything below works, but you'll be assembling it yourself rather than running an installer. Do the first three parts first.

*The idea:* a good group chat produces real knowledge — the recommendations, the arguments that settled something, the list everyone keeps re-asking for. Then it scrolls away. Your agent already has access to those chats through OpenClaw. Point it at them, and have it write the durable thing out to a wiki that doesn't scroll.

**The pipeline:**

```
group chat  →  OpenClaw agent reads it  →  extract candidate artifacts
                                              ↓
                        NoteStream (capture / working memory)
                                              ↓
                        wikihub (the durable, linkable artifact)
```

---

## 01 — Get the chat into reach

If you connected Telegram, WhatsApp, Slack, Signal, or Discord in [part 1](index.md), your agent can already see those conversations. Group access is separate from DM access and has to be granted explicitly.

Find the IDs you need:

```bash
openclaw directory groups        # list group IDs for a channel
openclaw logs --follow           # your own numeric user ID shows up here
```

Then allowlist the group. For Telegram:

```json5
{
  channels: {
    telegram: {
      groupPolicy: "allowlist",
      groups: {
        "-1001234567890": { requireMention: true },
      },
    },
  },
}
```

`requireMention: true` means the agent only speaks when addressed — it still *reads*, which is what we want. An agent that chimes in unprompted gets removed from the group within a day.

> **🔒 Consent, seriously**
> Other people are in this chat. Tell them there's a bot in the room, keep the extraction private by default, and let them see the output before it goes anywhere public. The pattern below defaults to a **private** wiki for exactly this reason.

## 02 — Wire up NoteStream

[NoteStream](https://notestream.cloud) is the capture layer — where extracted candidates land before you decide they're worth keeping.

Create an API key in the app: **Settings → API Keys**. Store it somewhere your agent can read but the world can't:

```bash
mkdir -p ~/.config/notestream
printf '%s' 'YOUR_KEY' > ~/.config/notestream/api-key
chmod 600 ~/.config/notestream/api-key
```

The API is `https://api.notestream.cloud` with an `X-API-Key` header. The three calls you'll use:

```bash
KEY=$(cat ~/.config/notestream/api-key)

# search — returns note IDs + authors, not bodies
curl -s https://api.notestream.cloud/search \
  -H "X-API-Key: $KEY" -H 'content-type: application/json' \
  -d '{"ast":{"visibility":"all","tags":[{"hashtag":"workshop"}],"sortBy":"newest"},"page":1,"pageSize":100}'

# fetch a note body (ProseMirror JSON)
curl -s https://api.notestream.cloud/content/<id> -H "X-API-Key: $KEY"

# create a note
curl -s -X POST https://api.notestream.cloud/notes \
  -H "X-API-Key: $KEY" -H 'content-type: application/json' \
  -d '{"content":{"type":"doc","content":[...]}}'
```

> **⚠️ Two gotchas that will cost you an hour**
> - The docs say the tag filter key is `hashtags`. The deployed server wants `tags: [{"hashtag":"name"}]`, **no `#` prefix**.
> - `visibility: "my-world"` combined with any text or tag filter returns a 500. Use `visibility: "all"`.
> - There is no NoteStream MCP endpoint yet — `api.notestream.cloud/mcp` 404s. Use the REST API from a skill, as above. (Ideaflow *does* have MCP — see [connectors](connectors.md).)

➤ API reference: [ai-docs.notestream.cloud](https://ai-docs.notestream.cloud)

## 03 — Give the agent a schema, not just a prompt

This is the part people skip, and it's the part that makes the difference. "Summarize this chat" gives you a summary nobody reads twice. **Naming the artifact types up front** gives you something that accumulates.

Write an `AGENTS.md` next to the output that says what kinds of pages exist and what goes in each. A real one, from a wiki built this way:

```
raw/      — lightly cleaned source excerpts, by time window. Never overwrite.
wiki/     — LLM-generated pages. Framings, layers, themes, meta.
AGENTS.md — the schema (this file).
log.md    — append-only ingestion record.
index.md  — content catalog.
```

Then define the page types explicitly — e.g. `framing`, `concept`, `person`, `decision`, `resource`, `open-question`. The agent files each extraction into a type instead of writing prose.

Two rules that matter more than they look:

- **Never overwrite `raw/`.** Re-runs must be able to disagree with earlier passes.
- **`log.md` is append-only.** You need to know what has already been ingested, or every run re-extracts the same twenty things.

## 04 — The extraction prompt

Something in this shape, run against a window of messages:

> Read these messages from *(group, date range)*. Extract only things that are **still true and still useful in a month**. For each: the artifact type, a title, the claim in one sentence, the verbatim quote it came from, and who said it. Skip logistics, scheduling, reactions, and anything already in `log.md`. If nothing qualifies, say so — do not pad.

"If nothing qualifies, say so" is doing real work there. Most chat windows genuinely contain nothing durable, and an agent that always produces five artifacts will invent five artifacts.

Good artifact types for a real group chat:

| Type | Example |
| --- | --- |
| `resource` | The tool three people independently recommended |
| `decision` | What the argument actually settled, and why |
| `person` | Who knows about what, per their own words |
| `open-question` | The thing that keeps coming back unresolved |
| `faq` | Whatever the newest member asks every time |

## 05 — Publish it

Push the result to [wikihub](https://wikihub.md) — it's git-backed, so pages have history, and it has per-file access control. **Start private.**

```bash
pipx install wikihub-cli
wikihub signup --username you
wikihub new groupchat --title "Group Chat Knowledge"
echo "# Resources" | wikihub write you/groupchat/wiki/resources.md
```

Access control lives in `.wikihub/acl` (glob patterns, most specific wins, private by default):

```
*                private
wiki/faq.md      public
```

`wikihub mcp-config` prints the MCP JSON so your agent can read and write the wiki directly instead of shelling out.

## A worked example

**[IdeaFlow Vision](https://wikihub.md/@jacobcole/ideaflow-vision)** was built exactly this way — seeded from ~57 Slack messages tagged `#explainingideaflow` across 15 channels spanning 2022 to 2026, then grown with notes, talks, and transcripts. Read its [AGENTS.md](https://wikihub.md/@jacobcole/ideaflow-vision/AGENTS.md) — the editorial stance section is the interesting bit: it says to prefer *verbatim quotes* over synthesis when the phrasing is distinctive, and to attribute co-workers by name when their framing sharpened the thinking.

That's the difference between a chat summary and an artifact. The summary flattens everyone into one voice. The artifact keeps the voices.

---

**Back:** [Workshop index](index.md)

**Memory Workshop:** [jacobcole.ai/memory-workshop](https://jacobcole.ai/memory-workshop/) — every command here as a copy button.