LibrAIum
ServiceSoloA desktop app (Tauri v2 + Rust core + Svelte 5) that accumulates best-practice GitHub repositories as plain files in a local git repository — one repository per YAML-frontmatter Markdown file. The core idea is to expose that same collection to Claude Code through an MCP server, so AI coding agents can search the shelf and suggest dependency libraries; it currently organizes 43 repositories into 18 categories.
- Rust
- Tauri v2
- Svelte 5
- +9
Problem
You bookmark a repository that looks handy on X or another social network, but once you actually start building, you draw a blank — "wait, what was that library again?" That is where LibrAIum began. For a solo developer, memories of promising tools gathered in fragments are useless unless they can be retrieved at the exact moment they are needed. A plain pile of bookmarks lets you neither search and compare them later in your own context, nor trace back to the rationale for why one should be chosen.
Approach
The solution: store the collection as plain files in a local git repository (one repository per Markdown file), with no database at all. The UI is a Tauri v2 + Rust core + Svelte 5 (runes) desktop app that pushes the heavy work — parsing, search, git, HTTP — onto the typed Rust side (24 Tauri IPC commands), and uses the system WebView to ship a small native binary that bundles no Chromium. The biggest design decision is that two independent consumers — the desktop app and an MCP server (Node/stdio) for Claude Code — share the very same on-disk collection; it is precisely because access goes through MCP that an agent can call the collection directly as a "tool" and suggest dependencies. Despite the name, there is no embedded LLM, no model key, and no embedding vectors: the "AI" is simply the search surface (MCP) that Claude Code hits. Details like keeping the GitHub token in the OS keychain (keyring), and wrapping the git CLI rather than libgit2 so existing credentials are reused as-is, are likewise driven by the constraint of "keep secrets out of files, require no setup."
Engineering Outcomes
Highlights
Deliberately implemented the frontmatter format (a 14-field EntryMeta schema) twice — in the Rust core (store.rs / frontmatter.rs) and in Node (mcp-server/lib/store.js) — so the desktop app and the MCP server never depend on each other. To keep the two from drifting, scripts/conformance.mjs feeds the same fixtures to both parsers and requires matching parse results, rejection of malformed input on both sides, byte-for-byte identical re-serialization, and agreement across a corpus of functions (slugify and the like).
Every entry carries a "## Reception" section that aggregates third-party assessments with sources and dates (complaints, adoption cases, constraints, migration signals), making that prose a search target in its own right. The 8th MCP tool, find_by_reception, scans this prose by signal type and returns the matching evidence bullets, answering questions like "which repositories on the shelf have documented pitfalls?" without changing the storage format at all.
Entry bodies embed GitHub descriptions and git-synced external content, and a page's scripts could reach Tauri's IPC. So src/lib/markdown.js swaps out marked's renderer to escape raw HTML into text, allows only http(s)/mailto/relative links, and strips control characters and BOMs code point by code point to kill bypasses that splice in scheme separators. It is a layered design — escaping as the first line of defense, CSP as the second — verified in tests/markdown.test.mjs.
Consolidated the verification entry point into a single scripts/verify-all.sh that runs 7 stages: data validation → cargo test (33 Rust unit tests) → frontend build + tests → MCP tests → Rust↔Node conformance → catalog diff → app binary build. The final stage actually assembles the binary because of a real incident where a regression that broke a bare cargo run slipped past every earlier stage. CI runs on 3 OSes — ubuntu, macOS, and Windows — and the Windows regression check was added after a repository lacking a .ico (built on macOS) broke the Windows build.
The repository dogfoods its own premise. It bundles 7 Claude subagents, 10 slash commands, an entry-writing skill, and a PostToolUse hook that runs data validation and rustfmt after edits; integrations/claude/skills/libraium-first/ is a user-scoped skill that makes agents consult this collection before making dependency decisions in other repositories.
Turned prose-only hints like "use langgraph" or "pairs well with llama_index" into structured, traversable edges. The superseded_by / pairs_with frontmatter is stored in only one direction, with the reverse (supersedes, symmetric pairs) derived at read time so the two directions cannot drift, and made traversable from the new get_related MCP tool — again kept consistent across both the Rust and Node implementations.
Turning Points
Dropped the whole foundation in one large commit
Rather than a staged scaffold, the Tauri v2 desktop app, Rust core, Svelte GUI, MCP server, and seed data all landed in one commit, following the design document. This locked in the dual-implementation (Rust/Node) data design that every subsequent piece of work would have to keep in sync.
Adopted agent-audited PDCA as the development method
Findings surfaced by an adversarial audit of 4 agents were stacked as an explicit backlog and cleared iteration by iteration. This loop of fix / chore / test back-and-forth produced the bulk of the commits and set the "audit → fix → converge" rhythm reused across every later phase.
Pivot to "Reception" — from first-party notes to sourced third-party assessments
Rebuilt the collection's differentiator from the curator's own notes into a "## Reception" layer carrying sources and dates, rolled out across all 43 entries. Threaded through storage, the MCP read path, and a new scanner, this layer becomes the "moat" later queried by find_by_reception.
First contact with Windows exposed cross-platform gaps
When the development machine moved from macOS to Windows, macOS-assuming icon generation broke the native Windows build. Addressed with a hand-made icon.ico, a dedicated Windows CI regression check to prevent recurrence, unified slashes in catalog links, and a Windows-only test skip.
Into a knowledge graph — from prose signals to structured edges
Promoted migration, succession, and pairing hints buried in free text into first-class frontmatter edges — superseded_by / pairs_with. With a get_related MCP tool and authored-first ranking, it replaced "every entry is an island" with a traversable graph.
Method shift — from pushing straight to main to reviewed PRs, closed by a convergence audit
The back half of the roadmap shipped as individual PRs run through a read-only review agent. It closed with a three-lens convergence audit by defect-hunter, drift-auditor, and completeness-critic, ending with zero critical findings — the point where solo velocity gave way to a process with self-inspection built in.