ErezShahaf/Lore: Local AI Memory for Developers Who Need Privacy

ErezShahaf/Lore: Local AI Memory for Developers Who Need Privacy

Developers juggle fragments of context across dozens of contexts: a curl command that fixed a production bug, a decision summary from last week's architecture review, a reminder to follow up with a teammate. Most tools force a choice between convenience and privacy—cloud note apps scan your data, local files aren't searchable by meaning, and setting up a personal RAG pipeline requires stitching together half a dozen services. ErezShahaf/Lore solves this with a single desktop application that captures thoughts via global hotkey, classifies them with a local LLM, and retrieves them through semantic search—all without network calls or API keys.

What is ErezShahaf/Lore?

ErezShahaf/Lore is an open-source desktop application (219 GitHub stars, 22 forks, MIT License) built in TypeScript that provides AI-powered thought capture and recall running entirely on the user's machine. It sits in the system tray and activates through a global keyboard shortcut, presenting a hover chat interface for immediate input.

The project is maintained by Erez Shahaf and last committed to on 2026-04-20. It belongs to the emerging category of local-first personal knowledge management tools with embedded AI—distinct from cloud-dependent services like Notion AI or Obsidian's optional cloud sync. Lore's architecture is deliberately minimal: it uses Ollama for local LLM inference and LanceDB as a local vector database. This two-component backend (embedding model + language model) enables retrieval-augmented generation without external dependencies.

The relevance is immediate and growing. As developers face increasing restrictions on cloud AI usage—whether from corporate data policies, HIPAA requirements, or personal privacy preferences—tools that deliver comparable functionality without data exfiltration become critical infrastructure. Lore's positioning as "fully private, zero cloud" directly addresses this shift.

The longer-term roadmap indicates ambitions beyond storage: personal agents that reason with user-specific context. This remains early-stage, but the foundation—a local, queryable memory system—is already functional.

Key Features

Global hotkey capture. Press Ctrl+Shift+Space (Windows/Linux) or Cmd+Shift+Space (macOS) to summon a popup chat bar. Type naturally; no app switching, no context loss. This addresses the core friction of knowledge capture: the gap between having a thought and having a place to put it.

AI-powered classification. Input is automatically categorized as a thought, question, command, or instruction. This determines downstream processing—whether to store, execute, or retrieve—without requiring explicit syntax from the user.

Semantic retrieval via RAG. Lore implements a retrieval-augmented generation pipeline: user queries are embedded, matched against stored notes in LanceDB, and relevant context is injected into the LLM prompt before response generation. This enables queries like "what was the stripe webhook event that caused our bug?" even when the original note used different phrasing.

Todo management with natural language. Add, list, complete, and organize todos through conversational input. Priority and category metadata are extracted automatically. Completion and modification work similarly: "My task about jumping 12 times is complete" or "I purchased the milk you can remove it from the todos."

Customizable instructions. Users can set persistent behavioral rules: formatting preferences ("show todo items in bullets with emojis"), citation requirements ("list the original database rows that helped you answer"), or conversational norms ("start each conversation by calling me [name]").

Full local operation. All data resides on-device. No account creation, no API keys, no telemetry. The trade-off is self-managed infrastructure: users must download and run Ollama models themselves.

Use Cases

Production incident documentation. During or after an outage, engineers often capture debugging commands, error signatures, and resolution steps in ephemeral Slack threads or personal notes. Lore provides immediate capture via hotkey and later retrieval through conceptual queries rather than exact keyword matches. The README's example—"The stripe webhook event that caused our refund bug {schawarma: true}"—demonstrates inline metadata tagging for structured retrieval.

Decision logging with temporal context. Architecture decisions, meeting outcomes, and rationale fade quickly. Storing "Daily note - sarah needs help with feature implementation" creates a searchable timeline. Later queries like "What notes did I write at daily today" leverage both semantic and temporal understanding.

Personal todo system without SaaS lock-in. For developers avoiding subscription services or working in air-gapped environments, Lore's natural language todo management replaces tools like Todoist or Things. The classification system distinguishes storage intent from action intent automatically.

Offline knowledge base for sensitive domains. Security researchers, healthcare developers, or anyone handling confidential data can maintain a queryable memory without compliance review of third-party AI providers. The MIT license permits internal modification if needed.

Foundation for custom agents (future). The roadmap indicates MCP support and semantic reasoning as forthcoming capabilities. Early adoption now builds the data foundation for these later features.

Installation & Setup

Lore distributes prebuilt installers for all major platforms. The setup process involves three phases: installation, model provisioning, and shortcut verification.

Download and Install

Download the appropriate artifact from the Releases page:

During installation, you'll be prompted to select directories for LLM model storage and for Ollama itself. Choose locations with sufficient disk space—models range from several gigabytes to tens of gigabytes depending on selection.

Configure Models

After installation, access settings via the system tray icon → Settings → Models. Download both:

1. An embedding model (for vectorizing text into LanceDB)
2. An LLM (for classification, retrieval, and generation)

The settings interface provides system-specific recommendations. Generally: smaller models (7B parameters) for limited RAM, larger models for better reasoning quality. Both run through Ollama, which Lore manages internally.

Verify Global Shortcut

The default shortcut is:

• Windows/Linux: Ctrl+Shift+Space
• macOS: Cmd+Shift+Space

Test by pressing the combination; the Lore popup should appear. If conflicts exist with window managers or other applications, modify in Settings.

Real Code Examples

The README provides direct examples of Lore's natural language interface. These are not API calls but documented interaction patterns showing how the system interprets user input.

Storing a Tagged Note

The stripe webhook event that caused our refund bug {schawarma: true}

This demonstrates inline metadata tagging. The {schawarma: true} JSON-like fragment appears to be a user-defined tag or structured field. Lore stores this with semantic embedding, making it retrievable by queries about "stripe webhook," "refund bug," or "schawarma" despite varying phrasing.

Natural Language Todo Creation

add to my todo "talk to Daniel about the integration tomorrow"

The classification system identifies this as a command (todo creation), extracts the task description and temporal reference, and stores it with appropriate metadata. No explicit syntax like /todo add is required.

Contextual Query with Implicit Filtering

I'm about to go home, is there anything I need to do on the way home?

This shows Lore's ability to interpret situational context ("about to go home," "on the way home") and match against stored todos with location or time relevance. The RAG pipeline retrieves matching items; the LLM synthesizes a direct answer rather than returning raw database rows.

Persistent Instruction Setting

From now on, when I ask for my to do list, show the items in bullets, and add an emoji for each one.

This establishes a user preference that persists across sessions. The instruction modifies prompt construction for subsequent todo queries, demonstrating a lightweight form of personalization without code changes.

Advanced Usage & Best Practices

Model selection strategy. The README recommends following Lore's system-based suggestions, but experienced users should consider task-specific trade-offs. Embedding models (like nomic-embed-text or all-MiniLM) prioritize retrieval speed and memory efficiency. Generation models balance reasoning quality against RAM usage and inference latency. For primarily storage-and-retrieval workflows, a smaller LLM may suffice; for complex synthesis, larger models provide measurable improvement.

Consistent tagging conventions. The {key: value} pattern in notes suggests Lore preserves structured markers. Establishing personal conventions—{project: backend}, {priority: high}, {type: decision}—creates implicit facets for more precise retrieval, even without explicit filtering syntax.

Shortcut ergonomics. Ctrl+Shift+Space may conflict with IDE shortcuts (IntelliJ's "Quick Definition") or system functions. Test in your primary working environment before building muscle memory. The settings allow remapping, but consistency across machines reduces friction.

Backup strategy. Since all data is local, standard filesystem backup tools apply. The LanceDB database directory and any Ollama model weights should be included in regular backups. Lore does not currently offer multi-device sync (roadmap item), so manual synchronization or future self-hosted solutions are required for cross-machine use.

Comparison with Alternatives

Lore's distinct position is local LLM inference with vector search in a single, purpose-built application. Obsidian offers greater extensibility but requires manual configuration of AI plugins. mem.ai provides superior collaboration at the cost of data control. For developers prioritizing privacy and willing to manage local infrastructure, Lore eliminates integration complexity.

FAQ

What hardware is required? Any machine capable of running Ollama. Minimum viable: CPU inference with 7B models (~8GB RAM). Comfortable: GPU with 16GB+ VRAM for larger models and responsive interaction.

Does Lore work without internet? Yes, after initial model download. All inference and storage are local.

Can I use my own Ollama installation? The README indicates Lore prompts for Ollama directory selection during setup, suggesting integration with existing installations is supported.

What license governs use? MIT License. Commercial use, modification, and redistribution permitted.

Is there a mobile version? No. The roadmap lists multi-device sync as future work, implying current focus remains desktop.

How do I contribute or report issues? The project maintains a Discord server for community discussion. Source is available at the GitHub repository.

What happens to my data if I uninstall? Data resides in user-selected directories; uninstallation does not automatically remove model weights or the LanceDB database. Manual cleanup required.

Conclusion

ErezShahaf/Lore delivers a focused solution for developers who need AI-assisted memory without compromising data sovereignty. Its architecture—Ollama for inference, LanceDB for vector storage, TypeScript/Electron for interface—reflects pragmatic choices that prioritize privacy over convenience features like cloud sync. The 219-star project is early but functional: thought capture, semantic retrieval, natural language todos, and persistent instructions all work today.

This tool best serves developers with sufficient local hardware, strict privacy requirements, and tolerance for self-managed infrastructure. It does not replace collaborative knowledge bases or mobile-first note apps. It excels as a personal, offline second memory—exactly what the README promises.

For installation, source code, and releases, visit https://github.com/ErezShahaf/Lore. Join the Discord community for support and roadmap discussion.

For related coverage of local-first developer tools, see our analysis of [INTERNAL_LINK: self-hosted AI infrastructure].