agent-friend
This server provides a comprehensive general-purpose utility toolkit of 51 built-in tools for AI agents, covering the following areas:
Alert Management: Define named alert rules with conditions (gt/gte/lt/lte/eq/ne/between/outside/contains/etc.) and severity levels; evaluate values, list/get/delete rules, and view alert history and stats.
Audit Logging: Record structured audit events with actor, resource, severity, and outcome; search, filter, export, and analyze logs with timeline bucketing and stats.
Batch Processing: Map, filter, reduce, partition, chunk, and zip lists using named or built-in functions; register custom Python functions for reuse.
Browser / Fetch: Open URLs and return page text content (HTML auto-converted to plain text).
Caching: Store, retrieve, and delete cached values with optional TTL expiration; view hit/miss statistics.
Text Chunking: Split text by chars, tokens, sentences, paragraphs, separator, or sliding window; chunk lists; get text statistics.
Code Execution: Execute Python or Bash code and return output.
Configuration Management: Set, get, list, delete, and export named config stores with dot-notation; load environment variables, set defaults, and validate required keys.
Cryptography: Generate secure tokens, UUIDs, and random bytes; hash data (MD5/SHA family); HMAC sign/verify; Base64 encode/decode.
Database (SQLite): Run SELECT queries and data-modifying statements; list tables and retrieve schemas.
Date & Time: Get current time, parse/format/diff datetimes, add durations, convert timezones, and convert to/from Unix timestamps.
Text Diffing: Compare texts or files with unified diffs, word-level diffs, similarity stats, and fuzzy matching.
Environment Variables: Get, set, list, and check environment variables; load from
.envfiles.Event Bus: Subscribe/unsubscribe to topics, publish events, view history, list subscribers, and get stats.
File Operations: Read, write, append, and list files and directories.
Formatting Utilities: Format bytes, durations, numbers, percentages, currencies, ordinals, plurals, truncated/padded text, and plain-text tables.
Integrates into CI pipelines to audit tool token budgets and provide optimization suggestions directly within GitHub Actions.
Supports exporting tool definitions for use with Google Gemini models.
Provides an agent runtime for multi-turn conversations with tool-use capabilities using local LLMs through Ollama.
Allows exporting Python functions for use with OpenAI function calling and supports agent runtimes using OpenAI models.
agent-friend
Bloated MCP schemas degrade tool selection accuracy by 3x — and burn tokens before your agent does anything useful. Scalekit's benchmark: accuracy drops from 43% to 14% with verbose schemas. The average MCP server wastes 2,500+ tokens on descriptions alone.
pip install agent-friend
agent-friend fix server.json > server_fixed.jsonGitHub's official MCP: 20,444 tokens → ~14,000. Same tools. More accurate. No config.
Fix
Auto-fix schema issues — naming, verbose descriptions, missing constraints:
agent-friend fix tools.json > tools_fixed.json
# agent-friend fix v0.59.0
#
# Applied fixes:
# ✓ create-page -> create_page (name)
# ✓ Stripped "This tool allows you to " from search description
# ✓ Trimmed get_database description (312 -> 198 chars)
# ✓ Added properties to undefined object in post_page.properties
#
# Summary: 12 fixes applied across 8 tools
# Token reduction: 2,450 -> 2,180 tokens (-11.0%)6 fix rules: naming (kebab→snake_case), verbose prefixes, long descriptions, long param descriptions, redundant params, undefined schemas. Use --dry-run to preview, --diff to see changes, --only names,prefixes to select rules.
Related MCP server: HiGHS MCP Server
Grade
See how your server scores against 201 others (A+ through F):
agent-friend grade --example notion
# Overall Grade: F
# Score: 19.8/100
# Tools: 22 | Tokens: 4483Notion's official MCP server. 22 tools. Grade F. Every tool name violates MCP naming conventions. 5 undefined schemas.
5 real servers bundled — grade spectrum from F to A+:
Server | Tools | Grade | Tokens |
| 22 | F (19.8) | 4,483 |
| 11 | D+ (64.9) | 1,392 |
| 12 | C+ (79.6) | 1,824 |
| 7 | A- (91.2) | 382 |
| 8 | A+ (97.3) | 721 |
We've graded 201 MCP servers — the top 4 most popular all score D or below. 3,991 tools, 512K tokens analyzed.
Try it live: See Notion's F grade — paste your own schema, get A–F instantly.
Validate
Catch schema errors before they crash in production:
agent-friend validate tools.json
# agent-friend validate — schema correctness report
#
# ✓ 3 tools validated, 0 errors, 0 warnings
#
# Summary: 3 tools, 0 errors, 0 warnings — PASS13 checks: missing names, invalid types, orphaned required params, malformed enums, duplicate names, untyped nested objects, prompt override detection. Use --strict to treat warnings as errors, --json for CI.
Or use the free web validator — no install needed.
Audit
See exactly where your tokens are going:
agent-friend audit tools.json
# agent-friend audit — tool token cost report
#
# Tool Description Tokens (est.)
# get_weather 67 chars ~79 tokens
# search_web 145 chars ~99 tokens
# send_email 28 chars ~79 tokens
# ──────────────────────────────────────────────────────
# Total (3 tools) ~257 tokens
#
# Format comparison (total):
# openai ~279 tokens
# anthropic ~257 tokens
# google ~245 tokens <- cheapest
# mcp ~257 tokensAccepts OpenAI, Anthropic, MCP, Google, or JSON Schema format. Auto-detects.
The quality pipeline: validate (correct?) → audit (expensive?) → optimize (suggestions) → fix (auto-repair) → grade (report card).
Write once, deploy everywhere
from agent_friend import tool
@tool
def get_weather(city: str, units: str = "celsius") -> dict:
"""Get current weather for a city."""
return {"city": city, "temp": 22, "units": units}
get_weather.to_openai() # OpenAI function calling
get_weather.to_anthropic() # Claude tool_use
get_weather.to_google() # Gemini
get_weather.to_mcp() # Model Context Protocol
get_weather.to_json_schema() # Raw JSON SchemaOne function definition. Five framework formats. No vendor lock-in.
from agent_friend import tool, Toolkit
kit = Toolkit([search, calculate])
kit.to_openai() # Both tools, OpenAI format
kit.to_mcp() # Both tools, MCP formatCI / GitHub Action
Token budget check for your pipeline — like bundle size checks, but for AI tool schemas:
- uses: 0-co/agent-friend@main
with:
file: tools.json
validate: true # check schema correctness first
threshold: 1000 # fail if total tokens exceed budget
grade: true # combined report card (A+ through F)
grade_threshold: 80 # fail if score < 80agent-friend grade tools.json --threshold 90 # exit code 1 if below 90
agent-friend audit tools.json --threshold 500 # exit code 2 if over budgetPre-commit hook
Grade and validate your MCP schema on every commit:
# .pre-commit-config.yaml
repos:
- repo: https://github.com/0-co/agent-friend
rev: v0.209.0
hooks:
- id: agent-friend-grade # fail if score < 60 (default)
- id: agent-friend-validate # fail on any structural errorOverride the threshold:
- id: agent-friend-grade
args: ["--threshold", "80"] # fail if score < 80Claude Code hook
Auto-check grades when you add MCP servers to Claude Code:
mkdir -p ~/.claude/hooks
curl -sL https://0-co.github.io/company/claude-code-hook.sh -o ~/.claude/hooks/af-check.sh
chmod +x ~/.claude/hooks/af-check.shAdd to ~/.claude/settings.json:
{
"hooks": {
"ConfigChange": [{
"matcher": ".",
"hooks": [{"type": "command", "command": "bash ~/.claude/hooks/af-check.sh"}]
}]
}
}Now every time you add an MCP server to Claude Code, you see its grade. See Discussion #191 for details.
Start a new MCP server
Use mcp-starter — a GitHub template repo that scaffolds a new server pre-configured for A+. agent-friend pre-commit hook and CI grading included.
REST API
Grade schemas without installing the package. Live at http://89.167.39.157:8082:
# Grade tools from a JSON body
curl -X POST http://89.167.39.157:8082/v1/grade \
-H 'Content-Type: application/json' \
-d '[{"name": "search", "description": "Search the web", "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "Search query"}}, "required": ["query"]}}]'
# Grade a remote schema by URL
curl "http://89.167.39.157:8082/v1/grade?url=https://example.com/schema.json"Returns {"score": 92.0, "grade": "A-", "tool_count": 1, "total_tokens": 43, ...}. CORS enabled. Source: api_server.py.
# CI pass/fail check (200=pass, 422=fail)
curl "http://89.167.39.157:8082/v1/check?url=https://example.com/schema.json&threshold=80"
# README badge redirect (shields.io)
curl -L "http://89.167.39.157:8082/badge?repo=owner/repo-name"Endpoints: /v1/grade, /v1/check?url=...&threshold=80, /v1/servers, /badge?repo=....
Also included
51 built-in tools — memory, search, code execution, databases, HTTP, caching, queues, state machines, vector search, and more. All stdlib, zero external dependencies. See TOOLS.md for the full list.
Agent runtime — Friend class for multi-turn conversations with tool use across 5 providers: OpenAI, Anthropic, OpenRouter, Ollama, and BitNet (Microsoft's 1-bit CPU inference).
CLI — interactive REPL, one-shot tasks, streaming. Run agent-friend --help.
Hosted version?
The REST API at http://89.167.39.157:8082 is free with rate limits. If you want unlimited API access, CI webhooks, or email alerts when your schema score drops — tell us in Discussion #188. Building it if there's demand.
Built by an AI, live on Twitch
This entire project is built and maintained by an autonomous AI agent, streamed 24/7 at twitch.tv/0coceo.
Discussions · Leaderboard · Web Tools · Bluesky · Dev.to
Available Tools
314 toolsalert_alert_clearA
[alert] Clear alert history for a rule (or all if rule omitted). Returns {cleared, rule}.
Inputs: rule. Returns: result
alert_alert_defineC
[alert] Define a named alert rule. Conditions: gt/gte/lt/lte/eq/ne/between/outside/contains/not_contains/is_empty/is_truthy. Severity: info/warning/error/critical.
Inputs: name (required), condition (required), threshold, threshold_high, +4 more. Returns: result
alert_alert_deleteB
[alert] Delete an alert rule by name.
Inputs: name (required). Returns: result
alert_alert_evaluateC
[alert] Evaluate a value against a named rule. Returns {fired, severity, value, timestamp}.
Inputs: name (required), value (required), metadata. Returns: result
alert_alert_getA
[alert] Get full definition of an alert rule by name.
Inputs: name (required). Returns: result
alert_alert_historyA
[alert] Retrieve fired alert history. Filter by rule name, severity, limit. Returns {events, count, total}.
Inputs: rule, limit, severity. Returns: result
alert_alert_listA
[alert] List all alert rules. Returns {rules, count}.
Inputs: no named parameters. Returns: result
alert_alert_statsA
[alert] Aggregate stats per rule: fire_count, last_fired. Returns {stats, total_fires}.
Inputs: no named parameters. Returns: result
audit_audit_clearB
[audit] Clear events. before=timestamp to clear only older events. Returns {cleared, remaining}.
Inputs: before. Returns: result
audit_audit_exportA
[audit] Export events as JSON lines. Filter by event_type, after, before. Returns {lines, count}.
Inputs: after, before, event_type. Returns: result
audit_audit_getB
[audit] Retrieve a single event by ID.
Inputs: event_id (required). Returns: result
audit_audit_logC
[audit] Record a structured audit event. Returns {id, type, actor, resource, timestamp}.
Inputs: event_type (required), actor, resource, metadata, +2 more. Returns: result
audit_audit_searchC
[audit] Filter the audit log. Filters: event_type, actor, resource, severity, outcome, after, before, text. Returns {events, count, total}.
Inputs: event_type, actor, resource, severity, +6 more. Returns: result
audit_audit_statsC
[audit] Aggregate stats: by_type, by_actor, by_resource, by_severity, by_outcome.
Inputs: after, before. Returns: result
audit_audit_timelineC
[audit] Bucket events by hour or day for trend analysis. Returns {buckets, total}.
Inputs: bucket, after, before. Returns: result
audit_audit_typesA
[audit] List distinct event types in the log. Returns {types, count}.
Inputs: no named parameters. Returns: result
batch_batch_chunkB
[batch] Split list into chunks of size. Returns {chunks, chunk_count, total}.
Inputs: items (required), size (required). Returns: result
batch_batch_filterA
[batch] Keep items where fn(item) is truthy. Returns {results, total, kept, rejected}.
Inputs: items (required), fn (required). Returns: result
batch_batch_mapA
[batch] Apply fn to each item. on_error: null/skip/raise. Returns {results, ok, errors, total, elapsed_ms}.
Inputs: items (required), fn (required), on_error. Returns: result
batch_batch_partitionB
[batch] Split into passing (truthy) and failing (falsy) lists. Returns {passing, failing, pass_count, fail_count}.
Inputs: items (required), fn (required). Returns: result
batch_batch_reduceB
[batch] Fold items with fn(acc, item). initial=starting accumulator. Built-in reducers: sum/product/max/min/concat.
Inputs: items (required), fn (required), initial. Returns: result
batch_batch_statsA
[batch] Stats from last batch_map run: ok, errors, total, elapsed_ms.
Inputs: no named parameters. Returns: result
batch_batch_zipB
[batch] Zip multiple lists into list of dicts with given keys. Returns {results, count}.
Inputs: keys (required), lists. Returns: result
batch_builtin_fnsB
[batch] List built-in function names (fns + reducers).
Inputs: no named parameters. Returns: result
batch_fn_defineA
[batch] Register a named function. def fn(item): ... for map/filter. def fn(acc, item): ... for reduce (is_reducer=True).
Inputs: name (required), source (required), is_reducer. Returns: result
browser_browseB
[browser] Open a URL and return the page text content.
Inputs: url (required). Returns: result
cache_cache_clearB
[cache] Remove ALL entries from the cache.
Inputs: no named parameters. Returns: result
cache_cache_deleteC
[cache] Remove a single key from the cache.
Inputs: key (required). Returns: result
cache_cache_getA
[cache] Retrieve a previously cached value by key. Returns the value string, or null if the key does not exist or has expired.
Inputs: key (required). Returns: result
cache_cache_setA
[cache] Store a value in the cache under the given key. Use ttl_seconds to control how long the value is valid. Pass ttl_seconds=null for a value that never expires.
Inputs: key (required), value (required), ttl_seconds. Returns: result
cache_cache_statsA
[cache] Return cache statistics: number of active entries, expired entries, and session hit/miss counts.
Inputs: no named parameters. Returns: result
chunker_chunk_by_separatorB
[chunker] Split text on a custom separator. Optionally merge parts up to max_chars.
Inputs: text (required), separator (required), max_chars, keep_separator. Returns: result
chunker_chunk_listC
[chunker] Split a list into batches of size. Returns [{index, items, count}].
Inputs: items (required), size. Returns: result
chunker_chunk_sliding_windowB
[chunker] Sliding window over text. Returns [{index, text, start, end}].
Inputs: text (required), window_chars, step_chars. Returns: result
chunker_chunk_statsA
[chunker] Return stats about text: char_count, token_estimate, line_count, sentence_count, paragraph_count, word_count.
Inputs: text (required). Returns: result
chunker_chunk_textB
[chunker] Split text into chunks. mode: chars/tokens/sentences/paragraphs. Returns [{index, text, char_count, token_estimate}].
Inputs: text (required), max_chars, overlap, mode. Returns: result
code_run_codeC
[code] Execute code and return the output. Supported languages: python, bash.
Inputs: code (required), language. Returns: result
config_config_defaultsA
[config] Set multiple defaults — only sets keys not already present.
Inputs: name (required), defaults (required). Returns: result
config_config_deleteC
[config] Delete a specific config key.
Inputs: name (required), key (required). Returns: result
config_config_dropC
[config] Delete an entire named config store.
Inputs: name (required). Returns: result
config_config_dumpC
[config] Export all config as a JSON object.
Inputs: name (required). Returns: result
config_config_getB
[config] Get a config value. as_type coerces: int/float/bool/str/json.
Inputs: name (required), key (required), default, as_type. Returns: result
config_config_listC
[config] List all keys, optionally filtered by prefix.
Inputs: name (required), prefix. Returns: result
config_config_list_storesA
[config] List all named config stores with key counts.
Inputs: no named parameters. Returns: result
config_config_load_envC
[config] Load environment variables into config. prefix filters by prefix.
Inputs: name (required), prefix, strip_prefix, lowercase. Returns: result
config_config_requireA
[config] Assert required keys exist. Returns {ok: bool, missing: [...]}.
Inputs: name (required), keys (required). Returns: result
config_config_setC
[config] Set a config key (dot-notation OK). Returns {ok, key, value}.
Inputs: name (required), key (required), value (required). Returns: result
crypto_base64_decodeB
[crypto] Decode a base64-encoded string. Returns the original string.
Inputs: data (required), url_safe. Returns: result
crypto_base64_encodeB
[crypto] Base64-encode a string. Returns the encoded string.
Inputs: data (required), url_safe. Returns: result
crypto_generate_tokenA
[crypto] Generate a cryptographically secure random token. Returns a hex string. length is the number of random bytes (output will be 2× as long in hex). Default 32 bytes → 64-char hex.
Inputs: length. Returns: result
crypto_hash_dataA
[crypto] Hash a string using the specified algorithm. Returns the hex digest. Supported: md5, sha1, sha224, sha256, sha384, sha512. Default: sha256.
Inputs: data (required), algorithm. Returns: result
crypto_hmac_signA
[crypto] Sign data with a secret key using HMAC. Returns the hex digest. Commonly used to sign webhook payloads. Supported algorithms: sha1, sha224, sha256, sha384, sha512.
Inputs: data (required), secret (required), algorithm. Returns: result
crypto_hmac_verifyA
[crypto] Verify an HMAC signature against data and a secret key. Returns true if valid, false otherwise. Uses constant-time comparison to prevent timing attacks.
Inputs: data (required), secret (required), signature (required), algorithm. Returns: result
crypto_random_bytesA
[crypto] Generate random bytes and return as hex. Useful for nonces, salts, or IVs.
Inputs: length. Returns: result
crypto_uuid4A
[crypto] Generate a random UUID (version 4). Returns a string like '550e8400-e29b-41d4-a716-446655440000'.
Inputs: no named parameters. Returns: result
database_db_executeA
[database] Run a SQL statement that modifies the database (INSERT, UPDATE, DELETE, CREATE TABLE, DROP TABLE, etc.).
Inputs: sql (required), params. Returns: result
database_db_queryC
[database] Run a SQL SELECT query and return results as a table of rows.
Inputs: sql (required), params. Returns: result
database_db_schemaB
[database] Get the CREATE TABLE statement for a specific table.
Inputs: table (required). Returns: result
database_db_tablesA
[database] List all tables in the database.
Inputs: no named parameters. Returns: result
datetime_add_durationC
[datetime] Add (or subtract) a duration to a datetime.
Inputs: dt_str (required), days, hours, minutes, +1 more. Returns: result
datetime_convert_timezoneC
[datetime] Convert a datetime string from one timezone to another.
Inputs: dt_str (required), to_tz (required), from_tz. Returns: result
datetime_diffC
[datetime] Compute the absolute difference between two datetime strings.
Inputs: a (required), b (required), unit. Returns: result
datetime_format_dtC
[datetime] Format a datetime string using a strftime format.
Inputs: dt_str (required), fmt, timezone. Returns: result
datetime_from_timestampC
[datetime] Convert a Unix timestamp to an ISO 8601 datetime string.
Inputs: timestamp (required), timezone. Returns: result
datetime_nowA
[datetime] Return the current date and time as ISO 8601.
Inputs: timezone. Returns: result
datetime_parseC
[datetime] Parse a date/time string and return ISO 8601.
Inputs: text (required), default_timezone. Returns: result
datetime_to_timestampB
[datetime] Convert a datetime string to a Unix timestamp (seconds since epoch).
Inputs: dt_str (required). Returns: result
diff_diff_filesA
[diff] Compare two files and return a unified diff. Returns {unified: str, added_lines: int, removed_lines: int, unchanged_lines: int, has_changes: bool}. Returns an error if either file cannot be read.
Inputs: path_a (required), path_b (required), context. Returns: result
diff_diff_similarB
[diff] Find the most similar strings to a query from a list of candidates. Returns [{text, score}, ...] sorted by similarity, highest first. Useful for fuzzy matching and near-duplicate detection.
Inputs: query (required), candidates (required), top_n, threshold. Returns: result
diff_diff_statsB
[diff] Compute similarity and change statistics between two texts. Returns {similarity: float (0-1), added_chars: int, removed_chars: int, added_lines: int, removed_lines: int, line_similarity: float}.
Inputs: text_a (required), text_b (required). Returns: result
diff_diff_textB
[diff] Compare two text strings and return a unified diff. Returns {unified: str, added_lines: int, removed_lines: int, unchanged_lines: int, has_changes: bool}.
Inputs: text_a (required), text_b (required), context, label_a, +1 more. Returns: result
diff_diff_wordsA
[diff] Compare two strings at the word level and return an inline diff. Added words are prefixed with '+', removed words with '-'. Returns {inline: str, added_words: int, removed_words: int}.
Inputs: text_a (required), text_b (required). Returns: result
env_env_checkA
[env] Check whether all required environment variables are set. Returns {ok: bool, present: [...], missing: [...]}. Use this to verify API keys before attempting to call external services.
Inputs: keys (required). Returns: result
env_env_getA
[env] Get the value of a single environment variable. Returns the value as a string, or 'null' if not set. Sensitive variables (containing KEY, TOKEN, SECRET, etc.) are hidden and return '[hidden]'.
Inputs: key (required), default. Returns: result
env_env_listA
[env] List environment variables as a JSON object. Pass a prefix to filter (e.g. 'AWS_' lists all AWS vars). Sensitive variables are excluded from the output.
Inputs: prefix. Returns: result
env_env_loadA
[env] Load key=value pairs from a .env file into the current process environment. Existing variables are not overwritten. Returns {loaded: [...], skipped: [...], errors: [...]}.
Inputs: path. Returns: result
env_env_setA
[env] Set an environment variable for the current process. Visible to child processes spawned after this call. Does not affect the parent shell.
Inputs: key (required), value (required). Returns: result
event_bus_bus_clearB
[event_bus] Clear history and subscribers for a topic, or all topics if topic is omitted.
Inputs: topic. Returns: result
event_bus_bus_historyC
[event_bus] Return the n most recent events for a topic (oldest first).
Inputs: topic (required), n. Returns: result
event_bus_bus_publishA
[event_bus] Publish an event to a topic. All subscribers (and wildcard subscribers) are notified. Returns {published, event_id, notified: [subscriber names]}.
Inputs: topic (required), data. Returns: result
event_bus_bus_statsA
[event_bus] Return total events published and per-subscriber call counts.
Inputs: no named parameters. Returns: result
event_bus_bus_subscribeA
[event_bus] Subscribe to a topic. Use topic='*' to receive all events. subscriber is a name string identifying who receives the events.
Inputs: topic (required), subscriber (required). Returns: result
event_bus_bus_subscribersA
[event_bus] List all subscribers to a specific topic.
Inputs: topic (required). Returns: result
event_bus_bus_topicsA
[event_bus] List all topics with their subscriber counts and event counts.
Inputs: no named parameters. Returns: result
event_bus_bus_unsubscribeC
[event_bus] Unsubscribe from a topic.
Inputs: topic (required), subscriber (required). Returns: result
fetch_fetchA
[fetch] Fetch the text content of a URL. HTML pages are automatically converted to readable plain text. Use 'search' to find URLs; use 'fetch' to read a specific URL.
Inputs: url (required), max_chars. Returns: result
file_file_appendA
[file] Append content to an existing file (creates it if missing).
Inputs: path (required), content (required). Returns: result
file_file_listC
[file] List files and directories at a given path.
Inputs: path, pattern. Returns: result
file_file_readA
[file] Read a file and return its contents. Files larger than 32 KB are truncated.
Inputs: path (required). Returns: result
file_file_writeB
[file] Write content to a file, overwriting any existing content.
Inputs: path (required), content (required). Returns: result
format_format_bytesB
[format] Format a byte count: 1234567 → '1.2 MB'. binary=true for KiB/MiB.
Inputs: value (required), decimals, binary. Returns: result
format_format_currencyB
[format] Format as currency: 1234.5 → '$1,234.50'. currency: USD/EUR/GBP/JPY/...
Inputs: value (required), currency, decimals. Returns: result
format_format_durationA
[format] Format seconds as a human string: 3661 → '1h 1m 1s'. verbose=true for full words.
Inputs: seconds (required), verbose. Returns: result
format_format_numberB
[format] Format with thousands separators: 1234567.89 → '1,234,567.89'.
Inputs: value (required), decimals, thousands_sep, decimal_sep. Returns: result
format_format_ordinalA
[format] 1 → '1st', 2 → '2nd', 3 → '3rd', 11 → '11th', 21 → '21st'.
Inputs: n (required). Returns: result
format_format_padC
[format] Pad text to width. align: left/right/center.
Inputs: text (required), width (required), align, fill. Returns: result
format_format_percentC
[format] Format as percent: 0.87 → '87.0%'. Ratios (|v|<1) multiplied by 100.
Inputs: value (required), decimals, include_sign. Returns: result
format_format_pluralA
[format] Pluralize: format_plural(3, 'item') → '3 items'. Optional custom plural form.
Inputs: count (required), singular (required), plural, include_count. Returns: result
format_format_tableB
[format] Render a JSON array of dicts as a plain-text table.
Inputs: data (required), columns, max_col_width. Returns: result
format_format_truncateA
[format] Truncate text to max_length, appending suffix (default '…').
Inputs: text (required), max_length, suffix. Returns: result
git_git_addC
[git] Stage files for commit.
Inputs: paths (required), repo_dir. Returns: result
git_git_branch_createC
[git] Create a new branch from the current HEAD.
Inputs: name (required), checkout, repo_dir. Returns: result
git_git_branch_listB
[git] List all local branches.
Inputs: repo_dir. Returns: result
git_git_commitC
[git] Commit staged changes with a message.
Inputs: message (required), repo_dir. Returns: result
git_git_diffC
[git] Show changes in the working tree or staging area.
Inputs: staged, path, repo_dir. Returns: result
git_git_logC
[git] Show recent commit history.
Inputs: n, oneline, repo_dir. Returns: result
git_git_statusA
[git] Show the working tree status — staged, unstaged, and untracked files.
Inputs: repo_dir. Returns: result
graph_graph_add_edgeB
[graph] Add a directed edge src → dst. Both nodes are auto-created.
Inputs: name (required), src (required), dst (required). Returns: result
graph_graph_add_nodeC
[graph] Add a node with optional metadata dict.
Inputs: name (required), node (required), meta. Returns: result
graph_graph_ancestorsC
[graph] Return all nodes that can reach the given node.
Inputs: name (required), node (required). Returns: result
graph_graph_createC
[graph] Create a named directed graph.
Inputs: name (required). Returns: result
graph_graph_deleteC
[graph] Delete a graph.
Inputs: name (required). Returns: result
graph_graph_descendantsC
[graph] Return all nodes reachable from the given node.
Inputs: name (required), node (required). Returns: result
graph_graph_edgesB
[graph] List all edges as [{from, to}].
Inputs: name (required). Returns: result
graph_graph_has_cycleC
[graph] Return {has_cycle: true/false}.
Inputs: name (required). Returns: result
graph_graph_listA
[graph] List all graphs with their node/edge counts.
Inputs: no named parameters. Returns: result
graph_graph_nodesC
[graph] List all node names.
Inputs: name (required). Returns: result
graph_graph_pathC
[graph] Find shortest path from src to dst. Returns {reachable, path, length}.
Inputs: name (required), src (required), dst (required). Returns: result
graph_graph_remove_edgeC
[graph] Remove a directed edge.
Inputs: name (required), src (required), dst (required). Returns: result
graph_graph_remove_nodeB
[graph] Remove a node and all its edges.
Inputs: name (required), node (required). Returns: result
graph_graph_statusC
[graph] Return node count, edge count, and node list.
Inputs: name (required). Returns: result
graph_graph_topo_sortA
[graph] Return topological order as a list, or error if the graph has a cycle.
Inputs: name (required). Returns: result
html_html_headingsA
[html] Extract all headings (h1–h6) from HTML. Returns list of {level: int, text: str} dicts. Useful for understanding page structure.
Inputs: html (required). Returns: result
html_html_linksA
[html] Extract all hyperlinks from HTML. Returns list of {text, href} dicts. Pass base_url to resolve relative links.
Inputs: html (required), base_url. Returns: result
html_html_metaA
[html] Extract and tags from HTML. Returns {title: str, meta: [...]}. Useful for Open Graph tags, descriptions, and keywords.
Inputs: html (required). Returns: result
html_html_selectA
[html] Find elements by tag name and optional attrs, return text content. E.g. html_select(html, 'span', {'class': 'price'}).
Inputs: html (required), tag (required), attrs. Returns: result
html_html_tablesA
[html] Extract all HTML tables. Returns list of tables; each table is a list of rows; each row is a list of cell strings. Use to extract structured tabular data from web pages.
Inputs: html (required). Returns: result
html_html_textA
[html] Extract all visible text from an HTML string. Strips tags, skips / blocks, preserves paragraph breaks. Use after FetchTool to make web content readable.
Inputs: html (required), max_chars. Returns: result
http_http_requestB
[http] Make an HTTP request to any URL. Use for REST APIs, webhooks, form submissions, or any HTTP endpoint. Returns a JSON object with 'status', 'headers', and 'body'.
Inputs: method (required), url (required), headers, body, +1 more. Returns: result
json_json_filterC
[json] Filter a JSON array, keeping items where the given key equals the given value. Returns a JSON array of matching items.
Inputs: data (required), key (required), value (required). Returns: result
json_json_formatB
[json] Pretty-print a JSON string with configurable indentation.
Inputs: data (required), indent. Returns: result
json_json_getA
[json] Extract a value from JSON using dot-notation path. Examples: 'user.name', 'items[0].price', 'users[*].email' (wildcard → list). Returns the value as a JSON string.
Inputs: data (required), path (required). Returns: result
json_json_keysA
[json] Return the top-level keys of a JSON object as a JSON array.
Inputs: data (required). Returns: result
json_json_mergeA
[json] Merge two JSON objects. Keys in the patch object override the base.
Inputs: base (required), patch (required). Returns: result
json_json_setA
[json] Set a value at a path in a JSON object, returning the modified JSON string. Path uses dot notation. Value must be a JSON-encoded string.
Inputs: data (required), path (required), value (required). Returns: result
lock_lock_acquireA
[lock] Acquire a named lock. owner identifies caller. ttl_s=auto-expire. wait_s=blocking wait. Returns {acquired, lock, owner, waited_ms}.
Inputs: name (required), owner, ttl_s, wait_s. Returns: result
lock_lock_expireB
[lock] Force-release a lock regardless of owner. Returns {expired, was_owner}.
Inputs: name (required). Returns: result
lock_lock_listA
[lock] List all currently held locks. Returns {locks, count}.
Inputs: no named parameters. Returns: result
lock_lock_releaseA
[lock] Release a lock held by owner. Only owner may release. Returns {released, lock}.
Inputs: name (required), owner. Returns: result
lock_lock_release_allA
[lock] Release all locks held by owner. Returns {released_count, locks}.
Inputs: owner (required). Returns: result
lock_lock_statsA
[lock] Aggregate lock stats: total_acquisitions, total_contentions, currently_held.
Inputs: no named parameters. Returns: result
lock_lock_statusA
[lock] Check if lock is held. Returns {held, owner?, remaining_s?}.
Inputs: name (required). Returns: result
lock_lock_tryB
[lock] Non-blocking lock attempt. Returns immediately with {acquired, held_by?}.
Inputs: name (required), owner, ttl_s. Returns: result
map_reduce_mr_filterC
[map_reduce] Keep items where field satisfies operator against value. Operators: eq, ne, gt, lt, gte, lte, contains, startswith, endswith, exists.
Inputs: data (required), field (required), operator (required), value. Returns: result
map_reduce_mr_flattenC
[map_reduce] Flatten a list of lists into a single list.
Inputs: data (required). Returns: result
map_reduce_mr_groupC
[map_reduce] Group items by field value → {group_key: [items]}.
Inputs: data (required), field (required). Returns: result
map_reduce_mr_mapB
[map_reduce] Extract a field from every item in a JSON array. Optional transform: upper, lower, strip, len, bool, str, int, float, abs, not.
Inputs: data (required), field (required), transform. Returns: result
map_reduce_mr_pickC
[map_reduce] Keep only specified fields in each dict item.
Inputs: data (required), fields (required). Returns: result
map_reduce_mr_reduceC
[map_reduce] Reduce a list to a scalar. Operations: count, sum, avg, min, max, first, last, join, unique.
Inputs: data (required), field (required), operation (required), separator. Returns: result
map_reduce_mr_sliceB
[map_reduce] Return a slice of the list (start inclusive, end exclusive).
Inputs: data (required), start, end. Returns: result
map_reduce_mr_sortC
[map_reduce] Sort a JSON array by a field (ascending by default).
Inputs: data (required), field (required), reverse. Returns: result
map_reduce_mr_zipA
[map_reduce] Zip two JSON arrays into [{left, right}, ...] pairs.
Inputs: left (required), right (required). Returns: result
memory_forgetB
[memory] Remove a stored fact by key.
Inputs: key (required). Returns: result
memory_recallB
[memory] Search persistent memory for relevant facts.
Inputs: query (required). Returns: result
memory_rememberC
[memory] Store a fact in persistent memory.
Inputs: key (required), value (required). Returns: result
metrics_metric_exportB
[metrics] Export all metrics. format: json (default) or prometheus text format.
Inputs: format. Returns: result
metrics_metric_gaugeA
[metrics] Set a gauge metric to a specific value. Gauges hold the last value set — useful for queue depth, memory usage, active connections. Returns the updated gauge state.
Inputs: name (required), value (required), tags. Returns: result
metrics_metric_getB
[metrics] Get the current state of a specific metric. Returns the full metric dict, or an error if not found.
Inputs: name (required). Returns: result
metrics_metric_incrementB
[metrics] Increment a counter metric by a value (default 1). Creates the counter if it doesn't exist. Tracks: count (number of increments), total, min, max, last. Returns the updated counter state.
Inputs: name (required), value, tags. Returns: result
metrics_metric_listA
[metrics] List all metric names and their types. Returns [{name, type}, ...] sorted by name.
Inputs: no named parameters. Returns: result
metrics_metric_resetA
[metrics] Reset a metric to its initial state (zero/empty). If name is not provided, resets ALL metrics. Returns the count of metrics reset.
Inputs: name. Returns: result
metrics_metric_summaryA
[metrics] Get a summary of all metrics as a single dict. Keys are metric names, values are metric state dicts.
Inputs: no named parameters. Returns: result
metrics_metric_timer_startA
[metrics] Start a timer for measuring elapsed time. Returns a timer_id string — pass it to metric_timer_stop. Multiple timers with the same name can run concurrently.
Inputs: name (required). Returns: result
metrics_metric_timer_stopA
[metrics] Stop a running timer and record its duration in milliseconds. Accumulates: count, total_ms, min_ms, max_ms, avg_ms, last_ms. Returns the recorded duration and updated timer state.
Inputs: timer_id (required). Returns: result
notify_bellA
[notify] Ring the terminal bell to alert the user.
Inputs: no named parameters. Returns: result
notify_notifyA
[notify] Send a notification using the best available channel. Tries desktop notification first, falls back to file log. Use when a task completes or an important event occurs.
Inputs: title (required), message (required). Returns: result
notify_notify_desktopA
[notify] Send a desktop notification popup. Uses notify-send (Linux) or osascript (macOS). Returns an error string if unavailable — does not raise.
Inputs: title (required), message (required). Returns: result
notify_notify_fileC
[notify] Append a notification entry to a log file (JSONL format). Reliable across all environments — no display required.
Inputs: title (required), message (required), path. Returns: result
notify_read_notificationsA
[notify] Return the last N notifications from the log file as a JSON array.
Inputs: n, path. Returns: result
process_runB
[process] Run a shell command and return stdout, stderr, and exit code. Returns JSON with: success, returncode, stdout, stderr, truncated.
Inputs: command (required), timeout, cwd, shell. Returns: result
process_run_scriptB
[process] Run a multi-line shell script. Writes to a temp file and executes it. Returns JSON with: success, returncode, stdout, stderr, truncated.
Inputs: script (required), timeout, cwd, interpreter. Returns: result
process_whichB
[process] Find the full path of an executable in PATH.
Inputs: name (required). Returns: result
queue_queue_clearB
[queue] Remove all items from a queue.
Inputs: name (required). Returns: result
queue_queue_createA
[queue] Create a named queue. kind: 'fifo' (default), 'lifo' (stack), 'priority' (min-heap — lower priority number = higher urgency). maxsize=0 means unlimited.
Inputs: name (required), kind, maxsize. Returns: result
queue_queue_deleteC
[queue] Delete a queue entirely.
Inputs: name (required). Returns: result
queue_queue_listA
[queue] List all active queues with their sizes and types.
Inputs: no named parameters. Returns: result
queue_queue_peekB
[queue] Return the next item WITHOUT removing it.
Inputs: name (required). Returns: result
queue_queue_popB
[queue] Remove and return the next item. Returns {item, size} or {item: null, empty: true}.
Inputs: name (required). Returns: result
queue_queue_pushA
[queue] Add an item to the queue. item can be any JSON value. priority (default 0) is used for priority queues — lower = more urgent.
Inputs: name (required), item (required), priority. Returns: result
queue_queue_sizeB
[queue] Return the number of items currently in the queue.
Inputs: name (required). Returns: result
rate_limit_limiter_acquireA
[rate_limit] Atomically check AND consume — the most common operation. If allowed, consumes a token and returns {allowed: true, ...}. If denied, returns {allowed: false, ...} without consuming.
Inputs: name (required), cost. Returns: result
rate_limit_limiter_checkA
[rate_limit] Check if a request is allowed WITHOUT consuming a token. Returns {allowed, remaining, reset_in_seconds} or {allowed, tokens, wait_seconds} for token bucket.
Inputs: name (required), cost. Returns: result
rate_limit_limiter_consumeB
[rate_limit] Record that a request was made (consumes one token). Returns {consumed: true/false}.
Inputs: name (required), cost. Returns: result
rate_limit_limiter_createA
[rate_limit] Create a named rate limiter. algorithm: fixed (window counter), sliding (no burst), or token_bucket (smooth rate with burst).
Inputs: name (required), max_calls, window_seconds, algorithm, +2 more. Returns: result
rate_limit_limiter_deleteC
[rate_limit] Remove a named limiter entirely.
Inputs: name (required). Returns: result
rate_limit_limiter_listA
[rate_limit] List all active limiters with their current state.
Inputs: no named parameters. Returns: result
rate_limit_limiter_resetC
[rate_limit] Reset a limiter's counters to their initial state.
Inputs: name (required). Returns: result
rate_limit_limiter_statusA
[rate_limit] Get the current state of a limiter: count, remaining, algorithm, window size.
Inputs: name (required). Returns: result
regex_regex_escapeA
[regex] Escape special regex characters in a string so it matches literally. Use when building patterns from user-supplied text.
Inputs: text (required). Returns: result
regex_regex_extract_groupsA
[regex] Extract captured groups from all matches. Returns list of {match, groups, named_groups} for each match. Use when the pattern defines named or numbered groups.
Inputs: pattern (required), text (required), flags. Returns: result
regex_regex_findallA
[regex] Return all non-overlapping matches as a list. If the pattern has groups, returns list of group strings. Simple and fast — use regex_findall_with_positions for positions.
Inputs: pattern (required), text (required), flags. Returns: result
regex_regex_findall_with_positionsC
[regex] Return all matches with their start/end positions and groups. Returns list of {match, start, end, groups, named_groups}.
Inputs: pattern (required), text (required), flags. Returns: result
regex_regex_matchA
[regex] Match a pattern at the START of text. Returns {matched, match, start, end, groups, named_groups}. Use regex_search for matching anywhere in text.
Inputs: pattern (required), text (required), flags. Returns: result
regex_regex_replaceA
[regex] Replace occurrences of pattern in text with replacement string. count=0 (default) replaces all. Replacement supports backreferences: \1, \g.
Inputs: pattern (required), replacement (required), text (required), count, +1 more. Returns: result
regex_regex_searchA
[regex] Search anywhere in text for the first match. Returns {matched, match, start, end, groups, named_groups}.
Inputs: pattern (required), text (required), flags. Returns: result
regex_regex_splitB
[regex] Split text by a regex pattern. Returns a list of strings.
Inputs: pattern (required), text (required), maxsplit, flags. Returns: result
regex_regex_validateB
[regex] Check if a pattern is a valid regular expression. Returns {valid: true/false}.
Inputs: pattern (required). Returns: result
retry_circuit_callA
[retry] Make an HTTP call through a named circuit breaker. If the circuit is open, returns immediately without making the request.
Inputs: name (required), url (required), method, body, +1 more. Returns: result
retry_circuit_createA
[retry] Create a named circuit breaker. The circuit opens (trips) after max_failures consecutive failures and stays open until reset_timeout_seconds have elapsed, then allows a single trial call.
Inputs: name (required), max_failures, reset_timeout_seconds. Returns: result
retry_circuit_resetC
[retry] Manually reset a circuit breaker to closed (normal) state.
Inputs: name (required). Returns: result
retry_circuit_statusB
[retry] Get the current state of a named circuit breaker.
Inputs: name (required). Returns: result
retry_retry_httpB
[retry] Make an HTTP request with automatic retry on failure. Retries on network errors, 429 rate limits, and 5xx server errors using exponential back-off with optional jitter.
Inputs: url (required), method, body, headers, +4 more. Returns: result
retry_retry_shellA
[retry] Run a shell command with automatic retry on non-zero exit code. Uses exponential back-off between attempts.
Inputs: command (required), max_attempts, delay_seconds, backoff_factor. Returns: result
retry_retry_statusA
[retry] Return retry statistics: total calls, retries, successes, failures.
Inputs: no named parameters. Returns: result
rss_fetch_feedB
[rss] Fetch the latest items from an RSS or Atom feed URL. Returns titles, links, and summaries.
Inputs: url (required), count. Returns: result
rss_list_feedsA
[rss] List all subscribed feed names and their URLs.
Inputs: no named parameters. Returns: result
rss_read_feedA
[rss] Fetch the latest items from a subscribed feed by name. Use list_feeds to see available names.
Inputs: name (required), count. Returns: result
rss_subscribeB
[rss] Save a feed URL under a short name for quick future access.
Inputs: url (required), name (required). Returns: result
rss_unsubscribeC
[rss] Remove a subscribed feed by name.
Inputs: name (required). Returns: result
sampler_random_choiceC
[sampler] Pick a single random item. Returns {choice, index}.
Inputs: items (required), seed. Returns: result
sampler_random_floatC
[sampler] Generate n random floats in [low, high). Returns {values}.
Inputs: low, high, n, decimals, +1 more. Returns: result
sampler_random_intB
[sampler] Generate n random integers in [low, high] inclusive. Returns {values}.
Inputs: low (required), high (required), n, seed. Returns: result
sampler_random_splitB
[sampler] Split list into partitions. ratios defaults to [0.8, 0.2] (train/test). Returns {splits, sizes}.
Inputs: items (required), ratios, seed. Returns: result
sampler_sample_listA
[sampler] Random sample of n items. replacement=true for oversampling. Returns {sample, n, total}.
Inputs: items (required), n (required), seed, replacement. Returns: result
sampler_sample_stratifiedA
[sampler] Balanced sampling: n_per_group items from each group dict key. Returns {sample: {group: [items]}}.
Inputs: groups (required), n_per_group (required), seed. Returns: result
sampler_sample_weightedA
[sampler] Weighted random selection. weights auto-normalized. Returns {sample, weights_normalized}.
Inputs: items (required), weights (required), n, seed, +1 more. Returns: result
sampler_shuffleA
[sampler] Return shuffled copy of items. Deterministic with seed.
Inputs: items (required), seed. Returns: result
scheduler_cancel_taskC
[scheduler] Remove a scheduled task by id.
Inputs: task_id (required). Returns: result
scheduler_clear_allA
[scheduler] Remove all scheduled tasks.
Inputs: no named parameters. Returns: result
scheduler_list_scheduledB
[scheduler] List all scheduled tasks.
Inputs: no named parameters. Returns: result
scheduler_run_pendingA
[scheduler] Check for tasks that are due and return them. Recurring tasks are rescheduled; one-shot tasks are removed.
Inputs: no named parameters. Returns: result
scheduler_schedule_taskA
[scheduler] Create or update a scheduled task. Provide either interval_minutes (recurring) or run_at (one-shot ISO datetime), but not both.
Inputs: task_id (required), prompt (required), interval_minutes, run_at. Returns: result
search_index_index_addA
[search_index] Add documents to an index. docs is a JSON array of dicts. Auto-creates index if it doesn't exist.
Inputs: name (required), docs (required). Returns: result
search_index_index_createC
[search_index] Create a named document index. fields limits which keys are indexed.
Inputs: name (required), fields. Returns: result
search_index_index_delete_docC
[search_index] Remove a document by its _id.
Inputs: name (required), doc_id (required). Returns: result
search_index_index_dropC
[search_index] Delete an index entirely.
Inputs: name (required). Returns: result
search_index_index_listA
[search_index] List all indexes with their document counts.
Inputs: no named parameters. Returns: result
search_index_index_list_docsC
[search_index] List documents in an index (paginated).
Inputs: name (required), limit, offset. Returns: result
search_index_index_searchB
[search_index] Search an index with a keyword query. Returns top matching documents with _score (BM25). field restricts to one field.
Inputs: name (required), query (required), top_n, field. Returns: result
search_index_index_statusB
[search_index] Return doc count, token count, and indexed fields.
Inputs: name (required). Returns: result
search_searchC
[search] Search the web and return titles, URLs, and snippets.
Inputs: query (required), max_results. Returns: result
state_machine_sm_add_transitionC
[state_machine] Define an allowed transition from one state to another.
Inputs: name (required), from_state (required), to_state (required). Returns: result
state_machine_sm_canA
[state_machine] Check if a transition to to_state is currently allowed. Returns {allowed: bool}.
Inputs: name (required), to_state (required). Returns: result
state_machine_sm_createA
[state_machine] Create a named state machine with an initial state. states: list of all valid state names. Then add allowed transitions with sm_add_transition.
Inputs: name (required), initial (required), states. Returns: result
state_machine_sm_deleteC
[state_machine] Delete a state machine.
Inputs: name (required). Returns: result
state_machine_sm_historyB
[state_machine] Return last n transitions as [{seq, from, to, timestamp}].
Inputs: name (required), n. Returns: result
state_machine_sm_listA
[state_machine] List all machines with their current state and transition count.
Inputs: no named parameters. Returns: result
state_machine_sm_resetA
[state_machine] Reset a machine to its initial state (or to state if specified). Clears history.
Inputs: name (required), state. Returns: result
state_machine_sm_stateB
[state_machine] Return the current state and list of allowed next states.
Inputs: name (required). Returns: result
state_machine_sm_statusA
[state_machine] Return full status: states, current, allowed_next, transition_count.
Inputs: name (required). Returns: result
state_machine_sm_triggerA
[state_machine] Attempt to transition to to_state. Returns {ok: true, from, to} or {ok: false, error} if not allowed.
Inputs: name (required), to_state (required). Returns: result
stats_stats_correlationB
[stats] Pearson correlation between x and y. Returns r, r_squared, interpretation.
Inputs: x (required), y (required). Returns: result
stats_stats_describeC
[stats] Descriptive stats: count/mean/median/std/variance/min/max/range/percentiles.
Inputs: values (required), percentiles. Returns: result
stats_stats_frequencyB
[stats] Frequency count for categorical data. Returns [{value, count, percent}].
Inputs: values (required), top_n. Returns: result
stats_stats_histogramC
[stats] Frequency histogram. Returns bins with range, count, and frequency.
Inputs: values (required), bins. Returns: result
stats_stats_moving_averageC
[stats] Moving average. kind: simple (SMA) or exponential (EMA, alpha=0.3).
Inputs: values (required), window, kind, alpha. Returns: result
stats_stats_normalizeA
[stats] Normalize values. method: minmax (0..1) or zscore (mean=0, std=1).
Inputs: values (required), method. Returns: result
stats_stats_outliersB
[stats] Detect outliers. method: iqr (threshold=IQR multiplier) or zscore (threshold=sigma).
Inputs: values (required), method, threshold. Returns: result
table_table_aggregateA
[table] Compute an aggregate over a column in a CSV/TSV file. Operations: count, sum, avg, min, max, unique.
Inputs: filepath (required), column (required), operation (required). Returns: result
table_table_columnsA
[table] Return the column names from the header row of a CSV/TSV file.
Inputs: filepath (required). Returns: result
table_table_filterA
[table] Filter rows in a CSV/TSV file where a column matches a condition. Returns matching rows as a JSON array. Operators: eq, ne, gt, lt, gte, lte, contains, startswith.
Inputs: filepath (required), column (required), operator (required), value (required). Returns: result
table_table_readB
[table] Read a CSV or TSV file and return all rows as a JSON array of objects.
Inputs: filepath (required). Returns: result
table_table_writeB
[table] Write rows to a CSV file. Rows must be a JSON array of objects (string). Returns the number of rows written.
Inputs: filepath (required), rows (required), delimiter. Returns: result
template_template_deleteA
[template] Delete a saved named template. Returns {deleted: name} or an error if not found.
Inputs: name (required). Returns: result
template_template_getA
[template] Get a saved named template's source string and variable list. Returns {name, template, variables} or an error if not found.
Inputs: name (required). Returns: result
template_template_listA
[template] List all saved named templates. Returns [{name, variables: [...]}, ...] sorted by name.
Inputs: no named parameters. Returns: result
template_template_renderC
[template] Render a template string with the given variables. Uses ${variable} syntax (Python string.Template). Returns the rendered string or an error if variables are missing.
Inputs: template (required), variables (required), strict. Returns: result
template_template_render_namedB
[template] Render a previously saved named template with the given variables. Returns the rendered string or an error if the template doesn't exist.
Inputs: name (required), variables (required), strict. Returns: result
template_template_saveA
[template] Save a named template for later reuse. Templates are stored in-memory for the session. Returns the template name and variable list.
Inputs: name (required), template (required). Returns: result
template_template_validateA
[template] Check that a set of variables satisfies a template's requirements. Returns {valid: bool, missing: [...], extra: [...]}.
Inputs: template (required), variables (required). Returns: result
template_template_variablesB
[template] Extract the list of variable names from a template string. Returns the sorted list of ${variable} names found.
Inputs: template (required). Returns: result
timer_countdown_listA
[timer] List all countdowns with remaining times.
Inputs: no named parameters. Returns: result
timer_countdown_remainingB
[timer] Get remaining countdown time. Returns {remaining_ms, remaining_s, expired}.
Inputs: name (required). Returns: result
timer_countdown_startB
[timer] Start a countdown for N seconds. Returns {name, duration_ms, started}.
Inputs: name (required), seconds (required). Returns: result
timer_timer_benchmarkA
[timer] Benchmark a shell command (N runs). Returns {avg_ms, min_ms, max_ms, total_ms}.
Inputs: command (required), runs, timeout_s. Returns: result
timer_timer_deleteC
[timer] Delete a timer. Returns {deleted: bool}.
Inputs: name (required). Returns: result
timer_timer_elapsedA
[timer] Get elapsed time without stopping. Returns {name, elapsed_ms, elapsed_s, running}.
Inputs: name (required). Returns: result
timer_timer_lapB
[timer] Record a lap split. Returns {name, lap_ms, lap_number, total_elapsed_ms}.
Inputs: name (required). Returns: result
timer_timer_listA
[timer] List all timers with elapsed times and lap splits.
Inputs: no named parameters. Returns: result
timer_timer_resetC
[timer] Reset and restart a timer.
Inputs: name (required). Returns: result
timer_timer_startA
[timer] Start (or restart) a named stopwatch. Returns {name, started}.
Inputs: name (required). Returns: result
timer_timer_stopC
[timer] Stop a timer. Returns {name, elapsed_ms, elapsed_s, laps}.
Inputs: name (required). Returns: result
transform_transform_coerceC
[transform] Type-coerce values. types={key: str/int/float/bool/list/dict/null}. Returns {result, coerced, errors}.
Inputs: record (required), types (required). Returns: result
transform_transform_flattenB
[transform] Flatten nested dict to dot-notation keys (arrays indexed as key.0). Returns {result, key_count}.
Inputs: record (required), sep. Returns: result
transform_transform_map_recordsC
[transform] Apply pick/omit/rename/coerce/add to each record in a list. Returns {results, count, errors}.
Inputs: records (required), pick, omit, rename, +2 more. Returns: result
transform_transform_mergeA
[transform] Deep merge multiple dicts. Later dicts win. Returns {result, merged_from}.
Inputs: dicts (required). Returns: result
transform_transform_omitB
[transform] Remove specified keys from a dict. Returns {result, omitted}.
Inputs: record (required), keys (required). Returns: result
transform_transform_pickA
[transform] Extract only specified keys from a dict. Returns {result, picked, missing}.
Inputs: record (required), keys (required). Returns: result
transform_transform_renameA
[transform] Rename keys using {old: new} mapping. Unmapped keys kept. Returns {result, renamed}.
Inputs: record (required), mapping (required). Returns: result
transform_transform_unflattenC
[transform] Convert dot-notation keys back into nested dict. Returns {result}.
Inputs: record (required), sep. Returns: result
validator_validate_emailA
[validator] Validate an email address. Checks format only (RFC 5322 simplified). Returns {valid: bool, reason: str}.
Inputs: email (required). Returns: result
validator_validate_ipA
[validator] Validate an IP address (IPv4 or IPv6). Returns {valid: bool, version: int, is_private: bool, is_loopback: bool}.
Inputs: ip (required). Returns: result
validator_validate_jsonA
[validator] Validate a JSON string. Returns {valid: bool, parsed: any, type: str, reason: str}. Optionally check that specific keys exist.
Inputs: value (required), required_keys. Returns: result
validator_validate_lengthC
[validator] Validate string or list length. Returns {valid: bool, length: int, reason: str}.
Inputs: value (required), min_length, max_length. Returns: result
validator_validate_patternA
[validator] Validate a string against a regex pattern. Returns {valid: bool, groups: list, reason: str}.
Inputs: value (required), pattern (required), flags. Returns: result
validator_validate_rangeA
[validator] Validate that a number is within a range. Returns {valid: bool, value: number, reason: str}.
Inputs: value (required), min_val, max_val. Returns: result
validator_validate_typeA
[validator] Check that a value is of the expected type. Returns {valid: bool, actual_type: str, expected_type: str}. Supported types: string, int, float, number, bool, list, dict, null.
Inputs: value (required), expected_type (required). Returns: result
validator_validate_urlB
[validator] Validate a URL. Checks that it has a valid scheme and host. Returns {valid: bool, scheme: str, host: str, path: str, reason: str}.
Inputs: url (required), allowed_schemes. Returns: result
validator_validate_uuidA
[validator] Validate a UUID string. Returns {valid: bool, version: int, variant: str}. Accepts with or without hyphens.
Inputs: value (required). Returns: result
vector_store_vector_addB
[vector_store] Add a vector (embedding) to a named store. Returns {id, name, dim}.
Inputs: name (required), vector (required), metadata, doc_id. Returns: result
vector_store_vector_deleteC
[vector_store] Delete a vector by ID. Returns {deleted: bool}.
Inputs: name (required), doc_id (required). Returns: result
vector_store_vector_dropB
[vector_store] Delete an entire named vector store.
Inputs: name (required). Returns: result
vector_store_vector_getC
[vector_store] Retrieve a vector and its metadata by ID.
Inputs: name (required), doc_id (required). Returns: result
vector_store_vector_listB
[vector_store] List stored vector IDs (paginated). Returns array of IDs.
Inputs: name (required), offset, limit. Returns: result
vector_store_vector_list_storesA
[vector_store] List all named stores with vector counts and dimensions.
Inputs: no named parameters. Returns: result
vector_store_vector_searchB
[vector_store] Find nearest neighbours. metric: cosine|euclidean|dot. Returns [{id, score, metadata}] sorted by score.
Inputs: name (required), query (required), top_k, metric, +1 more. Returns: result
vector_store_vector_statsA
[vector_store] Return {count, dim, max_vectors} for a named store.
Inputs: name (required). Returns: result
voice_speakA
[voice] Convert text to speech and play it aloud. Uses a neural TTS server if configured, otherwise falls back to the system TTS engine (espeak, festival, say, etc.).
Inputs: text (required), voice. Returns: result
webhook_wait_for_webhookA
[webhook] Start an HTTP server and wait for an incoming POST webhook. Returns the request body and headers when received. Use for payment callbacks, GitHub webhooks, form submissions, etc.
Inputs: path, timeout, port. Returns: result
workflow_builtin_fnsA
[workflow] List all built-in step function names.
Inputs: no named parameters. Returns: result
workflow_step_defineA
[workflow] Register custom step function from Python source. Must define def step(value, ctx): ....
Inputs: name (required), source (required). Returns: result
workflow_workflow_defineA
[workflow] Define a named workflow. Steps: {name, fn, retries?, on_error?, default?, condition?}. Use builtin_fns to list available fns.
Inputs: name (required), steps (required), description. Returns: result
workflow_workflow_deleteC
[workflow] Delete a workflow by name.
Inputs: name (required). Returns: result
workflow_workflow_getB
[workflow] Get full definition of a workflow by name.
Inputs: name (required). Returns: result
workflow_workflow_listA
[workflow] List all registered workflows. Returns {workflows, count}.
Inputs: no named parameters. Returns: result
workflow_workflow_runC
[workflow] Run a workflow on input data. Returns {output, steps, elapsed_ms, ok}.
Inputs: name (required), input, context. Returns: result
workflow_workflow_statusA
[workflow] Return execution history summary: total_runs, ok_runs, failed_runs, recent runs.
Inputs: no named parameters. Returns: result
xml_xml_attrsB
[xml] Return attributes of all elements with a given tag name as a list of dicts.
Inputs: xml_string (required), tag (required). Returns: result
xml_xml_extractA
[xml] Return the text content of all elements with a given tag name. E.g. xml_extract(xml, 'title') returns all title text values.
Inputs: xml_string (required), tag (required). Returns: result
xml_xml_findA
[xml] Find the first element matching an XPath expression. Returns tag, text, attrs, and child tag names. Example xpath: './/item', './/{http://…}title', './/item[@id="2"]'
Inputs: xml_string (required), xpath (required). Returns: result
xml_xml_findallB
[xml] Return all elements matching an XPath expression. Each result has tag, text, and attrs.
Inputs: xml_string (required), xpath (required). Returns: result
xml_xml_tagsA
[xml] Return all unique tag names in the document with occurrence counts. Useful for exploring an unfamiliar XML structure.
Inputs: xml_string (required). Returns: result
xml_xml_to_dictA
[xml] Convert an XML document to a nested Python dict (returned as JSON). Attributes use @ prefix, text content uses #text when mixed with children. Repeated tags become lists.
Inputs: xml_string (required). Returns: result
xml_xml_validateA
[xml] Check whether an XML string is well-formed. Returns {valid: true/false}.
Inputs: xml_string (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 314 tools
Domain prefixes keep tools within each category distinct, but cross-category overlaps exist: fetch_fetch, http_http_request, browser_browse, and retry_retry_http all retrieve URLs, while timer_timer_stop and metrics_metric_timer_stop are easy to confuse. The sheer number of tools also increases the chance an agent picks a related but wrong tool, though descriptions usually clarify.
Almost all tools follow a predictable snake_case category_prefix + verb_noun pattern, such as queue_queue_create, cache_cache_get, and lock_lock_release. Minor deviations like process_run, search_search, and browser_browse break the strict double-prefix style but are still readable and predictable.
314 tools is an extreme tool count, far beyond what an agent can reasonably scan or evaluate. Even though this is a general-purpose utility server, the surface is effectively a kitchen sink rather than a coherent, scoped toolset.
Most domains have strong lifecycle coverage: cache, locks, state machines, rate limiters, validators, and vector stores are essentially complete. Notable gaps exist in file operations (no delete/move) and git (no checkout/push/pull/merge), but these are workable given the enormous breadth elsewhere.
Maintenance
Related MCP Connectors
AI Agent Utility Layer for agent safety, web monitoring, crypto research and tool discovery.
Deterministic reasoning stack for AI agents: simulate, decide & compute, plus cross-domain tools.
AI workspace — shared knowledge, skills, and tools for AI agents
Train, explain, optimise and deploy transparent glass-box ML models via workflow tools.
Related MCP Servers
- MIT
- AlicenseNot gradedqualityDmaintenanceProvides linear programming (LP), mixed-integer programming (MIP), and quadratic programming (QP) optimization capabilities using the HiGHS solver, enabling AI assistants to solve complex optimization problems like production planning, logistics, and portfolio optimization.58 npm17MIT
- AlicenseAqualityCmaintenance17 decision intelligence algorithms as MCP tools for AI agents. Bandits (UCB1, Thompson), LP/MIP solver (HiGHS), Monte Carlo simulation, Bayesian inference, graph analytics (PageRank, Louvain), genetic algorithms, CMA-ES, anomaly detection, time series forecasting, and more. All under 25ms, deterministic, zero LLM cost.1713MIT
- AlicenseBqualityBmaintenanceProvides data science, plotting, statistics, system, and web tools via MCP, with interactive CLI clients for OpenAI-compatible and Anthropic providers.261MIT