Obsidian

Implements a Python-based MCP server that launches as a subprocess and communicates with MCP clients (Claude Desktop) via stdio, translating high-level tool requests into structured MCP protocol messages. The server registers 13 tools dynamically, handles request routing through call_tool and list_tools handlers, and manages the full MCP lifecycle including initialization and tool discovery without requiring direct file system access to Obsidian vaults.

Implements file reading capability by translating MCP tool requests into HTTP GET calls to Obsidian's REST API vault/read endpoint, parsing JSON responses containing file metadata and content, and returning formatted text content to the client. Supports reading any file type stored in the vault (markdown, JSON, images as base64) with automatic error handling for missing files and permission issues.

Implements the MCP server using Python's asyncio framework with async/await syntax, enabling non-blocking I/O for HTTP requests to Obsidian's REST API. The implementation uses async context managers for resource cleanup and async generators for streaming responses, allowing the server to handle multiple concurrent client requests without blocking.

Implements file listing capability by querying Obsidian's REST API vault/list endpoint to retrieve directory contents with file metadata (size, type, modification date). The implementation supports recursive directory traversal and filtering by file type, enabling clients to explore vault structure and discover files without direct file system access.

Implements tag-based filtering by parsing note frontmatter and content to extract tags, then filtering notes by tag matches. The implementation supports both YAML frontmatter tags and inline tag syntax (#tag), enabling clients to discover notes by topic without full-text search.

Implements link traversal capability by parsing note content to extract wiki-style links ([[note-name]]) and backlinks, enabling clients to navigate the knowledge graph and discover related notes. The implementation builds a link graph by analyzing note content and provides methods to traverse forward links (outgoing) and backlinks (incoming).

Implements file writing capability by translating MCP tool requests into HTTP POST calls to Obsidian's REST API vault/write endpoint, supporting both full file replacement and targeted content patching via search-and-replace operations. The implementation validates file paths, handles encoding for text and binary content, and provides atomic write semantics through Obsidian's internal file handling.

Implements search capability by translating MCP tool requests into HTTP POST calls to Obsidian's REST API vault/search endpoint with query parameters, returning ranked lists of matching files with excerpt snippets and relevance scores. The implementation supports boolean operators, phrase matching, and field-specific searches (title, content, tags) through Obsidian's native search syntax.

Implements periodic notes capability by querying Obsidian's REST API for notes matching periodic note naming conventions (daily, weekly, monthly, yearly notes) based on date parameters. The implementation translates date inputs into note paths using Obsidian's configurable periodic note naming format, retrieves matching notes, and returns their content with date metadata.

Implements change tracking capability by querying Obsidian's REST API for recently modified files, filtering by modification timestamp and returning a chronologically sorted list of changed files with metadata. The implementation enables time-window based queries (e.g., 'files changed in last 24 hours') without requiring external change logs or file system monitoring.

Implements a dedicated Obsidian class that manages HTTP communication with Obsidian's Local REST API, handling authentication via API key headers, request/response serialization, error parsing, and retry logic. The client abstracts HTTP details from tool handlers, providing typed methods for each REST endpoint (read, write, search, etc.) with consistent error handling and response normalization.

Implements a base ToolHandler class that all 13 tools inherit from, defining a consistent interface for tool execution (execute method), argument validation, and response formatting as TextContent objects. The pattern enables rapid tool development by providing common utilities for error handling, logging, and MCP response formatting while allowing each tool to focus on business logic.

Implements a tool registration system in the MCP server that dynamically discovers all ToolHandler subclasses at startup, registers them with the MCP server, and exposes them through the list_tools and call_tool handlers. The implementation uses Python's introspection to automatically generate tool schemas from handler class definitions, eliminating manual schema maintenance.

Implements configuration management through environment variables (OBSIDIAN_VAULT_NAME, OBSIDIAN_REST_API_KEY) loaded via python-dotenv, enabling secure credential storage and vault selection without hardcoding. The implementation supports .env file loading for local development and environment variable injection for production deployments (Claude Desktop config).