Local Semantic Search Tool Built in Rust for Files

What It Is

Recall Lite is an open-source semantic search engine that runs entirely on a local machine, designed to find files based on meaning rather than exact keyword matches. Built with Rust and Tauri, the tool generates embeddings for documents and performs vector similarity searches without sending any data to external services or requiring API keys.

Unlike traditional file search utilities that match filenames or scan for specific text strings, semantic search understands conceptual relationships. A query like “machine learning paper from last month” can surface relevant PDFs even if those exact words don’t appear in the filename. The system processes natural language queries and compares them against vector representations of file contents, returning results based on semantic similarity rather than literal text matching.

The architecture combines Rust’s performance characteristics with Tauri’s cross-platform UI framework. File indexing happens locally, creating embeddings that capture the semantic meaning of documents. Search operations use cosine similarity calculations to rank results, running these computations directly on the user’s hardware rather than offloading to cloud infrastructure.

Why It Matters

Desktop search has remained surprisingly primitive despite advances in natural language processing. Built-in tools from operating system vendors still rely heavily on filename matching and basic full-text indexing, which fails when users remember concepts but not exact phrasing. This gap becomes more pronounced as personal document collections grow larger and span longer time periods.

Privacy-conscious users gain a significant advantage from local-only processing. No file contents, queries, or metadata leave the machine, eliminating concerns about data exposure to third-party services. This matters particularly for professionals handling sensitive documents, researchers working with proprietary data, or anyone who simply prefers not to share their information retrieval patterns with cloud providers.

The Rust implementation addresses performance concerns that often plague semantic search tools. Embedding generation and vector operations can be computationally expensive, but Rust’s memory safety guarantees and zero-cost abstractions help maintain responsiveness even when indexing substantial file collections. Developers working on similar local-first applications can reference this approach as a practical example of building AI-powered tools without cloud dependencies.

Getting Started

The project repository is available at https://github.com/illegal-instruction-co/recall-lite. Installation requires cloning the repository and building from source, which assumes Rust and Tauri development dependencies are already configured.

Basic setup follows standard Rust workflows:

After building, users configure which directories to index through the application interface. The initial indexing pass processes files and generates embeddings, which may take considerable time depending on collection size. Subsequent searches query against these pre-computed embeddings, making retrieval relatively fast.

Search queries use natural language rather than boolean operators or special syntax. Instead of constructing complex search strings, users describe what they’re looking for conversationally. The system handles the translation from query text to vector representation and performs similarity matching against indexed documents.

Context

Several alternatives exist in the semantic search space, though most rely on cloud APIs. Tools like Algolia, Pinecone, and Weaviate offer sophisticated vector search capabilities but require external infrastructure. Elasticsearch supports vector search through plugins, though setup complexity increases significantly compared to traditional full-text indexing.

For local-only solutions, options remain limited. Some developers have built similar tools using Python with libraries like FAISS or Annoy, but these often sacrifice performance or require more complex dependency management. The Rust ecosystem provides fewer high-level semantic search libraries compared to Python, making Recall Lite’s approach particularly noteworthy for demonstrating what’s achievable with current tooling.

The brute force cosine similarity approach has scaling limitations. As document collections grow into tens of thousands of files, search latency will increase proportionally. Production systems typically use approximate nearest neighbor algorithms like HNSW or IVF to maintain sub-second query times at scale. For personal use cases with thousands rather than millions of documents, the simpler implementation may prove sufficient while remaining easier to understand and modify.

Embedding model selection significantly impacts result quality. The tool’s effectiveness depends on which model generates the vector representations, and different models excel at different content types. Technical documentation might benefit from models trained on code and academic text, while general notes might work better with models trained on conversational data.