I Built a Local-First AI Knowledge Base for Developers — Here's What Makes It Different

Stop losing context between projects. NoteCore is your second brain, built for devs.

Every developer I know has the same problem.

You finish a project. Six months later you're starting something similar and you know you've solved this exact auth problem before. You know you wrote down why you chose CQRS over a simple service layer in that one architecture doc. You know there was a snippet somewhere that handled exactly this edge case.

But you can't find it. It's buried in Notion, or Obsidian, or a random .md file in a repo you barely remember the name of.

So you solve it again from scratch. You spend two hours re-deriving something you already figured out.

That's the problem NoteCore exists to solve.

What is NoteCore?

NoteCore is a local-first AI knowledge base built specifically for developers. It's not another note-taking app. It's a queryable second brain — you throw in code snippets, architecture decisions, documentation fragments, lessons learned, and you get back answers in natural language.

The stack: Electron + React + Vite on the desktop, a local NestJS + SQLite backend running inside the app, Voyage AI for embeddings, and Claude (claude-sonnet-4-6) for the AI layer. Everything runs on your machine. Your notes never leave unless you explicitly opt into cloud sync.

Let's walk through what actually makes it work.

Semantic Search with Voyage AI Embeddings

Full-text search is table stakes. It's also not good enough.

If you wrote a note titled "JWT refresh token rotation strategy" and later search for "how did I handle token expiry", a keyword search returns nothing. The words don't overlap. But the meaning does — and that's exactly what semantic search solves.

NoteCore embeds every note you save using Voyage AI's voyage-code-2 model, which is optimized specifically for code and technical content. When you write a query, it gets embedded using the same model and we run a cosine similarity search over your entire local vector store.

The result: you can ask questions the way you actually think, not the way you happened to word something six months ago.

// Simplified version of what happens on every search const queryEmbedding = await voyageClient.embed({  input: userQuery,  model: 'voyage-code-2', });

// Simplified version of what happens on every search const queryEmbedding = await voyageClient.embed({  input: userQuery,  model: 'voyage-code-2', });

const results = await vectorStore.similaritySearch( queryEmbedding.embeddings[0], { topK: 10, threshold: 0.75 } );`

Enter fullscreen mode

Exit fullscreen mode

Embeddings are generated locally on save and stored in SQLite alongside the note content. No cloud round-trip on every search — it's fast.

Why Voyage AI over OpenAI embeddings?

Two reasons. First, voyage-code-2 is purpose-built for code — it understands that const handleAuth = async () => and "authentication handler function" are talking about the same thing. Generic text embedding models don't handle this nearly as well.

Second, Voyage AI's pricing model made more sense for a local-first product where we're not batching thousands of requests through a SaaS backend — we're embedding notes one at a time as they're saved.

AI Chat Over Your Notes (Claude)

Search gets you relevant notes. Chat gets you answers.

There's a big difference. When you search, you still have to read through results and connect the dots yourself. When you chat, NoteCore does that for you — it retrieves the most semantically relevant chunks from your knowledge base, injects them into context, and lets Claude synthesize an actual answer.

It works like this:

• You ask: "What was my approach to handling optimistic updates in that React project?"

• NoteCore runs a semantic search across your notes, pulls the top-k most relevant chunks

• Those chunks get injected into a Claude prompt as context

• Claude answers based on your actual notes, not generic knowledge

The key design decision here was keeping Claude grounded. We explicitly instruct it not to answer from general knowledge if the answer isn't in your notes. If you haven't written anything about a topic, it tells you that — it doesn't hallucinate an answer and make you think you already figured something out when you didn't.

const systemPrompt = You are a personal knowledge assistant. Answer the user's question using ONLY the notes provided below as context.

If the answer is not present in the notes, say so clearly. Do not use general knowledge to fill in gaps.

Notes context: ${relevantChunks.map(c => c.content).join('\n\n---\n\n')} ;

Enter fullscreen mode

Exit fullscreen mode

This constraint is actually the most important part of the feature. A second brain that makes things up is worse than useless — it gives you false confidence.

Conversation context

NoteCore maintains conversation history within a session, so you can do multi-turn reasoning over your notes:

"What was my auth approach in that project?" "Why did I choose that over sessions?" "Would that still work with the new architecture I'm planning?"

Each follow-up is aware of what came before. The full conversation history gets passed to Claude on each turn, so context accumulates naturally.

BYOK — Bring Your Own Key

This one was non-negotiable for me when designing NoteCore.

Most AI tools that embed an LLM work one of two ways: they either route everything through their own backend (meaning your notes hit their servers, they pay for inference and charge you a margin) or they lock you into a specific model with no flexibility.

NoteCore does neither. With BYOK, you connect your own API keys — Anthropic for Claude, Voyage AI for embeddings — and NoteCore calls the APIs directly from the local backend. We never see your requests, your notes, or your responses.

From the user's perspective it's simple: you paste your keys in settings, they're stored encrypted locally using electron-store with OS-level encryption, and that's it. From that point on, you're billed directly by Anthropic/Voyage at their standard rates. No markup, no middleman.

// Keys are stored encrypted, never in plaintext await secureStore.set('anthropic_api_key', encrypted(apiKey));

// Keys are stored encrypted, never in plaintext await secureStore.set('anthropic_api_key', encrypted(apiKey));

// On each AI request, retrieved and used directly const key = decrypt(await secureStore.get('anthropic_api_key')); const client = new Anthropic({ apiKey: key });`

Enter fullscreen mode

Exit fullscreen mode

Why does this matter? A few reasons:

Privacy. Your notes are your thoughts. Architecture decisions, half-formed ideas, things you're figuring out — none of that should sit on someone else's server.

Cost transparency. You see exactly what you're spending. No opaque "AI credits" that obscure actual API costs.

Model flexibility. When Anthropic ships a new model, you can switch immediately. You're not waiting for us to update our backend. You control which model version you're running.

Trust. Honestly, this one's simple. Developers don't trust SaaS products with their sensitive context by default. BYOK removes the trust requirement entirely.

Why NoteCore Is Different

There are other tools in this space. Obsidian, Notion AI, Mem, Reflect. Here's the honest comparison:

Obsidian is brilliant but its AI features are plugin-dependent, fragmented, and the semantic search story is weak without significant setup. It's also a general-purpose tool — not optimized for code and technical content.

Notion AI requires your notes to live in Notion's cloud. Full stop. If that's fine with you, great. It wasn't fine for me.

Mem and Reflect are cloud-first, subscription-based, and neither is particularly developer-focused. They're optimized for the knowledge worker, not the engineer who wants to query their own code snippets.

NoteCore's specific bets:

• Local-first by default. Your data lives on your machine. Cloud sync is opt-in.

• Developer-focused embeddings. voyage-code-2 understands code semantically in a way generic models don't.

• BYOK as a first-class feature, not an afterthought. You own your API relationships.

• Grounded AI. The chat feature answers from your notes, not from the internet or general LLM knowledge.

• One-time payment. No subscription. Buy it, own it, use it forever.

The Architecture in Brief

For those who want to understand how the pieces fit:

┌─────────────────────────────────────┐ │ Electron Shell │ │ ┌─────────────┐ ┌──────────────┐ │ │ │ React UI │ │ Local NestJS │ │ │ │ (Vite) │◄─► + SQLite │ │ │ └─────────────┘ └──────┬───────┘ │ └─────────────────────────┼───────────┘  │ BYOK keys  ┌──────▼────────┐  │ Voyage AI │ (embeddings)  │ Anthropic │ (chat)  └───────────────┘

┌─────────────────────────────────────┐ │ Electron Shell │ │ ┌─────────────┐ ┌──────────────┐ │ │ │ React UI │ │ Local NestJS │ │ │ │ (Vite) │◄─► + SQLite │ │ │ └─────────────┘ └──────┬───────┘ │ └─────────────────────────┼───────────┘  │ BYOK keys  ┌──────▼────────┐  │ Voyage AI │ (embeddings)  │ Anthropic │ (chat)  └───────────────┘

Enter fullscreen mode

Exit fullscreen mode

The local NestJS backend runs as a child process inside Electron. The React frontend communicates with it over a local HTTP port. SQLite holds both note content and vector embeddings. Everything is single-tenant, single-machine by design.

There's also an optional cloud backend (NestJS + Postgres on Railway) for sync and the web dashboard, but that's entirely opt-in. The app works fully offline with zero cloud dependency.

Current Status

NoteCore is approaching beta. The local backend is complete across all core phases — note management, embedding pipeline, semantic search, AI chat, BYOK. Active work right now is on the onboarding flow, feature flag gating via Gatedly, and packaging via GitHub Releases.

If you're a developer who's felt the pain of losing your own context between projects — this is built for you.

Waitlist is open at notecore.app.

Drop your email. Beta is coming soon and early access will be limited.

Building NoteCore in public. Follow along on X for updates.