obsidian-remote-mcp 0.1.0__tar.gz

obsidian_remote_mcp-0.1.0/.env.example

@@ -0,0 +1,20 @@
+# Required: absolute path to your Obsidian vault
+VAULT_PATH=/path/to/your/vault
+
+# Set to true to disable all write operations
+READ_ONLY=false
+
+# Comma-separated relative paths where writes are allowed (empty = everywhere)
+WRITE_PATHS=
+
+# Comma-separated paths to exclude from listing/search
+EXCLUDE_PATHS=private,.obsidian,.trash
+
+# Transport mode: "stdio" (default, local use) or "sse" (remote/network use)
+TRANSPORT=stdio
+
+# API key for network transport (SSE). If set, all requests must include:
+# Authorization: Bearer <your-key>
+# Generate with: openssl rand -hex 32
+# Not required for stdio transport.
+API_KEY=

obsidian_remote_mcp-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: uv sync --dev
+
+      - name: Lint (ruff)
+        run: uv run ruff check src/ tests/
+
+      - name: Tests
+        run: uv run pytest tests/ -v --tb=short

obsidian_remote_mcp-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,64 @@
+name: Release
+
+on:
+  push:
+    tags: ['v*']
+
+jobs:
+  # ── PyPI ────────────────────────────────────────────────────────────────────
+  publish-pypi:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write  # required for trusted publishing
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v4
+        with:
+          python-version: "3.12"
+
+      - name: Build
+        run: uv build
+
+      - name: Publish
+        run: uv publish
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
+
+  # ── Docker → GHCR ───────────────────────────────────────────────────────────
+  publish-docker:
+    name: Publish Docker image to GHCR
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Log in to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ghcr.io/ykoellmann/obsidian-mcp
+          tags: |
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=raw,value=latest
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

obsidian_remote_mcp-0.1.0/.gitignore

@@ -0,0 +1,24 @@
+# Python
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+dist/
+*.egg-info/
+
+# Caches
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+
+# Environment
+.env
+
+# Local planning notes
+plan.md
+
+# Example vault (local only – jeder nutzt seinen eigenen Vault)
+example-vault/
+
+# Lock files for file operations (vault per-file locks)
+*.md.lock

obsidian_remote_mcp-0.1.0/Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.12-slim
+
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/
+
+WORKDIR /app
+COPY pyproject.toml uv.lock ./
+COPY src/ src/
+
+RUN uv pip install --system --no-cache .
+
+ENTRYPOINT ["obsidian-mcp"]

obsidian_remote_mcp-0.1.0/FEATURES.md

@@ -0,0 +1,254 @@
+# Feature-Roadmap – second-brain-mcp
+
+Ziel: vollständige Obsidian-Unterstützung und darüber hinaus.
+
+---
+
+## Phase 2 – Enhanced Core (nächste Schritte)
+
+### 2.1 Search mit Snippets & Ranking
+**Tool:** `search_notes_tool` erweitern
+
+Aktuell: gibt nur Pfad + Tags zurück, kein Kontext.
+
+```python
+# Neu: strukturierte Ergebnisse
+{
+  "path": "Notizen/Python-Tipps.md",
+  "score": 0.92,
+  "snippets": [
+    {"line": 23, "text": "...`filelock` verhält sich anders wenn der **Lock-File** auf einem NFS-Mount..."}
+  ],
+  "tags": ["konzept/programmierung"]
+}
+```
+
+- Ranking: exakter Treffer > Wort-Anfang > Teilstring
+- Snippets: ±2 Zeilen um den Treffer, Match bold-markiert
+- Optional: `regex=True` für Regex-Suche
+- Optional: `limit=20` für Ergebnis-Anzahl
+
+### 2.2 `move_note` – Umbenennen + Backlink-Rewriting
+**Neues Tool**
+
+```python
+@mcp.tool()
+def move_note(from_path: str, to_path: str) -> dict:
+    # 1. Datei verschieben (atomar)
+    # 2. Alle .md-Dateien im Vault scannen
+    # 3. [[from_path]]-Wikilinks auf [[to_path]] umschreiben
+    # 4. Index aktualisieren
+    # Gibt zurück: {moved: ..., updated_links_in: [...]}
+```
+
+### 2.3 `get_orphans` – Notizen ohne Backlinks
+**Neues Tool**
+
+```python
+@mcp.tool()
+def get_orphans(exclude_folders: list[str] = ["Journal", "Templates"]) -> list[str]:
+    # Notizen die von keiner anderen Notiz verlinkt werden
+    # Journal-Einträge standardmäßig ausgeschlossen
+```
+
+### 2.4 `get_broken_links` – tote Wikilinks finden
+**Neues Tool**
+
+```python
+@mcp.tool()
+def get_broken_links() -> list[dict]:
+    # [{source: "Notizen/X.md", link: "[[NichtExistent]]", line: 12}]
+    # Prüft gegen: existierende Dateien + bekannte Aliases
+```
+
+### 2.5 `list_notes_with_meta` – Listing mit Metadaten
+**`list_notes_tool` Erweiterung**
+
+```python
+@mcp.tool()
+def list_notes_tool(folder: str = "", include_meta: bool = False) -> list[str | dict]:
+    # include_meta=True: [{path, title, tags, status, created, mtime}]
+```
+
+---
+
+## Phase 3 – Graph & Navigation
+
+### 3.1 `get_link_graph` – traversierbarer Link-Graph
+**Neues Tool – das wichtigste dieser Phase**
+
+```python
+@mcp.tool()
+def get_link_graph(
+    root: str,          # Startnotiz
+    depth: int = 2,     # wie viele Ebenen ausgehend
+    direction: str = "both",  # "outgoing" | "incoming" | "both"
+    include_tags: bool = False
+) -> dict:
+    # {
+    #   "root": "Projekte/second-brain-mcp.md",
+    #   "nodes": [{"path": ..., "title": ..., "tags": [...]}],
+    #   "edges": [{"from": ..., "to": ..., "type": "wikilink"}]
+    # }
+```
+
+Erlaubt: „Zeig mir alles was mit diesem Projekt zusammenhängt (2 Ebenen tief)".
+
+### 3.2 `get_tag_tree` – verschachtelter Tag-Baum
+**Neues Tool**
+
+```python
+@mcp.tool()
+def get_tag_tree() -> dict:
+    # {
+    #   "konzept": {
+    #     "mcp": ["Notizen/MCP-Protokoll.md"],
+    #     "ki": {
+    #       "llm": ["Notizen/Claude.md"]
+    #     }
+    #   },
+    #   "projekt": {
+    #     "aktiv": ["Projekte/second-brain-mcp.md"]
+    #   }
+    # }
+```
+
+### 3.3 `get_vault_stats` – Vault-Statistiken
+**Neues Tool**
+
+```python
+@mcp.tool()
+def get_vault_stats() -> dict:
+    # {total_notes, total_links, total_tags, orphans_count,
+    #  broken_links_count, most_linked: [...], most_linking: [...]}
+```
+
+---
+
+## Phase 4 – Vollständige Obsidian-Feature-Unterstützung
+
+### 4.1 Block-Referenzen
+**Parser + Index erweitern**
+
+- Parsen von `^block-id`-Ankern in Notizen
+- Auflösen von `[[Note^block-id]]`-Links
+- Neues Tool: `read_block(path, block_id) -> str`
+- Index: `block_index[note_path][block_id] = line_number`
+
+### 4.2 Aliases – transparente Auflösung
+**Parser + Index erweitern**
+
+- `aliases:` aus Frontmatter in Index aufnehmen
+- `[[Alias]]` → automatisch zur echten Notiz auflösen
+- `get_broken_links` berücksichtigt Aliases (kein false positive)
+- Neues Tool: `resolve_alias(name) -> str | None`
+
+### 4.3 Embedded Notes – `![[Note]]` Transclusion
+**Parser + neues Tool**
+
+- `![[Note]]` und `![[Note#Section]]` parsen
+- Neues Tool: `render_note(path) -> str` – löst alle Embeddings auf,
+  gibt vollständigen Text zurück (für vollständigen Kontext an Claude)
+
+### 4.4 Daily Notes
+**Neues Tool**
+
+```python
+@mcp.tool()
+def get_daily_note(date: str = "today") -> dict:
+    # date: "today" | "yesterday" | "YYYY-MM-DD"
+    # Sucht in Journal/ nach YYYY-MM-DD.md
+    # Erstellt aus Template wenn nicht vorhanden
+
+@mcp.tool()
+def get_daily_notes_range(from_date: str, to_date: str) -> list[dict]:
+    # Alle Daily Notes im Zeitraum, mit Aufgaben-Summary
+```
+
+### 4.5 Task-Extraktion quer über den Vault
+**Neues Tool**
+
+```python
+@mcp.tool()
+def get_tasks(
+    status: str = "open",  # "open" | "done" | "all"
+    folder: str = "",
+    tag: str | None = None
+) -> list[dict]:
+    # [{text, done, source_path, line, due_date (aus [[due::YYYY-MM-DD]])}]
+```
+
+### 4.6 Callout-Parsing
+**Parser erweitern**
+
+- Callout-Typen erkennen: `[!NOTE]`, `[!WARNING]`, `[!TIP]`, `[!IMPORTANT]`, `[!QUESTION]`
+- In `Note`-Dataclass aufnehmen: `callouts: list[Callout]`
+- `read_note` gibt Callouts strukturiert zurück
+
+### 4.7 Canvas-Support (`.canvas`-Dateien)
+**Neues Tool**
+
+Obsidian Canvas = JSON-Format mit Nodes und Edges.
+
+```python
+@mcp.tool()
+def read_canvas(path: str) -> dict:
+    # {nodes: [{id, type, text/file, x, y}], edges: [{from, to, label}]}
+
+@mcp.tool()
+def list_canvases() -> list[str]:
+```
+
+---
+
+## Phase 5 – Erweiterte Suche & Abfragen
+
+### 5.1 Dataview-ähnliche Abfragen
+**Neues Tool**
+
+```python
+@mcp.tool()
+def query_notes(
+    tags: list[str] | None = None,
+    status: str | None = None,
+    frontmatter_filter: dict | None = None,  # {"prioritaet": {"gte": 3}}
+    sort_by: str = "mtime",
+    limit: int = 50
+) -> list[dict]:
+    # Filtert Notizen nach Metadaten ohne Volltextsuche
+```
+
+### 5.2 Fuzzy- und Regex-Suche
+**`search_notes_tool` erweitern**
+
+- `mode: "exact" | "fuzzy" | "regex"`
+- Fuzzy: Levenshtein-Distanz, für Tippfehler-Toleranz
+
+### 5.3 Template-Engine
+**Neues Tool**
+
+```python
+@mcp.tool()
+def create_from_template(
+    template_path: str,
+    output_path: str,
+    variables: dict  # {"title": "Mein Projekt", "date": "2026-07-23"}
+) -> dict:
+    # Ersetzt {{title}}, {{date}} etc. im Template
+    # Erstellt Zieldatei atomar
+```
+
+---
+
+## Build-Order
+
+```
+Phase 2: 2.4 get_broken_links → 2.3 get_orphans → 2.1 Search+Snippets → 2.2 move_note → 2.5 list_meta
+Phase 3: 4.2 Aliases (braucht Index) → 3.1 get_link_graph → 3.2 get_tag_tree → 3.3 vault_stats
+Phase 4: 4.1 Block-Refs → 4.3 Embeddings → 4.4 Daily Notes → 4.5 Tasks → 4.6 Callouts → 4.7 Canvas
+Phase 5: 5.1 Query → 5.2 Fuzzy → 5.3 Templates
+```
+
+Aliases (4.2) vor dem Link-Graph (3.1), weil der Graph Aliases für korrekte
+Auflösung braucht. Block-Refs (4.1) vor Embeddings (4.3), weil Embeddings
+Block-Refs auflösen müssen.

obsidian_remote_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yannik Koellmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

obsidian_remote_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,246 @@
+Metadata-Version: 2.4
+Name: obsidian-remote-mcp
+Version: 0.1.0
+Summary: MCP server for Obsidian vaults — read, write, search, graph, canvas, kanban
+Project-URL: Homepage, https://github.com/ykoellmann/obsidian-mcp
+Project-URL: Repository, https://github.com/ykoellmann/obsidian-mcp
+Project-URL: Issues, https://github.com/ykoellmann/obsidian-mcp/issues
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: fastmcp>=2.0
+Requires-Dist: filelock>=3.13
+Requires-Dist: python-frontmatter>=1.1
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: watchdog>=4.0
+Description-Content-Type: text/markdown
+
+# obsidian-mcp
+
+[![CI](https://github.com/ykoellmann/obsidian-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/ykoellmann/obsidian-mcp/actions/workflows/ci.yml)
+
+An MCP (Model Context Protocol) server for [Obsidian](https://obsidian.md) vaults. Connects Claude (or any MCP client) directly to your vault — read, write, search, navigate links, and manage notes, canvases, and kanban boards.
+
+## Why obsidian-mcp?
+
+The official Obsidian MCP plugin requires the Obsidian desktop app to be running and only works on the same machine. **obsidian-mcp is a standalone server** — no Obsidian app needed.
+
+The intended setup is to host obsidian-mcp on a server or NAS where your vault is continuously synced (via [Syncthing](https://syncthing.net), [git](https://github.com/denolehov/obsidian-git), [rclone](https://rclone.org), or [Obsidian Sync](https://obsidian.md/sync)). Claude then connects to that server over the network, so:
+
+- **Always up to date** — the server sees every change your Obsidian app writes, immediately
+- **Access from anywhere** — connect from Claude Desktop, Claude Code, or any MCP client on any machine, without the vault being present locally
+- **Multiple clients** — several Claude sessions can read the vault simultaneously; writes are serialized with per-file locking
+- **No app dependency** — the server runs headless and starts automatically (systemd, Docker, etc.)
+
+```
+[Obsidian app]  ──sync──►  [vault on server]  ◄──MCP──  [Claude on any machine]
+  (phone/laptop)              (NAS / VPS)                  (Claude Desktop / Code)
+```
+
+## Features
+
+- **Read & Search** — read notes, search full-text (exact/regex/fuzzy), render embedded transclusions, inspect note outlines
+- **Write** — create/overwrite notes, patch sections, append content, update frontmatter, manage tags, move notes with automatic wikilink rewriting
+- **Folders** — list, create, delete, rename folders; renaming rewrites path-based wikilinks vault-wide
+- **Query & Graph** — backlinks, broken links, orphan detection, BFS link graph, vault stats, task collection across vault
+- **Dataview-like queries** — filter notes by tags, status, frontmatter fields, or inline fields (`key:: value`)
+- **Periodic Notes** — read/preview daily, weekly, monthly, quarterly, yearly journal notes from templates
+- **Canvas** — read, create, and patch Obsidian Canvas (`.canvas`) files
+- **Kanban** — read, create, and manipulate Obsidian Kanban boards (columns and cards)
+- **Attachments** — list, read (text or base64), and add binary files
+- **Templates** — render Obsidian templates with built-in (`{{date}}`, `{{title}}`, …) and custom variables
+- **MCP Resources** — expose vault notes, stats, and tags as MCP resources for direct context injection
+
+## Installation
+
+**Via uvx (no clone needed):**
+```bash
+VAULT_PATH=/your/vault uvx obsidian-remote-mcp
+```
+
+**Via Docker (no Python needed):**
+```bash
+docker compose up -d   # see docker-compose.yml
+```
+
+**From source:**
+```bash
+git clone https://github.com/ykoellmann/obsidian-mcp.git
+cd obsidian-mcp
+uv sync
+uv run obsidian-remote-mcp
+```
+
+## Configuration
+
+Copy `.env.example` to `.env` and set your vault path:
+
+```env
+VAULT_PATH=/path/to/your/obsidian/vault
+# Optional:
+# READ_ONLY=true            # prevent all writes
+# WRITE_PATHS=Notes/,Inbox/ # restrict writes to specific folders
+# TRANSPORT=stdio           # stdio (default) or sse
+```
+
+## Usage with Claude Code
+
+Add to your MCP config (e.g. `~/.claude/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "obsidian": {
+      "command": "uv",
+      "args": ["--directory", "/path/to/obsidian-mcp", "run", "obsidian-remote-mcp"],
+      "env": {
+        "VAULT_PATH": "/path/to/your/obsidian/vault"
+      }
+    }
+  }
+}
+```
+
+## Usage with Claude Desktop
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "obsidian": {
+      "command": "uv",
+      "args": ["--directory", "/path/to/obsidian-mcp", "run", "obsidian-remote-mcp"],
+      "env": {
+        "VAULT_PATH": "/path/to/your/obsidian/vault"
+      }
+    }
+  }
+}
+```
+
+## Docker
+
+```bash
+# 1. Copy and edit the environment variables
+cp .env.example .env
+
+# 2. Set HOST_VAULT_PATH and API_KEY in .env, then:
+docker compose up -d
+```
+
+The `docker-compose.yml` pulls the pre-built image from GHCR — no cloning or building required. To build locally instead, swap `image:` for `build: .` in the compose file.
+
+## Remote Setup (Recommended)
+
+Run obsidian-mcp on a server and connect to it remotely via SSE transport.
+
+**1. Generate an API key:**
+```bash
+openssl rand -hex 32
+```
+
+**2. Configure the server** (`docker-compose.yml` or `.env`):
+```env
+VAULT_PATH=/data/vault
+TRANSPORT=sse
+API_KEY=your-generated-key
+```
+
+**3. Start:**
+```bash
+docker compose up -d   # or: uv run obsidian-remote-mcp
+```
+
+**4. Connect from your MCP client** (anywhere on the network):
+```json
+{
+  "mcpServers": {
+    "obsidian": {
+      "type": "sse",
+      "url": "https://your-server/sse",
+      "headers": {
+        "Authorization": "Bearer your-generated-key"
+      }
+    }
+  }
+}
+```
+
+> **Security:** Always put a TLS-terminating reverse proxy (e.g. [Caddy](https://caddyserver.com)) in front when exposing to the internet. `API_KEY` is not needed for stdio transport (local use only).
+
+Keep the vault synced on the server with Syncthing, git+cron, rclone, or Obsidian Sync — obsidian-mcp picks up changes automatically via its file watcher.
+
+## Vault Conventions (Customization)
+
+Create `_AI_INSTRUCTIONS.md` in your vault root to teach the AI how your specific vault is organized:
+
+```markdown
+## Structure
+- `Notes/` — evergreen notes and concepts
+- `Projects/` — active and archived projects (tag: #project/active, #project/done)
+- `Journal/` — daily notes (YYYY-MM-DD.md)
+
+## Frontmatter Schema
+- status: active | done | inbox
+- tags: nested with / (e.g. #concept/programming)
+
+## Conventions
+- Link by stem only, never by full path
+- Every note needs a created: date in frontmatter
+```
+
+The server loads this file at startup and sends it to the AI as system instructions. Without it, built-in generic Obsidian syntax guidance is used. The `_AI_INSTRUCTIONS.md` is the right place for everything vault-specific — folder layout, tag schema, naming conventions, and any workflow rules.
+
+## Tool Reference
+
+| Category | Tools |
+|---|---|
+| **Read** | `list_notes`, `read_note`, `search_notes`, `render_note`, `get_note_outline` |
+| **Write** | `write_note`, `patch_note`, `delete_note`, `append_to_note`, `patch_frontmatter`, `manage_tags`, `move_note` |
+| **Folders** | `list_folder`, `create_folder`, `delete_folder`, `rename_folder` |
+| **Query** | `query_notes`, `get_backlinks`, `get_broken_links`, `get_orphans`, `get_link_graph`, `get_vault_stats`, `get_tasks`, `resolve_alias` |
+| **Tags** | `get_notes_by_tag`, `get_tag_tree`, `list_all_tags` |
+| **Periodic** | `get_daily_note`, `get_periodic_note` |
+| **Canvas** | `list_canvases`, `read_canvas`, `write_canvas`, `patch_canvas` |
+| **Kanban** | `read_kanban`, `create_kanban_board`, `add_kanban_card`, `move_kanban_card`, `delete_kanban_card` |
+| **Attachments** | `list_attachments`, `read_attachment`, `add_attachment` |
+| **Templates** | `list_templates`, `create_from_template` |
+
+Full parameter documentation is embedded in the server and shown automatically to connected AI clients.
+
+## Architecture
+
+```
+src/obsidian_mcp/
+├── config.py          # env-based config (VAULT_PATH, READ_ONLY, WRITE_PATHS)
+├── server.py          # FastMCP entry point, tool and resource registrations
+├── domain/
+│   ├── models.py      # Note dataclass (frontmatter, tags, wikilinks, tasks, …)
+│   ├── parser.py      # Markdown parser (YAML frontmatter, wikilinks, block refs, …)
+│   └── index.py       # VaultIndex — alias resolution, backlinks, tag tree, BFS
+├── storage/
+│   ├── filesystem.py  # atomic writes (temp + os.replace), path validation
+│   ├── locking.py     # per-file filelock to prevent concurrent write conflicts
+│   └── watcher.py     # watchdog-based vault change detection (polling fallback)
+└── tools/
+    ├── read.py        # read_note, search_notes, render_note, get_note_outline
+    ├── write.py       # write_note, patch_note, move_note, manage_tags, …
+    ├── query.py       # graph tools, task aggregation, periodic notes, query_notes
+    ├── folders.py     # folder management
+    ├── canvas.py      # Obsidian Canvas (.canvas JSON) tools
+    ├── kanban.py      # Obsidian Kanban plugin tools
+    ├── attachments.py # binary and text attachment handling
+    └── templates.py   # template rendering with variable substitution
+```
+
+## Development
+
+```bash
+uv run pytest                  # run tests (238 tests)
+uv run ruff check src/ tests/  # lint
+```
+
+## License
+
+MIT