WikiMem

Self-improving memory for agents: ingest anything, query everything.

Codex is an agent-native, recursively self-improving agent employee whose job is memory. Coding agents use it through its skills, its MCP server and its command line. It improves itself through its own evals and a scheduled improvement loop, and a person reviews every change.

AGENTS.md · llms.txt · Skills · Security · Contributing · All projects

WikiMem gives an agent a memory it can read, search and improve. Drop in files, links or a connected app, and it
compiles them into linked Markdown pages with citations, then answers questions from those pages. It is for anyone
who wants an agent, or a person, to build on what it learned last week instead of starting cold.

Use it from any coding agent

Claude Code: the plugin brings the skills, sub-agents, hooks and MCP server.

/plugin marketplace add naman10parikh/wikimem
/plugin install wikimem@wikimem

Its MCP server, in any MCP client:

claude mcp add --transport stdio wikimem -- npx -y -p github:naman10parikh/wikimem wikimem-mcp
codex mcp add wikimem -- npx -y -p github:naman10parikh/wikimem wikimem-mcp

Cursor (.cursor/mcp.json), Gemini CLI (.gemini/settings.json) and most other clients take the same command as JSON:

{
  "mcpServers": {
    "wikimem": {
      "command": "npx",
      "args": [
        "-y",
        "-p",
        "github:naman10parikh/wikimem",
        "wikimem-mcp"
      ]
    }
  }
}

Gemini CLI: the extension brings the context and the MCP server.

gemini extensions install https://github.com/naman10parikh/wikimem

One skill (3 in all, in skills/), in any agent that reads Agent Skills:

gemini skills install https://github.com/naman10parikh/wikimem --path skills/wikimem
git clone --depth 1 https://github.com/naman10parikh/wikimem /tmp/wikimem && cp -r /tmp/wikimem/skills/wikimem ~/.claude/skills/

The command line:

npx -y -p github:naman10parikh/wikimem wikimem --help

Codex, Cursor, OpenCode, GitHub Copilot and other agents read AGENTS.md; Claude Code reads CLAUDE.md and Gemini CLI reads GEMINI.md, which import it. llms.txt maps every surface for agents that read first.

Quick start

These commands were run for this README. They need Node.js 18 or later and no API key.

alias wikimem='npx -y -p github:naman10parikh/wikimem wikimem'
wikimem init my-wiki      # create a vault: wiki/, raw/, AGENTS.md, config.yaml
cd my-wiki
wikimem status            # pages, words, sources, links, orphans
wikimem lint              # orphan pages, broken wikilinks, missing summaries
wikimem observe           # score every page and list what to improve (free without --improve)
wikimem serve             # the web app at http://localhost:3141, and the MCP endpoint /mcp

The first npx run downloads and builds WikiMem, which takes a minute; later runs start at once. npx wikimem@latest
installs the last npm release (0.8.6); the GitHub form above runs this repository's code (0.10.0).

To turn sources into pages and ask questions, give WikiMem an LLM: set ANTHROPIC_API_KEY or OPENAI_API_KEY, or run
Ollama locally. Then:

wikimem ingest paper.pdf
wikimem ingest https://en.wikipedia.org/wiki/Large_language_model
wikimem ask "What are the key themes across my sources?"

How it works

WikiMem takes Karpathy's LLM wiki idea and turns it into a full
tool. A vault has two layers. raw/ holds your original sources and is never edited. wiki/ holds the pages an LLM
writes from them, with cross-references and citations. Every change is a git commit, so you can browse history and
restore any snapshot.

raw/                        wiki/
  paper.pdf                   index.md ........... content catalog
  podcast.mp3    ──LLM──>    sources/paper.md ... summary + citations
  screenshot.png              entities/openai.md . people, orgs, tools
  meeting.docx                concepts/rag.md .... ideas + frameworks
  blog-url                    syntheses/ ......... cross-cutting analysis

The vault's own AGENTS.md is the schema that tells the LLM how to structure pages, and it changes as the wiki grows.
Three automations keep the wiki growing and improving while you sleep:

13 formats, one pipeline

WikiMem detects the file type, runs the right processor, and writes pages with cross-references and citations. The
web app shows each step: file detection, text extraction, LLM processing, page generation, cross-linking, indexing.

wikimem add-source <path> ingests only new or changed files (by modification time and SHA-256), so a folder that
changes daily stays in sync cheaply. wikimem sandbox-run fetches untrusted pages inside an isolated E2B sandbox
and keeps only the cleaned Markdown.

Search, ask and see the graph

• Search: wikimem search is BM25 keyword search across every page; embeddings can add semantic search.
• Ask: wikimem ask answers from your pages and cites them; wikimem query --file saves the answer as a
  synthesis page.
• Knowledge graph: an interactive D3 force-directed graph. Click a node to highlight its neighbours,
  double-click to open it. Community detection clusters related pages; hub nodes are sized by their links.
• Time-lapse: watch the wiki grow commit by commit, as pages appear and links form.

The web app

wikimem serve opens a full editor at localhost:3141:

• File tree with collapsible folders, and a tabbed editor with WYSIWYG Markdown (Cmd+S saves and commits)
• Knowledge graph, pipeline view (drag and drop a file, watch each step) and time-lapse
• Search (Cmd+K) and a command palette (Cmd+P)
• Settings for API keys, models and automations, and Ask your knowledge from the browser

Connectors

Sync outside sources into the vault on a schedule.

MCP server and Claude custom connector

Over stdio, wikimem-mcp --vault <path> (or wikimem mcp --vault <path>) serves a vault's 19 tools to Claude Code,
Cursor or any MCP client; with no --vault it serves the current folder. The tools are listed in
AGENTS.md.

Over HTTP, wikimem serve exposes the same tools at /mcp behind OAuth 2.1, in the dialect Claude's custom
connectors speak:

1. Start WikiMem: wikimem serve (default http://localhost:3141).
2. Expose it with HTTPS. Claude requires HTTPS except for localhost. For example, run ngrok http 3141, then
   export WIKIMEM_PUBLIC_URL=https://abc.ngrok.app and restart wikimem serve so the metadata advertises it.
3. Add it in Claude: Settings, then Connectors, then Add Custom
   Connector, and paste https://abc.ngrok.app/mcp (or http://localhost:3141/mcp on the same machine). Claude
   fetches /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server, registers a client
   at /oauth/register, opens /oauth/authorize (click Allow once), exchanges the code at /oauth/token, and
   calls /mcp with the token. All 19 tools appear, and Claude cites pages from your vault.

Tokens never leave your machine, and the signing secret stays inside your vault folder.

Commands

Configuration

After wikimem init, the vault holds config.yaml:

provider: claude                    # claude | openai | ollama
model: claude-sonnet-4-20250514

sources:
  - name: "HN Front Page"
    type: rss
    url: "https://hnrss.org/frontpage"

  - name: "GitHub Trending TS"
    type: github
    query: "stars:>100 created:>7d language:typescript"

improvement:
  threshold: 80
  schedule: "0 3 * * *"            # 3am nightly

Ollama runs fully local: no API keys, no network, no data leaves your machine.

Obsidian and privacy

Every vault is an Obsidian vault. Open the folder in Obsidian with no plugins: [[wikilinks]] become backlinks,
YAML frontmatter becomes page metadata, and the graph and tag views work.

Everything runs locally; the wiki is a folder of Markdown files. Nothing leaves your machine except LLM calls, and
those are optional with Ollama. raw/ and config.yaml are excluded from git by default.

Credits

Inspired by Andrej Karpathy's LLM wiki pattern: LLMs should
compile knowledge into structured, linked wikis rather than only answer from raw chunks. Built with
Express, D3, simple-git, and the
Claude, OpenAI and Ollama APIs.

What it is made of

Every project in this fleet is graded on the same 11 harness components and on self-improvement. Each mark is backed by a file you can open.

✅ real and tested · 🟡 partial, with the reason in the row · ❌ absent

How it improves itself

It carries its own evals and a self-improvement contract, dsip.json (level L2). A scheduled loop runs the evals, tries a change in a sandbox and opens it for review. A change that lowers a score is not merged, and a person merges every change. Lessons it learns are kept as rules in its memory files.

Part of a fleet

One of the agent-native, recursively self-improving open-source projects by Naman Parikh. Each one is an agent employee that owns one part of an agent's harness or of the product around it.

Siblings: agentdial (identity) · skillsmith (skills) · agent-booster (tools / CLIs) · armory (MCPs and the component registry) · agentgrid (dispatch) · agentswarm (dispatch) · agentbench (evals) · agentmoney (observability) · claude-harness (the whole harness, as a template).

Contributing and security

Read CONTRIBUTING.md; AI-assisted pull requests are welcome. Report a vulnerability privately, as SECURITY.md explains.

License

MIT, © 2026 Naman Parikh. See LICENSE.

Star history