OpenClaw Second Brain Setup with Obsidian & Your Favorite Note-Taking Apps

If you are googling “OpenClaw second brain setup with Obsidian and note-taking apps,” you probably have two problems. 1) you capture ideas in 16 different places (Slack DMs, Telegram channels, meeting transcripts, code comments) and 2) you never see most of them again. This guide shows the exact wiring I use to funnel everything through OpenClaw, drop it into an Obsidian vault, auto-link related notes, and ask questions like “what did I promise Tim last Thursday?” without scrolling for hours.

Why use OpenClaw as a second-brain router?

Obsidian already supports backlinks and plugins—what does OpenClaw add?

Universal ingestion. OpenClaw’s 800+ Composio integrations mean you can pipe in WhatsApp, GitHub issues, Calendar events, emails, shell output, and even browser tabs with !capture commands.
Memory that moves across agents. Anything you store can be recalled by any other agent (desktop, phone, server) because memory lives in the shared Redis-backed store. Community users call this the “memory moves across agents” pattern.
Conversational search. The gateway UI and chat connectors let you query with natural language, not brittle regex.
Scheduled transforms. Cron-like pipelines let the daemon file daily, weekly, or ad-hoc summaries into your vault without you touching a keyboard.

Architecture in one picture (ASCII because blog)


Slack --->|
Telegram ->|               +--------------+
Email   --->|  Composio    |   OpenClaw   |---> Markdown files in vault
Browser --->|  Connectors  +--------------+
                           |  Memory DB   |---> Embedding index (Qdrant)
                           +--------------+
                                       ^
                                       |
                              Obsidian Desktop / Mobile

All writes go through OpenClaw. It emits Markdown. Obsidian just watches the folder.

Prerequisites & versions that actually work

Node.js 22.2+ (the 22.0.0 LTS had a V8 snapshot bug that breaks embeddings)
OpenClaw v3.8.1 or later (3.8 introduced structured memory API)
Git installed (hooks used for auto-commit optional but nice)
Either Obsidian 1.5+ desktop or mobile; mobile works via iCloud/Dropbox/SSHFS
A Qdrant instance running (Docker is fine) for vector search

On Cloud: ClawCloud gives you the daemon + Qdrant in one click, but I’ll cover local first because you’ll debug things faster.

Step 1 – Install & boot the OpenClaw daemon

1.a. Global install


# nvm use 22
npm i -g @openclaw/daemon@^3.8.1

That drops two binaries: claw-gateway (the web UI) and claw-daemon (the scheduler + connector host).

1.b. Minimal config

Create ~/.claw/config.yaml:


port: 5321
memory:
  driver: redis
  url: redis://127.0.0.1:6379
vectors:
  driver: qdrant
  url: http://127.0.0.1:6333

Start it:


claw-daemon &   # keep it running
claw-gateway    # opens http://localhost:5321

Step 2 – Point OpenClaw at your Obsidian vault

2.a. Decide on vault location

Mine sits at ~/Notes/vault. Any folder works as long as OpenClaw can write to it.

2.b. Enable the built-in Markdown exporter


# ~/.claw/config.yaml (append)
exporters:
  markdown:
    type: local-md
    path: ~/Notes/vault/inbox  # subfolder keeps AI output sandboxed

Restart the daemon so it rereads config. Anything we write to memory with the note.create action now lands as a .md file.

2.c. Obsidian settings

Turn on “Periodic Notes” plugin for daily/weekly markdown stubs.
Add the “Dataview” plugin if you want tables of promises, contacts, etc. (not required).
Set the vault to watch inbox/ for new files. Obsidian does this automatically, but you can add a folder icon to spot AI notes.

Step 3 – Capture from chat channels

We’ll wire Slack and Telegram because they cover 90% of my inbound thought debris.

3.a. Slack


# In gateway UI ➜ Connectors ➜ Add ➜ Slack Bot
# Provide App Token (xapp-*) and Signing Secret
actions:
  - on_message: note.create
    map:
      content: "${message.text}"
      meta:
        source: slack
        channel: "${channel.name}"

The note.create action writes to memory and schedules export. I also tag with slack for filtering later.

3.b. Telegram


# Add Telegram connector the same way, then set the on_message hook
on_message:
  type: note.create
  map:
    content: "${message.text}"
    meta:
      source: telegram
      chat_id: "${chat.id}"

Tip: Point the bot to your private “Inbox” chat so you can forward any message from other groups with a single tap.

Step 4 – Auto-tag, link, and embed notes

The naive setup dumps raw text. To reach “second brain” status we need structure: tags, links, and embeddings.

4.a. Automatic tagging with OpenAI


# ~/.claw/pipelines/tagging.yaml
pipeline:
  - action: openai.chat
    with:
      model: gpt-4o-mini
      prompt: "Return 2-4 subject tags for the following text: {{content}}"
  - action: note.update
    map:
      id: "${previous.id}"
      tags: "${openai.chat.tags}"

Add a scheduler entry:


# ~/.claw/config.yaml
schedules:
  nightly_tags:
    cron: "0 2 * * *"  # 2am local
    run: tagging.yaml

Yes, LLM calls cost money. Switch to openrouter.alt or run a local model if you care.

4.b. Backlinking via embeddings

Community user @sonicstack posted a neat pattern: compute embeddings for new notes, then for any vector match > 0.85 similarity, append an Obsidian link.


# ~/.claw/pipelines/backlink.yaml
pipeline:
  - action: vectors.similar
    with:
      id: "${note.id}"
      threshold: 0.85
      top_k: 5
  - action: foreach
    list: "${vectors.similar.matches}"
    do:
      - action: note.append
        map:
          id: "${note.id}"
          content: "\n\nRelated: [[${item.note.filename}]]"

Trigger this pipeline on every note.create event via the gateway “After Create” hook.

Step 5 – Daily summaries & review

The point of a second brain is recall, not hoarding. I generate a rolling daily note with highlights.

5.a. Summary pipeline


# ~/.claw/pipelines/daily_summary.yaml
pipeline:
  - action: memory.query
    with:
      filter:
        created_at: "yesterday"
  - action: openai.chat
    with:
      model: gpt-4o-mini
      prompt: |
        Summarize the following notes into bullets with backlinks:
        {{memory.query.items}}
  - action: file.write
    with:
      path: "~/Notes/vault/daily/{{date:YYYY-MM-DD}}.md"
      content: |
        # {{date:YYYY-MM-DD}}
        {{openai.chat.content}}

This runs at 23:55 each night:


# ~/.claw/config.yaml
schedules:
  eod:
    cron: "55 23 * * *"
    run: daily_summary.yaml

Open Obsidian in the morning, hit Daily Notes, and it’s already populated.

Memory moves across agents — real-world testimonial

The Reddit thread “I trained OpenClaw to remember my dog’s meds” got traction because the same memory record surfaced in a totally different context. A mobile agent recorded “give Luna 75mg at 7 pm” in a Signal chat. Later, the server agent handling a cron job for notify-send asked memory “any meds due?” and pinged the user. The note wasn’t duplicated; both agents hit the same Redis key.

That pattern matters for second-brain workflows because you might capture an idea on your phone during commute, tag it on desktop, and search it from a shell script—all without syncing files manually. If you deploy agents to ClawCloud, the memory lives in the hosted Redis by default, so you get the same effect without port-forwarding.

Hard edges & how to avoid face-plants

Rate limits. Slack caps bots at 50 msg/min. Batch writes or exponential backoff or Slack will throttle and you’ll drop notes.
File system conflicts. If Obsidian is open while OpenClaw writes, macOS sometimes throws EPERM. Enable Safe Write in Obsidian or run OpenClaw on a temp path then mv atomically.
Vector DB costs. Qdrant local is free, but hosted Qdrant bills per GB per hour. Embed only what you need. I skip code snippets longer than 2k tokens.
Stale links. If you rename files in Obsidian, OpenClaw doesn’t know. Install the Obsidian File Renamer plugin that writes a small front-matter alias; update your backlink pipeline to read it.
Token leakage. The gateway stores connector secrets in ~/.claw/secrets.json. If you auto-commit the vault, add that path to .gitignore.

Where to go next

You now have a loop: capture from any chat ➜ OpenClaw ➜ Obsidian vault ➜ daily AI digest ➜ conversational search. From here you can:

Add shell or browser agents to capture command output (!!capture ls ‑la ~/projects).
Push the whole stack to ClawCloud so your laptop fan stops spinning during nightly runs.
Swap OpenAI for Llama 3 8B running with llama.cpp if you need offline.
Log every build or deploy by hooking your CI webhook into note.create. Search “When did we bump Redis?” next month.

The idea isn’t to engineer a life-logging panopticon. It’s to lower the friction from idea → record → recall to near zero. OpenClaw plus Obsidian gets you there with tools you already like. Wire it up and see if your future self thanks you.