MCP Tools

17 tools, one protocol

Everything your AI needs to understand your codebase.

Tool Reference

Detailed documentation for each MCP tool

search_code

Semantic code search by meaning

Free

What It Does

Semantic code search that finds code by meaning rather than exact keyword matches. Instead of searching for "auth_handler", you can ask "where do we handle JWT validation?" and get the relevant files—not just string matches.

Why You'd Use It

Know what you want but not the exact filename or function name? Semantic search understands code semantics, not just text. Perfect for exploring unfamiliar codebases or finding implementation patterns.

Benefits

  • Faster file discovery in large codebases
  • Understands code semantics, not just text matches
  • ~50ms typical query time with indexed codebase

Example Usage

> search_code "where is our auth middleware?"

index_codebase

Index your codebase for semantic search

Free

What It Does

Builds a searchable vector index of your entire codebase. Once indexed, semantic queries return results in ~50ms instead of scanning every file on each search.

Why You'd Use It

This is the one-time setup that enables fast semantic search. Without indexing, every search would scan your entire codebase. With it, searches are instant.

Benefits

  • Enables ~50ms semantic queries
  • One-time setup, ongoing value
  • Local-first: your code stays on your machine

Example Usage

> index_codebase /path/to/project

index_stats

View indexing statistics and health

Free

What It Does

Displays indexing statistics and health metrics: file count, chunk sizes, last update time, index size, and any errors during indexing.

Why You'd Use It

Transparency into the indexing process. Helps diagnose why certain files might not appear in search results or if there are issues with your index.

Benefits

  • See what's been indexed and when
  • Diagnose indexing issues quickly
  • Monitor index health over time

Example Usage

> index_stats

token_stats

Track and optimize token usage

Pro

What It Does

Tracks token usage across queries. Shows how many tokens are being used per query, how much context is being injected, and calculates potential savings from context optimization.

Why You'd Use It

Understand the ROI of context optimization. See exactly how many tokens you're saving with semantic search versus naive approaches.

Benefits

  • Quantify cost savings from context optimization
  • Identify queries with high token usage
  • Make informed decisions about context budget

Example Usage

> token_stats --last 10

session_continue

Resume sessions with full context

Pro

What It Does

Resumes sessions with full context memory—brings back what was discussed, what files were examined, and what was learned in previous conversation turns.

Why You'd Use It

AI tools typically lose context between sessions. This preserves the knowledge from your work session so you don't have to re-explain your codebase every time.

Benefits

  • Continuity across work sessions
  • No need to re-explain context each session
  • Pick up exactly where you left off

Example Usage

> session_continue --session-id abc123

session_summary

Generate session activity summaries

Pro

What It Does

Generates summaries of session activity: what files were read, what was discussed, what was modified, and key decisions made during the session.

Why You'd Use It

Get a quick overview of what happened in a work session. Perfect for onboarding to resume work, or sharing context with teammates.

Benefits

  • Quick session recap
  • Share session context with teammates
  • Faster onboarding to resume work

Example Usage

> session_summary --session-id abc123

register_edit

Track file edits for context coherence

Pro

What It Does

Tracks file edits for context coherence. When you edit a file, this tool updates the system's awareness so search results remain accurate.

Why You'd Use It

After making code changes, your index may become stale. Registering edits keeps the context aware of changes without manual re-indexing.

Benefits

  • Keeps search results accurate after changes
  • No manual re-indexing required
  • Automatic context refresh

Example Usage

> register_edit --file src/auth.py

graph_neighbors

Explore code dependencies and connections

Pro

What It Does

Explores code dependencies and connections—shows what imports what, what calls what, and the relationships between files and modules in your codebase.

Why You'd Use It

Understand the relationships in your codebase at a glance. When editing a core module, see everything that depends on it before making changes.

Benefits

  • Visualize code relationships
  • Find all dependencies before refactoring
  • Understand module boundaries

Example Usage

> graph_neighbors --file src/core/utils.py

graph_impact

Analyze blast radius of code changes

Pro

What It Does

Analyzes the "blast radius" of proposed code changes—shows how many files might be affected downstream if you make a particular change.

Why You'd Use It

Before refactoring, understand the scope of impact. Make informed decisions about whether a change is safe, or what else needs updating.

Benefits

  • Understand change impact before refactoring
  • Make informed refactoring decisions
  • Identify risk surface before large changes

Example Usage

> graph_impact --file src/core/config.py

index_obsidian

Index an Obsidian vault for semantic retrieval

Pro

What It Does

Indexes all .md notes in an Obsidian vault using PyckLM embeddings. The indexed notes become searchable via search_code, letting any MCP client query your personal knowledge base alongside code.

Why You'd Use It

Find design decisions, meeting notes, and architecture docs by meaning — without leaving your editor. Your Obsidian vault becomes part of your code context.

Benefits

  • Cross-searches code + personal knowledge
  • Automatically skips system directories (.obsidian, attachments, .trash)
  • Reports note count and chunk count on completion

Example Usage

> index_obsidian "/Users/me/vault"

index_notion

Index a Notion database or page for semantic queries

Pro

What It Does

Exports a Notion database or page to markdown via the Notion API, then indexes the content with PyckLM. Supports single pages, full databases (up to 500 pages), and nested content up to 5 levels deep.

Why You'd Use It

Query your Notion project specs, onboarding docs, and product requirements by natural language directly from your AI editor. Keep product context in sync with code.

Benefits

  • Requires a Notion integration token (from notion.so/my-integrations)
  • Handles all block types (code, callouts, toggles, todos, lists)
  • Force re-indexes every run for fresh content

Example Usage

> index_notion --token "secret_xxx" --database-id "abc123"

index_git_history

Query commit history with natural language

Pro

What It Does

Indexes git commit messages, diffs, and co-change patterns from any local repository. Commits are stored alongside code chunks and fully searchable via search_code.

Why You'd Use It

Find when a bug was introduced, discover which files change together, or recall what work touched a specific area — without git blame archaeology.

Benefits

  • Indexes up to 500 commits by default (configurable)
  • Co-change extraction reveals implicit file coupling
  • Fully compatible with standard search_code queries

Example Usage

> index_git_history "/home/user/myrepo" --max-commits 200

auto_context

Model-agnostic prompt routing for any MCP client

Pro

What It Does

The editor-side equivalent of Pyckle's Claude Code hook. Given a user prompt, it decides whether code context is needed and injects the most relevant chunks — automatically. Works in Cursor, Windsurf, Continue, VS Code, and Zed.

Why You'd Use It

Pyckle's automatic context injection without needing Claude Code or a hook. Any MCP-compatible editor gets the same intelligence as Claude Code users.

Benefits

  • Filters out greetings and confirmations (no wasted API calls)
  • Session-aware: boosts recently-touched files automatically
  • Token-budget capped so context always fits within model limits

Example Usage

> auto_context "how does the payment webhook handler work?"

autoloop_init

Start an autonomous goal-directed iteration session

Pro

What It Does

Initializes a structured improvement loop with a measurable goal. Stores the loop state (goal, metric command, scope, baseline) locally so Pyckle can track progress across many iterations.

Why You'd Use It

Autonomous optimization of any metric — test coverage, benchmark score, bundle size, error rate — with a full audit trail of what was tried and what worked.

Benefits

  • Persists to ~/.pyckle-mcp/loops/ for durability across sessions
  • Sets a baseline metric before any changes begin
  • Supports higher_is_better and lower_is_better directions

Example Usage

> autoloop_init "/repo" "improve test coverage" "pytest --co -q | tail -1" higher_is_better

autoloop_log

Record an iteration result — keep, discard, or crash

Pro

What It Does

Appends an iteration entry to the active loop's JSONL log. Tracks the metric value, commit hash, status, and description for every attempt, updating the running best automatically.

Why You'd Use It

Maintain a structured record of which changes improved the metric and which didn't — essential for autonomous iteration loops and post-analysis audits.

Benefits

  • Auto-updates current_best on keep status
  • Tracks K/D/C (keep/discard/crash) counts per loop
  • Delta vs baseline shown on every log entry

Example Usage

> autoloop_log 3 "a1b2c3d" 87.4 keep "added test for edge case"

autoloop_status

Get live progress and metrics for an active loop

Pro

What It Does

Returns a markdown summary of a loop's current state: baseline → best improvement, keep/discard/crash counts, and a table of recent iterations with metrics and statuses.

Why You'd Use It

Check how an autonomous session is performing mid-run, or audit results before deciding to continue, pause, or stop the loop.

Benefits

  • Shows last N iterations as a markdown table (configurable)
  • Computes signed delta for every entry vs baseline
  • Reflects current best and progress direction at a glance

Example Usage

> autoloop_status --last-n 10

autoloop_history

List all autoloop sessions for a codebase

Pro

What It Does

Lists every autoloop session run against a given codebase, sorted by most recent first. Shows goal, status, baseline-to-best improvement, and iteration counts for each loop.

Why You'd Use It

Review past autonomous sessions, compare outcomes across different optimization goals, or resume a previous loop from where it left off.

Benefits

  • Sorted by most recent first for quick review
  • Shows baseline→best delta per session and total iterations
  • Includes K/D/C (keep/discard/crash) summary for each loop

Example Usage

> autoloop_history "/home/user/myrepo"

Unlock all tools

Free tier includes core search and indexing. Upgrade to Pro for session memory, dependency graphs, autoloop, and more.