obsidian-vault-sql-mcp 0.1.0__py3-none-any.whl

obsidian_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Obsidian MCP Server — file-based vault management with SQLite indexing."""
+
+__version__ = "0.1.0"

obsidian_mcp/database.py

@@ -0,0 +1,197 @@
+import shutil
+import sqlite3
+from pathlib import Path
+from typing import Optional
+
+DB_FOLDER = "data-base-sqlite"
+DB_FILE = "notes.db"
+
+
+class VaultDB:
+    def __init__(self, name: str, vault_root: Path):
+        self.name = name
+        self.vault_root = vault_root.resolve()
+        self.db_dir = self.vault_root / DB_FOLDER
+        self.db_path = self.db_dir / DB_FILE
+        self.db_dir.mkdir(exist_ok=True)
+        self._init_db()
+
+    def _connect(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(str(self.db_path))
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _init_db(self) -> None:
+        with self._connect() as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS notes (
+                    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name          TEXT    NOT NULL,
+                    filename      TEXT    NOT NULL,
+                    relative_path TEXT    NOT NULL UNIQUE,
+                    absolute_path TEXT    NOT NULL,
+                    folder        TEXT    DEFAULT '',
+                    last_modified REAL,
+                    created_at    REAL    DEFAULT (unixepoch())
+                )
+            """)
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_name ON notes(name)")
+            conn.commit()
+
+    # ------------------------------------------------------------------
+    # Indexing
+    # ------------------------------------------------------------------
+
+    def index_all(self) -> int:
+        """Scan vault root for all .md files and upsert into DB."""
+        count = 0
+        with self._connect() as conn:
+            for md_file in self.vault_root.rglob("*.md"):
+                if DB_FOLDER in md_file.parts:
+                    continue
+                rel = md_file.relative_to(self.vault_root)
+                folder = str(rel.parent) if str(rel.parent) != "." else ""
+                conn.execute(
+                    """
+                    INSERT INTO notes (name, filename, relative_path, absolute_path, folder, last_modified)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                    ON CONFLICT(relative_path) DO UPDATE SET
+                        name          = excluded.name,
+                        absolute_path = excluded.absolute_path,
+                        folder        = excluded.folder,
+                        last_modified = excluded.last_modified
+                    """,
+                    (
+                        md_file.stem,
+                        md_file.name,
+                        str(rel).replace("\\", "/"),
+                        str(md_file),
+                        folder,
+                        md_file.stat().st_mtime,
+                    ),
+                )
+                count += 1
+            conn.commit()
+        return count
+
+    # ------------------------------------------------------------------
+    # Search / find
+    # ------------------------------------------------------------------
+
+    def search(self, query: str) -> list[dict]:
+        """Case-insensitive substring search by note name."""
+        with self._connect() as conn:
+            rows = conn.execute(
+                "SELECT name, filename, relative_path, folder FROM notes WHERE name LIKE ? ORDER BY name",
+                (f"%{query}%",),
+            ).fetchall()
+        return [dict(r) for r in rows]
+
+    def find_note(self, note_name: str) -> Optional[dict]:
+        """Exact match first, then fuzzy. Returns full row or None."""
+        with self._connect() as conn:
+            row = conn.execute(
+                "SELECT * FROM notes WHERE name = ? LIMIT 1", (note_name,)
+            ).fetchone()
+            if row is None:
+                row = conn.execute(
+                    "SELECT * FROM notes WHERE name LIKE ? LIMIT 1",
+                    (f"%{note_name}%",),
+                ).fetchone()
+        return dict(row) if row else None
+
+    def list_all(self) -> list[dict]:
+        with self._connect() as conn:
+            rows = conn.execute(
+                "SELECT name, relative_path, folder FROM notes ORDER BY folder, name"
+            ).fetchall()
+        return [dict(r) for r in rows]
+
+    # ------------------------------------------------------------------
+    # Mutations
+    # ------------------------------------------------------------------
+
+    def create_note(self, name: str, content: str, folder: str = "") -> Path:
+        filename = f"{name}.md"
+        if folder:
+            note_path = self.vault_root / folder / filename
+            note_path.parent.mkdir(parents=True, exist_ok=True)
+        else:
+            note_path = self.vault_root / filename
+        note_path.write_text(content, encoding="utf-8")
+        rel = note_path.relative_to(self.vault_root)
+        with self._connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO notes (name, filename, relative_path, absolute_path, folder, last_modified)
+                VALUES (?, ?, ?, ?, ?, ?)
+                ON CONFLICT(relative_path) DO UPDATE SET last_modified = excluded.last_modified
+                """,
+                (
+                    name,
+                    filename,
+                    str(rel).replace("\\", "/"),
+                    str(note_path),
+                    folder,
+                    note_path.stat().st_mtime,
+                ),
+            )
+            conn.commit()
+        return rel
+
+    def update_note(self, note_name: str, content: str) -> None:
+        note = self._require(note_name)
+        path = Path(note["absolute_path"])
+        path.write_text(content, encoding="utf-8")
+        with self._connect() as conn:
+            conn.execute(
+                "UPDATE notes SET last_modified = ? WHERE relative_path = ?",
+                (path.stat().st_mtime, note["relative_path"]),
+            )
+            conn.commit()
+
+    def move_note(self, note_name: str, new_folder: str) -> Path:
+        note = self._require(note_name)
+        old_path = Path(note["absolute_path"])
+        if new_folder:
+            new_dir = self.vault_root / new_folder
+            new_dir.mkdir(parents=True, exist_ok=True)
+            new_path = new_dir / old_path.name
+        else:
+            new_path = self.vault_root / old_path.name
+        shutil.move(str(old_path), str(new_path))
+        new_rel = new_path.relative_to(self.vault_root)
+        with self._connect() as conn:
+            conn.execute(
+                """
+                UPDATE notes
+                SET relative_path = ?, absolute_path = ?, folder = ?, last_modified = ?
+                WHERE relative_path = ?
+                """,
+                (
+                    str(new_rel).replace("\\", "/"),
+                    str(new_path),
+                    new_folder,
+                    new_path.stat().st_mtime,
+                    note["relative_path"],
+                ),
+            )
+            conn.commit()
+        return new_rel
+
+    def delete_note(self, note_name: str) -> None:
+        note = self._require(note_name)
+        Path(note["absolute_path"]).unlink()
+        with self._connect() as conn:
+            conn.execute(
+                "DELETE FROM notes WHERE relative_path = ?", (note["relative_path"],)
+            )
+            conn.commit()
+
+    # ------------------------------------------------------------------
+
+    def _require(self, note_name: str) -> dict:
+        note = self.find_note(note_name)
+        if note is None:
+            raise ValueError(f"Note '{note_name}' not found in vault '{self.name}'")
+        return note

obsidian_mcp/server.py

@@ -0,0 +1,177 @@
+import argparse
+import json
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+from .database import VaultDB
+
+mcp = FastMCP("obsidian-mcp")
+
+_vaults: dict[str, VaultDB] = {}
+
+
+def _get(vault_name: str) -> VaultDB:
+    if vault_name not in _vaults:
+        available = list(_vaults.keys())
+        raise ValueError(f"Vault '{vault_name}' not configured. Available: {available}")
+    return _vaults[vault_name]
+
+
+# ------------------------------------------------------------------
+# Tools
+# ------------------------------------------------------------------
+
+
+@mcp.tool()
+def list_vaults() -> dict:
+    """List all configured vaults."""
+    return {"vaults": list(_vaults.keys())}
+
+
+@mcp.tool()
+def index_vault(vault_name: str) -> dict:
+    """
+    Scan a vault directory and populate its SQLite database with all .md notes.
+    Call this once after first setup, or whenever notes are added/moved outside this server.
+    """
+    db = _get(vault_name)
+    count = db.index_all()
+    return {"vault": vault_name, "indexed": count}
+
+
+@mcp.tool()
+def list_notes(vault_name: str) -> dict:
+    """List all notes in a vault (reads from SQLite — fast)."""
+    db = _get(vault_name)
+    return {"vault": vault_name, "notes": db.list_all()}
+
+
+@mcp.tool()
+def search_notes(vault_name: str, query: str) -> dict:
+    """
+    Search notes by name in SQLite (case-insensitive substring match).
+    Returns list of matching notes with their paths.
+    """
+    db = _get(vault_name)
+    results = db.search(query)
+    return {"vault": vault_name, "query": query, "results": results, "count": len(results)}
+
+
+@mcp.tool()
+def read_note(vault_name: str, note_name: str) -> dict:
+    """
+    Find note by name via SQLite and return its full markdown content.
+    Supports exact and fuzzy name matching.
+    """
+    db = _get(vault_name)
+    note = db.find_note(note_name)
+    if note is None:
+        raise ValueError(f"Note '{note_name}' not found in vault '{vault_name}'")
+    content = Path(note["absolute_path"]).read_text(encoding="utf-8")
+    return {
+        "vault": vault_name,
+        "name": note["name"],
+        "path": note["relative_path"],
+        "folder": note["folder"],
+        "content": content,
+    }
+
+
+@mcp.tool()
+def create_note(vault_name: str, name: str, content: str, folder: str = "") -> dict:
+    """
+    Create a new .md note and register it in SQLite.
+    folder: relative path from vault root, e.g. "projects/2026". Leave empty for root.
+    """
+    db = _get(vault_name)
+    rel = db.create_note(name, content, folder)
+    return {"vault": vault_name, "created": name, "path": str(rel).replace("\\", "/")}
+
+
+@mcp.tool()
+def update_note(vault_name: str, note_name: str, content: str) -> dict:
+    """
+    Overwrite the content of an existing note.
+    SQLite last_modified is updated automatically.
+    """
+    db = _get(vault_name)
+    db.update_note(note_name, content)
+    return {"vault": vault_name, "updated": note_name}
+
+
+@mcp.tool()
+def move_note(vault_name: str, note_name: str, new_folder: str) -> dict:
+    """
+    Move a note to a different folder inside the vault.
+    SQLite path is updated automatically.
+    new_folder: relative path from vault root, e.g. "archive/2025". Empty string = vault root.
+    """
+    db = _get(vault_name)
+    new_path = db.move_note(note_name, new_folder)
+    return {
+        "vault": vault_name,
+        "moved": note_name,
+        "new_path": str(new_path).replace("\\", "/"),
+    }
+
+
+@mcp.tool()
+def delete_note(vault_name: str, note_name: str) -> dict:
+    """Delete a note from disk and remove its record from SQLite."""
+    db = _get(vault_name)
+    db.delete_note(note_name)
+    return {"vault": vault_name, "deleted": note_name}
+
+
+# ------------------------------------------------------------------
+# Entry point
+# ------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="obsidian-mcp",
+        description="MCP server for Obsidian vaults with SQLite indexing",
+    )
+    parser.add_argument(
+        "--config",
+        metavar="FILE",
+        help='Path to JSON config file: {"vaults": {"name": "/path/to/vault"}}',
+    )
+    parser.add_argument(
+        "--vault",
+        action="append",
+        metavar="NAME=PATH",
+        help="Add a vault inline, e.g. --vault personal=/home/user/notes. Can be repeated.",
+    )
+    args = parser.parse_args()
+
+    vaults: dict[str, str] = {}
+
+    if args.config:
+        with open(args.config, encoding="utf-8") as f:
+            cfg = json.load(f)
+        vaults.update(cfg.get("vaults", {}))
+
+    if args.vault:
+        for entry in args.vault:
+            if "=" not in entry:
+                parser.error(f"--vault must be in NAME=PATH format, got: {entry!r}")
+            name, path = entry.split("=", 1)
+            vaults[name.strip()] = path.strip()
+
+    if not vaults:
+        parser.error("No vaults configured. Use --config FILE or --vault NAME=PATH.")
+
+    for name, path in vaults.items():
+        vault_path = Path(path)
+        if not vault_path.exists():
+            raise SystemExit(f"Vault path does not exist: {path}")
+        _vaults[name] = VaultDB(name, vault_path)
+
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

obsidian_vault_sql_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: obsidian-vault-sql-mcp
+Version: 0.1.0
+Summary: MCP server for Obsidian vaults — file-based note management with SQLite indexing
+License: MIT
+Keywords: markdown,mcp,notes,obsidian,sqlite
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: mcp[cli]>=1.0.0
+Description-Content-Type: text/markdown
+
+# obsidian-vault-sql-mcp
+
+MCP server for [Obsidian](https://obsidian.md) vaults. Works directly with `.md` files on disk — no Obsidian app needed. Each vault gets its own SQLite index for fast note lookup by name.
+
+## How it works
+
+```
+your-vault/
+├── notes/
+│   └── my-note.md
+├── projects/
+│   └── project-alpha.md
+└── data-base-sqlite/       ← created automatically
+    └── notes.db            ← SQLite index (name → path)
+```
+
+When you call `index_vault`, the server scans all `.md` files and stores their names and paths in SQLite. After that, finding a note by name is instant — no directory traversal needed. When you create, move or delete notes through the server, the index updates automatically.
+
+Multiple vaults are supported — each has its own database inside it.
+
+---
+
+## Installation
+
+Requires [uv](https://docs.astral.sh/uv/) installed.
+
+```bash
+uvx obsidian-vault-sql-mcp --help
+```
+
+No manual install needed — `uvx` handles everything on first run.
+
+---
+
+## Configuration
+
+### Option A — inline vaults
+
+```bash
+uvx obsidian-vault-sql-mcp --vault personal=/path/to/my-vault --vault work=/path/to/work-vault
+```
+
+### Option B — config file
+
+Create `config.json`:
+
+```json
+{
+  "vaults": {
+    "personal": "/path/to/my-vault",
+    "work": "/path/to/work-vault"
+  }
+}
+```
+
+```bash
+uvx obsidian-vault-sql-mcp --config /path/to/config.json
+```
+
+---
+
+## Claude Code setup
+
+Add to your Claude Code MCP settings (`~/.claude/settings.json`):
+
+```json
+{
+  "mcpServers": {
+    "obsidian": {
+      "command": "uvx",
+      "args": [
+        "obsidian-vault-sql-mcp",
+        "--config", "/path/to/config.json"
+      ]
+    }
+  }
+}
+```
+
+Or with inline vaults:
+
+```json
+{
+  "mcpServers": {
+    "obsidian": {
+      "command": "uvx",
+      "args": [
+        "obsidian-vault-sql-mcp",
+        "--vault", "personal=C:/Users/you/Documents/MyVault"
+      ]
+    }
+  }
+}
+```
+
+---
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_vaults()` | List all configured vault names |
+| `index_vault(vault_name)` | Scan vault and build/update SQLite index |
+| `list_notes(vault_name)` | List all indexed notes |
+| `search_notes(vault_name, query)` | Search notes by name (case-insensitive substring) |
+| `read_note(vault_name, note_name)` | Read note content (exact or fuzzy name match) |
+| `create_note(vault_name, name, content, folder?)` | Create a new `.md` note |
+| `update_note(vault_name, note_name, content)` | Overwrite note content |
+| `move_note(vault_name, note_name, new_folder)` | Move note to a different folder |
+| `delete_note(vault_name, note_name)` | Delete note from disk and index |
+
+---
+
+## First-time setup
+
+1. Start the server with your vault path
+2. Call `index_vault("personal")` once — this scans all existing notes
+3. Done — all other tools work immediately
+
+After that, `index_vault` only needs to be called again if you add/move notes **outside** this server (e.g. manually in Obsidian).
+
+---
+
+## Example usage
+
+```
+search_notes("personal", "yandex")
+→ [{ "name": "conspect-yandex-tracker", "relative_path": "notes/conspect-yandex-tracker.md" }]
+
+read_note("personal", "conspect-yandex-tracker")
+→ { "content": "# Конспект Yandex Tracker\n..." }
+
+create_note("personal", "new-idea", "# New Idea\nText here", "inbox")
+→ { "path": "inbox/new-idea.md" }
+
+move_note("personal", "new-idea", "projects/2026")
+→ { "new_path": "projects/2026/new-idea.md" }
+```
+
+---
+
+## License
+
+MIT

obsidian_vault_sql_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+obsidian_mcp/__init__.py,sha256=pJwf0fq2miKGIqARZ-P9844wILdRbmVezxT-mZQ1occ,103
+obsidian_mcp/database.py,sha256=wEA9ZlzWyAiJepLfGjYcX8rWTd9qjAXIq_rQ-2960yQ,7582
+obsidian_mcp/server.py,sha256=YMWLf7l5IcAwDl_iEyTCTNOrTOGp0XLKEvxvehgUNu8,5253
+obsidian_vault_sql_mcp-0.1.0.dist-info/METADATA,sha256=3q15xW2abCXyauY1ksMc9h2jXK2frLWMxL4BhQ_WjD0,3939
+obsidian_vault_sql_mcp-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+obsidian_vault_sql_mcp-0.1.0.dist-info/entry_points.txt,sha256=GSYex1O3V6cYLsbDWvGpJkpgGzGQ_Y4AluBDsTyDVOA,68
+obsidian_vault_sql_mcp-0.1.0.dist-info/RECORD,,

obsidian_vault_sql_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

obsidian_vault_sql_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+obsidian-vault-sql-mcp = obsidian_mcp.server:main