close

Close a Sandbox Session

Close an E2B sandbox session and stop its billing. Pass the `session_id`. Captures the final metered uptime cost and releases the hold. ALWAYS call this when finished with a session — an open session keeps billing per second of uptime. Safe to call repeatedly (idempotent).

The session_id to close.

Wallet balance remaining, in cents.

Total metered uptime cost, in cents.

Error code/message when ok=false.

True when the call succeeded.

The closed session id.

Final session state.

Close a Sandbox Session

consult

Consult Vaaya — Plan Any Capability

Vaaya's consultant. Describe ANY external capability you or the user might want — generate an image/video, search or scrape the web, run code in a sandbox, send/receive email, enrich a contact — and it helps figure out the best way, teaching the user what Vaaya can do. It is CONVERSATIONAL and remembers prior turns. It returns: mode='converse' (a reply to RELAY to the user verbatim — questions, options, ideas; get the user's response and call consult again with it, so the conversation continues), mode='call' (an ordered list of calls to run via `use`, with a message explaining the preferred choice + alternatives + why; multi-step results may contain placeholders like '<from step 1: sandbox_id>' — run earlier steps first and substitute), or mode='unsupported'. Every reply includes `suggestions` (2-3 things to do next) — surface these to the user. AFTER you run a `call` result's calls via `use`, call consult ONE more time with a short note on the outcome (what was produced / any failures) — it returns result-aware, Vaaya-grounded next steps to offer the user (the `call` result's `after_running` field reminds you). Call consult whenever you hit a capability gap or the user wants to know what's possible. It does NOT execute or bill — you run returned calls via `use`. ALWAYS show the user consult's `message` and `suggestions` and let them steer.

Plain-English description of what you want, or your answer to a previous clarify question. Be concrete — include the prompt text, URL, budget, or target the task implies.

Reminder to call consult again with the outcome.

Ordered list of { service, action, params, max_cost_cents, why } to run via `use`.

What to do when a named first-party tool (gtm_*, worker_*, …) is missing from your tool list: it was just unlocked — refresh the tool list; never improvise a fallback.

What to do when the `use` tool is missing from your tool list — relay to the user.

Consultant's reply — relay to the user verbatim.

How to proceed: relay 'converse', run 'call', or report 'unsupported'.

Why the request is unsupported (mode='unsupported').

Which tool to execute the calls with.

2-3 suggested next steps to surface to the user.

Consult Vaaya — Plan Any Capability

docs

Read Vaaya Deep Reference

Vaaya's deep reference, FREE and instant. Pass `topic` to get the full playbook for a capability area — exact services, actions, params, prices, model lists, and gotchas — the same reference files the vaaya skill ships. Topics: 'media' (image/video/audio models + product-demo videos), 'gtm' (leads, enrichment, outreach, signals, email), 'research' (OneSearch lanes, deep research, company/market research playbooks), 'data' (scraping, people, social platforms, public records, onchain, compliance), 'compute' (sandboxes, browser automation, files, memory, workers, phone calls, llm). Read the matching topic BEFORE non-trivial work in that area — it is cheaper than a wrong call. Never bills; safe to call any time.

Which reference to fetch.

The full reference document (markdown).

Set when the topic is unknown.

True when the call succeeded.

The topic served.

Valid topics, returned on an unknown-topic error.

Read Vaaya Deep Reference

llm

Ask Another LLM

Ask a DIFFERENT LLM a question and get its answer, billed per token from the Vaaya wallet (model cost + 3%, usually a fraction of a cent). Use it to get a second opinion from a rival model, cross-check an answer, summarize a huge blob cheaply, or query a specific model the user names (Kimi, GPT, Gemini, Claude, DeepSeek, and 300+ more). `model` accepts 'auto' (default: short prompts go cheap, long go mid), 'cheap' | 'mid' | 'best' tiers, or any exact OpenRouter slug like 'moonshotai/kimi-k3'. Typical costs: cheap tier well under 0.1 cents, best tier 1-3 cents per call. Not for the conversation you are already having — it is a one-shot ask to another model.

Optional cap on the response length in tokens (default 4096, max 16384).

'auto' (default), 'cheap', 'mid', 'best', or an exact OpenRouter model slug (e.g. 'moonshotai/kimi-k3', 'anthropic/claude-opus-5').

The question or task for the other model.

Optional system prompt for the other model.

What the user pays for this call, in USD (model cost plus 3 percent).

Completion tokens billed.

Error code/message when ok=false.

The concrete model that served the request.

True when the call succeeded.

Prompt tokens billed.

What the caller asked for ('auto', a tier, or a slug).

The other model's answer.

Ask Another LLM

logout

Disconnect this Vaaya connection — deletes local credentials.

reauthorize

Re-run the authorization flow against the Vaaya backend.

result

Poll an Async Job

Fetch the status + output of an async job started by `use` (e.g. a video render). Pass the `job_id` that `use` returned with `{ async: true }`. Returns `{ status, result?, progress?, charged_cents }`: `running` (still working — when the job reports it, `progress` carries `{ phase, percent, rendered_frames, total_frames, eta_sec }` and `hint` is a one-line summary like "rendering 42% (380/900 frames, ~120s left)", so you can tell real progress from a hang; wait a bit and call again), `succeeded` (`result` holds the output, e.g. the video URL; the call is charged now), or `failed`/`cancelled` (no charge; on `failed`, read `error` AND `hint` — `hint` carries the service's usage notes, which usually explain how to fix the call). Safe to call repeatedly — it never starts new work or double-charges. ALWAYS use this to retrieve an async result instead of re-running `use` (re-running starts a new paid job).

The job_id returned by an async `use` call.

Wallet balance remaining, in cents.

Amount billed for this call, in cents.

Error code/message when ok=false.

Human-readable progress summary.

The polled job id.

True when the call succeeded.

Progress detail (e.g. percent) while running.

Final output when succeeded.

Job state.

Poll an Async Job

session

Run Code in a Sandbox Session

Run a command or code in an open E2B sandbox session (started by `use` with action `create_session`, which returns a `session_id`). Pass `session_id` plus either `command` (a shell command) or `code` (+ optional `language`: python/javascript/bash). Returns stdout/stderr/exit_code (or the code result). The sandbox stays alive — and billed per second of uptime — until you `close` it; re-running reuses the SAME box, so filesystem + process state persist between calls. ALWAYS `close` when done.

Code to execute (alternative to `command`).

Shell command to run in the sandbox.

Language for `code`: python (default), javascript, or bash.

The session_id returned by create_session.

Error code/message when ok=false.

Process exit code.

True when the call succeeded.

Structured result, when the runtime returns one.

Captured standard error.

Captured standard output.

Run Code in a Sandbox Session

use

Execute a Paid Service Call

Execute a single external call, and bill on success. Used for any external capability (image/video/audio generation, web search, scraping, email, document parsing, code sandbox, browser automation, embeddings, etc.). The server validates params against a registered schema and proxies to the upstream — you never pass URLs or API keys. Call it directly when you know the exact (service, action, params, max_cost_cents) — from the vaaya skill's catalog or a call you've made before; when unsure, get the call from `consult` rather than guessing.

Action within the service (e.g. "search", "generate", "create_session"), taken from the call `consult` returned.

Optional: the one-line `why` from the consult call you're running (or the user's goal for it). Used only for internal transaction visibility — it never affects validation, billing, or execution. Pass it through when you have it.

Hard ceiling in cents on what you will be charged. `use` refuses if the registry price exceeds this. Pick at least 2× the listed price so retries work.

Parameters from the call `consult` returned, validated against the service's registered schema.

Service identifier, taken verbatim from the call `consult` returned.

True when the job runs asynchronously — poll with `result`.

Wallet balance remaining, in cents.

Amount billed for this call, in cents.

Upstream result payload (URLs, text, ids, …).

Error code/message when ok=false.

Async job id for `result` polling.

True when the call succeeded.

Settlement rail used (x402 / mpp / ledger).

Upstream HTTP status when the call failed.

Vaaya transaction id for this call.

Execute a Paid Service Call

Show Connected Account & Balance

Show which Vaaya account this connection is linked to and its money state. Returns { email, name, user_id, connected_client, scopes, balance_cents, credit_line, available_cents, credits_url, switch_account }. Call it whenever the user asks "which account is connected", "what's my balance", "how much credit is left", or "how do I switch accounts" — and relay the answer. `credit_line` is the card-backed credit the account can spend past its prepaid balance (a $2 welcome line plus any GitHub-score line); `available_cents` = balance + active line, the number calls are gated on.

Wallet balance remaining, in cents.

OAuth client name this connection was made through.

Where the user buys credit packs.

Email of the connected Vaaya account.

What to tell the user to get connected.

Display name of the connected user.

True when this agent is not linked to a Vaaya user yet.

True when the call succeeded.

Gated free-tier state for premium services: cap, purchased, spent, remaining (cents). Separate from wallet balance.

Authorized scopes for this connection.

Where a new user signs up.

How to connect a different account — relay to the user.

Vaaya user id.

Where the user approves the connection.

Show Connected Account & Balance

Disconnect / Switch Vaaya Account

Disconnect this client from the current Vaaya account: revokes this connection's authorization server-side, so every later call fails with 401 until the user reconnects. Call it when the user asks to log out, sign out, disconnect, or switch Vaaya accounts — then relay the returned switch steps VERBATIM (the browser sign-out step is what actually enables switching accounts).

Error code/message when ok=false.

True when the authorization was revoked.

What happened — relay to the user.

True when the call succeeded.

Exact steps to reconnect with a different account — relay verbatim.

Disconnect / Switch Vaaya Account

Get Onboarding Instructions

Public onboarding hint for an agent whose user isn't linked to Vaaya yet. Returns where the human should go to connect (and sign up if new). Call this when vaaya_test_connection reports needs_auth, or any tool returns unauthorized, then relay the instructions to the user. If the user IS already linked it returns `first_call` instead — show `first_call.show_to_user` as written so they know what to try.

True when the agent is already connected.

What to tell the user to get connected.

Status message to relay to the user.

Where a new user signs up.

Where the user approves the connection.

Get Onboarding Instructions

Test Vaaya Connection

Round-trip ping that confirms the agent → Vaaya connection and whether the user is linked. Returns { ok:true, userId, scope, version, server_time, first_call } when linked — SHOW `first_call.show_to_user` to the user as written, it is the same set of starter examples the website and installer give them. Returns { ok:false, needs_auth:true, verification_uri, signup_uri, instructions } when not linked yet — relay that to the user so they can connect (and sign up if new).

What to tell the user to get connected.

True when the agent is linked to a Vaaya user.

Space-separated authorized scopes.

Server time, ISO 8601.

Where a new user signs up.

Linked Vaaya user id.

Where the user approves the connection.

Server version.

Test Vaaya Connection


get-create-docs-instructions

Get instructions to create a new document


help

Built-in agent docs — call early and often, even if you know JMAP. Topics: overview, installation, auth, jmap_cheatsheet, tools, presets, cron, multi_account, troubleshooting, readme. Omit topic for overview; use presets before jmap_request, cron after register, troubleshooting when stuck.

Topic name; omit for overview. Use readme for package README.md.

Atomic Mail documentation

JMAP method-call batch with automatic auth. Exactly one of: `ops` (JSON string: methodCalls array or full envelope) or `ops_file` (preset path; relative to credential directory). `$VAR` substitution and optional file `attachments`: see `help` topics presets and jmap_cheatsheet.

Local files POSTed to session uploadUrl before ops; see help topic presets.

MIME type for upload `Content-Type` (default: guessed from filename).

Attachment filename in the message (default: basename of path).

Readable file path on the MCP host (absolute or relative to cwd).

Credential directory for this call (default: ATOMIC_MAIL_CREDENTIALS_DIR or ~/.atomicmail). Use separate paths per account; see help topic multi_account.

Resolve variables/envelope and return the request body without sending it.

Inline JSON. Mutually exclusive with ops_file.

Preset path. Mutually exclusive with ops.

Capability URNs merged when `ops` has no `using` (ignored if ops sets `using`).

String map for `$PLACEHOLDER` values (keys without `$`). Overrides session keys and `ATTACHMENT_*` when attachments are set.

Send a JMAP request

register

PoW signup; writes credentials. Usernames are 5–21 characters. Idempotent for the same username and stored inbox. To register another account alongside an existing one, pass `credentials_dir` with a separate path. Returns inbox, accountId, apiKey (first signup only). The `watch` value is your operator's decision, not the agent's — ask them before calling.

Danger: replacing an account's credentials is irreversible and permanently destroys access to the current inbox. Operator-authorised only; the refusal error explains the safe path instead (a separate credential directory).

Permanent public address: the local-part of your @atomicmail.ai address, 5–21 characters. It appears on every message this inbox sends and cannot be changed afterwards — if your operator has not named it, ask them rather than inventing one.

Whether a recurring job is set up to read this inbox unattended. A standing commitment on your operator's machine, so it is their decision — ask them; do not choose or infer it. The two values are "scheduled" and "on-demand"; what each one means is in help topic cron. Omit it and the call returns the requirement.

Register an Atomic Mail inbox


reddit_by_id

Bulk-fetch posts by their t3_ fullnames in ONE call (up to 100), instead of a request per post. Pass a comma-separated list of fullnames you already have from a search or listing to hydrate them. Returns posts with title, author, score, comment count, and permalink, the same post shape as the listing endpoints. The result is NOT always one-to-one with your request, so read `meta`: `listing_status` is `complete` only when every fullname came back, `truncated` is the boolean to branch on, and `missing_fullnames` names exactly which ids did not. Example: fullnames='t3_abc123,t3_def456'.

Comma-separated post fullnames, each a t3_ prefix followed by the base-36 id (e.g. 't3_abc123,t3_def456'). Up to 100. Required (path parameter).

reddit_deep_comment_search

Genuine comment search: returns the ACTUAL comments whose body matches your keyword, sorted by score (highest first), with body, score, author, a comment-deep permalink, and the parent post. Unlike reddit_search_comments (which returns the parent posts, a Reddit limitation), this fetches each matching post's comment tree and filters the comment bodies for you, so you get first-hand opinions and answers directly. Premium call (it fans out into several reads): `limit` sets how many parent POSTS to expand, 1-25 (default 5), not how many comments come back. To go deeper than one call, paginate: pass the response's `after` cursor back as `after` to expand the NEXT batch of parent posts. `max_comments` optionally caps how many comments come back (the top-scored are kept). Matching is on the visible comment text at word boundaries (link URLs are ignored), so a result always mentions your query where a reader can see it. Best-effort: a deleted or deeply-nested comment may be missed (meta.truncated flags when a tree was too deep). Set group_by='author' for the research mode that returns WHO is talking about your query (distinct people ranked by matching-comment count) instead of a flat comment list, capped by max_authors. Example: q='best mechanical keyboard' sort='top'.

Opaque pagination cursor. Pass back the previous response's `after` value EXACTLY as it was returned; the format is not stable and a hand-written Reddit fullname loses the paging depth the cursor carries. Omit on the first call. When `after` comes back null there is no next page to request, and that does NOT reliably mean you have every item: Reddit often stops serving a busy listing long before it runs out. Read `listing_status` on that final response instead. It is `complete`, `truncated` or `unknown`, and ONLY `complete` means nothing is missing. Never report `truncated` or `unknown` to a user as the end of the data; say the answer is partial and widen across sorts, timeframes or search terms.

Set to 'author' for the RESEARCH mode: instead of a flat comment list, return the distinct PEOPLE who mentioned your query, ranked by how many of their comments matched (then total score). Each author has comment_count, total_score, the subreddits they matched in, and their top comment. Omit for the normal comment list.

Number of parent POSTS to expand into their comment trees (1-25, default 5). Each is one upstream read, so higher = deeper coverage but slower and more expensive. To go past 25, paginate with `after`.

Only with group_by='author'. Optional cap on how many people are returned (the most prolific first). Omit to return everyone. meta.authors_capped is true when this trimmed the list.

Optional cap on how many comments are returned; the highest-scored are kept. Omit to return every match. meta.capped is true when this trimmed the result.

Set 'true' to include over-18 / NSFW results. Omit or 'false' to exclude them (default).

Search query text. Supports Reddit search syntax (e.g. `subreddit:webdev`, `author:spez`, `"exact phrase"`, `title:...`).

Sort order for search. 'relevance' = best match (default), 'top' = highest score in the `t` window, 'new' = most recent, 'hot' = trending, 'comments' = most-discussed.

Time window that bounds which posts the search returns, e.g. 'week' = only posts from the past week. Unlike a subreddit listing, search applies this to the 'relevance' and 'top' sorts too. When omitted, Reddit defaults to 'all', so a broad 'relevance' query surfaces old high-upvote posts that only loosely match. Pass 'week' or 'month' to keep results recent and on-topic.

reddit_monitor_add

Create a new Reddit monitor: watch one or more subreddits, or ALL of Reddit, for new posts (or comments, via `kind`) matching a filter, and get every match delivered to a webhook you've registered with reddit_monitor_webhook_create. Omit `subreddit` and set `q` for a sitewide keyword monitor covering every subreddit at once (posts only). By default matches go to EVERY active webhook on your account; pass `webhook_ids` to route this monitor's matches to only specific webhook(s). Every redditapis.com account holds a free entitlement of ONE all-of-Reddit post watch at a 60s cadence (up to 10,000 deliveries a day), so no subscription is needed to create that monitor. Naming a `subreddit`, matching comments, a faster cadence and any additional watch require a paid plan. Needs at least one monitor slot free (see reddit_monitor_list's `slots`). Forward-looking only from the moment of creation, or from `baseline_item_id` if given -- it never backfills posts that already existed. Returns the created monitor (with its `id`) on success, or `subscription_required` (402) if the account holds no recognised entitlement at all, `subreddit_scope_requires_paid_plan` (402) if a free account named a `subreddit`, `monitor_slots_exhausted` (402) if the plan's slot limit is reached, `sitewide_slots_exhausted` (402) if the plan's separate sitewide cap is reached, `distinct_subreddit_limit_reached` (402) if the account already watches as many DIFFERENT subreddits as the plan covers (the limit counts distinct subreddits across all your monitors, not monitors, and the same subreddit in two monitors counts once; see reddit_monitor_list's `slots.distinct_subreddits_total`), `sitewide_comment_monitoring_not_available` (501) if a sitewide monitor asks for comments, `subreddit_reserved` (400) if `subreddit` names 'all', `subreddit_not_found` (400) if a named subreddit does not exist, or `webhook_not_found` (400) if a `webhook_ids` entry is not yours.

Only match posts by this Reddit username (without u/).

A Reddit post fullname (e.g. 't3_abc123') to use as the starting point instead of 'now' -- matching starts strictly after this item. Omit to start from the moment of creation.

Requested poll interval in seconds. May only be SLOWER than the plan tier's floor, never faster -- a too-low value is silently clamped up to the tier's minimum. Omit to use the tier's default.

Outbound link domains to watch for (e.g. ['example.com']). Matches the post's link URL, any URL inside a self-post/comment body, and a crosspost's original link, including one that only appeared in the original post's body. Exact-or-subdomain match only: 'example.com' matches 'blog.example.com' but never 'notexample.com'. Does NOT resolve shortened links (bit.ly, t.co).

Subreddits to SUPPRESS, without the r/ prefix (e.g. ['politics', 'AskReddit']). SITEWIDE MONITORS ONLY: pass this only when you have OMITTED `subreddit` and anchored the monitor with `q`. Passing it together with `subreddit` is rejected with a field-level 400 -- a monitor that names its subreddits should drop the unwanted name from that list instead. Up to 50, matched exactly like `subreddit` so 'r/Politics', '/r/politics' and 'politics' are one entry. This is the noise control for an all-of-Reddit keyword watch: it filters DELIVERY only, so it never changes what is polled, never frees quota, and never affects matching in any other subreddit. Independent of exclude_terms -- an item is dropped if either fires.

Posts containing any of these terms are suppressed even if they otherwise match. Use to cut noise (e.g. exclude 'giveaway' from a brand-mention monitor).

Optional label to bundle multiple matches into one delivery instead of one webhook call per match. Omit for one delivery per matching item.

EVERY one of these terms must appear (AND match) for the post to qualify, on top of any `q`.

At least ONE of these terms must appear (OR match) for the post to qualify, on top of any `q`.

What to watch in the named subreddits: 'post' (default when omitted), 'comment', or 'both'. Comment monitoring requires a Growth, Pro or Scale plan -- on a lower tier this returns `comment_monitoring_requires_higher_tier` (402). Comments run roughly 7x the volume of posts, so expect proportionally more deliveries and check reddit_monitor_health's delivery ceiling before enabling it on a busy subreddit.

Only match posts with at least this many upvotes.

Set false to EXCLUDE NSFW/over-18 posts. Omitted or true both mean NSFW is allowed through -- there is no exclude-by-default; you must explicitly pass false to filter it out. POSTS ONLY: nsfw=false is REJECTED with a field-level 400 when kind is 'comment' or 'both', because Reddit flags NSFW on a post and never on an individual comment, so there is no field to filter a comment on. Run a kind='post' monitor to keep NSFW filtering, and cut unwanted comment text with exclude_terms.

Free-text keyword or phrase to match. Matched against the fields in `search_in` (default title+body+url). Omit to match every new post in the watched subreddits.

Which fields keyword/term matching is scoped to. Default ['title', 'body', 'url']. Narrow to avoid false positives, e.g. a term that only appears in a URL slug matching a post that never mentions it in prose. All four resolve on comments as well as posts: on a comment, 'title' matches the title of the THREAD the comment sits under (a comment has no title of its own), which also applies through the default scope and can deliver every comment under a busy matching thread. Scope to ['body'] if you only want comments that say the term themselves.

Restrict delivery to specific webhook(s) instead of every active webhook on the account. Pass id(s) from reddit_monitor_webhook_create/reddit_monitor_webhook_list. Omit (or pass an empty array) for the default: deliver to every active webhook you've registered. Every id must be a webhook you own -- returns `webhook_not_found` (400) otherwise.

reddit_monitor_deliveries

Delivery history: the actual Reddit posts a monitor's webhook has received (or attempted), newest first, including the real post content (title, subreddit, permalink, author). Answers 'what did I actually get sent', not just 'how many' (see reddit_monitor_health for counts). Omit `id` to aggregate history across every monitor you own.

ISO 8601 timestamp cursor for pagination -- pass the `created_at` of the oldest row from the previous page to fetch older deliveries.

Narrow to one monitor's history. Omit to aggregate across every monitor you own.

Max rows to return, 1 to 200. Default 50.

Filter to one delivery status. 'dead' = retries exhausted, gave up. 'suppressed' = matched but deliberately not sent, and `payload.suppressed.reason` says which of the two reasons applied: 'delivery_ceiling' (the monitor's daily cap) or 'stale_item' (the item was already older than the freshness window when we first saw it, so it was withheld rather than delivered as if it were new). A 'stale_item' row is NOT a fault and was NOT rejected by any plan limit, and retrying cannot recover it; `payload.suppressed` carries the age and the threshold. Omit for all statuses.

pending delivered failed dead suppressed

reddit_monitor_health

Per-monitor health: whether it's active, its poll cadence, when it last matched something, and delivery counts for the last 24h (`delivered_24h`, `failed_24h`, `suppressed_24h`) plus whether its delivery ceiling has been hit (`ceiling_reached`) and what that ceiling is (`daily_delivery_ceiling`). `suppressed_24h` COUNTS TWO DIFFERENT THINGS AND `suppressed_breakdown` SPLITS THEM: `ceiling` (the monitor's daily cap was reached) and `stale` (the item was already older than the freshness window when we first saw it, so it was withheld rather than delivered as if it were new). A stale withhold is the usual reason a monitor's delivered count sits far below its matched count with no error anywhere, and it is the freshness gate working as intended -- nothing failed, the endpoint is fine, no limit on the plan rejected them, and retrying cannot recover the items. Do NOT read `suppressed_24h > 0` as 'this monitor is over its limit': `ceiling_reached` is the field that answers that, and a stale withhold deliberately does not set it. When `suppressed_breakdown.resolved` is false the counts do not add up to the total and `unresolved_reason` says why, so do not report a split off them; `ceiling_reached` stays conservative in that case rather than being cleared. THOSE COUNTS ONLY COVER POSTS WE FETCHED. A post we never fetched was never matched and leaves no row behind, so it is absent from all three counters rather than counted in any of them -- zeros there mean 'no matches recorded', never 'nothing was missed'. `coverage_24h` is the separate field that speaks to fetching, and its `status` is the one to read first: `complete` (every poll reached the point where the previous poll finished), `degraded` (at least one poll was truncated and posts were lost unrecoverably -- see `gaps[]`, `posts_in_window_at_least` and the estimated `posts_missed_estimate`), `partial` (nothing found, but not every kind of loss was checked -- see `unobserved_events`), or `unknown` (the check could not be run at all -- see `reason`). Do NOT report a monitor as healthy on `unknown` or `partial`, and do not treat a null count as zero: both mean the question went unanswered. `coverage_24h` is fed by the poll log and covers BOTH ways a poll loses posts unrecoverably (`listing_exhausted`, where Reddit stopped serving older posts, and `poll_overflow`, where the feed outran one poll's page budget); `observed_events` names what was actually checked, and a status of `complete` is only ever awarded when both were. WHAT `complete` DOES AND DOES NOT ESTABLISH: it means every poll that RAN got back to where the previous poll finished, AND that every feed was actually polled. The second half is `stream_liveness`, the field to read FIRST. `coverage_24h` is computed from the poll log, and a feed that is never polled writes nothing to that log, so it records no truncated poll and the coverage read comes back clean -- identical to a healthy monitor. `stream_liveness` reads a different source (the polling registry plus the per-feed last-successful-poll stamp), neither of which a poll that never ran can produce. Its `status` is `live` (every feed checked within three times its own interval), `degraded` (at least one is not: see `streams[]` for `never_polled`, `stalled` or `unregistered` per feed), or `unknown` (could not be established, including `streams_awaiting_first_poll` on a monitor created moments ago, which clears itself). `coverage_24h` can never read `complete` while this is anything but `live`. Do NOT report a monitor as healthy unless `stream_liveness.status` is `live`, and do not read a zero delivery count on a `never_polled` feed as a quiet subreddit: nothing was checked, so nothing could match. `gaps[]` IS A SAMPLE, NOT THE WHOLE LIST: it carries the most recent gaps only, `gaps_returned` says how many are in it, `gaps_truncated` says whether more exist, and `gap_events_24h` is always the true total. Count gaps from `gap_events_24h` and never from the length of `gaps[]`. FINALLY, `cadence` ANSWERS 'AM I BEING CHECKED AS OFTEN AS I PAY TO BE', which none of the fields above can. Cadence is a priced feature, so this is the field that says whether the monitor is being served the interval its plan sells. `promised_cadence_s` is the floor the account's CURRENT plan includes and `requested_cadence_s` is what this monitor is actually set to; `meets_entitlement` false means the monitor is set slower than the plan allows, which happens because a plan upgrade does NOT re-cadence monitors that already exist -- the fix is to set `cadence_s` on the monitor, and a deliberately slower cadence is also a legitimate choice. `last_checked_s_ago`, `freshness_ratio` and `within_margin` describe the slowest feed feeding this monitor, named in `slowest_stream`. READ `freshness_reading` BEFORE QUOTING ANY OF THEM: it is ONE INSTANTANEOUS SAMPLE, not an average and not a sustained verdict, so a single reading past the margin is not by itself proof of under-service. Every one of these is TRI-STATE and null NEVER means fine: a null `within_margin` or `meets_entitlement` means the question could not be answered, and `unknown_reason` says why. Do not report a monitor as on-cadence on a null.

The monitor's id, from reddit_monitor_add's response or reddit_monitor_list.

reddit_monitor_list

List every monitor on the caller's account, with each one's filter, active state, and cadence, plus a `slots` object ({used, total, tier}) showing how many monitor slots are purchased vs in use. Reading your own list never requires an active plan (a lapsed subscription shows an empty or paused list, not an error). `webhook_ids` NULL DOES NOT MEAN THE MONITOR HAS NO DESTINATION: null is the default and means matches go to EVERY active webhook on the account, which is the normal healthy state. A non-empty array narrows delivery to just those webhook ids. Never report a monitor as having no delivery target on the strength of a null here -- to see where a monitor's matches actually went, read reddit_monitor_deliveries, whose rows carry the resolved `webhook_id`.

reddit_monitor_remove

Delete a monitor. There is no undo endpoint -- it stops matching immediately, its slot is freed for a new monitor, and it disappears from reddit_monitor_list. Its past deliveries are NOT erased: they remain queryable via reddit_monitor_deliveries (both scoped by monitor_id and in the aggregate, no-id view) forever. Returns 404 `monitor_not_found` if the id does not exist or is not yours.

reddit_monitor_update

Update an existing monitor: pause/resume it (`active`), change its poll interval (`cadence_s`), switch between posts and comments (`kind`), replace its filter entirely, or re-target which webhook(s) it delivers to (`webhook_ids`). IMPORTANT: if you pass ANY filter field (subreddit, q, kind, domain, etc.), it REPLACES the whole filter, it does not merge with the existing one -- resupply every field you want kept, including `subreddit` AND `kind` (omitting `kind` reverts that monitor to posts-only). Same rule for `webhook_ids`: passing it REPLACES the monitor's targeting outright (an empty array clears back to 'every active webhook'); omitting it entirely leaves the monitor's existing targeting untouched. Omit all filter/webhook_ids fields to change only `active`/`cadence_s`. Returns 404 `monitor_not_found` if the id does not exist or is not yours, or 400 `webhook_not_found` if a `webhook_ids` entry is not yours.

Set false to pause the monitor (stops matching/delivering), true to resume it.

Only match posts by this Reddit username (without u/).

New poll interval in seconds, same tier-floor clamping as reddit_monitor_add.

Posts containing any of these terms are suppressed even if they otherwise match. Use to cut noise (e.g. exclude 'giveaway' from a brand-mention monitor).

Optional label to bundle multiple matches into one delivery instead of one webhook call per match. Omit for one delivery per matching item.

EVERY one of these terms must appear (AND match) for the post to qualify, on top of any `q`.

At least ONE of these terms must appear (OR match) for the post to qualify, on top of any `q`.

Only match posts with at least this many upvotes.

Free-text keyword or phrase to match. Matched against the fields in `search_in` (default title+body+url). Omit to match every new post in the watched subreddits.

Subreddits to watch, without the r/ prefix (e.g. ['SaaS', 'startups']). 1 to 50. OMIT this entirely (and set `q`) to watch ALL of Reddit for a keyword -- a monitor must be anchored by either a subreddit list or a keyword, never neither. Do NOT pass ['all']: r/all is Reddit's site-wide listing rather than a subreddit, so it is refused with 400 subreddit_reserved. Sitewide monitors are capped per plan tier (see reddit_monitor_list's `slots`) and cover POSTS only. On an update, omitting this while passing another filter field makes the monitor SITEWIDE (the filter is replaced wholesale, not merged), so resupply it if you meant to keep the monitor scoped.

reddit_monitor_webhook_create

Register a delivery target for monitors to send matches to. Requires an active monitoring plan (a webhook with no plan could never receive anything). Returns the webhook with its signing `secret` SHOWN ONCE -- store it immediately, it is never returned again by reddit_monitor_webhook_list. HTTPS only; the URL is re-validated (including a fresh DNS check) at every delivery, not just at creation.

Payload shape to send. PREFER OMITTING THIS: for a hooks.slack.com or discord.com/api/webhooks URL the kind is inferred from the host, and the response reports what it inferred in `kind_inferred_from`. 'slack'/'discord' format as native incoming-webhook messages; 'webhook' sends redditapis' generic signed JSON envelope and is the fallback only for a host we do not recognise; 'email' is not yet a real delivery transport. Passing 'webhook' for a Slack or Discord URL does NOT force the generic envelope (that combination can never deliver -- Slack answers 400 invalid_payload); the host wins and `kind_corrected_from` says so. Passing one SPECIFIC kind for a different platform's host (e.g. 'discord' with a hooks.slack.com URL) is refused with `webhook_kind_mismatch` (400) rather than stored.

HTTPS URL to deliver matches to. Must be publicly reachable HTTPS, no embedded credentials, no loopback/private/link-local address.

reddit_monitor_webhook_delete

Permanently delete a webhook. Any monitor still pointing at it will fail to deliver until repointed at a different webhook -- this does NOT cascade-delete or pause the monitors using it. Cannot be undone. Returns 404 `webhook_not_found` if the id does not exist or is not yours.

The webhook's id, from reddit_monitor_webhook_create's response or reddit_monitor_webhook_list.

reddit_monitor_webhook_list

List every webhook registered on the caller's account. Never returns the signing secret (shown once, at creation, by reddit_monitor_webhook_create).

reddit_monitor_webhook_test

Send a one-off test delivery to a registered webhook (rate-limited to 10/min) so you can confirm it's wired up correctly before waiting for a real match. Uses the webhook's `kind` to format the test payload the same way a real delivery would. On failure the response carries `reason` and `status` plus TWO fields that say what to actually do: `hint`, our sentence naming the fix (most often that the target's `kind` does not match its host, which no test can succeed through), and `detail`, a bounded, sanitised copy of what the destination itself replied. Report `hint` to the user rather than the bare `reason` -- `http_error` with a 400 names no field, no value and no remedy. Returns 404 `webhook_not_found` if the id does not exist or is not yours, or `webhook_url_rejected` if the URL fails re-validation (e.g. now resolves to a private address).

reddit_post

Fetch a single Reddit post by its id. Returns the full post object (title, author, score, text, permalink, subreddit, url). Use when you already have a post id and want its details. Example: id='abc123' (the base-36 id, no t3_ prefix).

The post's base-36 id (e.g. 'abc123'), without the 't3_' fullname prefix. Required (path parameter).

reddit_post_comments

Fetch a single post and its comment tree by permalink. Returns the post plus threaded comments (author, body, score, replies) and an `after` cursor. Use after finding a post via search/listing to read the full discussion. Pass the post's `permalink` from a prior result.

The post permalink path from a prior post result, e.g. '/r/programming/comments/abc123/some_title/'. Required.

reddit_search

Search Reddit posts across all of Reddit or within one subreddit. Returns matching posts with author, score, comments, permalink, and an `after` cursor. Use for topic/keyword research, brand monitoring, or finding discussions. Scope to a community with `subreddit`. Optional advanced filters narrow the results by minimum/maximum score, comment count, media type, and post flags, with an optional re-sort of the page. Because filters are applied to the returned page, the response then carries a `meta` object with page-completeness counts, so a filtered result is never mistaken for the whole set; paginate with `after` to filter more. Example: q='rust vs go' sort='top' t='year'.

Filter by the contest_mode flag.

true = only self/text posts, false = only link posts.

true = only video posts, false = only non-video.

Max items to return (1 to 100). The API clamps out-of-range values; endpoint default applies if omitted.

Filter by the locked flag.

Keep only posts with comment count <= this.

Keep only posts with score <= this.

Keep only posts with comment count >= this.

Keep only posts with score >= this (applied to the returned page).

Set 'true' to include over-18 / NSFW results. Omit or 'false' to exclude them (default).

Filter the page by NSFW flag (distinct from nsfw, which controls inclusion in the search).

Search query text. Supports Reddit search syntax (e.g. `subreddit:webdev`, `author:spez`, `"exact phrase"`, `title:...`).

Sort order for search. 'relevance' = best match (default), 'top' = highest score in the `t` window, 'new' = most recent, 'hot' = trending, 'comments' = most-discussed.

Re-sort the filtered page (descending) by this field.

Filter by the spoiler flag.

Filter by the stickied flag.

Optional subreddit name (without r/) to restrict the search to one community. Omit to search all of Reddit.

reddit_search_comments

Search Reddit by COMMENT text. Reddit's comment search matches your keyword against comment bodies but returns the PARENT POSTS, not the individual comments, so each result is a post whose discussion mentions your query, carrying that post's title, selftext, score, and comment count. Use it to surface threads where a topic comes up in the replies that plain post-title search would miss. Reddit does not expose which specific comment matched or its text, so this returns posts, not comment bodies. For the actual comment bodies, use reddit_deep_comment_search. Example: q='best mechanical keyboard' sort='top'.

reddit_search_communities

Search for subreddits (communities) by name or topic. Returns matching subreddits with title, subscriber count, description, and NSFW flag. Use to discover where a topic is discussed before listing or searching its posts. Example: q='machine learning'.

reddit_search_media

Search Reddit posts filtered to media (images, video, gifs). Returns media posts with the media URL/type, author, score, and the post url. Use `kind` to narrow to a media type. Example: q='aurora borealis' kind='image'.

Media type filter. 'image', 'video', 'gif', or 'all' (default). Filters the raw Reddit results to that media kind.

reddit_search_users

Search for Reddit users (redditors) by name or keyword. Returns matching accounts with username, karma, and account age. Use to find a person's handle before fetching their profile or comments. Example: q='spez'.

Max items to return (1 to 100). The API clamps out-of-range values; endpoint default applies if omitted.

reddit_subreddit_about

Fetch a subreddit's public metadata by name (Reddit's /r/<name>/about data). Returns the subreddit's title, public description, subscriber count, active-user count, creation timestamp, type, and NSFW flag. Use it to size or vet a community before listing or searching its posts. Example: name='python'.

Subreddit name WITHOUT the r/ prefix (e.g. 'python'). Required (path parameter).

reddit_subreddit_comments

Stream the NEWEST comments across an entire subreddit (Reddit's /r/<name>/comments feed), not one post's thread. Returns comments with body, author, score, subreddit, the parent post link, and timestamp, plus an `after` cursor. Poll it to catch new comments in a community as they are posted. Example: name='python'.

reddit_subreddit_moderators

Fetch a subreddit's moderator team by name (Reddit's /r/<name>/about/moderators data). Returns a `moderators` list, each with `name`, `id`, `mod_permissions`, `flair_text`, and `added` (when they joined the mod team). Use it to see who moderates a community. Example: name='python'.

reddit_subreddit_posts

List posts from a subreddit by sort order. Use this to read a community's feed: newest, hot/trending, top-of-week, rising, etc. Returns post title, author, score, comment count, and permalink, plus an `after` cursor for paging. When `after` comes back null the response carries `listing_status`: `complete` means no older posts and is only claimed when the whole run came back in under one page, `truncated` means Reddit's cap cut you off, and `unknown` means we cannot tell, so do NOT report `unknown` as the end of the data. A busy feed that Reddit simply stops serving reports `unknown`, not `complete`, so treat `unknown` as an incomplete answer and widen across sorts, timeframes or search rather than paging deeper. Example: subreddit='programming' sort='top' t='week'.

Sort order for a subreddit listing. 'hot' = trending now, 'new' = most recent (default), 'top' = highest score in the `t` window, 'rising' = gaining fast, 'controversial' = polarizing, 'best' = Reddit's blended rank.

Subreddit name WITHOUT the r/ prefix (e.g. 'programming', 'AskReddit'). Required.

Time window, only applied when sort is 'top' or 'controversial'. E.g. 'week' = top of the past week. Ignored for other sorts.

reddit_subreddit_rules

Fetch a subreddit's posting rules by name (Reddit's /r/<name>/about/rules data). Returns a `rules` list, each with name, description, what it applies to (posts, comments, or all), violation reason, priority, and creation date, plus a `site_rules` list of Reddit's site-wide rules. Use it to check a community's rules before posting or commenting. Example: name='python'.

reddit_subreddit_top

Get the TOP posts of a subreddit for a time window. Shorthand for the highest-scoring posts of a community. Returns posts with score, author, comments, and permalink plus an `after` cursor. Example: name='science' t='month'.

Subreddit name WITHOUT the r/ prefix (e.g. 'science'). Required (path parameter).

reddit_subreddit_wiki

Fetch a subreddit's wiki page by name and page (Reddit's /r/<name>/wiki/<page> data). Returns a single object with `content_md` and `content_html`, a `may_revise` flag, and the last revision (`revision_id`, `revision_date`, `revised_by`, `reason`). Use it to read a community's wiki, such as its rules or FAQ. The page may be multi-segment, for example index, rules, or config/sidebar. Example: name='python', page='index'.

Wiki page name (e.g. 'index'). Required (path parameter). May be multi-segment like 'config/sidebar'.

reddit_subreddits_default

Browse Reddit's default front-page set of subreddits, no keyword needed. Returns a `subreddits` list (each with name, title, subscriber count, description, type, and NSFW flag) plus an `after` cursor for paging. This BROWSES the default communities; use reddit_search_communities instead to SEARCH communities by keyword.

reddit_subreddits_new

Browse the newest subreddits, the communities most recently created, no keyword needed. Returns a `subreddits` list (each with name, title, subscriber count, description, type, and NSFW flag) plus an `after` cursor for paging. This BROWSES communities by recency; use reddit_search_communities instead to SEARCH communities by keyword.

Max items to return (1 to 100). The API clamps out-of-range values; endpoint default applies if omitted.

reddit_subreddits_popular

Browse the most-subscribed, trending subreddits right now, no keyword needed. Returns a `subreddits` list (each with name, title, subscriber count, description, type, and NSFW flag) plus an `after` cursor for paging. This BROWSES communities by popularity; use reddit_search_communities instead to SEARCH communities by keyword.

reddit_user_comments

List a Reddit user's recent comments. Returns comments with body, score, subreddit, parent link, and timestamp plus an `after` cursor. Use to understand what a redditor talks about or to gather their opinions. Example: name='spez' sort='top'.

Reddit username WITHOUT the u/ prefix (e.g. 'spez'). Required (path parameter).

Sort order for a user's comments. 'new' = most recent (default), 'hot', 'top' (in the `t` window), 'controversial'.

reddit_user_gilded

List the posts and comments a Reddit account has received an award (gold) on. PRIVATE data -- Reddit only serves it to the account that owns it, so you must be logged in as `name` (see the `reddit_session`/`loid` args) or this returns 403. Mixed listing: each item is a post or a comment, tagged `kind`. Requires calling POST /api/reddit/login on the REST API first to get session cookies (not an MCP tool). Example: name='spez' (must match the logged-in account).

Reddit CSRF cookie, from the same login response. Not required for a read (CSRF only guards state-changing calls) but harmless to pass if you have it.

Reddit account loid cookie, from the same POST /api/reddit/login response. Required.

Reddit username WITHOUT the u/ prefix. Must be the SAME account the supplied cookies belong to, or Reddit returns 403. Required (path parameter).

Reddit account session cookie. Obtain it by calling POST /api/reddit/login on the REST API first (not an MCP tool) and reusing the `reddit_session` cookie it returns. Required.

Time window, only applied when sort is 'top' or 'controversial'. E.g. 'week' = top of the past week. Ignored for other sorts.

reddit_user_hidden

List the posts and comments a Reddit account has HIDDEN. PRIVATE data -- Reddit only serves it to the account that owns it, so you must be logged in as `name` (see the `reddit_session`/`loid` args) or this returns 403. Mixed listing: each item is a post or a comment, tagged `kind`. Requires calling POST /api/reddit/login on the REST API first to get session cookies (not an MCP tool). Example: name='spez' (must match the logged-in account).

reddit_user_profile

Fetch a Reddit user's public profile by username. Returns account info: username, id, karma (post + comment), account age, verified/employee flags, and avatar. Use to vet or summarize a redditor. Example: name='spez'.

reddit_user_saved

List the posts and comments a Reddit account has SAVED. PRIVATE data -- Reddit only serves it to the account that owns it, so you must be logged in as `name` (see the `reddit_session`/`loid` args) or this returns 403. Mixed listing: each item is a post or a comment, tagged `kind`. Requires calling POST /api/reddit/login on the REST API first to get session cookies (not an MCP tool). Example: name='spez' (must match the logged-in account).

reddit_user_submitted

List a Reddit user's submitted POSTS (their post history, the sibling of reddit_user_comments). Returns posts with title, author, score, comment count, and permalink, plus an `after` cursor. Use to see what a redditor posts, not just what they comment on. Example: name='spez' sort='top'.

reddit_user_upvoted

List the posts and comments a Reddit account has UPVOTED. PRIVATE data -- Reddit only serves it to the account that owns it, so you must be logged in as `name` (see the `reddit_session`/`loid` args) or this returns 403. Mixed listing: each item is a post or a comment, tagged `kind`. Requires calling POST /api/reddit/login on the REST API first to get session cookies (not an MCP tool). Example: name='spez' (must match the logged-in account).

Max items to return (1 to 100). The API clamps out-of-range values; endpoint default applies if omitted.


Return the structured prop / category / default / description rows for a single VaneUI component, derived from `ComponentCategories`, `ComponentKeys`, `defaultTheme`, and `PropDescriptions`. Use this to look up the exact prop list, find which prop is the default in a category, or distinguish common layout props from component-specific ones. The slug matches the resource basename — `button`, `card`, `icon-button`, `page-title`, etc.

Component slug (e.g. `button`, `card`, `icon-button`, `page-title`).

Search the VaneUI markdown docs (component usage, prop-to-Tailwind mapping, patterns, testing, etc.) for a substring or regex. Returns up to 50 matches with URI, line number, and a short snippet. Use this before guessing prop names, defaults, or class mappings.

Text to search for (case-insensitive).

If true, interpret `query` as a JavaScript regex. Defaults to false (literal substring).


System Administration operations dispatcher (7 operations)

Operation to perform

Compliance & Security operations dispatcher (16 operations)

Operation to perform

Device Management operations dispatcher (9 operations)

Operation to perform

Identity & Access operations dispatcher (13 operations)

Operation to perform

Query & Analytics operations dispatcher (17 operations)

Operation to perform


Add an upvoter to a post

Upvoter email

Post ID

Upvoter name

Create a new comment or reply

Post as specific user

Changelog ID or slug (required if no submissionId)

Comment content

Set creation date

Make comment private (admins only)

Parent comment ID for replies

Notify voters (default: true)

Post ID or slug (required if no changelogId)

Create a new post

Name for new user if email not found

The board (category) for the post

Allow comments on post

Post content (can be empty)

Custom field values

Post creation date

Email of the user submitting

Post status

Array of tag names

Post title (min 2 characters)

Delete a comment (soft delete if has replies)

Comment ID to delete

Delete a post permanently

Post ID to delete

Get comments for a post or changelog. Available fields: upvoted, downvoted, inReview, isSpam, pinned, emailSent, sendNotification, organization, submission, author, authorId, authorPicture, isPrivate, isDeleted, confidenceScore, content, upvotes, downvotes, score, parentComment, path, createdAt, updatedAt, id, replies(upvoted, downvoted, inReview, isSpam, pinned, emailSent, sendNotification, organization, submission, author, authorId, authorPicture, isPrivate, isDeleted, confidenceScore, content, upvotes, downvotes, score, parentComment, path, createdAt, updatedAt, id)

Get all comments in a thread

Filter for comments in review

Results per page (default: 10)

Page number (default: 1)

Filter by privacy setting

Fields to return. Examples: "id,content,author(name)" | "content,upvotes,createdAt" | "author(name,email),replies(content)". Leave empty for all fields.

Sort order (default: best)

Get list of users who upvoted a post

Results per page (default: 10, max: 100)

Page number (default: 1)

Post ID

Find posts similar to the given query text

Locale for search (default: 'en')

Search query text to find similar submissions

List posts with optional filtering. Available fields: id, title, content, author, authorId, authorPicture, commentsAllowed, organization, upvotes, upvoted, postCategory(category,private,prefill,roles,hiddenFromRoles,id), postTags(name,color,private,id), postStatus(name,color,type,isDefault,id), date, lastModified, comments, isSubscribed, inReview, lastDraggedTimestamps

Filter posts by category (board) names

Get posts created before this date

Find submission by its id

Number of results per page

Page number

Search for posts by title or content

Fields to return. Examples: "id,title,upvotes" | "title,author(name)" | "postCategory(category),postStatus(name)". Leave empty for all fields.

Sort posts (e.g., "date:desc" or "upvotes:desc")

Get posts created after this date

Filter posts by status ids

Convert a post slug to post ID and get post details

Post slug from URL (e.g., 'spacectl-stack-local-preview-target')

Update an existing comment

New content

Update creation date

Comment ID

Put comment in review

Make private (admins only)

Pin comment to top

Update an existing post

New category

Allow comments

New content

Custom field values

Post creation date

Post ID to update

Put post in review

Send status update email to upvoters

New status

New tags

New title


Add new observations to existing entities in the knowledge graph.

Array of observations to add

An array of observation contents to add

The name of the entity to add observations to

Create multiple new entities in the knowledge graph. Entities are the fundamental nodes with a name, type, and list of observations. Stored in ZeroDB cloud — persists across sessions and devices.

Array of entities to create

The type of the entity

The name of the entity

An array of observation contents associated with the entity

Create multiple new relations between entities in the knowledge graph. Relations should be in active voice.

Array of relations to create

The name of the entity where the relation starts

The type of the relation

The name of the entity where the relation ends

Delete multiple entities and their associated relations from the knowledge graph.

An array of entity names to delete

Delete specific observations from entities in the knowledge graph.

Array of deletions

The name of the entity containing the observations

An array of observations to delete

Delete multiple relations from the knowledge graph.

Array of relations to delete

The type of the relation

Open specific nodes in the knowledge graph by their names.

An array of entity names to retrieve

Read the entire knowledge graph from ZeroDB cloud storage.

Search for nodes in the knowledge graph based on a text query. Matches against entity names, types, and observation content (case-insensitive substring match).

The search query to match against entity names, types, and observation content

Search for nodes in the knowledge graph using semantic vector similarity. Unlike search_nodes which does exact text matching, this finds entities by meaning — e.g., searching "machine learning frameworks" would find entities about "PyTorch" or "TensorFlow" even without those exact words.

Maximum number of results (default: 10)

Natural language query to search by meaning