Issue · 02 · Spring Knovya · Letters
Letter · 06

The note-taking app that knows your codebase.

— Spring, the year you switched IDEs three times

Built for the programmer with three AI tools open, a vault of Markdown they keep meaning to clean up, and a search bar that never finds that JWT thing from last sprint. One letter, in three parts: where context lives now, where it should live, and what your next IDE switch keeps.

The Letter

Dear Developer, on the note app that knows your codebase

Monday you're in Cursor. Wednesday you switched to Claude Desktop. Friday someone on the team is trying Continue and you're curious. Each time you change tools, the AI starts not knowing you — your codebase conventions, the bug from last sprint, the architectural decision your team made in October.

The model is fine. The model is the easy part. The problem is that context is local — it lives in this IDE, in this project, in this chat session. Switch tools and you start over. Hand the project to a teammate and they start over. The intelligence is per-session. Your real work is across sessions.

The right note-taking app for programmers isn't one with prettier code blocks. It's the one that survives the IDE switch. The one where the RFC you wrote in February is one semantic-search query away from the retro you wrote in April, and both are readable from whatever AI you opened this morning. That's the brief. Most note tools fail it.

Knovya MCP fixes this. Thirty-three tools, seven AI clients, OAuth 2.1 with PKCE — your knowledge base shows up the same way in Claude as it does in Cursor as it does in ChatGPT. AI Memory persists across every model. Knowledge Graph means the AI can read related decisions, ADRs, postmortems — not just the file you have open.

And the editor stays out of the way. Block Editor with first-class code blocks, syntax-highlighted, line-anchored, copy-button-when-you-need-it. Mermaid for architecture sketches. Math blocks for the technical notes. Hybrid search finds the snippet by exact identifier or by fuzzy concept — both routes ranked together. API and webhooks for the CI/CD edges your team eventually wires up.

Stop re-explaining yourself to new tools. The context is in Knovya — every AI you use can read it.

— Knovya

The Switch · Try it

One knowledge base, seven AI clients, every IDE switch survived.

This is what doesn't change when you switch tools. Three lenses on the same notes — the search, the protocol fan-out, the graph trace.

search · "JWT refresh pattern"
— hybrid · FTS + vector + RRF

Three lenses, one knowledge base. The search is what you type. The fan-out is what your AI tools see. The trace is what makes any one of them an entry point to all of them.

The Stack — six things, one developer workflow

From the IDE chat to the RFC, in one knowledge base.

MCP, code-first editor, hybrid search, knowledge graph, AI memory, and the API hooks that wire it all to your CI. Built for the engineering work between commits.

  1. 01

    MCP — seven AI clients

    Thirty-three tools over OAuth 2.1, exposed to Claude, Cursor, ChatGPT, Continue, Goose, VS Code, and Copilot. Connect once; your knowledge base shows up the same way in every client. The IDE switch becomes a non-event.

    MCP →
  2. 02

    Block Editor

    Code blocks with syntax highlighting, line anchors, and copy-on-hover. Mermaid for sequence diagrams and architecture sketches. Math blocks for the technical notes that need it. Toggles, callouts, tables, embeds — the editor stays out of your way.

    Block editor →
  3. 03

    Hybrid Search

    Full-text search finds exact identifiers. Vector search finds fuzzy concepts. Reciprocal Rank Fusion blends them into one ordered list. NoteRank surfaces the entries you've actually engaged with. Search becomes the way you remember.

    Hybrid search →
  4. 04

    Knowledge Graph

    The RFC links to the commit links to the retro links to the customer issue. Any one entry is the door to the others. The graph is what your AI reads, not just the file you have open — which is why the answer is usually richer than the prompt.

    Knowledge graph →
  5. 05

    AI Memory

    Persists across every model and every IDE. The codebase conventions, the architectural decisions, the patterns your team prefers — read into context whenever the AI you're using asks for it. The model changes; the memory doesn't.

    AI memory →
  6. 06

    API + Webhooks

    REST API over every note operation. Webhooks fire on create / edit / graph-change. Engineering teams wire postmortem automation, RFC promotion in standup, changelog generation — the boring connective tissue your CI eventually needs.

    API + webhooks →
A Week, in Practice

Sprint 12, somewhere between RFC and ship.

You ship features and triage incidents. You write more decisions than you remember writing. Here's the week, in seven scenes.

  1. Mon · 09:30

    Cursor · feature branch

    You ask Cursor to refactor the auth middleware. It reads the related RFC from Knovya through MCP — without you pasting it in. The pattern was already decided in August; the refactor matches it.

  2. Tue · 11:00

    Postmortem capture

    A Sentry alert at 4am. You write the postmortem in Knovya with the block editor — code blocks for the offending diff, mermaid for the failure sequence, links to the RFC that should have caught it. The graph wires itself.

  3. Wed · 14:15

    Claude Desktop · debug

    Switched to Claude Desktop for a deep stack trace dive. The MCP server exposes the same notes; you ask Claude about "that JWT refresh thing from last sprint", and the RFC surfaces. No re-explaining.

  4. Thu · 10:00

    RFC draft

    Multi-region read strategy. AI Co-Edit pulls precedent from the Knowledge Graph — three past data-store decisions, one postmortem about replication lag, the customer call from two weeks ago. The Background section writes itself; you edit.

  5. Fri · 16:00

    Continue · code review

    Tried Continue this week. Same MCP server, twenty-two tools. The review surfaces a pattern from a different service in the monorepo — because Knovya remembered it across IDEs and sessions.

  6. Sat · 11:30

    Side project · weekend

    Same Knovya account, side-project workspace. The personal project benefits from the same editor, the same MCP, the same code-block muscle memory. No tool sprawl.

  7. Sun · 21:40

    Weekly review

    One paragraph: what you shipped, what slipped, what you learned. Reflect & Crystals files it. In a quarter, you'll search "refresh tokens" and see the whole arc — RFC, postmortem, retro, decisions, and the call that nudged it.

None of this is theoretical. It's a sprint. The IDE keeps changing. The brain stays.

The Blind Spot — what every dev note tool gets wrong

Engineering memory is a graph problem, not a file problem.

The note tools developers reach for split into two camps, and each gets engineering memory wrong from a different angle. The Markdown vault — Obsidian, foam, dendron — is the developer's instinct: local, file-system-based, plugin-driven. It's legitimately powerful, especially once you wire it to Claude Code with a CLAUDE.md file, qmd, notesmd-cli, and a vault rules document. That setup works. It also takes a weekend, and the knowledge graph is a folder tree.

The hosted note tools — Notion, Coda — solve the sync and collaboration problem the vaults never quite did. Their AI layers are competent at summarizing pages. They read your knowledge as documents, not as a graph. Code blocks render; semantic search across snippets and decisions doesn't. A retro from October doesn't surface when you ask about the same shape of question in April, because the model isn't looking at a graph; it's looking at one page at a time.

And the IDE-resident memory — Cursor's project memory, GitHub Copilot's repo context, in-IDE chat history — is real but scoped. The context lives in this IDE, in this project, in this session. Switch tools and you start over. Hand the project to a teammate and they start over. The intelligence is per-session; the work is across sessions.

Knovya is built for the graph, the switch, and the share. Native MCP across seven AI clients. Knowledge Graph as the primary structure, not a folder tree. Hybrid search across snippets and decisions. AI Memory that persists across models and across teammates. No vault rules to maintain. No re-pasting context into the next chat.

Build the graph, and every note becomes a door.

The Plan — for developers, specifically

Three ways in. Pick the one your codebase needs.

Solo developers run Pro. Engineering teams run Team. Free is enough to point Cursor or Claude Desktop at Knovya and see if the context survives one sprint.

Free

$0 forever

Hook one IDE up to Knovya. Capture a few RFCs and a postmortem. See if the IDE switch holds.

  • Up to fifty notes — one sprint of RFCs and decisions
  • MCP for one AI client of your choice
  • Block Editor, code blocks, mermaid, math — full
  • One public link, to share an RFC with a teammate
  • Templates for RFC, ADR, postmortem, weekly review
Open the workspace
For solo developers

Pro

$15 per month

Built for the developer who wants their notes to follow them across every IDE, every model, every project.

  • Unlimited notes — every RFC, every decision, every retro
  • MCP across all seven AI clients (Claude, Cursor, ChatGPT, Continue, Goose, VS Code, Copilot)
  • Hybrid search + Knowledge Graph + NoteRank precedent surfacing
  • AI Memory persists across every model
  • End-to-end encryption — code-adjacent notes stay private
  • Unlimited public links for RFC sharing
  • Full API + webhooks for CI/CD integration
Start with Pro
For engineering teams

Team

$25 per seat / month

For engineering groups running shared RFCs, ADRs, and postmortems. Real-time co-editing, shared workspace, org-level memory.

  • Everything in Pro, for the whole engineering team
  • Real-time co-editing on RFCs and design docs
  • Shared folders with role-based permissions
  • Workspace-level Knowledge Graph — org-wide engineering memory
  • Team templates for RFC, ADR, postmortem workflows
  • Audit log and SAML SSO (enterprise add-on)
Start with Team

All plans include unlimited notes archive — your past RFCs and decisions never expire on a free tier. See the full pricing →

Other Letters

We wrote six more. One might read like yours.

Try Knovya for the next sprint.

Point Cursor or Claude Desktop at Knovya MCP. Capture an RFC, a postmortem, a retro. Free is enough to see if the context follows.

Open the workspace Or browse all 26 features
Questions, answered

What developers usually ask first.

  1. What's the best note-taking app for programmers?

    The best note-taking app for programmers is the one that survives the IDE switch. Cursor on Monday, Claude Desktop on Wednesday, Continue on Friday — the AI keeps starting over because context lives in the chat session, not in your knowledge base. Knovya is built for programmers who use AI across tools: a managed knowledge base with native MCP, code blocks with syntax highlighting, hybrid search across snippets and natural language, and a knowledge graph that connects RFCs to commits to retros.

  2. Is Knovya an Obsidian alternative for developers?

    Knovya solves a different problem than Obsidian. Obsidian is a Markdown vault — local, plugin-driven, and increasingly powerful when you wire it to Claude Code with CLAUDE.md, qmd, notesmd-cli, and PARA folder rules. That setup works; it also takes a weekend. Knovya is the managed version: hosted knowledge base, native MCP for seven AI clients, hybrid search and knowledge graph out of the box. Many developers run both — Obsidian for personal Markdown, Knovya for shared engineering memory.

  3. How does Knovya MCP work with Cursor and Claude Desktop?

    Knovya runs an MCP server with thirty-three tools, OAuth 2.1, and per-client tool subsets. Cursor sees eighteen tools. Claude Desktop sees twenty-four. ChatGPT sees twelve. The same knowledge base, every AI client. Connect once, and the AI you're using can read your notes, your decisions, your code snippets, and the knowledge graph. Switch IDEs and the context comes with you — that's the point.

  4. Does Knovya support code blocks and mermaid diagrams?

    Yes. The block editor includes syntax-highlighted code blocks (every common language plus your config files), mermaid diagrams for architecture and flow, math blocks via KaTeX for technical notes, tables for benchmarks, and tab groups for multi-language snippets. Code blocks support line anchors so you can deep-link to a specific line from another note or an MCP query.

  5. Can Knovya search code semantically?

    Hybrid search combines full-text search and vector similarity, then re-ranks. You can search for an exact identifier (FTS finds it) or a fuzzy concept like 'JWT refresh pattern' (vector finds the RFC even if the words don't match). Reciprocal Rank Fusion blends both into one ordered list. NoteRank then surfaces the entries you've engaged with most. Snippets are first-class — code lives next to decisions and retros, all searchable from the same query.

  6. Does Knovya have an API and webhooks for CI/CD?

    Yes. The REST API covers every note operation — create, read, update, search, link. Webhooks fire on note creation, edits, and graph changes. Engineering teams use them for postmortem automation (a Sentry alert opens an incident note), RFC promotion (a tagged note gets surfaced in standup), and changelog generation from decision-tagged notes. API keys are workspace-scoped with role-based permissions.

  7. How is Knovya different from Notion AI for engineers?

    Notion AI is a chat layer on top of Notion pages. It's competent at summarizing what you ask about. It doesn't read your knowledge as a graph — it reads it as documents. For engineering work, the graph matters: an RFC links to a retro links to a commit links to a customer issue. Knovya is graph-native, with semantic search across the graph and an MCP that exposes that graph to whatever AI you use. Same notes, different shape.