tiny-tools — MCP tools for document search, spreadsheet SQL and agent workflows

MCP tools for file analysis and reliable agent workflows. tiny-context searches documents, queries spreadsheets, summarizes logs, reuses saved document profiles and finds actual changes in JSON/JSONL exports by record ID. tiny-runtime collects API pages with checkpoints, detects repeated failures and turns tool progress into cache-scheduling hints. Built by AVRG3.

Choose file tools for documents, tables and logs, or runtime tools for pagination, retry loops and progress integration.

Looking for a tool for a specific task? Find the right tool, with example inputs · Machine-readable tool catalog · Copyable MCP config.

Designed for agents seeking fewer steps on file tasks:

• Explain a large error log: summarize_log returns repeated errors, counts and time ranges without sending every log line into context.

• Answer a spreadsheet question: query_table runs SQL over CSV/XLSX/Parquet and returns the result instead of the source rows.

• Find a PDF, Word or PowerPoint passage: go directly to query_file for ranked matches or read_section for a known location. file_map supplies an outline when needed.

• Resume a paginated API job: collect_pages saves checkpoints and returns a clear completion status without a model turn for each page.

• Investigate repeated agent failures: check_progress analyzes a trace; automatic blocking requires the host SDK integration.

• Find changed orders, issues or inventory: diff_files records mode compares JSON/JSONL snapshots by explicit IDs, ignoring record order. Select the fields that matter; get exact scoped counts, before/after previews and an optional complete local report. Examples and limits.

Measure the whole task: the tool response can be much smaller than the source file, but startup, validation and extra agent turns still cost time. Results depend on the task and client. Agent comparison, including regressions · Historical first comparison.

The whole-file-read benchmark below measures a different baseline; its savings are not a prediction for a capable agent.

Find the tools

Official MCP Registry entries: tiny-context (io.github.Warddamn/tiny-context) and tiny-runtime (io.github.Warddamn/tiny-runtime). Task guide · Plain-text overview · Glama repository profile.

The public catalog includes all 11 tool descriptions and input schemas, generated from the two actual servers and checked in CI. A directory profile does not by itself prove successful inspection or search placement; current discovery status. Your client must connect and permit the chosen server before an agent can call it.

Related MCP server: Agent Helper

New in tiny-context 0.3.0: reusable document profiles

Save a document's labels and checks once, then use extract on recurring forms/reports in one batch. TXT/Markdown, DOCX and text-layer PDFs; no training, model calls or automatic inference. Missing or ambiguous fields return needs_review without partial values. Profiles remain local, and every new document is parsed and checked again. Save and reuse a profile · Setup, batch and prepared-script measurements.

A smaller response is not proof of a smaller bill. Earlier keyed-comparison trials ran faster but cost about 33% and 3% more in their two paired runs. Profiles are opt-in for repeated work, not a replacement for a cheap single read or an existing correct script. Their total tool-definition payload is slightly smaller than 0.2.0 after shortening descriptions; agent/setup/cache costs still depend on the client. The saved-profile trial and its limits include the initial extra-call issue and the corrected result.

Introduced in tiny-context 0.2.0: keyed export comparison

Ask “which orders changed status?” without loading both exports into the model. The existing diff_files tool now supports mode: "records", explicit key pointers and optional fields. It refuses duplicate identities and numbers that would silently round. No extra MCP tool, dependency, model call or telemetry. Try a known answer · Measured results, including script overhead · Agent checks.

This reduces returned context for large snapshots; it still scans both local files. An existing correct script or source-side change feed can be faster. Small files usually need only built-ins.

Safety controls (introduced in 0.1.1)

Upgrade older installs using the current install button/config below, then reconnect the server. Existing version-pinned installations do not update automatically.

SQL accepts one read-only query against the supplied table. External file/network access and SQL write commands are disabled; exports require out and never replace existing files. Input/export limits are 64 MB; the query worker defaults to a 15-second deadline with bounded engine/JavaScript memory. These controls are not an operating-system security sandbox.

Go directly to query_file for a question or read_section for a known location; use file_map only when an outline is useful. Repeated document reads reuse a cache of up to eight files, 16 MB of serialized parsed data, and 30 seconds, checking file identity and modification metadata on every hit. The optional Read hook still builds an outline and starts a separate process; it can add work and is not required. Small text and exact-string searches often need only built-ins. Tools have startup/validation overhead and do not guarantee lower total cost on every task.

Install

MCPB-compatible clients: download the bundle for your OS from the agent bundle release and open it in your client. darwin = macOS, win32 = Windows, linux = Linux. Each bundles dependencies for x64 and arm64; a Node.js 20+ runtime is still required (some clients provide it). These are unsigned bundles with SHA-256 hashes in the registry. Downloads are approximately 77 MiB for macOS, 96 MiB for Linux and 34 MiB for Windows. All eight tools were tested from extracted bundles on macOS, Linux and Windows; not every CPU/OS combination or client UI has been tested.

Other MCP clients: use the existing commands below. They download only the dependencies needed for the current machine.

Node.js 20+ required. No npm account or token needed. Use the published GitHub release below. The npm package is not yet published; these commands do not depend on it. The server runs locally over stdio. Allow the first launch time to download its dependencies.

Claude Code

claude mcp add tiny-context -- npx -y -p https://github.com/Warddamn/tiny-tools/releases/download/context-v0.3.0/tiny-context-standalone-0.3.0.tgz tiny-context-mcp

Codex CLI (writes [mcp_servers.tiny-context] to ~/.codex/config.toml)

codex mcp add tiny-context -- npx -y -p https://github.com/Warddamn/tiny-tools/releases/download/context-v0.3.0/tiny-context-standalone-0.3.0.tgz tiny-context-mcp

Cursor — .cursor/mcp.json, or click the Install in Cursor badge above

{ "mcpServers": { "tiny-context": { "command": "npx", "args": ["-y", "-p", "https://github.com/Warddamn/tiny-tools/releases/download/context-v0.3.0/tiny-context-standalone-0.3.0.tgz", "tiny-context-mcp"] } } }

VS Code — .vscode/mcp.json (note the servers key), or click the Install in VS Code badge above

{ "servers": { "tiny-context": { "type": "stdio", "command": "npx", "args": ["-y", "-p", "https://github.com/Warddamn/tiny-tools/releases/download/context-v0.3.0/tiny-context-standalone-0.3.0.tgz", "tiny-context-mcp"] } } }

Windsurf — ~/.codeium/windsurf/mcp_config.json

{ "mcpServers": { "tiny-context": { "command": "npx", "args": ["-y", "-p", "https://github.com/Warddamn/tiny-tools/releases/download/context-v0.3.0/tiny-context-standalone-0.3.0.tgz", "tiny-context-mcp"] } } }

Claude Desktop — ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) · %APPDATA%\Claude\claude_desktop_config.json (Windows)

{ "mcpServers": { "tiny-context": { "command": "npx", "args": ["-y", "-p", "https://github.com/Warddamn/tiny-tools/releases/download/context-v0.3.0/tiny-context-standalone-0.3.0.tgz", "tiny-context-mcp"] } } }

Then paste the snippet below into CLAUDE.md / AGENTS.md / .cursorrules so the agent reaches for the tools at the right moments. Claude Code users can also add the Read guard hook, an optional stricter policy. Start with the snippet; the hook did not improve the measured comparison.

Try it with your agent

Restart or reconnect your client after setup. Confirm that tiny-context is connected and exposes eight tools. Then use the three worked examples for a CSV question, a PDF clause and an error log, with expected answers.

Claude Code plugin: /plugin marketplace add Warddamn/tiny-tools, then /plugin install tiny-context@tiny-tools. This includes both the server and task-selection guidance. Choose this or the manual MCP setup to avoid duplicate servers.

Privacy

• No telemetry from the tools. No usage reports or analytics are sent by the server.

• The published tiny-context tools process local files and return selected text to your MCP client. They do not call a model or upload files themselves; your client may send that text to its model provider according to its settings.

• tiny-runtime also supports explicitly configured HTTP GET sources and an optional SDK cache adapter; requests go only to the configured endpoints. It has no telemetry or model calls.

• First launch downloads the release and third-party dependencies using npm, including optional DuckDB for query_table. This is not an offline installer. GitHub and npm maintain their own download counters; those are not counts of agents or people.

Install tiny-runtime

Three tools for agent developers: resumable API pagination (collect_pages), repeated-failure trace analysis (check_progress), and tool-progress cache hints (plan_cache). The SDK supports automatic guards and live progress delivery; cache effects require a compatible serving engine.

claude mcp add tiny-runtime -- npx -y -p https://github.com/Warddamn/tiny-tools/releases/download/runtime-v0.1.1/tiny-runtime-0.1.1.tgz tiny-runtime-mcp

Or download the portable MCPB bundle. Requires Node.js 20+. No npm account is needed. All client options · Three worked examples · Registry listing.

When to choose it: collect a configured multi-page dataset with a clear completion status; investigate repeated failures against measured state; or integrate tool progress into an inference server. A small note, one API request or an existing correct script often needs no extra tool. The first five agent selection/answer checks passed; validation and limits do not establish real-world token or GPU savings.

Available packages

• tiny-context: eight file-analysis tools, with a CLI and library. Published version 0.1.1.

• tiny-runtime: three API pagination, retry-trace and progress tools, with a CLI and SDK. Published version 0.1.1.

Other media tools in the original build specification are unimplemented roadmap ideas, not available products.

Agent usage snippet (all installed packages)

## tiny-context (installed MCP)
- For large or PDF/Office files, choose the shortest useful path: `query_file` for a question, `read_section` for a known location, `file_map` only when you need an outline. Skip extra calls once the answer is sufficient.
- Questions about CSV/TSV/XLSX/Parquet data ("total by…", "how many rows…"): `query_table` with SQL (table is `t`). Never load raw rows into context.
- Logs: `summarize_log` first (add `focus: "errors"`); Grep/`extract` only afterwards, for the exact message it surfaced.
- Comparing documents: `diff_files` summary. For JSON/JSONL exports: `diff_files` mode `records`, explicit `key` JSON Pointers, optional `fields` scope; ignore reordered records, return actual changes. Prefer an existing correct script or source-side change feed when available.
- Verifying JSON/CSV/YAML/HTML/Markdown you just wrote: `validate_file`. Pulling emails/URLs/IDs/jq values out of files: `extract`.
- Small plain-text files (< 20 KB, e.g. notes, configs, short docs): just Read them and answer — do NOT also call file_map/query_file on a file you have already read. Grep is right for an exact string in one text file.

Benchmarks — tiny-context

17 tasks · 7,417,733 naive tokens → 9,158 tool tokens · 99.9% saved overall · median 11ms per call

Fixtures (generated locally, seeded): sales.csv 5.2 MB · app.log 2.8 MB · contract.pdf 206 KB · handbook.docx 29 KB (100,000 rows · 50,000 lines · 100 pages · ~18k words) · src/ 38 TypeScript files. · Generated 2026-09-22; re-run with npm run bench.

Full table and method: bench/RESULTS.md. Tool-selection evals: evals/RESULTS.md. Read the next section before quoting the 99.9%.

Does it actually help? (measured honestly)

The benchmark above compares against reading whole files. A capable agent with a shell doesn't do that — so we also ran the same 12 tasks through headless Claude Code in four conditions with identical built-ins (Bash, Read, Grep, Glob) allowed:

Historical 2026-09-19 run, before this patch: same answers either way. In that single run: ~20% fewer tokens, ~50% less wall-clock, fewer turns — because one call replaces a loop of shell probes, and every turn carries ~24k tokens of fixed context. The 99.9% figure applies to agents that cannot run a shell or open the file at all. Historical table and method: evals/COMPARISON-2026-09-19.md; what we concluded from it: PROPOSALS.md.

Size

Install size: 134.7 MB (108 packages) — 21.9 MB without DuckDB, which only query_table needs. Largest: @duckdb/node-bindings-darwin-arm64 112.1 MB · zod 5.9 MB · @modelcontextprotocol/sdk 4.1 MB · unpdf 2.0 MB. Measured 2026-09-22 by npm run bench.

Design rules every tool follows

Whole jobs, not endpoints · files in, summaries out · safe output defaults (never overwrite an input; -1, -2 on collision) · errors that teach (what went wrong and what to do next) · deterministic processing with explicit checkpoint/trace state · descriptions written as prompts (USE WHEN / PREFER OVER / DOES NOT / EXAMPLE / RETURNS) · validate before working · batches report per file · every response bounded (≤ ~4,000 tokens) · a savings or timing line on every response · ≤ 8 tools per server · absolute paths in responses.

Develop

npm install
npm test          # builds, then tests all packages, MCP stdio integration, CLI
npm run bench     # fixtures + benchmark table → bench/RESULTS.md, embedded in READMEs
npm run demo:runtime  # synthetic demo of all three runtime helpers
npm run bench:runtime # compare against an ordinary correct script
npm run evals     # headless Claude Code tool-selection evals → evals/RESULTS.md
npm run discovery:catalog # regenerate public schemas + pinned install config from local builds
npm run discovery:check   # fail if the public catalog differs from the actual servers

Node ≥ 20, TypeScript, ESM. See ENV.md, PROGRESS.md, DECISIONS.md. MIT.

Built by AVRG3 · MIT