A Markdown vault optimized for LLM consumption — graph-aware, full-text searchable, semantic when you need it. Works progressively: start with files, add layers as you grow.

Three problems every AI-coding workflow eventually hits:

1. Your AI has no memory between sessions. Every conversation starts from zero.
2. Your knowledge is unstructured prose. Loading the right context burns tokens you didn't budget for.
3. You can't search your own notes the way an LLM needs to. Filename grep doesn't cut it; semantic search alone misses structure.

Cortex turns a plain Markdown folder into a graph-aware, full-text-searchable, optionally-semantic knowledge base that an LLM can query precisely — by tag, by link graph, by full text, by section, by similarity. Conventions plus a lint script keep notes clean as the vault grows.

Notes are Markdown files with YAML frontmatter:

---
type: log
status: active
summary: One-sentence TLDR so the LLM can decide whether to load the rest.
tags: [payments, stripe, bugfix]
created: 2026-04-13
updated: 2026-04-13
---

# Stripe rate limiting fix

Brief problem description, [[stripe-integration]] context, and the resolution.

Cortex parses these into a Postgres index that an LLM can query in milliseconds:

• --search-fts "rate limiting" — full-text search across all bodies
• --backlinks projects/strata/README.md — what references this note
• --section infrastructure/vps.md "Identity" — pull just one section
• --type spec --status active — filter by structured metadata

The LLM reads only the files it needs, in the right slices. You get cross-session memory and your tokens stay under control.

Cortex works at every layer. Each row is a valid configuration:

Capabilities by level:

You can stop at any level. Going up later costs nothing — your existing notes get indexed automatically.

curl -sL https://raw.githubusercontent.com/wynexlabs/cortex/main/install.sh | bash

Installs the Cortex Claude Code plugin. Then in Claude Code:

"Set up Cortex for my vault."

That's it. Claude creates .cortex/config.yaml, walks you through whatever level fits, and starts saving notes with proper frontmatter.

Point Obsidian at your vault folder. Notes become browsable with backlinks and a graph view. Free.

cd ~/your-vault
git init && git remote add origin [email protected]:you/your-vault.git

Cortex auto-commits and pushes (configurable). Multi-machine sync without conflict drama.

Sign up at neon.tech (free tier covers most personal use), copy the connection string into .cortex/config.yaml, and run:

python scripts/cortex_migrate.py --config .cortex/config.yaml
python scripts/cortex_reindex.py --config .cortex/config.yaml

Schema migrates additively. All your existing notes get indexed.

Set an embedding_provider and API key in your config. Run reindex once to embed the vault. Queries via --semantic-search find notes by meaning, not just keywords. Coming in v1.5.

Just files plus Obsidian. Cortex saves notes with structured frontmatter. Claude reads the right files instead of the whole vault. No cloud required.

Files + GitHub + Neon. Same notes on your laptop and your VPS, both querying the same Neon index. Push from one, pull from the other.

The original Cortex use case. Run Open Claw on a VPS for 24/7 availability while you do dev work locally. Both reach the same vault.

Local Machine  ←──  GitHub  ──→  VPS (Open Claw)
       ↕                                ↕
       └─────────  Neon Postgres  ──────┘
                  (shared index)

Cortex's CLI is scriptable. Lint as a CI gate, query in pre-commit hooks, bundle context for agent runs. See the setup guide.

A vault built for LLMs benefits from a writing standard. Cortex ships with 10 LLM-first conventions covering required frontmatter (summary:, aliases:, see-also:), atomic note size, wikilink rules, and pronoun avoidance at section openers.

The cortex_lint.py script enforces 7 of the 10 mechanically — never modifies files, never blocks indexing, just surfaces warnings:

python scripts/cortex_lint.py --config .cortex/config.yaml

The other 3 conventions need human judgment and are documented for self-application.

Cortex can silently log every Claude Code session as a type: log note. Add to ~/.claude/settings.json:

{
  "hooks": {
    "Stop": [{
      "matcher": "",
      "hooks": [{
        "type": "command",
        "command": "python3 ~/.claude/plugins/cache/wynexlabs/cortex/1.4.0/scripts/cortex_autosave.py"
      }]
    }]
  }
}

Reads the transcript, skips trivial sessions, captures topics/files/commands. Always exits 0 — never blocks Claude Code.

┌─────────────────────────────────────────────┐
│              Your Markdown Vault             │
│   .md files with YAML frontmatter           │
│   (Obsidian-compatible)                      │
├──────────────────┬──────────────────────────┤
│   GitHub Repo    │    Neon Postgres          │
│   (file sync)    │    (query index)          │
│                  │                           │
│   Source of      │  cortex_notes (metadata,  │
│   truth          │  body, FTS tsvector)      │
│                  │  cortex_links (graph)     │
│                  │  cortex_headings (anchors)│
│                  │  cortex_embeddings (v1.5) │
├──────────────────┴──────────────────────────┤
│              Any number of machines          │
│   Each pushes/pulls GitHub, queries Neon     │
└─────────────────────────────────────────────┘

All scripts support --help and --dry-run where applicable.

Custom fields via schema.extensions in config. See the setup guide.

MIT — use it however you want.