AutoGineer
Generated banner for Semantic Notes Vault MCP
Generated logo for Semantic Notes Vault MCP

Semantic Notes Vault MCP

Memory server

Created by Aaron Bockelie

Published in aaronsb/obsidian-mcp-plugin. Publisher page

468 GitHub stars

What it is

Read, write, search, and traverse your vault from Claude Desktop and any AI assistant — via a built-in MCP server, no external server to run.
— the description by Aaron Bockelie

AutoGineer overview, from the brain’s own files

Semantic Notes Vault MCP transforms your Obsidian vault into a persistent, intelligent memory layer for AI agents. By running an MCP server directly within the Obsidian application, it eliminates the need for external processes or complex API bridges. The plugin exposes eight tool families that allow AI assistants to perform comprehensive vault operations, including file management, graph traversal, and semantic search. It is designed to respect user-defined security permissions, ensuring that AI interactions remain within controlled boundaries while enabling deep, context-aware knowledge synthesis.

How it works

Memory model: Knowledge graph

AutoGineer overview, from the brain’s own files

The plugin functions as a built-in Model Context Protocol (MCP) server inside Obsidian. It uses a direct Obsidian API integration to read, write, and traverse your notes. It organizes your data into a knowledge graph, allowing AI to navigate links, tags, and backlinks. The system includes a security layer for path validation and permissions, and it supports Dataview queries and database views for advanced data retrieval.

Folders
FolderRoleFiles
.githubagent-config11
docsdocs34
scriptsscripts9
srcsource-code79
teststests74
wikiwiki1
.claude-githubfolder2
mcpbfolder2

The agent reads

The agent writes

Requirements

Apps: Obsidian

Runtimes: Node.js

API keys (by name): YOUR_API_KEY

Works with: Claude Code, OpenCode

Set it up

  1. This brain runs code automatically: 1 plugin code item (obsidian), 1 script. Review Makefile, manifest.json before opening the folder in Claude Code. No step below turns a hook on for you.

    • Makefile: npm install
    • manifest.json: runs inside Obsidian once the plugin is enabled
  2. Download main.js, manifest.json and styles.css of release 0.13.0: https://github.com/aaronsb/obsidian-mcp-plugin/releases/tag/0.13.0

  3. Check main.js against the SHA-256 AutoGineer recorded:

    curl -fsSLO https://github.com/aaronsb/obsidian-mcp-plugin/releases/download/0.13.0/main.js && shasum -a 256 main.js  # expect 47da0b5aa8880e21d50bb7c883c976d8563d19694620ae8f3a3f84ead28d65b8

  4. Copy the three files into <vault>/.obsidian/plugins/semantic-vault-mcp/ and enable the plugin in Settings → Community plugins.

  5. You will install release 0.13.0, which AutoGineer scanned (main.js SHA-256 47da0b5aa8880e21d50bb7c883c976d8563d19694620ae8f3a3f84ead28d65b8).

  6. Not scanned by AutoGineerObsidian installs the plugin’s current release; AutoGineer scanned release 0.13.0 (2026-11-12). https://obsidian.md/plugins?id=semantic-vault-mcp

  7. Created by Aaron Bockelie. Published in aaronsb/obsidian-mcp-plugin. Licence: MIT License.

Usage

AutoGineer overview, from the brain’s own files

  • Connect Claude Desktop to your Obsidian vault for direct note interaction.
  • Enable AI agents to perform complex research by traversing your note graph.
  • Automate note creation and organization based on existing knowledge structures.
  • Execute Dataview queries via AI prompts to summarize or analyze your vault data.
“What are my recent thoughts on project X?”
The AI searches your vault for notes related to project X and synthesizes your recent entries.
“Find connections between my psychology and philosophy notes”
The AI traverses your knowledge graph to identify shared concepts and bridge notes between the two domains.

Documentation by Aaron Bockelie

Semantic Notes Vault MCP

Image: GitHub stars Image: GitHub forks Image: Downloads Image: Latest Release Image: License

📦 Available in the Obsidian Community Plugin directory →

Read, write, search, and traverse your Obsidian vault from any AI assistant — through an MCP server that runs inside Obsidian.

No external Node process to launch, no separate REST-API plugin to bridge through: the server is the plugin. Setup is a drag-and-drop — drop the .mcpb bundle onto Claude Desktop, paste your key, done.

It exposes 8 powerful tools — each a whole family of operations, not a single call (the vault tool alone handles 13: list, read, create, search, move, split, combine, and more) — with first-class Dataview and Bases support plus graph traversal across links, tags, and backlinks. And every operation respects the permissions you set — a read-only mode, per-operation controls, and path allow/block lists — so the AI only ever does what you've allowed, not unrestricted run of your vault.

Works with any MCP-compatible client — Claude Desktop, Claude Code, Cline, Continue.dev, and anything that speaks local MCP.

New to MCP? The Model Context Protocol is the open standard that lets AI assistants interact with external tools and data. You don't need to understand it to use this — the Quick Start is three steps.

Quick Start

Prerequisites: an MCP-compatible AI client like Claude Desktop, Claude Code, or Continue.dev.

📦 ──drag──▶ 🤖💬

Download the .mcpb bundle from the plugin's config page → drag it onto Claude Desktop → paste your key. Done.

For most people that's the entire setup. The numbered steps below spell it out, then cover other MCP clients.

1. Install the Plugin

Via Obsidian Community Plugins

  • Open Settings → Community plugins → Browse

  • Search for "Semantic Notes Vault MCP"

  • Install and enable — or install straight from the plugin listing

Via BRAT (for beta testing)

  • Install BRAT

  • Add beta plugin: aaronsb/obsidian-mcp-plugin

2. Configure Your AI Client

Three onboarding paths, ordered by audience. All three are also shown in the plugin's Settings tab with copy-ready values.

📦 → 🤖 Claude Desktop — one-click .mcpb install (recommended)

Download obsidian-mcp-<version>.mcpb — either from the plugin's Settings tab (button right on the config page) or the latest release — then either drag it onto the Claude Desktop window or double-click it. Claude Desktop opens an install dialog with two fields — paste the URL and API key shown in the plugin's Settings tab, hit Save, and you're done.

Cross-platform note: .mcpb files install via Claude Desktop's bundled handler. If double-click doesn't trigger Claude on your system, drag the file onto Claude Desktop's window instead, or right-click → "Open with…" and pick Claude Desktop (then "always open with" if your OS asks). Behavior varies by platform: macOS usually auto-associates, Windows may need a one-time association, Linux varies by desktop environment.

Claude Code — one command (copy the ready-made version with your API key from the plugin's Settings tab):

claude mcp add --transport http obsidian http://localhost:3001/mcp --header "Authorization: Bearer YOUR_API_KEY"

For HTTPS, use https://localhost:3443/mcp instead — see Trusting the self-signed certificate below. Claude Code runs on Bun, which does not read the macOS system keychain, so you will need to set NODE_EXTRA_CA_CERTS.

Other MCP clients (Cline, Continue, custom integrations, multi-vault setups)

Add an entry to the client's MCP config file — one entry per vault if you run multiple Obsidian instances on different ports:

{
  "mcpServers": {
    "obsidian-vault": {
      "transport": {
        "type": "http",
        "url": "http://localhost:3001/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_API_KEY"
        }
      }
    }
  }
}

Advanced: custom .mcpb per vault

For multi-vault setups that want one-click install per vault, clone this repo and run the maker:

node scripts/make-mcpb.mjs
# Prompts for display name, URL, and API key
# Outputs obsidian-mcp-<slug>.mcpb with everything pre-filled

Drop the resulting bundle into Claude Desktop and click Install — no fields to type.

Trusting the self-signed certificate

The plugin's HTTPS server uses a self-signed certificate auto-generated on first start and stored under .obsidian/plugins/semantic-vault-mcp/certificates/default.crt inside your vault. MCP clients reject self-signed certificates by default, so you need to explicitly trust it before connecting over HTTPS. Pick the method that matches your client runtime.

macOS Keychain (for clients that use the system trust store — Claude Desktop, browser-based tools, Node with --use-system-ca):

sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain \
  /path/to/vault/.obsidian/plugins/semantic-vault-mcp/certificates/default.crt

NODE_EXTRA_CA_CERTS (required for Claude Code and other Bun-based runtimes):

Bun does not consult the macOS system keychain for TLS trust, so trusting the certificate via Keychain Access alone has no effect — this is almost always the real reason an HTTPS connection from Claude Code fails. Bun only honors certificates listed in NODE_EXTRA_CA_CERTS:

# Point directly at the plugin cert, or append it to an existing CA bundle:
export NODE_EXTRA_CA_CERTS=/path/to/vault/.obsidian/plugins/semantic-vault-mcp/certificates/default.crt

# Propagate to GUI apps launched from the macOS dock (including Claude Code):
launchctl setenv NODE_EXTRA_CA_CERTS /path/to/vault/.obsidian/plugins/semantic-vault-mcp/certificates/default.crt

Re-run these whenever the plugin regenerates its certificate (e.g. after the 1-year validity expires).

Avoid NODE_TLS_REJECT_UNAUTHORIZED=0. It disables TLS verification process-wide — for every HTTPS connection the client makes, not just this plugin — and masks legitimate certificate problems (expired, revoked, tampered). Trust the certificate explicitly instead.

3. Start Using

Once connected, simply chat with your AI assistant about your notes! For example:

  • "What are my recent thoughts on project X?"

  • "Find connections between my psychology and philosophy notes"

  • "Summarize my meeting notes from this week"

  • "Create a new note linking my ideas about Y"

Your AI assistant now has these capabilities:

  • Navigate your vault's link structure

  • Search and rank across all notes

  • Read, edit, and create notes

  • Analyze your knowledge graph

  • Work with Dataview queries (if installed)

  • Manage Obsidian Bases (database views)

Why It's Different

Traditional file access gives AI a narrow view — one document at a time. This plugin gives it the whole connected picture:

  • Graph Navigation: AI follows links between notes, understanding relationships and context

  • Concept Discovery: Search and graph traversal surface related ideas across your vault

  • Contextual Awareness: AI understands where information lives in your knowledge structure

  • Intelligent Synthesis: Combine fragments from multiple notes to answer complex questions

Core Tools

The plugin provides 8 powerful tools that give AI comprehensive vault access — each one a family of related operations, all subject to the permissions you set:

ToolPurposeKey Actions
📁 vaultFile operationslist, read, create, search, move, split, combine
✏️ editContent modificationwindow editing, append, patch sections
👁️ viewContent displayview files, windows, active note
🕸️ graphLink navigationtraverse, find paths, analyze connections
💡 workflowContextual hintssuggest next actions based on state
📊 dataviewQuery notesExecute DQL queries (if installed)
🗃️ basesDatabase viewsQuery and export Bases (if available)
ℹ️ systemVault infoServer status, commands, web fetch (off by default), running allowlisted commands (off by default)

Documentation

Detailed documentation for each tool and feature:

In Practice

This plugin doesn't just give AI access to files — it lets AI work across your vault as a connected whole:

Example: Research Assistant
User: "Summarize my research on machine learning optimization"

AI uses these tools to:
1. Search for notes with ML optimization concepts
2. Traverse graph to find related papers and techniques  
3. Follow backlinks to discover applications
4. Synthesize findings from multiple connected notes
Example: Knowledge Explorer
User: "What connections exist between my notes on philosophy and cognitive science?"

AI uses graph tools to:
1. Find notes tagged with both topics
2. Analyze shared concepts via graph traversal
3. Identify bridge notes that connect domains
4. Map the conceptual overlap

Features

Full-Text Search

  • Advanced query operators: tag:, path:, content:

  • Regular expressions and phrase matching

  • Relevance ranking and snippet extraction

Graph Intelligence

  • Multi-hop traversal with depth control

  • Backlink and forward-link analysis

  • Path finding between concepts

  • Tag-based navigation

Content Operations

  • Fuzzy text matching for edits

  • Structure-aware modifications (headings, blocks)

  • Batch operations (split, combine, move)

  • Template support

Integration

  • Dataview query execution

  • Bases database operations

  • Web content fetching

  • Read-only mode for safety

Plugin Settings

Access settings via: Settings → Community plugins → Semantic Notes Vault MCP

Key configuration options:

  • Server Ports: HTTP (3001) and HTTPS (3443)

  • Authentication: API key protection

  • Security: Path validation and permissions

  • Performance: Connection pooling and caching

Support

License

MIT

docs/bases-implementation.md

Obsidian Bases MCP Implementation Design

Overview

Obsidian Bases is a new core plugin feature (v1.9.0+) that transforms note collections into powerful databases. This document outlines how to integrate Bases support into our MCP server.

Key Bases Concepts

  1. Base Files: .base file format containing database configuration

  2. Views: Different visualizations of data (table, card view, etc.)

  3. Properties: YAML frontmatter fields used as database columns

  4. Formulas: Dynamic calculated properties

  5. Filters: Query mechanisms to subset data

  6. Templates: Automatic note generation with inherited properties

Proposed MCP Operations

New bases Operation Category
operation: 'bases'
actions:
  - list         // List all bases in vault
  - read         // Read base configuration and data
  - create       // Create new base from notes
  - update       // Update base configuration
  - delete       // Delete a base
  - query        // Query base with filters
  - view         // Get specific view of base
  - formula      // Calculate formula values
  - template     // Generate notes from base template
  - export       // Export base data (CSV, JSON)

Implementation Architecture

1. ObsidianAPI Layer Extensions
// New methods in ObsidianAPI class
class ObsidianAPI {
  // Base file operations
  async listBases(): Promise<BaseFile[]>
  async getBase(path: string): Promise<BaseData>
  async createBase(config: BaseConfig): Promise<BaseFile>
  async updateBase(path: string, config: BaseConfig): Promise<void>
  async deleteBase(path: string): Promise<void>
  
  // Base data operations
  async queryBase(path: string, filters: BaseFilter[]): Promise<BaseQueryResult>
  async getBaseView(path: string, viewName: string): Promise<BaseView>
  async calculateFormula(basePath: string, formula: string): Promise<any>
  async generateFromTemplate(basePath: string, template: BaseTemplate): Promise<TFile>
  async exportBase(path: string, format: 'csv' | 'json'): Promise<string>
}
2. Type Definitions
interface BaseFile {
  path: string;
  name: string;
  views: string[];
  properties: BaseProperty[];
  noteCount: number;
  created: number;
  modified: number;
}

interface BaseConfig {
  name: string;
  source: string | string[]; // Folder paths or tags to include
  properties: BaseProperty[];
  views: BaseViewConfig[];
  filters?: BaseFilter[];
}

interface BaseProperty {
  key: string;
  type: 'text' | 'number' | 'date' | 'checkbox' | 'list' | 'formula';
  formula?: string; // For calculated properties
  required?: boolean;
  defaultValue?: any;
}

interface BaseView {
  name: string;
  type: 'table' | 'card' | 'list' | 'calendar';
  columns?: string[]; // For table view
  sortBy?: string;
  groupBy?: string;
  filters?: BaseFilter[];
}

interface BaseFilter {
  property: string;
  operator: 'equals' | 'contains' | 'gt' | 'lt' | 'between' | 'in' | 'not';
  value: any;
}

interface BaseQueryResult {
  notes: BaseNote[];
  total: number;
  page?: number;
  pageSize?: number;
}

interface BaseNote {
  path: string;
  title: string;
  properties: Record<string, any>;
  content?: string; // Optional, for performance
}
3. Semantic Router Integration
// Add to SemanticRouter.executeOperation()
case 'bases':
  return this.executeBasesOperation(action, params);

private async executeBasesOperation(action: string, params: any): Promise<any> {
  switch (action) {
    case 'list':
      return await this.api.listBases();
    case 'read':
      return await this.api.getBase(params.path);
    case 'create':
      return await this.api.createBase(params.config);
    case 'query':
      return await this.api.queryBase(params.path, params.filters);
    case 'view':
      return await this.api.getBaseView(params.path, params.viewName);
    case 'formula':
      return await this.api.calculateFormula(params.basePath, params.formula);
    case 'template':
      return await this.api.generateFromTemplate(params.basePath, params.template);
    case 'export':
      return await this.api.exportBase(params.path, params.format);
    // ... other actions
  }
}
4. Implementation Phases
Phase 1: Read-Only Operations (MVP)

  • List bases in vault

  • Read base configuration

  • Query base data with filters

  • Get different views

Phase 2: Base Management

  • Create new bases

  • Update base configuration

  • Delete bases

  • Export functionality

Phase 3: Advanced Features

  • Formula calculation

  • Template-based note generation

  • Real-time updates

  • Performance optimization with caching

Technical Considerations

1. File Format Handling

  • Parse .base files (likely JSON or YAML format)

  • Handle base file validation

  • Maintain backward compatibility

2. Performance

  • Cache base data for frequent queries

  • Implement pagination for large datasets

  • Use indexes for property-based filtering

3. Integration Points

  • Leverage existing Obsidian vault API

  • Reuse property extraction from frontmatter

  • Integrate with existing search functionality

4. Error Handling

  • Handle missing bases gracefully

  • Validate property types

  • Provide meaningful error messages

Example Usage

List All Bases
{
  "operation": "bases",
  "action": "list"
}
Query Base with Filters
{
  "operation": "bases",
  "action": "query",
  "params": {
    "path": "Projects.base",
    "filters": [
      {
        "property": "status",
        "operator": "equals",
        "value": "active"
      },
      {
        "property": "priority",
        "operator": "in",
        "value": ["high", "critical"]
      }
    ]
  }
}
Create Base from Folder
{
  "operation": "bases",
  "action": "create",
  "params": {
    "config": {
      "name": "Reading List",
      "source": "Books/",
      "properties": [
        { "key": "title", "type": "text", "required": true },
        { "key": "author", "type": "text" },
        { "key": "rating", "type": "number" },
        { "key": "finished", "type": "checkbox" },
        { "key": "pages", "type": "number" },
        { "key": "progress", "type": "formula", "formula": "{{pages_read}} / {{pages}} * 100" }
      ],
      "views": [
        {
          "name": "All Books",
          "type": "table",
          "columns": ["title", "author", "rating", "finished"]
        },
        {
          "name": "Reading Now",
          "type": "card",
          "filters": [
            { "property": "finished", "operator": "equals", "value": false }
          ]
        }
      ]
    }
  }
}

Benefits for MCP Clients

  1. Structured Data Access: Query vault content as databases

  2. Dynamic Views: Get different perspectives on notes

  3. Automation: Generate notes with consistent structure

  4. Export Capabilities: Extract data for external processing

  5. Performance: Optimized queries vs full-text search

Testing Strategy

  1. Unit Tests: Test each ObsidianAPI method

  2. Integration Tests: Test semantic router integration

  3. Performance Tests: Benchmark large base queries

  4. Compatibility Tests: Ensure works with different Obsidian versions

Migration Path

  1. Detect if Bases plugin is available

  2. Provide graceful degradation for older Obsidian versions

  3. Clear feature flags for Bases-specific operations

  4. Documentation for client applications

Next Steps

  1. ✅ Research Bases feature documentation

  2. ✅ Analyze current codebase structure

  3. ✅ Design MCP operations for Bases

  4. ⏳ Implement ObsidianAPI extensions

  5. ⏳ Add semantic router handlers

  6. ⏳ Create comprehensive tests

  7. ⏳ Update documentation

  8. ⏳ Release as beta feature

236 files · 218 not served here

Advantages

  • No external Node process to launch, no separate REST-API plugin to bridge through: the server is the plugin. evidence: README.md
  • Every operation respects the permissions you set — a read-only mode, per-operation controls, and path allow/block lists. evidence: README.md

Limitations

  • MCP clients reject self-signed certificates by default, so you need to explicitly trust it before connecting over HTTPS. evidence: README.md

Security

Risk level: Medium risk

This brain runs

Agent instructions that run or fetch something (42)

  • CLAUDE.md: Test locally with `npm run build`
  • CLAUDE.md: Click **Run workflow**
  • CLAUDE.md: Click **Run**
  • CLAUDE.md: git tag -d X.Y.Z && git push origin :refs/tags/X.Y.Z · uses the network
  • CLAUDE.md: Users install via: `aaronsb/obsidian-mcp-plugin` in BRAT
  • CLAUDE.md: **Pre-releases**: All releases ship as prereleases by default (`make release-patch` etc.)
  • CLAUDE.md: **Promoting to stable**: When a release is bounded and proven, run `make promote` (or `make promote TAG=X.Y.Z`) to flip it from prerelease → stable and mark it as GitHub's "Latest" release.
  • CLAUDE.md: "package": "npm run build && npm run test && node package-release.js"
  • CLAUDE.md: **ALWAYS run these commands before pushing to GitHub:**
  • CLAUDE.md: npm run build
  • CLAUDE.md: # 2. Run linting to ensure code quality
  • CLAUDE.md: npm run lint
  • CLAUDE.md: # 3. Run tests to catch regressions
  • CLAUDE.md: npm test
  • CLAUDE.md: git add -A && git commit -m "..."
  • CLAUDE.md: git push origin main · uses the network
  • CLAUDE.md: npm run build && npm run lint && npm test && echo "✅ All checks passed!"
  • CLAUDE.md: npm supply-chain attacks have been ticking up — malicious package versions get published, ingested by automation, then discovered/yanked days later.
  • CLAUDE.md: The exemption exists because the hold otherwise fights our own freshness goal: it delays exactly the vuln patches that Obsidian's plugin review (and `npm audit`) flag, leaving us knowingly exposed to a *named, real* CVE to guard against a *hypothetical* malicious republish.
  • CLAUDE.md: **Security fix → land it now.** If a dependabot/manual upgrade resolves a flagged vulnerability (dependabot security PR, `npm audit` advisory, or an Obsidian-review dependency warning), merge as soon as it's green regardless of version age.
  • CLAUDE.md: The same split applies to manual `npm install` / `npm update`: security fixes immediately, routine pins to versions older than 7 days.
  • CLAUDE.md: Re-run `npm audit` after each merge batch to see what residual exposure remains.
  • CLAUDE.md: This is not zero-risk — an ESLint plugin executes on the maintainer's machine during `npm run lint`, so the exposure moves from users to the developer rather than disappearing.
  • CLAUDE.md: Install scripts are blocked pending approval (`npm install-scripts ls` shows what is waiting), but that is **npm 12+ default behaviour, not something this repo enforces** — there is no `.npmrc` or `package.json` setting pinning it.
  • CLAUDE.md: Approve install scripts one package at a time and never with `--all`;
  • CLAUDE.md: Consequence: after a plugin is approved/updated on the portal, there is a **propagation lag** before it appears in the in-app browser search — the mirror bot has to run, then the app refreshes its cached list (a restart helps *only after* the mirror includes you).
  • CLAUDE.md: `make promote` now auto-updates **real users**, not just BRAT testers.
  • CLAUDE.md: `versions.json` must contain a `"<version>": "<minAppVersion>"` entry matching `manifest.json` (`make release-*` maintains this).
  • CLAUDE.md: Run `make promote` to flip the proven release to stable + "Latest".
  • CLAUDE.md: The developer portal offers a **"preview a branch scan"** that accepts a branch, tag, or commit SHA — use it to confirm a release candidate passes Obsidian's checks *before* running `make promote`.
  • CLAUDE.md: Treat it as a validation/dry-run tool: end-user installs and updates still come from the matching stable release tag's assets, not from a scanned branch.
  • CLAUDE.md: make scorecard # prose + freshness delta, for reading
  • CLAUDE.md: node scripts/scorecard.mjs --json # one JSON line, for diffing across releases
  • CLAUDE.md: The **dependency** scan *does* run, so treat a regression there as real, not a disclosure.
  • CLAUDE.md: The portal scan and local `npm audit` **can diverge**, and the local audit is the leading indicator — it sees advisories published since the last portal scan.
  • CLAUDE.md: Re-run `npm audit` before reading a portal result as current.
  • CLAUDE.md: **`npm audit --omit=dev` is the number that gates a release.** Anything it reports reaches users through `main.js`.
  • CLAUDE.md: **If that is zero, the bare count is not a release problem.** Confirm the remainder is dev-only rather than assuming it: `npm ls <pkg> --omit=dev` shows whether a package is in the production tree at all, and a production copy can sit *outside* an advisory's range while an older nested …[+41 chars]
  • CLAUDE.md: Plain `npm audit fix` (lockfile-only, no `package.json` change) is the tool for this job.
  • CLAUDE.md: When ours lags, `npm run lint` passes while the portal reports warnings we cannot reproduce — findings then arrive *after* a release is already cut.
  • CLAUDE.md: node -e "console.log(require('eslint-plugin-obsidianmd/package.json').version)"
  • CLAUDE.md: npm view eslint-plugin-obsidianmd version

Install scripts (1)

  • Makefile (make install): npm install

Plugin code (1)

  • manifest.json: runs inside Obsidian once the plugin is enabled
  • Medium risk: runs-instruction-instruction-network (CLAUDE.md:136)
  • Medium risk: runs-instruction-instruction-network (CLAUDE.md:202)
  • Low risk: scripts-present (esbuild.config.mjs)
  • Low risk: scripts-present (scripts/build-mcpb.mjs)
  • Low risk: scripts-present (scripts/scorecard-findings.mjs)
  • Low risk: scripts-present (scripts/scorecard.mjs)
  • Low risk: scripts-present (src/formatters/dataview.ts)
  • Low risk: scripts-present (src/formatters/graph.ts)
  • Low risk: scripts-present (src/formatters/index.ts)
  • Low risk: scripts-present (src/formatters/search.ts)
  • Low risk: scripts-present (src/formatters/system.ts)
  • Low risk: scripts-present (src/formatters/utils.ts)
  • Low risk: scripts-present (src/formatters/vault.ts)
  • Low risk: scripts-present (src/formatters/view.ts)
  • Low risk: scripts-present (src/indexing/adaptive-index.ts)
  • Low risk: scripts-present (src/indexing/fragment-retriever.ts)
  • Low risk: scripts-present (src/indexing/proximity-index.ts)
  • Low risk: scripts-present (src/indexing/semantic-chunk-index.ts)
  • Low risk: scripts-present (src/main.ts)
  • Low risk: scripts-present (src/mcp-server.ts)
  • Low risk: scripts-present (src/plugin-settings.ts)
  • Low risk: scripts-present (src/security/http-auth.ts)
  • Low risk: scripts-present (src/security/index.ts)
  • Low risk: scripts-present (src/security/mcp-ignore-manager.ts)
  • Low risk: scripts-present (src/security/path-validator.ts)
  • Low risk: scripts-present (src/security/safe-fetch.ts)
  • Low risk: scripts-present (src/security/secure-obsidian-api.ts)
  • Low risk: scripts-present (src/security/url-validator.ts)
  • Low risk: scripts-present (src/security/vault-security-manager.ts)
  • Low risk: scripts-present (src/semantic/operations/bases.ts)
  • Low risk: scripts-present (src/semantic/operations/edit.ts)
  • Low risk: scripts-present (src/semantic/operations/graph.ts)
  • Low risk: scripts-present (src/semantic/operations/router-context.ts)
  • Low risk: scripts-present (src/semantic/operations/shared.ts)
  • Low risk: scripts-present (src/semantic/operations/system.ts)
  • Low risk: scripts-present (src/semantic/operations/vault.ts)
  • Low risk: scripts-present (src/semantic/operations/view.ts)
  • Low risk: scripts-present (src/semantic/operations/workflow.ts)
  • Low risk: scripts-present (src/semantic/router.ts)
  • Low risk: scripts-present (src/semantic/state-tokens.ts)
  • Low risk: scripts-present (src/tools/dataview-tool.ts)
  • Low risk: scripts-present (src/tools/fetch.ts)
  • Low risk: scripts-present (src/tools/graph-search-tag-traversal.ts)
  • Low risk: scripts-present (src/tools/graph-search-tool.ts)
  • Low risk: scripts-present (src/tools/graph-search-traversal.ts)
  • Low risk: scripts-present (src/tools/graph-search.ts)
  • Low risk: scripts-present (src/tools/graph-tag-tool.ts)
  • Low risk: scripts-present (src/tools/semantic-tools.ts)
  • Low risk: scripts-present (src/tools/window-edit.ts)
  • Low risk: scripts-present (src/types/bases-yaml.ts)

The plugin you install is release 0.13.0, which AutoGineer scanned.

Attribution and licence

Created by
Aaron Bockelie
Declared authors
  • Aaron Bockelie (declared in package.json)
  • Aaron Bockelie (declared in manifest.json)
Publisher
Aaron Bockelie (Community)
Source
aaronsb/obsidian-mcp-plugin · commit 103ee96
Licence
MIT License (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Aaron Bockelie.

Install from source

218 of its files are not served here, so there is no ZIP. aaronsb/obsidian-mcp-plugin at 103ee96