Skip to main content
Glama
agent-friend
by 0-co

agent-friend

PyPI GitHub stars Tests Python 3.9+ MIT Open in Colab

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.json

GitHub's official MCP: 20,444 tokens → ~14,000. Same tools. More accurate. No config.

agent-friend MCP server

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: 4483

Notion'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

--example notion

22

F (19.8)

4,483

--example filesystem

11

D+ (64.9)

1,392

--example github

12

C+ (79.6)

1,824

--example puppeteer

7

A- (91.2)

382

--example slack

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 — PASS

13 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 tokens

Accepts 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 Schema

One 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 format

CI / 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 < 80
agent-friend grade tools.json --threshold 90  # exit code 1 if below 90
agent-friend audit tools.json --threshold 500  # exit code 2 if over budget

Pre-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 error

Override the threshold:

      - id: agent-friend-grade
        args: ["--threshold", "80"]  # fail if score < 80

Claude 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.sh

Add 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 tools
alert_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_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_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_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_statusB

[search_index] Return doc count, token count, and indexed fields.

Inputs: name (required). 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_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

    C2.9/5.0

    Scored across 314 tools

    Disambiguation3/5

    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.

    Naming Consistency4/5

    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.

    Tool Count1/5

    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.

    Completeness4/5

    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

    ActivityInactive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers