Token Optimizer MCP

Clear all cached data. Use with caution.

Verify external grader evidence, then propose and activate evidence-backed cognition authored by the active model. Use operation=verify-evidence before recording unfamiliar evidence.

Compress text using Brotli, returned as a base64 string. Intended for AT-REST STORAGE/caching (reduces bytes ~50%). NOTE: base64 tokenizes poorly, so the output usually has MORE LLM tokens than the input — do NOT feed the result into a model context expecting savings. The response includes originalTokens/compressedTokens and a warning when the output would increase tokens.

Compute a unified-diff delta for a file in a given session so the model only sees changes since the last snapshot. Operations: compute-delta, seed, clear.

Obtain bounded decision-specific cognition. Returns an explicit empty result when nothing safe applies.

Verify that one adapter-delivered context receipt and its correction trace to authenticated external grader evidence.

Count tokens in text using the pluggable tokenizer framework (#124). Picks a model-specific tokenizer (tiktoken for GPT/Claude, Google AI REST for Gemini, content-aware heuristic fallback).

Create and manage custom dashboard widgets with an unmeasured design target of 88% token reduction through template caching and configuration compression

Create and manage interactive data visualizations with an unmeasured design target of 92% token reduction through SVG/Canvas optimization and configuration caching

Decompress base64-encoded Brotli-compressed text.

Retrieve the full output behind a preview reference, served from the local store rather than by re-running anything. Pass `section` to say which named part of the preview you needed -- that is what teaches the next preview to keep it. Pass `claim` and `anchor` to record what you learned, so the same expansion never happens again.

Export all analytics data in JSON or CSV format. Supports filtering by date range, hook phase, tool name, and MCP server. Useful for external analysis, reporting, and data integration.

Look across every project on this machine at once: which projects hold the cost (ranked with dollar figures), which fixes proven in one project apply to others containing the SAME FILE CONTENTS, and how enforcing clients compare with directive ones as a natural experiment (reported with its confound). Reads transcripts and graphs locally, uploads nothing, and names every directory it opened. Use dryRun=true to see what it would read before it reads anything; mode="explicit" with `projects` to scan only what you name.

Get detailed token usage analytics broken down by tool/action (Read, Write, Grep, Bash, count_tokens, etc.). Shows which tools consume the most tokens and identifies optimization opportunities for specific operations.

Get cache statistics including hit rate, compression ratio, and token savings.

Retrieve previously cached and optimized text. Returns the original text if found in cache.

Get detailed token usage analytics broken down by hook phase (PreToolUse, PostToolUse, SessionStart, PreCompact, UserPromptSubmit). Shows which hook phases consume the most tokens and where optimization efforts should be focused.

Get detailed token usage analytics broken down by MCP server (token-optimizer, filesystem, github, etc.). Shows which MCP servers are contributing the most to token usage and helps identify cross-server optimization opportunities.

Get a provenance-gated token report. Verified savings require a materialized MCP payload before and after optimization; historical and tool-reported estimates are excluded. Direct API-price equivalents use each exact captured model and route; ambiguous operations remain unpriced.

Get comprehensive statistics from the PowerShell wrapper session tracker including system reminders, tool operations, and total tokens with accurate tiktoken-based counting.

Retrieve the original, uncompressed content for a compression marker. Call this when you need the full data behind a <<ccr:...>> marker.

Monitor system and application health with an unmeasured design target of 91% token reduction through health state compression and metric aggregation

Monitor health status of systems, services, and applications with dependency tracking. Supports 8 operations: check, register-check, update-check, delete-check, get-status, get-history, configure-dependencies, get-impact. Achieves 87% token reduction through status caching and dependency graph compression.

Check that this installation actually works. Runs the real hook binaries with synthetic payloads and asserts a large read is refused and a small one is not, that session-start emits the policy, and that the graph directory is writable and private -- rather than checking that config files exist, which can pass while the plugin saves nothing. Every failure names its fix. Pass uninstallPlan=true to see exactly what a removal would delete and what it would refuse to touch.

Answers questions from a document corpus the caller supplies, quoting sentences with the id of the document they came from. Ranks by an idf cosine, reports the question terms the corpus does not contain, and refuses rather than composing an answer it cannot quote.

Build a directed graph of entities and relations you supply, then query it by pattern, find paths between nodes, detect communities, rank nodes, infer relations, visualize it, merge two graphs, or export it. The graph is held in the cache between calls, so a query does not have to resend the entities. This is a general-purpose graph over data you provide; it does not read your codebase.

List every file path in the repository.

List files in the isolated evaluation workspace. Returns relative paths and byte sizes.

Interactive log analysis dashboard with filtering, searching, pattern detection, and an unmeasured design target of 90% token reduction through intelligent caching and compression

Comprehensive metrics collection and aggregation with multi-source support, time-series compression, and an unmeasured design target of 88% token reduction through delta encoding and intelligent caching

Which model tier this project's work actually goes better on, measured from episode outcomes in the client transcript rather than guessed from task size. Reports expected cost per tier including retries, and prices BOTH mistakes: what an overpowered model wastes and what an underpowered one costs in retries. Pass `shape` (multi-file-change, single-file-change, investigation, build-or-test, conversation) and `currentModel` for a decision note that also states what switching would cost in discarded prompt cache.

External monitoring platform integration with an unmeasured design target of 87% token reduction through data compression and intelligent caching

Parse, translate, optimize and validate queries written in a published restricted grammar, and describe a result set against the query that produced it

Persist and retrieve brotli-compressed optimization results keyed by text hash. Operations: store, retrieve.

Analyzes operations in the current session from the session JSONL log, identifies large text blocks from file-based tools (Read, Write, Edit), compresses them, and stores them in the cache to reduce future token usage. Returns a summary of the optimization.

Compress and cache text to reduce token usage. Returns compressed version and saves to cache for future use.

Record correctness-first task outcome and deterministic grader evidence.

Frequency, clustering, correlation, sequence and trend analysis over event and metric arrays you supply

Tracks and analyzes performance metrics (CPU, memory, response times, throughput) with advanced statistical capabilities. Supports 8 operations: track, query, analyze-trends, forecast, compare, detect-regressions, get-baseline, generate-report. Achieves 89%+ token reduction through intelligent caching and data aggregation.

ML-based predictive caching with an unmeasured design target of 91%+ token reduction using ARIMA, exponential smoothing, LSTM, and collaborative filtering

Least-squares fitting, forecasting, anomaly detection and prediction scoring over numeric series you supply

Read a file by absolute path, optionally selecting a line range.

Read one file from the repository.

Item-based collaborative filtering, workflow transition analysis, proportional allocation and config trial comparison over records you supply

Score the sentiment of text you supply -- logs, review comments, issue threads, survey answers -- and derive emotions, topics, a feedback classification, a trend over timestamped samples, or a comparison between two sets. Scoring is lexicon-based and runs locally; results are cached so a second pass over the same text is free.

Execute HTTP requests with intelligent caching and retry logic. Features: - Automatic retry with exponential backoff (1s, 2s, 4s, 8s) - Response caching with TTL-based invalidation (default: 5 minutes) - Request deduplication for in-flight requests - Circuit breaker pattern (opens after 5 consecutive failures) - ETag/Cache-Control header support - 83% average token reduction through intelligent output formatting Token Reduction Strategy: - Cached responses: 95% reduction (summary only) - Error responses: 90% reduction (error details only) - Retried requests: 85% reduction (success summary wi…

Perform structural code search with an unmeasured design target of 83% token reduction through AST indexing and caching

List and manage git branches with an unmeasured design target of 60% token reduction through structured JSON output and smart filtering

Run TypeScript build with intelligent caching, diff-based change detection, and token-optimized output

Advanced multi-tier cache with an unmeasured design target of 90%+ token reduction, 6 eviction strategies, stampede prevention, and automatic tier management

API Response Caching with 83% token reduction through intelligent cache management. Features: - Multiple caching strategies (TTL, ETag, Event-based, LRU, Size-based) - Intelligent cache key generation with query normalization - Pattern-based and tag-based invalidation - Stale-while-revalidate support - Cache hit rate analysis and recommendations - Cache warming and preloading Actions: - get: Retrieve cached API response - set: Cache an API response - invalidate: Remove cached entries (pattern/tag/manual) - analyze: Get cache performance metrics - warm: Pre-cache specific endpoints Token Red…

Analyze code complexity metrics including cyclomatic, cognitive, Halstead, and maintainability index. Measured token reduction vs reading the file: 31-73% first read, 31-73% repeated (bench/tools, 3 fixtures).

Read and parse configuration files (JSON, YAML, TOML) with schema-aware caching and intelligent diffing. Measured token reduction vs reading the file: 18-30% first read, 84-99.3% repeated (bench/tools, 2 fixtures) -- a first read pays little, because it returns the parsed config as well as what is wrong with it: 30% on a minimal package.json and 18% on a 5,198-token one; the saving is on the repeat, where an unchanged file is answered with a diff rather than its contents.

Intelligent scheduled task management with smart caching (unmeasured design target: 85%+ token reduction). Manage cron jobs (Linux/macOS) and Windows Task Scheduler with validation, history tracking, and next run predictions.

Database query optimizer with connection pooling, circuit breaking, and an unmeasured design target of 83% token reduction. Supports query execution, EXPLAIN analysis, performance optimization, health monitoring, slow query detection, and batch operations.

Analyze project dependencies through graph caching and incremental updates. Measured token reduction vs reading the file: 97-99% first read, 97-99% repeated (bench/tools, 2 fixtures) -- it resolves the imports of the files it is pointed at, so a scope matching no source file is refused rather than answered with an empty graph.

Get git diffs with an unmeasured design target of 85% token reduction through diff-only output and smart filtering

Docker operations with build/run/stop/logs support, image layer analysis, and optimization suggestions

Edit files with an unmeasured design target of 90% token reduction through line-based operations and diff-only output

Smart environment variable analyzer with security checking and suggestions. Measured token reduction vs reading the file: -27% to 37% first read, -27% to 37% repeated (bench/tools, 4 fixtures) -- it names every variable without returning any value, which is where the saving comes from; the loss is the other mode, because `includeLocations` adds each line and the length of each value back and costs 32-48% more.

Analyze TypeScript/JavaScript export statements with intelligent caching. Tracks exports, detects unused exports, and provides optimization suggestions. Measured token reduction vs reading the file: 70-98% first read, 70-98% repeated (bench/tools, 3 fixtures).

Search files with glob patterns and an unmeasured design target of 75% token reduction through path-only results and smart filtering

GraphQL query optimizer with complexity analysis and caching (unmeasured design target: 83% token reduction)

Search file contents with an unmeasured design target of 80% token reduction through match-only output and smart filtering

Analyze TypeScript/JavaScript import statements with intelligent caching. Detects unused imports, missing imports, and provides optimization suggestions. Measured token reduction vs reading the file: 92-97% first read, 92-97% repeated (bench/tools, 3 fixtures).

Package installation with dependency analysis, conflict detection, and smart caching for npm/yarn/pnpm

Run ESLint with intelligent caching, incremental analysis, and auto-fix suggestions

Get git commit history with an unmeasured design target of 75% token reduction through structured JSON output and smart filtering

System log aggregation and analysis with multi-source support, pattern filtering, error detection, and insights

Manage git merges with an unmeasured design target of 80% token reduction through structured status and conflict management

Database migration tracker with status monitoring and an unmeasured design target of 83% token reduction. Supports listing migrations, checking status, viewing history, rollback operations, and migration generation.

Network diagnostics and monitoring with connectivity testing, port scanning, DNS resolution, and anomaly detection

ORM query optimizer with N+1 detection (unmeasured design target: 83% token reduction)

Analyze package.json with dependency resolution, version conflict detection, and security scanning. Measured token reduction vs reading the file: -2% to 91% first read, 8-92% repeated (bench/tools, 2 fixtures) -- the loss is on a minimal package.json, the saving on a real one.

Syntax highlighting and code formatting. Supports 50+ languages, ANSI/HTML output, multiple themes, and Prettier integration. Measured token reduction vs reading the file: -2% to 1% first read, -2% to 1% repeated (bench/tools, 3 fixtures) -- both operations hand the code itself back, so there is nothing here to reduce: two fixtures cost 1-2% more than the file, and the third comes back four tokens shorter because Prettier collapsed something. The earlier 94% was an elided payload counted as economy.

Intelligent process management with smart caching (unmeasured design target: 88%+ token reduction). Start, stop, monitor processes with resource tracking and cross-platform support. TRUST BOUNDARY: the "start" operation launches an arbitrary executable of the caller's choosing, with caller-supplied arguments, working directory and environment. It runs in argv mode with no shell, so there is no command injection, but granting this tool is equivalent to granting local command execution as the user running the server. Operators who do not want that should expose smart_processes (read-only monitor…

Monitor and analyze system processes with anomaly detection and resource tracking

Read files with intelligent caching, diff-based updates, and syntax-aware optimization. Measured token reduction vs reading the file: -2% to 0% first read, 99-99.9% repeated on an unchanged file (bench/tools, 3 fixtures) -- a first read returns the file plus a one-field header, so it still costs a little more than reading the file; the saving is on the repeat.

Provides intelligent refactoring suggestions with code examples and impact analysis. Measured token reduction vs reading the file: 2-85% first read, 2-85% repeated (bench/tools, 3 fixtures) -- the floor is the smallest fixture, where 19 findings and a code example for each very nearly outweigh the file they are about: 1,631 tokens of answer against 1,676 of file.

REST API analyzer with endpoint discovery and health scoring (unmeasured design target: 83% token reduction)

Database schema analyzer with intelligent caching and an unmeasured design target of 83% token reduction. Supports PostgreSQL, MySQL, and SQLite. Provides schema introspection, relationship analysis, index recommendations, and schema diff.

Security vulnerability scanner with pattern detection and intelligent caching. Measured token reduction vs reading the file: 23-99% first read, 22-99% repeated (bench/tools, 4 fixtures) -- the three clean fixtures cost a flat 84 tokens each, because a scan that finds nothing says so in the same words whatever it was pointed at; the fourth is the floor, where six findings and a remediation for each are reported against a 597-token file.

Intelligent service management with smart caching (unmeasured design target: 86%+ token reduction). Manage systemd, Windows Services, and Docker containers with health monitoring and dependency tracking.

SQL query analyzer with optimization suggestions and execution plan analysis (unmeasured design target: 83% token reduction)

Get git status with an unmeasured design target of 70% token reduction through status-only output and smart filtering

Extract and analyze TypeScript/JavaScript symbols with scope, type, and reference information. Measured token reduction vs reading the file: 78-95% first read, 78-95% repeated (bench/tools, 3 fixtures).

System resource monitoring with CPU, memory, disk usage tracking, anomaly detection, and performance recommendations

Run the project's tests (Jest, Vitest, Mocha, AVA or node --test) with intelligent caching, coverage tracking, and incremental test execution

Parse and analyze TypeScript configuration. Resolves extends chains, detects issues, and caches results for 7 days. Measured token reduction vs reading the file: 40-92% first read, 40-92% repeated (bench/tools, 3 fixtures) -- it answers what the resolved config is and what is wrong with it, and sends the merge only where there was one: a config that extends nothing is answered with that fact and its suggestions, because the caller already holds the file.

Run TypeScript type checking with intelligent caching and categorized error reporting

Incremental TypeScript compilation with dependency tracking and intelligent caching. Measured token reduction vs reading the file: 92-93% first read, 92-93% repeated (bench/tools, 1 fixture).

Intelligent user and permission management with smart caching (unmeasured design target: 86%+ token reduction). Manage users, groups, permissions, ACLs, and perform security audits across Windows, Linux, and macOS.

WebSocket connection manager with message tracking (unmeasured design target: 83% token reduction)

Parse a CI/CD workflow file and answer questions about it without reading the file into the conversation: GitHub Actions, GitLab CI, CircleCI and Azure Pipelines. Returns jobs, triggers, the dependency graph, syntax validation, hardcoded-secret and unsafe-action findings, and caching or parallelization suggestions. Parses are cached against the file hash for 24 hours.

Write files with an unmeasured design target of 85% token reduction through verification, atomic operations, and change tracking

Unified dashboard management with widget management and multi-source data integration. Supports 8 operations: check, register-check, update-check, delete-check, get-status, get-history, configure-dependencies, get-impact. Achieves 87% token reduction through status caching and dependency graph compression.

Extractive summarisation, digests, period comparison and categorisation over text you supply. Selects sentences from the input; never generates prose.

The one thing to run. A single ranked queue of what is costing the most in this project -- waste detectors, prompt-cache invalidation attributed to a file and line, and model routing -- each priced per session and per month, each naming how to act on it. Reports what already-applied fixes actually saved, whether habits improved since the advice, and its own token cost; findings worth less than their printing cost are withheld unless full=true. Pass decline="<id>" to stop being told about something.

Report behavioural token waste in this project, ranked by cost per session and compared against the previous week. Detectors are a shipped floor plus patterns derived from this project's own history, each carrying what it has actually saved. Use action="apply" to put the fixes we own into force (reversible and measured), or action="revert" with an id to undo one. Changes to your own files are only ever proposed as a diff.

Read the project's knowledge graph: fetch a finding by key, search findings by terms, inspect a node and its neighbours, or get the graph's audit, token balance and overall shape. Use it when the session index mentions a finding you want in full, or to find out what the graph holds at all. NOT for anchored retrieval: to ask what is known about a particular file or symbol, call wiki_read, which does exactly that and is the tool the enforcement layer points at.

Retrieve what this project's knowledge graph already records about the files you are about to work on, so you do not re-derive it. Call it BEFORE reading a file you have not seen: it returns prior conclusions anchored to that file — dead ends and why, decisions and what was rejected, commands that worked — plus lessons carried from other repositories on this machine. Subagents especially: you never receive the session-start briefing, so this is the only way to reach the graph. Costs nothing and sends nothing off the machine.

Record a durable finding in this project's knowledge graph so a later session retrieves it instead of re-deriving it. Use it the moment you conclude something that cost real work and is not obvious from the code: a dead end and why, a decision and its rejected alternatives, a command that finally worked, or how a subsystem fits together. Anchor it to the files it is about — the anchor is what lets the claim be invalidated when that code changes, and what makes it surface automatically when the file is next touched. Costs nothing and sends nothing off the machine.

Write the final result.json. This is the only allowed workspace mutation.