Turbovault

TurboVault

[](https://crates.io/crates/turbovault) [](https://docs.rs/turbovault) [](https://github.com/epistates/turbovault/blob/main/LICENSE) [](https://www.rust-lang.org/) [](https://deepwiki.com/Epistates/turbovault)

The ultimate Rust SDK and high-performance MCP server for Obsidian-flavored Markdown (.ofm) and standard .md vaults.

TurboVault is a dual-purpose toolkit designed for both developers and users. It provides a robust, modular Rust SDK for building applications that consume markdown directories, and a full-featured MCP server that works out of the box with Claude and other AI agents.

---

Two Ways to Use TurboVault

1. As a Rust SDK (For Developers)

Build your own applications, search engines, or custom MCP servers using our modular crates. TurboVault handles the heavy lifting of parsing .md and .ofm files, building knowledge graphs, and managing multi-vault environments.

• Modular Architecture: Use only what you need (Parser, Graph, Search, etc.).
• High Performance: Sub-100ms operations for most tasks.
• Extensible: Easily build your own specialized MCP servers on top of our core logic.
• SOTA Standards: Fully supports Obsidian-flavored Markdown (wikilinks, embeds, callouts).

2. As a Ready-to-Use MCP Server (For Users)

Transform your Obsidian vault into an intelligent knowledge system immediately. Connect TurboVault to Claude Desktop or any MCP-compatible client to gain 47 specialized tools for your notes.

• Zero Coding Required: Install the binary and point it at your vault.
• 47 Specialized Tools: Searching, link analysis, SQL frontmatter queries, health checks, and more.
• Multi-Vault Support: Switch between personal and work notes seamlessly at runtime.

---

Core Crates (The SDK)

TurboVault is a modular system composed of specialized crates. You can depend on individual components to build your own tools:

| Crate | Purpose | Docs | |-------|---------|------| | [turbovault-core](crates/turbovault-core) | Core models, MultiVault management & types | [](https://docs.rs/turbovault-core) | | [turbovault-parser](crates/turbovault-parser) | High-speed .md & .ofm parser | [](https://docs.rs/turbovault-parser) | | [turbovault-graph](crates/turbovault-graph) | Link graph analysis & relationship discovery | [](https://docs.rs/turbovault-graph) | | [turbovault-vault](crates/turbovault-vault) | Vault management, file I/O & atomic writes | [](https://docs.rs/turbovault-vault) | | [turbovault-tools](crates/turbovault-tools) | 47 MCP tool implementations | [](https://docs.rs/turbovault-tools) | | [turbovault-sql](crates/turbovault-sql) | SQL frontmatter queries (GlueSQL) | [](https://docs.rs/turbovault-sql) | | [turbovault-batch](crates/turbovault-batch) | Atomic batch operations | [](https://docs.rs/turbovault-batch) | | [turbovault-export](crates/turbovault-export) | Export & reporting (JSON/CSV/MD) | [](https://docs.rs/turbovault-export) | | [turbovault](crates/turbovault) | Main MCP server binary / SDK orchestrator | [](https://docs.rs/turbovault) |

Why TurboVault?

Unlike basic note readers, TurboVault understands your vault's knowledge structure:

• Full-text search across all notes with BM25 ranking
• Link graph analysis to discover relationships, hubs, orphans, and cycles
• Vault intelligence with health scoring and automated recommendations
• Atomic batch operations for safe, transactional multi-file edits
• Multi-vault support with instant context switching
• Runtime vault addition — no vault required at startup, add them as needed

Powered by TurboMCP

TurboVault is built on TurboMCP, a Rust framework for building production-grade MCP servers. TurboMCP provides:

• Type-safe tool definitions — Macro-driven MCP tool implementation
• Standardized request/response handling — Consistent envelope format
• Transport abstraction — HTTP, WebSocket, TCP, Unix sockets (configurable features)
• Middleware support — Logging, metrics, error handling
• Zero-copy streaming — Efficient large payload handling

This means TurboVault gets battle-tested reliability and extensibility out of the box. Want to add custom tools? TurboMCP's ergonomic macros make it straightforward.

Quick Start

Installation

From crates.io

# Minimal install (7.0 MB, STDIO only - perfect for Claude Desktop)
cargo install turbovault

# With HTTP server (~8.2 MB)
cargo install turbovault --features http

# With all cross-platform transports (~8.8 MB)
# Includes: STDIO, HTTP, WebSocket, TCP (Unix sockets only on Unix/macOS/Linux)
cargo install turbovault --features full

# With SQL frontmatter queries (adds GlueSQL-powered query_frontmatter_sql tool)
cargo install turbovault --features sql

# Binary installed to: ~/.cargo/bin/turbovault

From source:

git clone https://github.com/epistates/turbovault.git
cd turbovault
make release
# Binary: ./target/release/turbovault

Option 1: Static Vault (Recommended for Single Vault)

turbovault --vault /path/to/your/vault --profile production

Then add to ~/.config/claude/claude_desktop_config.json:

{
  "mcpServers": {
    "turbovault": {
      "command": "/path/to/turbovault",
      "args": ["--vault", "/path/to/your/vault", "--profile", "production"]
    }
  }
}

Option 2: Runtime Vault Addition (Recommended for Multiple Vaults)

Start the server without a vault:

turbovault --profile production

Then add vaults dynamically:

{
  "mcpServers": {
    "turbovault": {
      "command": "/path/to/turbovault",
      "args": ["--profile", "production"]
    }
  }
}

Once connected to Claude:

You: "Add my vault at ~/Documents/Notes"
Claude: [Calls add_vault("personal", "~/Documents/Notes")]

You: "Search for machine learning notes"
Claude: [Uses search() across the indexed vault]

You: "What are my most important notes?"
Claude: [Uses get_hub_notes() to find key concepts]

What Can Claude Do?

Search & Discovery

You: "Find all notes about async Rust and show how they connect"
Claude: search() -> recommend_related() -> get_related_notes() -> explain relationships

Vault Intelligence

You: "What's the health of my vault? Any issues I should fix?"
Claude: quick_health_check() -> full_health_analysis() -> get_broken_links() -> generate fixes

Knowledge Graph Navigation

You: "What are my most important notes? Which ones are isolated?"
Claude: get_hub_notes() -> get_isolated_clusters() -> suggest connections

Structured Note Creation

You: "Create a project note for the TurboVault launch with status tracking"
Claude: list_templates() -> create_from_template() -> write auto-formatted note

Batch Content Operations

You: "Move my 'MLOps' note to 'AI/Operations' and update all links"
Claude: move_note() + batch operations -> atomic multi-file update

Link Suggestions

You: "Based on my vault, what notes should I link this to?"
Claude: suggest_links() -> get_link_strength() -> recommend cross-references

47 MCP Tools Organized by Category

File Operations (5)

• read_note — Get note content with hash for conflict detection
• write_note — Create/overwrite notes (auto-creates directories)
• edit_note — Surgical edits via SEARCH/REPLACE blocks
• delete_note — Safe deletion with link tracking
• move_note — Rename/relocate with automatic wikilink updates

Link Analysis (6)

• get_backlinks — All notes that link TO this note
• get_forward_links — All notes this note links TO
• get_related_notes — Multi-hop graph traversal (find non-obvious connections)
• get_hub_notes — Top 10 most connected notes (key concepts)
• get_dead_end_notes — Notes with incoming but no outgoing links
• get_isolated_clusters — Disconnected subgraphs in your vault

Vault Health & Analysis (5)

• quick_health_check — Fast 0-100 health score ( anyhow::Result {

// 1. Initialize the MultiVault manager let manager = MultiVaultManager::new();

// 2. Add and initialize a vault (scans files, builds graph) manager.add_vault("notes", "/home/user/notes").await?;

// 3. Perform high-level operations let vault = manager.get_vault("notes")?; let results = vault.search("machine learning")?;

// 4. Use these components to build your own custom MCP server // or integrate into existing Rust applications. Ok(()) }

Each crate is published to crates.io, so you can depend on individual components or the full stack.

## Architecture

Built as a modular Rust workspace:

turbovault-core — Core types, MultiVaultManager, configuration turbovault-parser — OFM (Obsidian Flavored Markdown) parsing turbovault-graph — Link graph analysis with petgraph turbovault-vault — Vault operations, file I/O, atomic writes turbovault-batch — Transactional batch operations turbovault-export — JSON/CSV/Markdown export turbovault-sql — SQL frontmatter queries (GlueSQL, feature-gated) turbovault-tools — 47 MCP tool implementations turbovault (binary) — CLI and MCP server entry point

All crates are published to [crates.io](https://crates.io/crates/turbovault-core) for public use.

## Obsidian Flavored Markdown (OFM) Support

TurboVault fully understands Obsidian's syntax:

- **Wikilinks**: `[[note]]`, `[[note|alias]]`, `[[note#section]]`, `[[note#^block]]`
- **Embeds**: `![[image.png]]`, `![[note]]`, `![[note#section]]`
- **Tags**: `#tag`, `#parent/child/tag`
- **Tasks**: `- [ ] Task`, `- [x] Done`
- **Callouts**: `> [!type] Title`
- **Frontmatter**: YAML metadata with automatic parsing
- **Headings**: Hierarchical structure extraction

## Security

- **Path traversal protection** — No access outside vault boundaries
- **Type-safe deserialization** — Rust's type system prevents injection
- **Atomic writes** — Temp file → atomic rename (never corrupts on failure)
- **Hash-based conflict detection** — `edit_note` detects concurrent modifications
- **File size limits** — Default 5MB per file (configurable)
- **No shell execution** — Zero command injection risk
- **Security auditing** — Detailed logs in production mode

## System Requirements

- **Rust**: 1.90.0 or later
- **OS**: Linux, macOS, Windows
- **Memory**: 100MB base + ~80MB per 10k notes
- **Disk**: Negligible (index is in-memory)

## Building from Source

```bash
git clone https://github.com/epistates/turbovault.git
cd turbovault

# Development build
cargo build

# Production build (optimized)
cargo build --release

# Run tests
cargo test --all

Or use the Makefile:

make build       # Debug build
make release     # Production build
make test        # Run tests
make clean       # Clean build artifacts

Documentation

[Docs](./docs/README.md)

Examples

Example 1: Search-Driven Organization

You: "What topics do I have the most notes on?"
Claude:
  1. get_hub_notes() -> [AI, Project Management, Rust, Python]
  2. For each hub:
     - get_related_notes() -> related topics
     - get_backlinks() -> importance/connectivity
  3. Report: "Your core topics are AI (23 notes) and Rust (18 notes)"

Example 2: Vault Health Improvement

You: "My vault feels disorganized. Help me improve it."
Claude:
  1. quick_health_check() -> Health: 42/100
  2. full_health_analysis() -> Issues: 12 broken links, 8 orphaned notes
  3. get_broken_links() -> List of specific broken links
  4. suggest_links() -> AI-powered link recommendations
  5. batch_execute() -> Atomic fixes
  6. explain_vault() -> New health: 78/100

Example 3: Template-Based Content Creation

You: "Create project notes for Q4 initiatives"
Claude:
  1. list_templates() -> "project", "task", "meeting"
  2. create_from_template("project", {
       "title": "Q4 Planning",
       "status": "In Progress",
       "deadline": "2024-12-31"
     })
  3. Creates structured note with auto-formatting
  4. Returns path for follow-up edits

Benchmarks

M1 MacBook Pro, 10k notes, production build:

• File read: <10ms
• File write: <20ms
• Simple search: <50ms
• Graph analysis: <200ms
• Vault initialization: ~500ms
• Memory usage: ~80MB

Roadmap

• [ ] Real-time vault watching (VaultWatcher framework ready)
• [ ] Cross-vault link resolution
• [ ] Encrypted vault support
• [ ] Collaborative locking
• [ ] WebSocket transport (beyond MCP stdio)

Contributing

Contributions welcome! Please ensure:

• All tests pass: cargo test --all
• Code formats: cargo fmt --all
• No clippy warnings: cargo clippy --all -- -D warnings

License

MIT License - See [LICENSE](LICENSE) for details

Links

• Repository: https://github.com/epistates/turbovault
• Issues: https://github.com/epistates/turbovault/issues
• MCP Protocol: https://modelcontextprotocol.io
• Obsidian: https://obsidian.md
• Related: TurboMCP

---

Get started now: ./target/release/turbovault --profile production

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: Epistates
• Source: Epistates/turbovault
• License: MIT

Install and usage instructions live in the source repository linked above.