reor

Reor implements semantic search by embedding note content using Transformers.js (client-side ONNX models) and storing vectors in LanceDB, a local vector database with native bindings. The system supports both pure vector similarity search and hybrid mode combining semantic matching with keyword indexing, enabling full-text discovery without cloud API calls. Search operates entirely on-device with no data transmission, using LanceDB's columnar storage for fast approximate nearest neighbor queries across note collections.

Reor automatically discovers and surfaces related notes by computing vector similarity between note embeddings and clustering semantically similar content. The system runs in the background, generating embeddings for all notes and maintaining a similarity graph that populates a sidebar panel showing related notes while editing. This creates a knowledge graph without requiring manual wiki-style link syntax, using the same embedding infrastructure as semantic search to identify conceptual relationships.

Reor maintains conversation history in the chat interface, storing user messages and LLM responses with timestamps. The system preserves conversation context by including previous messages when generating new responses, enabling multi-turn dialogue. Conversation history is stored in-memory during the session; users can optionally save conversations to disk for later reference. The system manages context window constraints by truncating older messages if the full history exceeds the LLM's context limit.

Reor is built as an Electron application that runs on macOS (x64/ARM), Windows (x64), and Linux (x64), providing a native desktop experience across platforms. The build system packages the application for each platform with platform-specific optimizations (e.g., ARM support for Apple Silicon). Auto-update functionality checks for new releases and prompts users to upgrade, with differential updates to minimize download size.

While Reor is designed for local-first operation, it supports optional integration with cloud LLM providers (OpenAI, Anthropic) for users who prefer higher-quality models or need specific capabilities. Users can configure API keys in settings and switch between local and cloud models at runtime. The system maintains a unified chat interface regardless of LLM provider, with fallback logic to use local models if cloud API calls fail.

Reor implements a Retrieval-Augmented Generation (RAG) chat system where user questions trigger semantic search across notes to retrieve relevant chunks, which are then passed as context to a local LLM (via Ollama or Transformers.js) for answer generation. The system manages a conversation history, formats retrieved note chunks as context, and streams LLM responses back to the UI. All processing occurs locally; no conversation data or note content is sent to external APIs unless explicitly configured to use cloud models (OpenAI/Anthropic).

Reor provides an Obsidian-like markdown editor built into the Electron renderer process, supporting syntax highlighting, real-time preview, and backlink/wikilink syntax (`[[note-name]]`). The editor integrates with the note filesystem layer to enable creating, editing, and linking notes within the PKM system. Backlinks are rendered as clickable references that navigate to linked notes, and the editor supports standard markdown formatting with code block syntax highlighting.

Reor integrates with Ollama, a local LLM runtime, to execute language models entirely on the user's machine. The system allows users to configure which Ollama model to use for chat and text generation, with support for switching models without restarting the app. The main process communicates with Ollama via HTTP API calls, streaming responses back to the renderer for real-time display. Users can also configure cloud-based LLM providers (OpenAI, Anthropic) as fallbacks or alternatives.

Reor uses Transformers.js to run embedding models (e.g., all-MiniLM-L6-v2) directly in the browser/Electron renderer process using ONNX format. This eliminates the need for embedding API calls or external services; embeddings are generated on-device as notes are created or updated. The system manages model loading, caching, and batching of embedding requests to optimize performance. Embeddings are then stored in LanceDB for semantic search and similarity computation.

Reor stores notes as markdown files in the local filesystem, organized in a directory structure that mirrors the user's knowledge base organization. The main process handles all filesystem operations (create, read, update, delete) via IPC communication with the renderer, ensuring thread-safe access and preventing concurrent modification conflicts. Notes are stored in a configurable vault directory, and the system maintains metadata (creation date, modification date) alongside note content.

Reor implements a settings system that persists user configuration (LLM model choice, embedding model, theme, vault path) to disk via the main process. Settings are loaded on app startup and can be modified via the UI settings panel. The system supports theme switching (light/dark mode) with real-time UI updates via React Context, and LLM/embedding model configuration with validation. Settings are stored in a JSON file in the app's data directory.

Reor uses Electron's IPC (Inter-Process Communication) system to enable secure communication between the main process (Node.js with filesystem/LLM access) and renderer process (React UI). The main process exposes handlers for filesystem operations, LLM inference, and embedding generation; the renderer invokes these via IPC calls and receives results asynchronously. This architecture provides security isolation (renderer cannot directly access filesystem) while enabling the UI to trigger backend operations.

Reor automatically chunks long notes into smaller segments (by paragraph, sentence, or token count) to fit within LLM context windows and improve retrieval precision. When answering questions via RAG, the system retrieves relevant chunks rather than entire notes, allowing more context to be included without exceeding token limits. Chunks are embedded separately and stored in the vector database with source attribution (note name, chunk index).