Obsidian Tasks MCP

This is a Go-based MCP server for parsing tasks in Obsidian notes. It supports filtering tasks through query syntax and does not rely on the REST API.

Note-taking tools Knowledge management and memory #Task Management #Obsidian Plugin #MCP Service #Note Parsing .Go

rating : 2.5 points

downloads : 0

update time : 2026-03-12

Open Site

What is Obsidian Tasks MCP Server?

This is an MCP (Model Context Protocol) server specifically designed for the Obsidian note-taking software. It can scan your Obsidian note library, automatically identify and extract all tasks (task lists in the format of the Tasks plugin), and then enable AI assistants (such as Cursor, Claude, etc.) to query and manage these tasks. In simple terms, it acts like a task query translator, allowing AI to understand and operate the task lists you create in Obsidian.

How to use Obsidian Tasks MCP Server?

You just need to install this server and then configure it in an AI tool that supports MCP (such as Cursor) to start using it. After the configuration is complete, you can directly use natural language to ask the AI assistant to query tasks, such as 'Find all tasks due today' or 'Show all tasks with the #urgent tag'.

Use Cases

1. **Task Query and Management**: Let the AI assistant help you find, filter, and organize tasks in Obsidian. 2. **Intelligent Task Reminders**: Query tasks that are due soon or have already expired. 3. **Task Statistical Analysis**: Analyze task distribution by tags, status, and other dimensions. 4. **Cross-note Task Integration**: View all tasks from multiple note libraries in a unified manner.

Main Features

Native Task Parsing

Directly parse the task syntax in Obsidian markdown files without relying on the REST API of the Tasks plugin. It provides faster and more stable responses.

Full Query Syntax Support

Supports the core query syntax of the Obsidian Tasks plugin, including common functions such as status filtering, date filtering, and tag queries.

Multi-note Library Support

It can scan multiple Obsidian note libraries simultaneously and query all tasks in these libraries in a unified manner, which is suitable for users managing multiple projects.

Standard MCP Protocol

Uses the standard Model Context Protocol and is compatible with all AI tools that support MCP, such as Cursor and Claude Desktop.

Lightweight Go Implementation

Written in Go language and compiled into a single executable file. It does not require complex dependencies, is easy to install, and runs efficiently.

Advantages

No network connection required: Runs locally without relying on external API services.

Fast response speed: Directly parses local files and provides instant query responses.

Privacy and security: All data is processed locally and will not be uploaded to the cloud.

Simple configuration: Just specify the note library path to start using.

Good compatibility: Supports all Obsidian notes using the standard Tasks syntax.

Limitations

Limited functionality: Only supports the core query functions of the Tasks plugin and does not support advanced functions such as task editing.

Requires manual configuration: You need to configure the MCP server in the AI tool.

Query-only: Currently only provides query functions and cannot directly modify tasks through AI.

Depends on Tasks syntax: Only recognizes task lists that conform to the syntax of the Tasks plugin.

How to Use

Install the Server

Install the Obsidian Tasks MCP server using the Go package manager. If you haven't installed Go, you need to install the Go language environment first.

Configure the AI Tool (Taking Cursor as an Example)

Add the server configuration to the MCP configuration file of Cursor. The configuration file is usually located at ~/.cursor/mcp.json.

Restart the AI Tool

After saving the configuration file, restart Cursor or other AI tools to make the configuration take effect.

Start Querying Tasks

In the AI conversation, use natural language to describe the tasks you want to query, and the AI will automatically call the MCP server to get the results.

Usage Examples

Query Today's To-do List

Check all tasks that need to be completed today every morning to help plan the day's work.

Project Task Tracking

Track all tasks of a specific project to understand the project progress and to-do list.

Weekly Task Review

Review completed and incomplete tasks every week for work summary and next week's planning.

Urgent Task Handling

Quickly locate urgent tasks that need to be handled immediately to avoid missing important matters.

Frequently Asked Questions

Do I need to install the Obsidian Tasks plugin?

Which query syntaxes are supported?

Can I query multiple note libraries simultaneously?

What information does the query result contain?

How can I update the task status?

Which AI tools are supported?

Related Resources

GitHub Repository

Project source code and the latest version

Obsidian Tasks Plugin Documentation

Complete reference for the query syntax of the Tasks plugin

Model Context Protocol Official Website

Official documentation and specifications of the MCP protocol

Go Language Installation Guide

Official installation tutorial for the Go programming language

Cursor MCP Configuration Guide

Detailed instructions for configuring the MCP server in Cursor

🚀 Obsidian Tasks MCP Server

A standalone Go MCP server that parses Obsidian tasks from markdown files in your vault and evaluates core Tasks query filters without relying on the REST API.

🚀 Quick Start

This server implements a subset of the query filters from the Obsidian Tasks plugin. For complete query syntax and examples, refer to the Tasks plugin documentation.

📦 Installation

You can install the server in the following ways:

Install via `go install`

go install github.com/hairyhenderson/obsidian-tasks-mcp@latest

Install from source

git clone https://github.com/hairyhenderson/obsidian-tasks-mcp.git
cd obsidian-tasks-mcp
go install .

💻 Usage Examples

Basic Usage

The server runs over stdin/stdout and communicates using the MCP protocol. You can specify one or more root directories as command-line arguments:

obsidian-tasks-mcp -root /path/to/vault -root /path/to/other/vault

MCP Tool: `query_tasks`

The server provides a single MCP tool query_tasks with the following input parameters:

query (string, optional): A Tasks query string with filters (one filter per line). Refer to the Tasks plugin query documentation for supported filters and syntax.
rootDirs (array of strings, required): Root directories to scan for markdown files

It returns an array of task objects with id, description, status, filePath, lineNumber, tags, and dueDate fields.

Configuration for Cursor

You can add the following configuration to your Cursor MCP settings (usually ~/.cursor/mcp.json or similar):

Single root directory

{
  "mcpServers": {
    "obsidian-tasks": {
      "command": "obsidian-tasks-mcp",
      "args": [
        "-root",
        "/path/to/your/obsidian/vault"
      ]
    }
  }
}

Multiple root directories

{
  "mcpServers": {
    "obsidian-tasks": {
      "command": "obsidian-tasks-mcp",
      "args": [
        "-root",
        "/path/to/vault1",
        "-root",
        "/path/to/vault2"
      ]
    }
  }
}