TurboVault

Grafo de conocimiento compatible con Markdown y Obsidian.

Documentación

TurboVault

El SDK definitivo en Rust y el servidor MCP de alto rendimiento para vaults de Markdown con sabor Obsidian (.ofm) y .md estándar.

TurboVault es un kit de herramientas de doble propósito diseñado tanto para desarrolladores como para usuarios. Proporciona un SDK de Rust robusto y modular para construir aplicaciones que consumen directorios de markdown, y un servidor MCP con todas las funciones que funciona de inmediato con Claude y otros agentes de IA.

Dos formas de usar TurboVault

1. Como SDK de Rust (para desarrolladores)

Construye tus propias aplicaciones, motores de búsqueda o servidores MCP personalizados usando nuestros crates modulares. TurboVault se encarga del trabajo pesado de analizar archivos .md y .ofm, construir grafos de conocimiento y gestionar entornos de múltiples vaults.

Arquitectura modular: Usa solo lo que necesites (Parser, Graph, Search, etc.).
Alto rendimiento: Operaciones en menos de 100 ms para la mayoría de las tareas.
Extensible: Construye fácilmente tus propios servidores MCP especializados sobre nuestra lógica central.
Estándares de vanguardia: Soporte completo para Markdown con sabor Obsidian (wikilinks, embeds, callouts).

2. Como servidor MCP listo para usar (para usuarios)

Transforma tu vault de Obsidian en un sistema de conocimiento inteligente de inmediato. Conecta TurboVault a Claude Desktop o a cualquier cliente compatible con MCP para obtener 74 herramientas especializadas para tus notas.

Sin necesidad de programar: Instala el binario y apúntalo a tu vault.
74 herramientas especializadas: Búsqueda, análisis de enlaces, escrituras atómicas respaldadas por Git, consultas SQL de frontmatter, comprobaciones de salud y más.
Soporte multi-vault: Cambia entre notas personales y de trabajo sin problemas en tiempo de ejecución.

Crates principales (el SDK)

TurboVault es un sistema modular compuesto por crates especializados. Puedes depender de componentes individuales para construir tus propias herramientas:

Crate	Propósito	Documentación
turbovault-core	Modelos centrales, gestión de MultiVault y tipos
turbovault-parser	Analizador de alta velocidad para .md y .ofm
turbovault-graph	Análisis de grafos de enlaces y descubrimiento de relaciones
turbovault-vault	Gestión de vaults, E/S de archivos y escrituras atómicas
turbovault-tools	74 implementaciones de herramientas MCP
turbovault-plugin-api	Fachada estable, contrato de proveedor y hooks acotados para plugins compilados
turbovault-sql	Consultas SQL de frontmatter (GlueSQL)
turbovault-batch	Lotes de operaciones validados con fallo rápido
turbovault-export	Exportación e informes (JSON/CSV/MD)
turbovault	Binario principal del servidor MCP / orquestador del SDK

¿Por qué TurboVault?

A diferencia de los lectores de notas básicos, TurboVault entiende la estructura de conocimiento de tu vault:

Búsqueda de texto completo en todas las notas con clasificación BM25
Análisis de grafos de enlaces para descubrir relaciones, hubs, huérfanos y ciclos
Inteligencia de vault con puntuación de salud y recomendaciones automatizadas
Lotes de operaciones validados para menos viajes de ida y vuelta y ejecución con fallo rápido
Soporte multi-vault con cambio de contexto instantáneo
Adición de vaults en tiempo de ejecución: no se requiere vault al inicio, agrégalos según sea necesario

Impulsado por TurboMCP

TurboVault está construido sobre TurboMCP, un framework de Rust para construir servidores MCP de nivel de producción. TurboMCP proporciona:

Definiciones de herramientas con seguridad de tipos: implementación de herramientas MCP impulsada por macros
Manejo estandarizado de solicitudes/respuestas: formato de sobre consistente
Abstracción de transporte: HTTP, WebSocket, TCP, sockets Unix (características configurables)
Soporte de middleware: registro, métricas, manejo de errores
Transmisión de copia cero: manejo eficiente de cargas útiles grandes

Esto significa que TurboVault obtiene confiabilidad y extensibilidad probadas en batalla de inmediato. ¿Quieres agregar herramientas personalizadas? Las macros ergonómicas de TurboMCP lo hacen sencillo.

Inicio rápido

Instalación

Binarios precompilados

Cada versión de GitHub tiene binarios para Linux, macOS y Windows compilados con todas las características: todos los transportes, consultas SQL de frontmatter y el plugin de búsqueda vectorial. La búsqueda vectorial permanece desactivada hasta que la habilites con --plugins vector_search (o TURBOVAULT_PLUGINS=vector_search) y la apuntes a un modelo local.

Desde 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

# Everything the prebuilt binaries have (add `unix` on Unix)
cargo install turbovault --features release

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

Desde el código fuente:

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

Opción 1: Vault estático (recomendado para un solo vault)

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

Luego agrega a ~/.config/claude/claude_desktop_config.json:

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

Opción 2: Adición de vault en tiempo de ejecución (recomendado para múltiples vaults)

Inicia el servidor sin un vault:

turbovault --profile production

Luego agrega vaults dinámicamente:

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

Una vez conectado a 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]

Escrituras atómicas respaldadas por Git

Para vaults ya gestionados por Git, habilita el backend transaccional en la configuración YAML de TurboVault:

vaults:
  - name: personal
    path: ~/Documents/Notes
    is_default: true
    write_backend: git
    git:
      include_ignored: false
      require_commit_message: false

Inicia con turbovault --config ~/.turbovault/config.yaml. Cada mutación es entonces un commit de Git. Los lotes de múltiples operaciones construyen un árbol aislado y avanzan la rama con comparación e intercambio, por lo que una ruta obsoleta aborta todo el lote y los procesos concurrentes de TurboVault no pueden intercalar commit/materialización. El backend también se niega a sobrescribir rutas sucias o no rastreadas y se niega a restablecer un índice que contenga cambios en el área de preparación.

¿Qué puede hacer Claude?

Búsqueda y descubrimiento

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

Inteligencia de vault

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

Navegación por grafos de conocimiento

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

Creación estructurada de notas

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

Operaciones de contenido por lotes

You: "Move my 'MLOps' note to 'AI/Operations' and identify links to update"
Claude: get_backlinks() -> move_note() -> edit_note() for each affected reference

Sugerencias de enlaces

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

74 herramientas MCP organizadas por categoría

Operaciones de archivos y lotes (8)

read_note — Obtiene el contenido de una nota con hash para detección de conflictos
write_note — Crea/sobrescribe notas (crea directorios automáticamente)
edit_note — Ediciones quirúrgicas mediante bloques SEARCH/REPLACE
delete_note — Eliminación segura con seguimiento de enlaces
move_note — Renombra/reubica una nota; los vaults respaldados por Git reescriben atómicamente los wikilinks entrantes
move_file — Mueve/renombra archivos que no son notas (p. ej., adjuntos, imágenes)
get_notes_info — Metadatos para múltiples notas en una sola llamada
batch_execute — Un solo commit de todo o nada con write_backend: git; directo permanece secuencial

Git Fanout (4)

begin_fanout — Abre un worktree aislado para escrituras paralelas de agentes
commit_fanout — Fusiona un fanout activo de vuelta a su vault base
abandon_fanout — Descarta un fanout sin cambiar el vault base
list_orphan_fanouts — Diagnostica worktrees dejados por sesiones interrumpidas

Metadatos y etiquetas (3)

update_frontmatter — Parchea campos de frontmatter (fusiona o reemplaza)
get_metadata_value — Extrae valores de frontmatter (soporte de notación de puntos)
manage_tags — Agrega, elimina o lista etiquetas de notas

Análisis de enlaces (6)

get_backlinks — Todas las notas que enlazan HACIA esta nota
get_forward_links — Todas las notas a las que esta nota enlaza
get_related_notes — Recorrido de grafo de múltiples saltos (encuentra conexiones no obvias)
get_hub_notes — Las 10 notas más conectadas (conceptos clave)
get_dead_end_notes — Notas con enlaces entrantes pero sin enlaces salientes
get_isolated_clusters — Subgrafos desconectados en tu vault

Métricas de grafo y sugerencias (3)

suggest_links — Sugerencias de enlaces impulsadas por IA para una nota
get_link_strength — Fuerza de conexión entre notas (0.0–1.0)
get_centrality_ranking — Métricas de centralidad de grafo (intermediación, cercanía, vector propio)

Búsqueda (8)

search — Búsqueda clasificada por BM25 en todas las notas (<500 ms en 100k notas)
advanced_search — Búsqueda con filtros de etiqueta, frontmatter, ruta y límite
search_by_frontmatter — Encuentra notas por par clave-valor de frontmatter
recommend_related — Recomendaciones impulsadas por ML basadas en similitud de contenido
find_notes_from_template — Encuentra todas las notas que usan una plantilla específica
query_metadata — Consultas de patrones de frontmatter
inspect_frontmatter — Inspección de esquema para consultas SQL (característica: sql)
query_frontmatter_sql — SQL arbitrario contra frontmatter mediante GlueSQL (característica: sql)

Semántica y similitud (5)

semantic_search — Búsqueda semántica TF-IDF con puntuaciones de similitud y términos compartidos
find_similar_notes — Notas con contenido similar a una nota dada
find_duplicates — Detección de casi duplicados (filtro SimHash + verificación TF-IDF)
compare_notes — Puntuación de similitud, vocabulario compartido, diff y recomendación de fusión
diff_notes — Diff unificado entre dos notas

Salud y calidad del vault (10)

quick_health_check — Puntuación de salud rápida de 0-100 (<100 ms)
full_health_analysis — Auditoría integral del vault con recomendaciones
get_broken_links — Todos los enlaces que apuntan a notas inexistentes
detect_cycles — Cadenas de referencias circulares (a veces intencionales)
explain_vault — Vista general holística que reemplaza 5+ llamadas separadas
evaluate_note_quality — Puntuación de calidad por nota con recomendaciones de mejora
vault_quality_report — Evaluación de calidad en todo el vault (notas N peores)
find_stale_notes — Notas no modificadas dentro de un umbral de días
analyze_note_grounding — Primitivas de fundamentación para una nota (afirmaciones, citas, bandera sin citar) para alimentar a un juez LLM externo
find_ungrounded_notes — Encuentra notas con riesgo de alucinación que hacen afirmaciones pero no citan fuentes

Formato de conocimiento abierto (4)

okf_validate — Valida el vault como un paquete OKF v0.1 (conformidad + vocabulario de concepto type); utilizable como puerta de CI/pre-publicación
generate_index — Genera/actualiza archivos index.md para divulgación progresiva (idempotente)
append_log_entry — Agrega una entrada fechada al historial de actualizaciones log.md de un directorio (§7)
visualize — Renderiza el grafo de conceptos como un archivo HTML compartible y autocontenido (grafo dirigido por fuerza + notas renderizadas + backlinks)

Plantillas y OFM (6)

list_templates — Descubre plantillas disponibles
get_template — Detalles de plantillas y campos obligatorios
create_from_template — Renderiza y escribe notas con plantillas
get_ofm_syntax_guide — Referencia enfocada de Markdown con sabor Obsidian
get_ofm_quick_ref — Hoja de referencia rápida de OFM
get_ofm_examples — Ve todas las características de Markdown con sabor Obsidian

Ciclo de vida del vault (8)

create_vault — Crea programáticamente un nuevo vault
add_vault — Registra e inicializa automáticamente un vault en tiempo de ejecución
remove_vault — Anula el registro de un vault (seguro, no elimina archivos)
list_vaults — Todos los vaults registrados con estado
get_vault_config — Inspecciona la configuración del vault
set_active_vault — Cambia el contexto entre múltiples vaults
get_active_vault — Vault activo actual
get_vault_context — Meta-herramienta: una sola llamada devuelve el estado del vault, herramientas disponibles, guía OFM

Auditoría e historial (5)

audit_log — Registro de cambios cronológico con IDs de operación para reversión
audit_stats — Vista general de auditoría: desglose de operaciones + uso de disco de instantáneas
diff_note_version — Diff de una nota contra una versión auditada pasada
rollback_preview — Vista previa de lo que cambiaría una reversión (solo lectura)
rollback_note — Deshace un cambio por ID de operación (atómico, auditado)

Exportación (4)

export_health_report — Exporta la salud del vault como JSON/CSV
export_broken_links — Exporta enlaces rotos con sugerencias de corrección
export_vault_stats — Exportación de estadísticas y métricas
export_analysis_report — Rastro de auditoría completo

Flujos de trabajo del mundo real

Inicializar sin un vault

# Server starts with NO vault required
response = client.call("get_vault_context")
# Returns: "No vault registered. Call add_vault() to get started."

response = client.call("add_vault", {
    "name": "personal",
    "path": "~/Documents/Obsidian"
})
# Auto-initializes: scans files, builds link graph, indexes for search

Flujo de trabajo multi-vault

# Add multiple vaults
client.call("add_vault", {"name": "work", "path": "/work/notes"})
client.call("add_vault", {"name": "personal", "path": "~/notes"})

# Switch context instantly
client.call("set_active_vault", {"name": "work"})
search_results = client.call("search", {"query": "Q4 goals"})

client.call("set_active_vault", {"name": "personal"})
recommendations = client.call("recommend_related", {"path": "AI/ML.md"})

Mantenimiento y reparación del vault

# Quick diagnostic
health = client.call("quick_health_check")
if health["data"]["score"] < 60:
    # Deep analysis if needed
    full_analysis = client.call("full_health_analysis")

# Find and fix issues
broken = client.call("get_broken_links")
# Process broken links...

# Atomic bulk repair
client.call("batch_execute", {
    "operations": [
        {"type": "DeleteNote", "path": "old/deprecated.md"},
        {"type": "MoveNote", "from": "old/notes.md", "to": "new/notes.md"},
        # ... more operations
    ]
})

# Verify improvement
client.call("explain_vault")  # Holistic view

Descubrimiento de contenido

# Find what matters
hubs = client.call("get_hub_notes")  # Top concepts
orphans = client.call("get_dead_end_notes")  # Incomplete topics

# Deep search
results = client.call("search", {"query": "machine learning"})

# Explore relationships
related = client.call("get_related_notes", {
    "path": "AI/ML.md",
    "max_hops": 3
})

# Get suggestions
suggestions = client.call("suggest_links", {"path": "AI/ML.md"})

Perfil de rendimiento

Operación	Tiempo	Notas
`read_note`	<10ms	Instantáneo con caché
`get_backlinks`, `get_forward_links`	<50ms	Búsqueda en grafo
`write_note`	<50ms	Incluye actualización del grafo
`search` (10k notas)	<100ms	Tantivy BM25
`quick_health_check`	<100ms	Puntuación heurística
`full_health_analysis`	1–5s	Exhaustivo, usar con moderación
`explain_vault`	1–5s	Agrega 5+ análisis
Inicialización del vault	100ms–5s	Depende del tamaño del vault

Idea clave: Operaciones rápidas (<100ms) para tareas comunes, operaciones más lentas (1–5s) para análisis exhaustivo. Claude usa respaldos inteligentes.

Perfiles de Configuración

--profile establece el nivel de registro (RUST_LOG lo anula) y la configuración desde la que parte cada vault. Un nombre desconocido detiene el inicio en lugar de recurrir a un valor predeterminado.

Perfil	Nivel de registro	Además
`development` (predeterminado)	debug
`production`	info
`readonly` (o `read-only`)	warn	Toda herramienta no anotada como de solo lectura se oculta y se rechaza, la misma puerta que `--require-read-only-tools`
`high-performance`	warn
`minimal`	error	No concilia con ediciones realizadas fuera de TurboVault
`multi-vault`, `collaboration`	info

Visibilidad de Herramientas

TurboVault puede reducir el contexto de tools/list aplicando las reglas de visibilidad de TurboMCP desde ~/.turbovault/config.yaml o --config:

tool_visibility:
  hidden:
    - full_health_analysis
    - explain_vault
  disabled:
    - delete_note

Usa hidden para herramientas avanzadas que deben permanecer invocables por nombre exacto, disabled para herramientas que deben fallar de forma cerrada, y allowed cuando quieras una lista de permitidos explícita. Hay anulaciones equivalentes de entorno/CLI disponibles mediante TURBOVAULT_HIDDEN_TOOLS, TURBOVAULT_DISABLED_TOOLS, TURBOVAULT_ALLOWED_TOOLS, y --hidden-tools, --disabled-tools, --allowed-tools.

Implementación del SDK y del Servidor

TurboVault está diseñado para dos audiencias principales: desarrolladores que construyen sobre el SDK de Rust y usuarios que buscan un servidor MCP independiente.

Como Servidor MCP Independiente

La forma más rápida de empezar es usar el binario precompilado. Es totalmente autónomo y optimizado para el rendimiento:

Optimización en tiempo de enlace (LTO) para máxima velocidad
Transportes configurables (STDIO, HTTP, WebSocket, TCP)
Cero dependencias externas (solo apúntalo a tu vault)

# Build the optimized binary
cargo build --release --features full

# Run it
./target/release/turbovault --vault /path/to/vault --profile production

Como SDK de Rust (Biblioteca)

El núcleo de TurboVault es una colección de crates modulares. Úsalos para construir tus propios motores de búsqueda, herramientas de gestión del conocimiento, o incluso tus propios servidores MCP especializados.

// Use in your own Rust projects
use turbovault_core::MultiVaultManager;
use turbovault_vault::VaultManager;
use turbovault_tools::SearchEngine;

#[tokio::main]
async fn main() -> 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(())
}

Cada crate se publica en crates.io, por lo que puedes depender de componentes individuales o de la pila completa.

Arquitectura

Construido como un espacio de trabajo modular de Rust:

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       — Validated sequential batch operations
turbovault-export      — JSON/CSV/Markdown export
turbovault-sql         — SQL frontmatter queries (GlueSQL, feature-gated)
turbovault-tools       — 74 MCP tool implementations
turbovault-plugin-api  — Curated plugin facade, provider contract, event hooks
turbovault (binary)    — CLI and MCP server entry point

Todos los crates se publican en crates.io para uso público.

Soporte de Markdown con Sabor a Obsidian (OFM)

TurboVault entiende completamente la sintaxis de Obsidian:

Wikilinks: [[note]], [[note|alias]], [[note#section]], [[note#^block]]
Incrustados: ![[image.png]], ![[note]], ![[note#section]]
Etiquetas: #tag, #parent/child/tag
Tareas: - [ ] Task, - [x] Done
Callouts: > [!type] Title
Frontmatter: Metadatos YAML con análisis automático
Encabezados: Extracción de estructura jerárquica

Seguridad

Protección contra recorrido de rutas — Sin acceso fuera de los límites del vault
Deserialización segura de tipos — El sistema de tipos de Rust previene la inyección
Escrituras atómicas — Archivo temporal → renombrado atómico (nunca corrompe en caso de fallo)
Detección de conflictos basada en hash — edit_note detecta modificaciones concurrentes
Límites de tamaño de archivo — 10MB por archivo por defecto (configurable), aplicado en lecturas y escrituras
Directorios protegidos — .obsidian/, .git/, node_modules/, y el estado propio de .turbovault/ de TurboVault son inaccesibles a través de las APIs de notas en ambos backends de escritura
Sin ejecución de shell — Cero riesgo de inyección de comandos
Rastro de auditoría: Cada escritura se registra bajo .turbovault/ (y como un commit en un vault respaldado por Git), en cada perfil
Modo de solo lectura: --profile readonly o --require-read-only-tools oculta y rechaza toda herramienta de mutación

Requisitos del Sistema

Rust: 1.90.0 o posterior
SO: Linux, macOS, Windows
Memoria: 100MB base + ~80MB por cada 10k notas
Disco: Insignificante (el índice está en memoria)

Compilación desde el Código Fuente

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

O usa just (consulta el justfile):

just build       # Debug build
just release     # Production build
just test        # Run tests (fmt check, lint, full suite)
just clean       # Clean build artifacts

Documentación

Docs

Ejemplos

Ejemplo 1: Organización Impulsada por Búsqueda

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)"

Ejemplo 2: Mejora de la Salud del Vault

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. Apply fixes individually, or use batch_execute() after reviewing its fail-fast semantics
  6. explain_vault() -> New health: 78/100

Ejemplo 3: Creación de Contenido Basada en Plantillas

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 notas, compilación de producción:

Lectura de archivo: <10ms
Escritura de archivo: <20ms
Búsqueda simple: <50ms
Análisis de grafo: <200ms
Inicialización del vault: ~500ms
Uso de memoria: ~80MB
Reconciliación de cambios externos: ~19ms por pasada, como máximo una vez cada 500ms

Mantenerse al día con ediciones que no hiciste

Un vault es un directorio compartido. Obsidian suele estar abierto sobre él, y un editor, un git pull, o un cliente de sincronización pueden tocarlo mientras TurboVault está en ejecución. La búsqueda, el grafo de enlaces, la similitud y las estadísticas del vault se derivan de las notas, por lo que nada de eso llegaría a ellos por sí solo.

Antes de servir cualquiera de esos datos, TurboVault compara un escaneo de (size, mtime) contra lo que registró por última vez y aplica lo que haya cambiado. Comparar el estado no puede perder un cambio de la manera en que las notificaciones del sistema de archivos pueden, lo cual importa más precisamente en las configuraciones donde las notificaciones son más débiles: recursos compartidos de red, y vaults de iCloud, Dropbox o Syncthing, ninguno de los cuales reporta las ediciones de un par en absoluto.

La pasada está con rebote, por lo que una ráfaga de llamadas a herramientas cuesta un escaneo y un servidor inactivo no cuesta nada. El peor caso de desactualización es el intervalo, al menos 500ms y escalado solo en un vault lo suficientemente grande como para necesitarlo. Establece reconcile_external_changes: false para desactivarlo en un vault que nada más escribe.

Hoja de Ruta

Resolución de enlaces entre vaults
Soporte de vaults cifrados
Bloqueo colaborativo
Transporte WebSocket (más allá de MCP stdio)

Contribuciones

¡Las contribuciones son bienvenidas! Por favor, asegúrate de:

Todas las pruebas pasan: cargo test --all
El código está formateado: cargo fmt --all
Sin advertencias de clippy: cargo clippy --all -- -D warnings

Licencia

Licencia MIT - Consulta LICENSE para más detalles

Enlaces

Repositorio: https://github.com/epistates/turbovault
Problemas: https://github.com/epistates/turbovault/issues
Protocolo MCP: https://modelcontextprotocol.io
Obsidian: https://obsidian.md
Relacionado: TurboMCP

Empieza ahora: ./target/release/turbovault --profile production