obsidian-mcp 2.2.1

MCP server for Obsidian vaults — direct filesystem access for AI agents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! Daemon-side indexing helpers shared by per-vault contexts and watcher updates.

#[cfg(has_embeddings)]
use crate::error::{VaultError, VaultResult};
#[cfg(has_embeddings)]
use crate::models::NoteMetadata;
#[cfg(has_embeddings)]
use crate::vault::{frontmatter, fs, index::VaultIndex};
#[cfg(has_embeddings)]
use std::path::Path;
#[cfg(has_embeddings)]
use std::sync::{Arc, RwLock};

#[cfg(has_embeddings)]
use crate::vault::embeddings::{self, EmbeddingModel, EmbeddingStore};

#[cfg(has_embeddings)]
pub(crate) fn build_or_load_embeddings(
    vault_root: &Path,
    index: &Arc<RwLock<VaultIndex>>,
    model: &EmbeddingModel,
    cache_path: &Path,
) -> VaultResult<EmbeddingStore> {
    let index_guard = index
        .read()
        .map_err(|err| VaultError::Other(format!("daemon index lock poisoned: {err}")))?;
    let note_entries: Vec<_> = index_guard
        .notes()
        .iter()
        .map(|(path, meta)| (path.clone(), meta.clone()))
        .collect();
    drop(index_guard);
    embeddings::build_or_load_embedding_store(cache_path, vault_root, &note_entries, model)
}

#[cfg(has_embeddings)]
pub(crate) fn embed_note(
    vault_root: &Path,
    relative: &Path,
    meta: &NoteMetadata,
    model: &EmbeddingModel,
    store: &Arc<RwLock<EmbeddingStore>>,
) -> bool {
    let Ok(content) = fs::read_file(vault_root, relative) else {
        return false;
    };

    let body = frontmatter::get_body(&content);
    let heading_texts: Vec<String> = meta.headings.iter().map(|h| h.text.clone()).collect();
    let text = embeddings::prepare_embed_text(&meta.title, &heading_texts, body);

    match model.embed_one(&text) {
        Ok(vector) => match store.write() {
            Ok(mut store_guard) => {
                store_guard.insert(relative.to_path_buf(), vector);
                true
            }
            Err(err) => {
                tracing::error!(error = %err, "daemon embedding store lock poisoned");
                false
            }
        },
        Err(err) => {
            tracing::warn!(
                path = %relative.display(),
                error = %err,
                "daemon embedding failed"
            );
            false
        }
    }
}

#[cfg(has_embeddings)]
pub(crate) fn remove_note_embedding(relative: &Path, store: &Arc<RwLock<EmbeddingStore>>) -> bool {
    match store.write() {
        Ok(mut store_guard) => {
            store_guard.remove(relative);
            true
        }
        Err(err) => {
            tracing::error!(error = %err, "daemon embedding store lock poisoned");
            false
        }
    }
}

#[cfg(has_embeddings)]
pub(crate) fn save_embedding_cache(cache_path: &Path, store: &EmbeddingStore) {
    if let Err(err) = store.save(cache_path) {
        tracing::warn!(
            cache = %cache_path.display(),
            error = %err,
            "failed to save daemon embedding cache"
        );
    }
}