blog: add v0.19.0 release, OpenClaw plugin, and agent skills posts

Author: bm-clawd

content/9.blog/.navigation.yml

@@ -0,0 +1,2 @@
+title: Blog
+icon: i-lucide-pen-line

content/9.blog/1.v0-19-0-release.md

@@ -0,0 +1,99 @@
+---
+title: "Basic Memory v0.19.0: Search That Understands What You Mean"
+description: "Semantic search, schema validation, per-project cloud routing, and more — the biggest Basic Memory release yet."
+---
+
+We just shipped v0.19.0 — the biggest release since we launched. Sixty-six commits, three months of work, and a fundamental change in how your AI finds what it knows.
+
+Here's what matters.
+
+---
+
+## Semantic Search, Everywhere
+
+Until now, Basic Memory searched your notes the way `grep` does: match the words, return the results. It works. It's fast. And it completely fails when you search for "login security improvements" but your notes say "authentication hardening."
+
+v0.19.0 adds semantic search — hybrid by default, combining keyword matching with meaning-based retrieval. It ships enabled out of the box. No configuration. No separate embedding service. No API keys. Install, and it works.
+
+```
+search_notes("how do I speed up the app")
+```
+
+That query now finds your note about "performance optimization strategies" even though you never used the word "speed." The embedding model runs locally, your data never leaves your machine, and the results are ranked by a fusion of exact matches and semantic similarity.
+
+Three modes if you want control:
+- **hybrid** (default) — best of both worlds
+- **text** — keyword-only, like before
+- **vector** — pure semantic similarity
+
+For most people: just search normally. It got smarter.
+
+## Schemas: Your AI Checks Its Own Work
+
+Knowledge bases grow organically. You write thirty person notes and realize half say `[name]`, a quarter say `[full_name]`, and a few just put the name in the title. Relation types drift — `works_at`, `employed_by`, `employer` — all meaning the same thing.
+
+The new schema system lets you define what "consistent" means, then validate against it. But here's the key design decision: **schemas are just notes.**
+
+```yaml
+---
+title: Person
+type: schema
+entity: person
+schema:
+  name: string, full name
+  role?: string, job title
+  works_at?: Organization, employer
+---
+```
+
+That's a regular markdown file in your knowledge base. Your AI reads it, uses it as a guide when creating new notes, and can validate existing notes against it. You can edit it in any text editor.
+
+The workflow is conversational. Ask your AI to analyze your existing notes and infer a schema. It finds the patterns, proposes a definition, and you approve it. Then it checks the outliers and offers to fix them. No migration scripts. No database alterations. Just a conversation about what "good" looks like for your notes.
+
+We built `schema_infer`, `schema_validate`, and `schema_diff` as MCP tools — so any AI that connects to Basic Memory can use them. Infer from what exists. Validate against the definition. Detect drift over time.
+
+## Per-Project Cloud Routing
+
+This one's for people running both local and cloud projects. You can now route individual projects through Basic Memory Cloud while keeping others purely local.
+
+```bash
+bm project set-cloud research       # this project syncs to cloud
+bm project set-local private-notes   # this one stays on your machine
+```
+
+The routing is transparent to your AI — it uses the same tools regardless of where the data lives. You decide what's sensitive and what's portable.
+
+Three levels of control: global default, per-project override, per-command flag. Mix and match however makes sense for your setup.
+
+## The Small Things That Matter
+
+**Write protection.** `write_note` no longer silently overwrites existing notes. If a note exists, you get an error instead of data loss. Pass `overwrite=True` when you mean it. This one change will save someone's knowledge base — AI assistants are enthusiastic writers.
+
+**Metadata search.** Filter notes by any frontmatter field — status, priority, tags, custom fields. No more searching for "status: in-progress" as a text string and hoping it matches.
+
+```
+search_notes(metadata_filters={"status": "active", "priority": {"$in": ["high", "critical"]}})
+```
+
+**Project dashboard.** `bm project info` now shows an htop-inspired dashboard with bar charts for note types, embedding coverage, and health status. It's the fastest way to see what's in your knowledge base.
+
+**JSON everywhere.** Every MCP tool supports `output_format="json"` for scripting and automation. Five more CLI commands got `--json` flags. If you're building on top of Basic Memory, this makes your life easier.
+
+---
+
+## The Upgrade
+
+```bash
+uv tool upgrade basic-memory
+bm reindex --embeddings
+```
+
+The reindex generates vector embeddings for semantic search — a one-time operation. Cloud projects handle this automatically.
+
+Everything else is backward compatible. Existing notes, permalinks, and workflows keep working. New defaults are saner, and the old behavior is one config flag away if you need it.
+
+[Full release notes →](/whats-new/v0.19.0)
+
+---
+
+*Basic Memory is local-first AI knowledge infrastructure. Plain text files, semantic knowledge graph, works with Claude, Codex, Cursor, and anything that speaks MCP. [Get started →](https://basicmemory.com)*

content/9.blog/2.openclaw-plugin.md

@@ -0,0 +1,78 @@
+---
+title: "Giving Your AI Agent a Memory That Actually Works"
+description: "The openclaw-basic-memory plugin gives OpenClaw agents persistent, searchable memory — two commands, zero configuration."
+---
+
+Most AI assistants wake up every morning with amnesia. You explain your project. Again. You remind them about that decision you made last week. Again. You re-establish context that took three conversations to build. Again.
+
+We built a plugin that fixes this for OpenClaw agents. Two commands, zero configuration, and your agent remembers everything — across sessions, across days, across context window resets.
+
+```bash
+openclaw plugins install @basicmemory/openclaw-basic-memory
+openclaw gateway restart
+```
+
+That's the whole setup.
+
+---
+
+## What Your Agent Gets
+
+**Composited memory search.** When your agent searches its memory, the plugin queries three sources in parallel: your MEMORY.md file, the full knowledge graph, and any active tasks. One search, three data sources, merged results. The agent doesn't need to know where something is stored — it just finds it.
+
+**Auto-capture.** Every conversation turn gets recorded as a timestamped entry in a daily note. You're not maintaining a journal — it happens in the background. Weeks later, when you need to know "what did we decide about the database migration?", it's there.
+
+**Auto-recall.** Session starts, the agent immediately loads active tasks and recent notes. No "let me catch you up" ritual. No "read my files first" prompt engineering. It just knows what it was working on.
+
+**14 tools, 7 slash commands, 6 skills.** The full Basic Memory toolset — search, read, write, edit, schema validation, project management. Plus shortcuts like `/remember` (save something), `/recall` (find something), and `/reflect` (review and consolidate).
+
+## Why This Isn't Just Another Memory Plugin
+
+Here's what's different: everything your agent remembers is stored as plain markdown files that you can open and read.
+
+Not embeddings in a vector database you can't inspect. Not JSON blobs in a cloud API you don't control. Markdown files. In a folder. On your machine.
+
+Your agent writes a note about a meeting? Open it in VS Code. See exactly what it captured. Fix the part it got wrong. Add the context it missed. Save the file — your agent sees the change instantly.
+
+This is what "bidirectional" means in practice. The AI writes things down. You read them. You correct them. The AI reads your corrections. The knowledge base gets better because both sides are working with the same transparent format.
+
+It's the difference between an AI that claims to remember and an AI whose memory you can verify.
+
+## Multi-Project Access
+
+Because the plugin connects to the full Basic Memory stack, your agent isn't limited to a single workspace. It can search across every project in your knowledge base — personal notes, work projects, research, whatever you've organized.
+
+Some projects stay local. Some route through Basic Memory Cloud for cross-device access. The agent uses the same tools either way. You decide what lives where.
+
+## The Skills
+
+The plugin bundles six pre-built skills that teach your agent best practices:
+
+- **memory-notes** — How to write well-structured notes with proper frontmatter, observations, and relations
+- **memory-tasks** — Structured task tracking that survives when the context window resets
+- **memory-schema** — Keeping note structures consistent as your knowledge base grows
+- **memory-reflect** — Reviewing recent work and consolidating insights (inspired by how humans review journals)
+- **memory-defrag** — Splitting bloated files, merging duplicates, pruning stale info
+- **memory-metadata-search** — Finding notes by status, priority, or any custom field
+
+These aren't documentation. They're instructions your agent reads and follows — like onboarding a new team member by handing them a playbook.
+
+---
+
+## Getting Started
+
+```bash
+openclaw plugins install @basicmemory/openclaw-basic-memory
+openclaw gateway restart
+```
+
+The plugin auto-detects your Basic Memory installation and starts working. If you don't have Basic Memory installed yet, it handles that too.
+
+From there, just talk to your agent. Say "remember that we decided to use Postgres for the new service." Say "what were we working on yesterday?" Say "create a task for the API refactor." The plugin handles the rest.
+
+[Full setup guide →](/integrations/openclaw)  
+[GitHub →](https://github.com/basicmachines-co/openclaw-basic-memory)
+
+---
+
+*Basic Memory gives AI assistants persistent knowledge stored as plain text you own. Works with Claude, Codex, Cursor, OpenClaw, and anything that supports MCP. [Try it →](https://basicmemory.com)*

content/9.blog/3.agent-skills.md

@@ -0,0 +1,91 @@
+---
+title: "Teaching Your AI How to Remember"
+description: "Pre-built skills that teach AI agents when and how to use Basic Memory effectively — not just tool access, but good habits."
+---
+
+You gave your AI a knowledge base. It has the tools — write notes, search, build context. But does it actually use them well?
+
+Probably not. At least, not consistently.
+
+An AI with access to Basic Memory's MCP tools is like a new hire with access to the company wiki. They *can* use it. But without guidance, they'll write notes in five different formats, forget to link related concepts, and never think to review what they wrote last week. The tools are there. The habits aren't.
+
+That's what skills fix.
+
+---
+
+## Skills Are Playbooks, Not Documentation
+
+Basic Memory Skills are markdown instruction files that teach AI agents *when* and *how* to use their memory tools. Not API docs. Not reference pages. Playbooks — "here's the workflow, here's when to use it, here are the patterns that work."
+
+Install them with a single command:
+
+```bash
+npx skills add basicmachines-co/basic-memory-skills
+```
+
+Your agent reads the skill file, learns the pattern, and follows it. Claude Desktop, Claude Code, Cursor, Windsurf — anything that supports markdown-based skills.
+
+## The Nine Skills
+
+**The foundation:**
+
+**memory-notes** is the one you install first. It teaches proper note structure — frontmatter, semantic observation categories, relations with wiki-links, memory:// URL usage. This is the difference between an agent that dumps text into a file and an agent that builds a connected knowledge graph.
+
+**memory-tasks** handles structured task tracking. AI context windows reset. Sessions end. Your agent loses its train of thought. Task notes externalize multi-step work so it survives compaction. The agent writes down where it is in a process, and picks up from that checkpoint next session.
+
+**memory-schema** manages the lifecycle of structured note types. Infer a schema from what you've already written. Validate notes against it. Detect when patterns drift over time. This is how consistency scales — not by enforcing rules upfront, but by observing patterns and codifying them.
+
+**Knowledge maintenance:**
+
+**memory-reflect** is inspired by what sleep researchers call "memory consolidation." Your agent reviews recent conversations, extracts the important parts, and writes them into long-term storage. Run it daily. It's like journaling — the act of reviewing forces the agent to decide what matters.
+
+**memory-defrag** is spring cleaning. Split a 500-line note into focused pieces. Merge three notes that are basically saying the same thing. Remove information that's no longer true. Run it weekly. Knowledge bases that never get reorganized become knowledge graveyards.
+
+**memory-lifecycle** manages status transitions — moving notes from active to archive, tracking where things are in a workflow. The philosophy is "archive, never delete." Information is preserved through moves, not removal.
+
+**Advanced workflows:**
+
+**memory-metadata-search** teaches your agent to query by structured fields instead of guessing at text matches. Find all notes with `status: active` and `priority: high`. Filter by date ranges. Search by tags. Frontmatter becomes queryable.
+
+**memory-ingest** handles external input — meeting transcripts, pasted documents, conversation logs. The agent parses unstructured text into properly formatted notes with observations, relations, and metadata. Bulk import without bulk cleanup.
+
+**memory-research** sends the agent to the web and brings findings back as structured knowledge. Research a company, a technology, a person — the agent searches, synthesizes, and writes a note you can actually use later.
+
+## Pick What You Need
+
+You don't need all nine. Start with what matches your workflow:
+
+**Developers:** `memory-notes` + `memory-tasks` + `memory-schema` — core note writing, task tracking across sessions, consistent project documentation.
+
+**Researchers:** `memory-notes` + `memory-research` + `memory-ingest` — capture web research and process external documents into structured knowledge.
+
+**Knowledge maintenance:** `memory-notes` + `memory-defrag` + `memory-lifecycle` + `memory-reflect` — keep your knowledge base healthy over time.
+
+**Everything:** All nine skills for comprehensive memory management. Install the full collection and let your agent use what's relevant.
+
+## Why This Matters
+
+The gap between "AI has access to tools" and "AI uses tools effectively" is larger than most people realize. An agent without skills will use `write_note` to create flat, unstructured text dumps. An agent *with* the memory-notes skill creates notes with proper observations, semantic categories, and wiki-link relations that connect to the rest of your knowledge graph.
+
+Same tool. Dramatically different output. The skill is the difference.
+
+This is also how Basic Memory stays useful as your knowledge base grows. A hundred notes are easy to manage. A thousand notes need structure, consistency, and maintenance. Skills teach your agent the habits that keep a large knowledge base navigable instead of overwhelming.
+
+---
+
+Install a single skill:
+```bash
+npx skills add basicmachines-co/basic-memory-skills --skill memory-tasks
+```
+
+Install everything:
+```bash
+npx skills add basicmachines-co/basic-memory-skills
+```
+
+[Full skill guide →](/integrations/skills)  
+[GitHub →](https://github.com/basicmachines-co/basic-memory-skills)
+
+---
+
+*Basic Memory is local-first AI knowledge infrastructure. Plain text files you can read, edit, and keep forever. [Get started →](https://basicmemory.com)*