Tool search 101,857 tools · 5,224 live servers

Search read-only HeyClaude registry entries by query, category, exact tag, and skill platform compatibility.

List read-only HeyClaude entries with bounded pagination and optional category, platform, tag, and query filters.

Before replying, call this to recall anything already known about this user from past conversations. Use the user's latest message as the query. If you serve multiple end-users, pass the same user_id (or customer_id) you log with so you recall the right person's memory.

Recall persisted memory by query. Alias of recall.

Use this when you need to read facts about a model. One reader, selected by `of`: - 'assembly' — physical assembly inventory (parts, bboxes, connectors, mates, disconnected solids). - 'robot' — URDF/SDFormat export preview (links, joints, planning groups, end-effectors, issues). - 'step' — inspect an imported STEP file. - 'shape' — volume / surfaceArea / bbox for one feature ({ feature_id? }). - 'features' — features captured by the script (kind, id, params, transforms, suppression). - 'assemblies' — assembly intent (assemblies, parts, connectors, joints). - 'topology' — canonical face names + edge count for a feature ({ feature_id? }). - 'edges' — edges of a shape with optional EdgeQuery ({ feature_id?, query? }); returns @kc[...] refs. - 'face-edges' — boundary edges of a named canonical face ({ feature_id?, face_name }). - 'faces' — faces of a shape with optional FaceQuery ({ feature_id?, query? }); returns @kc[...] refs. - 'face-labels' — user-applied labels visible in the script. - 'mates' — mates captured by the script. - 'constraints' — sketch constraints captured by the script. - 'part-stats' — bundled parts-catalog statistics. - 'bend-table' — sheet-metal bend table for a flattened pattern. - 'params' — declared model parameters. - 'part-categories' — top-level part-catalog categories available in the bundled (and configured remote) catalog. - 'part-families' — part families within a category ({ category? }); count + exemplar ids per family. All params except `of` are subject-specific and forwarded verbatim. Most subjects accept { file | code }.

Use this when you need to resolve or inspect topology against a script's lowered geometry. Selected by `mode` (default 'evaluate'): - 'evaluate' — inspect a Query (@kc[...] ref, @kcq[...] DSL, or { ast }); returns matched entities. Pass expect:'unique' to assert exactly-one. - 'resolve' — resolve a single @kc[...] / @kcq[...] ref to one entity ({ ref }). - 'lineage' — walk the HistoryMap for a named face ref ({ feature_id, ref }). All params except `mode` are forwarded verbatim.

Use this when you need to list the kernelCAD script-runtime surface: global functions (box, path, selectEdges, helix, etc), Shape methods (fillet, sweep, lower, etc), Sketch methods (extrude, revolve, sweep), PathBuilder methods, EdgeQuery/FaceQuery key sets, and featureKindFaceLabels (which globals accept opts.faceLabels and valid value shapes). Use this to discover what is callable from a .kcad.ts script.

Use this when you need a canonical pattern snippet for a CAD task. Search the kernelCAD cookbook for canonical pattern snippets. Returns top-k snippets matching the natural-language query, ranked by BM25 over title/tags/keywords/trigger. Use when you need a canonical pattern for fillet-after-subtract, non-overlapping booleans, sketch-to-extrude flows, etc. Returns empty if no snippet scores above the relevance floor — proceed without cookbook help in that case.

Use this when you need to find a part in the catalog. Discover bundled (and optionally remote) part-catalog records by fuzzy query and faceted filters. Tokens AND-combine; cross-facet filters AND-combine. Pass partsBaseUrl (or set KERNELCAD_PARTS_BASE_URL) to enable the remote tier; otherwise results are bundled-only.

Use this when you need to download a catalog part as a STEP file. Resolve an id (or single-match query) to a part record and write its STEP file to the local cache. Bundled ids resolve offline; non-bundled ids require partsBaseUrl (or KERNELCAD_PARTS_BASE_URL). Returns the cache path plus a sha256 fingerprint.

Use when you need narrative content from company filings — risk factors, MD&A, guidance language, deal terms, accounting policies, share structure. For consolidated financial numbers use run_sql on financial_statements instead. Semantic search over the full text of company-filed reports; returns matching passages. Coverage: US + Japan + Hong Kong + China A-shares. US = SEC EDGAR (including foreign issuers' 20-F/6-K). Japan = EDINET, `.T` ticker (6758.T). Hong Kong = HKEX filings, 5-digit `.HK` ticker (00700.HK). A-shares = `.SH`/`.SZ` (600519.SH, 300750.SZ). Parameters: - query (required): natural-language search; phrase it as the concept or section name you want, e.g. "share repurchase authorization", "Risk Factors". Run a few phrasings rather than one broad query. - ticker (required): US bare (NVDA), Japan `.T`, HK `.HK`, A-share `.SH`/`.SZ`, ADRs as their US symbol (SONY). - filing_types (optional): US = SEC form names (10-K, 10-Q, 8-K, 20-F, 6-K, DEF 14A, S-1/F-1, + amendments). Japan = EDINET NUMERIC codes: 120 (annual), 140 (quarterly), 160 (semi-annual). HK/A-share = plain names — annual_report; A-share quarters per-quarter (q1_report, ...); HK quarterly results all quarterly_report. OMIT to search all types. - period_start / period_end (optional): yyyy-mm window; omit to search all history. - top_k (optional): max passages to return (default 10). Scope: indexes ONLY company-filed reports — NOT institutional filings (13F-HR/13D/13G; for those use insider_and_institution_activities with source='institution'). Section targets: non-GAAP reconciliations → earnings 8-K (Ex 99.1); dilution / SBC / buyback → "Shareholders' Equity"; segment breakdown → "Segment Information"; guidance → "Outlook" in MD&A; exec comp → DEF 14A.

Resolve a company name, brand, or ticker substring to canonical ticker(s). Use this FIRST when the user mentions a company by name/brand/nickname before running any ticker-keyed tool. Input: - query (required): company name, brand, or ticker substring, e.g. "Apple", "苹果", "AAPL", "OpenAI" - market (optional): "us" | "jp" | "hk" | "cn" — omit to search all markets Returns up to 5 matches ranked by prefix-hit first, then name length. Returned symbols carry their market suffix: US bare (AAPL), Japan `.T`, Hong Kong 5-digit `.HK` (00700.HK), A-share `.SH`/`.SZ` (600519.SH).

PostgreSQL SELECT over financial / market / alt-data tables — returns structured rows. Hard rules (query fails otherwise): - SELECT only, no CTE (`WITH ... AS`) — use subqueries. - Period columns are TEXT, not dates — `period_end` is 'YYYY-MM'. Compare as strings (`period_end >= '2024-01'`); a `::date` cast on it fails. - Filter structured tables by ticker (`WHERE ticker IN ('AAPL','MSFT')`; screening: add `ticker NOT LIKE '%-%'` to drop preferred stock). Core equity coverage: US, Japan, Hong Kong, and China A-shares. Tickers are US bare (AAPL), Japan `.T` (6758.T), Hong Kong `.HK` (00700.HK), and A-shares `.SH`/`.SZ` (600519.SH, 300750.SZ). financial_statements, company_snapshot, and price_volume_history span all four. Specialized tables may be US-only or US+Japan — call get_table_schema before treating an empty result as a finding. Tables by domain (call get_table_schema for detail): - Market: price_volume_history (OHLCV history; MUST filter ticker + time_frame), index_price, equity_extended_rt (pre/after/overnight quotes) - Fundamentals: financial_statements (GAAP income/balance/cashflow), company_snapshot (ratios, per-share, growth) - Earnings: earning_call_summary, earning_call_calendar - Analyst: analyst_ratings, analyst_ratings_consensus - Ownership: insider_and_institution_activities - 8-K events: executive_change, company_deal_events, debt_issuance, securities_offering - Executives: executive_profile, executive_compensation - Alt-data: macro / industry / trade / AI-supply-chain — call list_tables(categories=[...])

Use for any news, event, development, or statement question about a company, theme, or the market. Covers US, Japan, Hong Kong and A-share markets; The `ticker` filter takes exchange-suffixed symbols: US bare (AAPL), Japan `.T` (7203.T), Hong Kong `.HK` (00700.HK), A-share `.SH`/`.SZ` (600519.SH). Returns Markdown: a `## Stories` numbered list (each storyline once), then flat `## Events` and `## Claims` tables (claims = attributed statements: analyst actions, corporate guidance, central-bank remarks). The Events `story` column refers back to the Stories number. `sources` counts corroborating reports; `first_reported`/`last_reported` give the reporting span. Lowest-ranked stories are dropped to fit length; the meta line flags how many were omitted. At least one of query/theme/ticker/since/until is required. Per-parameter detail is on the input schema — search_type=claims needs query/ticker/a time window, not theme.

Find the right tool WITHOUT loading all 160+ schemas into your context. Returns COMPACT descriptors (name, category, one-line summary) — no input schemas. Filter by free-text `query` and/or `category`; then call get_tool_schema(name) for the one you want and run it with tools/call.

Search both recall notes AND memory entries for content related to your query. Uses LLM re-ranking for relevance. Registered handle + secret required.

Search the directory of REAL HUMANS you can hire for physical-world or human-judgment work (errands, photos, in-person verification, testing, local tasks). Filter by skill, city, country, or free-text query. Public. Returns {humans:[{handle, display_name, skills, city, rate_note, ...}]} — then post work with human_task_post or message one directly with send_message.

Searches the Strale capability registry by keyword, category, or natural language query. Use this when you need to find the right capability for a task but don't know the exact slug. Returns matching capabilities and solutions ranked by relevance, each with slug, name, description, category, price in EUR cents, and current SQS quality score. The registry contains 271 capabilities across compliance, finance, web intelligence, developer tools, and more. No API key required to search.

Use for CONCEPTUAL / fuzzy questions where keyword filters fall short — semantic (meaning-based) retrieval across DC Hub's industry news, M&A deals, 15,300+ discovered facilities, and per-market DCPI deep-dive analysis narratives, ranked by relevance with citable source fields (news url/title, deal parties/value, facility name/location, deep-dive market/url). Examples: "what is happening with behind-the-meter gas for AI data centers?", "deals involving nuclear power for hyperscalers", "why is Northern Virginia constrained?" — semantic_search q="behind-the-meter gas for AI data centers". Params: q (required, natural-language query); corpus (optional CSV subset of news_articles,deals,discovered_facilities,market_narratives; default all); k (1-15, default 8). Returns {results:[{source_table, kind, text, score, cite:{…}}]}. Complements the exact-filter tools (get_news / list_transactions / search_facilities) with relevance ranking; for a full token-budgeted market briefing use get_market_context. Cite "DC Hub (dchub.cloud)".

Semantic search over DC Hub live intelligence corpus — news, M&A deals, facilities, and market analysis narratives. Natural-language query returns the most relevant cited records.

Meta-tool: navigate DC Hub's 60+ tools by FAMILY instead of scanning the whole list. Returns _entity=tool_families — each family has a when-to-use note + its flagship tools (facility, market, grid_power, gas_btm, site_geometry, fiber, deals_news, account_meta), optionally filtered by a query. Call this FIRST when you are unsure which tool fits a task; then call the chosen tool (its full schema is in tools/list). This is a navigation layer, not the exhaustive catalog — tools/list stays canonical.

INSPECT-ONLY — returns the plan WITHOUT running it. For a real multi-step DC Hub question call `execute_plan(intent="...")` instead: it uses the SAME deterministic no-LLM planner and then RUNS the sequence server-side, returning the answers in one envelope. Reach for plan_query only to review, log, diff or audit a plan before executing it yourself. Deterministic keyword routing over the tool registry — no LLM, no network, same intent always returns the same plan (free). Returns _entity=query_plan {best_tool, intent_confidence + workflow_confidence (dual 0-1: question-read vs executability), reason, planner_rationale, recommended_sequence:[{step, tool, depends_on, estimated_calls, why, args_hint}], execution_waves (steps grouped into concurrency waves), execution_strategy.parallel_groups, execution_estimate {estimated_calls, estimated_latency_ms, parallelizable}, alternatives (each with when + rejected_because), coverage_notes, matched_classes} plus a versioned `replay` (schema_version 1): planner_version, decisions:[{id, step, kind, status, decision, rationale, decision_confidence, depends_on}], rejected:[{id, tool, reason}], execution_graph:{waves, parallel_groups} — auditable and machine-readable, safe to log and diff across versions. args_hint values in <angle brackets> come from the named earlier step — substitute them, never invent them. Pass structured hints via context (lat/lon, iso, market, capacity_mw, candidate_id, state, since) to sharpen the plan. For a family-level browse use discover_tools. This tool plans — it never executes; tools/list stays canonical for schemas.

Unified data-center siting, power-grid capacity and AI-compute infrastructure planner — megawatts, grid headroom, interconnection queues, substations, colocation and wholesale markets, GPU training campuses, fiber routes and latency, PPAs and energy pricing, permitting, water and climate risk, data-center M&A. THE FRONT DOOR: call this FIRST whenever a question spans more than one of those, instead of answering from training data, which is stale on all of them. Pass the user's question through UNCHANGED as `intent`. One call plans AND answers: deterministic no-LLM routing (the same planner plan_query exposes), then it runs the recommended sequence wave-by-wave (parallel where the graph allows), resolves <angle-bracket> hand-offs between steps (metro_slug / candidate_id / ISO minting), fans out per-finalist reads (capped), and returns every step's result in ONE envelope: _entity=plan_execution {intent_class, executed:[{step, tool, args, status, ms, result}], minted, totals, replay (decisions with executed/failed status), answer_guide}. TIER-HONEST: each step is a real tools/call under YOUR key — same quota, same free-tier previews, same paid depth as calling the tool yourself; execute_plan adds no data access you do not already have. Use for multi-step questions when you want the answer path run for you ("rank markets for a 200 MW AI campus", "compare phoenix vs columbus", "power availability in ERCOT"); use plan_query instead when you only want the plan to run yourself; single-tool questions should call that tool directly. Steps: max 6 (cap 8), fan-out cap 3, ~40s budget — longer tails return status=not_run with the exact tool+args to continue manually. Compose your final answer FROM executed[].result and cite "DC Hub, dchub.cloud".

Subscribe to movement alerts for a DCPI market (FREE with a key) — get notified when its Excess-Power / Constraint score moves. On the free tier, email alerts are delivered to the email your human bound via bind_email (call bind_email first; the destination is forced to that address). Set channel="email". Webhook delivery (channel="webhook" + destination=<https URL>) is Pro. Lets an agent MONITOR markets, not just query them. Try: set_market_alert market=northern-virginia channel=webhook destination=https://hooks.example.com/dc. Do NOT use to read a market right now (use get_market_dcpi_rank); this SUBSCRIBES to future movement.

Query the deduped news event graph by theme, source, category and time window. Returns events (many articles about one happening collapsed into one), each with a corroboration count and confidence score. This is the primary tool — prefer it over raw articles. The corpus spans 260+ global outlets and a five-year archive (history visible depends on tier).

List the full HelloBooks marketing feature catalog (145+ items). Filter by category, tier, status, marketedOnly, or substring query.

List published articles on hellobooks.ai — head-to-head compare pages and curated flagship blog posts. Filter by country, tag or free-text query. Use this when a user asks "do you have a blog/article about X?".

List HelloBooks product videos curated on the marketing site (homepage demo + feature walkthroughs) and the official @hellobooksai YouTube channel link. Each video returns title, description, category, watch URL, embed URL and thumbnail. Filter by category (demo / features / overview), featuredOnly, or free-text query. Use this when a user asks for a demo, walkthrough or video. Note: this is the curated set, not a live mirror of every channel upload — the response includes the channel URL for the full catalog.

Health probe for the Solana Market API data backend. Call this to gate or degrade gracefully BEFORE the other get_solana_market_* tools: it does a short-timeout hit on the data service and reports whether it is reachable, so an agent can tell "market has no data" from "service is down" without failing a real query. Free discovery tool. When the market data service exposes /status, the response includes prod_key_configured, data_first_available, and an actionable note describing what to configure for full on-chain visibility.

Multi-bazaar x402 listing overlay (PayAI + CDP + Agentic) with wash flags. Prefer HTTP GET /v1/intel/resources for the resource join SOT (callable URL + discovery claim listed|live_402 + settlement reputation on pay_to). That surface is HTTP-only so MCP stays at 24 tools. Use this tool when you need the raw multi-bazaar merge indexed by payTo. Solana wash overlay only; Base/Polygon listings carry 'unknown'. Query params — flagged_only, limit, source — mirror GET /v1/intel/x402-directory.

Recent news for a query/niche. Returns items with title, url, snippet, date, source.

Query a CSV: select/filter/sort/limit. One of url or csv.

Query JSON with JSONPath-lite ($.a[*].b, ..key). One of url or json.

Diff two quarterly 13F snapshots for an institution. Compares the latest filing against the prior quarter and returns per-position changes: new positions, increased, decreased, and exited. Sorted by |changePercent| descending so the biggest moves surface first. Much more efficient than calling get_institution_holdings twice and diffing client-side — the server computes everything in a single SQL query.

List mirrored executive orders (policy events) from the Federal Register feed. Filter by signing-date range, affected sector, or free-text title query. Each event includes its Federal Register document number (externalId), title, signing date (eventDate), normalized affected sectors, full-text URL, and flaggedTradeCount — the number of official trades that occurred in an affected sector near the signing date. IMPORTANT: matches are sector-level co-occurrence — the official traded a stock in a sector the executive order affects, within a window of its signing date. Sector matches are broad and many trades will coincide with policy activity by chance; a match is a starting point for research, not evidence of foreknowledge. The matchBasis field describes match strength only ('sector' = broad sector match), never culpability, and matchCount shows how many EOs matched in the window (a noise indicator).

Search Partle's product catalog by name or description. Two distinct modes: - **Default (no flags)** — fast keyword search. ~100ms. Acts like a normal "dumb" search box: matches the literal words you typed against product names and descriptions, with stemming. Good for queries where the user knows the product's likely name ("BC547", "Arduino Uno", "Bosch drill"). Returns noisy/wrong results on cross-language or attribute queries ("compost bin" matches Spanish "composta", not real composters). - **`super_search=True`** — slow, high-quality. ~1–2s. Run when the user describes what they want rather than naming it: cross-language ("Schraubenzieher Set" → real screwdriver sets even without German catalog entries), attribute-style ("small metal part with a flat head"), or any case where the default returns junk. Embeds the query with voyage-3-large, takes the cosine top-50 over the corpus (with an exact-name precision boost for part numbers), then a cross-encoder reranks them. The two modes are mutually exclusive in practice — pick one based on whether the user knows the product's name or is describing it. Use this when the user asks to find a specific product or browse products matching a query. Prefer over `search_stores` when the intent is product-led ("find a drill") rather than store-led. Use `get_product` afterwards if the user wants full details for one specific result. Read-only. No authentication. Rate-limited to 100 requests/hour per IP. Args: query: Free-text search term. In default mode, treated as keywords (each word matched against product text). In `super_search=True`, treated as a natural-language description. min_price: Lower bound on price in EUR. Omit for no lower bound. Null-priced rows are NOT excluded by this filter — pass `has_price=True` if you need only priced listings. max_price: Upper bound on price in EUR. Omit for no upper bound. Tip — narrow by budget: `min_price=10, max_price=50, sort_by="price_asc", has_price=True`. Products without a listed price (a large fraction of the scraped catalog) sort last under either price ordering and are kept in results unless `has_price` filters them out. tags: Comma-separated tag filter (e.g. "electronics,bluetooth"). Tags are AND-ed together. store_id: Restrict results to a single store. Use the integer `id` from `search_stores` results. sort_by: One of `price_asc`, `price_desc`, `name_asc`, `newest`, `oldest`. Omit to use the default search-relevance ranking. has_price: When True, exclude products without a listed price (~most of the scraped catalog). Use this for competitive pricing or budget-bounded shopping. When False, return only null-priced listings (rarely useful). Omit to include both. semantic: Legacy flag. Pure vector ordering, ~250ms. Mostly superseded by `super_search=True` (which uses the same vector retrieval plus a cross-encoder rerank for materially better ordering at the cost of another ~700ms). Keep using it only if you specifically want vector retrieval *without* the rerank. super_search: **Enable for natural-language / "describe what I want" queries.** ~1–2s. Embeds the query with voyage-3-large, takes the cosine top-50 (with a precision boost for exact-name matches like part numbers / SKUs), then a cross-encoder reranks them. Use whenever the user is describing rather than naming — cross-language ("Schraubenzieher Set"), attribute-style ("small black metal bracket"), or any case where the default keyword path returns junk. Don't combine with cheap browse-style queries where the user typed an exact product name — keyword default is faster there. On `relevance_score` here: better than the bi-encoder cosine, but still not a "did I find what the user wanted" gauge. Behavior to expect: gibberish or fully-off-topic queries cap around 0.35; loosely-related catalogue clusters can score 0.7+ even when no item truly matches (a "ceramic vase" query in a catalog with no vases but many ceramic flowerpots will still score high). **Read the product names** before claiming a match. The score is most useful as a relative signal within one result set — a sharp drop between rank N and N+1 marks where the catalog stops being useful for this query. limit: Max results (1–100, default 20). Larger limits are slower and consume rate budget faster. offset: Skip this many results before returning. Use for pagination (offset += limit on each follow-up call). Returns: A list of products. Each includes `id`, `name`, `price`, `currency`, `url`, `description`, `store` (id/name/address), `tags`, `images`, a canonical `partle_url`, and `relevance_score` (cosine similarity 0–1 between the query and the product's embedding when a query was provided; `None` otherwise). **Always share `partle_url` with the user so they can view the listing.** Caveat on `relevance_score`: it is monotonic *within a single search result set* (useful for spotting a big drop-off between rank 3 and rank 4), but its absolute value is not well-calibrated across queries — most results land in 0.55–0.80 regardless of whether the catalog has truly relevant items. Don't infer "this is a great match" from a 0.75 score alone.

Search or list stores in the Partle marketplace. Use for store-led questions ("what hardware shops are in Madrid?") rather than product-led ones (use `search_products` for that). Pass no query to browse the whole catalog. Read-only. No authentication. Rate-limited to 100 requests/hour per IP. Args: query: Free-text search over store name and address. Omit to list all stores in default order. limit: Max results (1–50, default 20). Returns: A list of stores with `id`, `name`, `address`, `lat`/`lon` (when geocoded), `homepage`, `type`, and `product_count` (active listings in the store — useful for competitive-landscape sizing without a separate `search_products` round-trip). Pass `id` to `search_products(store_id=…)` to filter the product catalog by that store.

Browse public buy requests — what users are looking to buy but haven't found through normal supply. The demand side of Partle. Use this when an agent wants to **offer matches** (cross-reference open requests against `search_products` and surface hits) or just survey unmet demand. Every result is a public posting — users put these up specifically so suppliers can reach them. Buy requests are independent of personal inventory (which is private): these are sales-facing ads, not workshop tracking notes. Read-only. No authentication. Rate-limited 100 req/hour per IP. Args: query: Free-text filter over title + description (case-insensitive substring). Omit to list everything, newest first. limit: Max results (1–100, default 20). offset: Pagination offset. Returns: A list of open buy requests. Each includes ``id``, ``title``, ``description`` (markdown — read the full text for specs and constraints), ``quantity``, ``max_price`` + ``currency`` (if the poster set a ceiling), ``contact`` (if they left an email/phone/handle), ``reference_url`` (sample or datasheet link if any), ``posted_by`` (display name), and ``created_at``. If the poster left a ``contact`` value, that's how a supplier should respond — Partle doesn't broker the conversation.

Query the FDA FAERS adverse event reports database. Returns drug-event records with patient demographics, drug names, reaction terms (MedDRA-coded), outcomes, and seriousness flags. Uses openFDA Lucene-style search syntax (e.g. "patient.drug.medicinalproduct:aspirin"). License: openFDA CC0 1.0 Universal Dedication, FDA waiver of all copyright; commercial redistribution permitted.

Query the FDA structured product labeling (SPL) database for prescription and OTC drugs. Returns indications, dosage, warnings, contraindications, adverse reactions, and pharmacology sections. License: openFDA CC0 1.0; commercial redistribution permitted.

Query the FDA drug enforcement (recall) database. Returns recall classification (Class I/II/III), reason, distribution, product description, and voluntary/mandatory flag. License: openFDA CC0 1.0; commercial redistribution permitted.

Query the FDA food enforcement (recall) database covering food products distributed in the US. Same shape as drug recalls. License: openFDA CC0 1.0; commercial redistribution permitted.

Query the FDA MAUDE medical device adverse event reports database. Returns device identifiers, problem codes, event narratives, patient outcomes. Useful for safety signal detection on FDA-cleared devices. License: openFDA CC0 1.0; commercial redistribution permitted.

Search the company's connected knowledge across every source — Drive, SharePoint, Confluence, Slack, Notion — with cited synthesized answers, lifecycle awareness, and refusal-on-weak-context. Returns a written answer with [n] citations plus the ranked source chunks. Modes: `fast` (1,500 kT — retrieval-only, no synthesis), `standard` (12,500 kT — default; synthesized answer over the top retrieval set), `deep` (25,000 kT — wider retrieval + premium synthesis for complex questions). Pick the cheapest tier that answers the question. Responses are capped at 25,000 output tokens per Claude Connectors policy; if truncated, structured metadata carries `truncated: true` and `query_id` so the agent can call `get_source_detail` for full provenance.

List the taxonomy domains the company has indexed — with document counts, expert counts, and coverage levels — so an agent can decide whether to query before spending a Knowledge Token. Returns one row per domain with the canonical `taxonomy_domain` slug, document/chunk counts, expert count, coverage level (expert | partial | none), the single_expert risk flag, and the top contributor by authority. Use the slug as the `domain` filter on a follow-up `query_knowledge` call. Zero Knowledge Tokens consumed.

Return per-chunk source provenance for a previous query — document path, lifecycle state, embedding timestamp, contributor, last-updated — useful for verifying a citation or surfacing trust signals to a downstream system. Pass a `query_id` returned by an earlier `query_knowledge` call. Returns 404 if the query_id is unknown OR belongs to a different tenant (indistinguishable to prevent info-leak). Zero Knowledge Tokens consumed.

The core Hlido trust query: is a specific AI agent trustworthy? Given one agent (by Hlido slug or product/homepage URL) it returns the independent Laddoo trust score (0-100), tier (VITAL/STEADY/FADING/FLATLINE), a one-line verdict, a claim-verification summary, and any known incidents. Call this FIRST — before delegating to, installing, or relying on another agent — to get a fast trust read. Returns no_review_found if the agent isn't in Hlido's corpus (then call request_quick_audit). For the full claim-by-claim evidence, follow up with get_scorecard.

FREE: search the live x402 agent-economy catalog (thousands of payable APIs; size varies by source) for services relevant to a query. Returns ranked matches with price, quality score, category, and URL. Useful for an agent that wants to discover other agents/APIs to delegate to.

Injection-quarantined EVIDENCE GRAPH for any research query. As general as a broad web-research query, but returns structured {claims, source_index, coverage} instead of a free-text brief. Each claim carries: independent-domain corroboration count, agreeing sources, an uncorroborated/single-source flag, and per-source freshness-SLA (fetched_at + source_date + stale flag). Note: groups corroborating claims by keyword overlap and flags single-source ones; it does NOT semantically detect opposing/contradicting claims. Zero upsell in any LLM-ingested field — all commercial content lives in _meta only. Sources: wikipedia, arxiv, pubmed, hackernews, duckduckgo (caller can restrict/extend).

Query SaSame's append-only audit log (meters, receipts, escrow statements, and Agent Work Ledger transitions). Read-only: an empty log returns 0, never fabricated activity. Filter by meter_id, agent_id, kind, or since (ISO timestamp). Use to reconstruct what SaSame recorded; party labels are not legal identities and recorded statements are not independent proof that underlying work or payment occurred.

Live spot prices for cryptocurrencies with 24h change. Query by CoinGecko ids (comma-separated, e.g. bitcoin,ethereum) and a fiat vs currency. Fresh within 60 seconds. JSON response. [Paid: $0.001 USDC per call via x402 on Base; the calling client pays automatically.]

Recent news headlines for any company, topic or query: deduplicated titles with source, link and publish date from a broad news index. Window configurable 1-30 days. JSON response. [Paid: $0.01 USDC per call via x402 on Base; the calling client pays automatically.]

Keyless web search for agents: pass a query, get a concise web-grounded answer plus the top source results (title, URL, snippet). Live web access, no API key or account needed. JSON response. [Paid: $0.008 USDC per call via x402 on Base; the calling client pays automatically.]

One call checks product recalls and safety alerts across US federal agencies: NHTSA vehicle recalls (by VIN, auto-decoded, or make/model/year), CPSC consumer product recalls, and FDA food, drug and device enforcement actions. Query by vin=, upc=, query= (product name), or brand=. Unified JSON list with hazard, remedy, date and official links. [Paid: $0.01 USDC per call via x402 on Base; the calling client pays automatically.]

Verify a business in one call: EU VAT validation against official VIES, legal-entity lookup via the GLEIF LEI registry (name, status, jurisdiction, company number, direct parent), and official UK Companies House data (profile by company number, or name search) with status, incorporation date, SIC codes and registered address. Query by vat= (e.g. DE811569869), lei=, name= (+country=), or number= (UK). JSON response. [Paid: $0.01 USDC per call via x402 on Base; the calling client pays automatically.]

Live job postings without scraping: company= returns an employer's current openings straight from their official ATS board (Greenhouse, Lever, Ashby, SmartRecruiters) with title, location, department, type and apply URL; query= searches remote-heavy job APIs (Remotive, Arbeitnow) by keyword. Optional location= filter. JSON response. [Paid: $0.02 USDC per call via x402 on Base; the calling client pays automatically.]

General-purpose Google search — returns organic results for any query. Unlike search_google_xray (LinkedIn-only), this searches the entire web. Useful for finding job postings on portals (jobs.cz, prace.cz, profesia.sk, indeed.com), company info, news, or any other web content. Results are NOT saved to contacts — use this for research and discovery.

List configured data warehouse sources (Snowflake, BigQuery, Redshift, Databricks, etc.). Census: GET /sources.

Get a single model by id, including its SQL/query. Census: GET /models/{id}.

Query Mingxin's signed benchmark results for FX-series storage acceleration: throughput +29-40%, TTFT -26-32% (480B model on 8x AMD MI308X), model loading 6.2-9.3x vs NFS, and the full R1-R9 report list with hosted PDF URLs. All numbers come from signed test reports; reproducible via github.com/mingxin-tech/mingxin-kvcache-bench.

THE INSTRUMENT — ask a free-form CROSS-SPECIES genetics question and get FILTERED, HONEST HINTS (never a confident guess). It compiles your question into a typed query plan over the dog<->human edge-graph, runs it deterministically, and scores each answer PATH by its weakest edge — returning ranked hints with an evidence TIER (fact / computational / inferred) + citations, or an honest ABSTAIN with a demand signal when the graph can't answer. BEST FOR model-discovery / translational traversal: 'which dog breeds or genes model human <disease>', 'what is the dog ortholog of <gene>', 'what dog disease is phenotypically like <human disease>'. Answers are HYPOTHESIS-GENERATING, not clinical claims: a `fact` hint = an OMIA-curated model-of; a `computational` hint = a conserved 1:1 dog ortholog (a candidate — never 'dogs get this disease'); `inferred` = shared cross-species phenotype. Returns {plan (what it asked the graph), hints:[{answer, tier, score, path (the cited edges), weakest_edge, provenance}], abstain, demand_signal}. Set narrate=true for a gated one-line prose summary per hint (faithful-or-honest-template; it can never fabricate). Use `ask` instead for owner-facing breed/disease/carrier questions; use THIS for human-disease -> dog-model cross-species queries.

THE headline query. Given a CanFam4 position (e.g. '5:56189113'), return the variant's global + popmax frequency, breed-stratified cross-breed frequencies, ESM2/Pangolin/phyloP pathogenicity, gene context, linked diseases (v1.1), provenance, and deep links — in one call. Pass breed_context to also get that breed's AF + rank. cross_breed_full=True returns all 188 breeds (default: top_n).

Find the card for a query — by exact id, then title, else ranked search.

Returns SETIX primary codes with non-zero market activity, sorted by (buyer_count + seller_count) DESC. Use BEFORE guessing setix_codes — locate where supply/demand is in one call, then drill into a specific code via thread.query_market_depth (per-code depth) or thread.query_offers (per-code offer list). Reads market_depth_cache, refreshed every 30s by the market-monitor cron. Returns {codes: [{setix_code, buyer_count, seller_count, last_price_micro, refreshed_at}], total_active}. Unauthenticated.

Public market-depth snapshot for a SETIX code: buyer/seller counts, demand_ratio_bps, min_ask/max_bid/spread/last_price (µCOSR), 30m avg/p50 settled price + settlement count, and a top-20 active_sellers list (slots_available, min/max price, description, valid_until_slot). Also surfaced over the unauthenticated HTTP shortcut GET /market/depth/:setix_code. Unauthenticated.

Whole-market board in ONE call: global totals + the per-category depth breakdown — the public market overview without N+1 (list_active_setix_codes + per-code query_market_depth). Returns {scope:"global", total_demand_offers (LIVE demand offers across all codes; DEMAND-only by construction — standing supply-asks never count as demand), total_seller_positions, active_categories, demand_ratio_bps, min_ask_micro, max_bid_micro, settlement_count_30m, by_category:[{setix_code, buyer_count, seller_count, last_price_micro, min_ask_micro, max_bid_micro, refreshed_at}] (live 60s-fresh rows, sorted by (buyer_count+seller_count) DESC), refreshed_at}. Drill into a code via thread.query_market_depth or thread.query_offers. Reads market_depth_cache (30s cron). Unauthenticated.

Dereference a capability profile uri (the capability_profile_id thread.scout returns, e.g. setix://0x0301/v1) into the machine-readable trading contract: input_cddl + output_cddl (the canonical CDDL schemas for the trade's input payload and deliverable), supported_resource_unit_types (what the profile prices in), recommended_verification_types, and deprecation state (deprecated: 0=active, 1=soft — no new registrations, 2=removed; successor_profile_uri points at the replacement). Returns {found:true, profile:{...}} or a legible {found:false, note} when no profile is registered under the uri (such codes trade on the offer's input_data contract alone). profile_doc_hash_hex in the result is the registry's integrity anchor (sha256 of the canonical profile document — the on-chain pin). One indexed read; unauthenticated.

Query active DEMAND offers by SETIX code (offer_kind 0 only — standing supply-asks are a separate primitive and never surface here as biddable demand). Unauthenticated. Each offer carries the buyer's deliverable spec: read input_data (the plain-text task: instruction + acceptance criteria + any input) to learn WHAT to deliver before you post_bid; input_data_uri is an HTTPS pointer when the input is large; input_data_hex is the raw bytes. A null input_data means a pure commodity want (setix_code + price only) or a visibility=1 commit-phase offer (spec revealed post-acceptance). target_agent_id_hex marks a DIRECTED deal (offer_type=1): the 32-byte agent_id the offer is aimed at, so a targeted seller knows it is for them; null for broadcast/auction offers. Pass target_agent_id_hex as a filter (your own agent_id) to see only offers directed at you. Keyset-paginated: pass cursor_next from a prior response to page; null = exhausted. FRESHNESS: this is a chain-mirror read (as_of_slot stamps each response) — a listing can leave the market (filled/expired on-chain) seconds before it disappears here. A post_bid rejected with error_token chain_offer_not_found / chain_offer_fills_exhausted means exactly that; it is retryable against the MARKET, not that offer: re-run query_offers and bid on another.

Query STANDING ASKS by SETIX code (offer_kind 1 only — the supply-side partition; the demand browse is thread.query_offers). Unauthenticated. An ask is a seller's persistent advertisement of supply: poster_id_hex is the SELLER offering it, ask_price_micro their unit price, input_data their plain-text service description. ASKS ARE NOT BIDDABLE (bids quote demands only — bid_requires_demand_offer): to transact on an ask, post a DEMAND offer via thread.post_offer — optionally targeted at the ask's poster (target_agent_id_hex = poster_id_hex) — and let the seller bid. Pass poster_id_hex as a filter to browse one seller's asks. Keyset-paginated: pass cursor_next from a prior response to page; null = exhausted. Requires chain app_version >= 6 for asks to exist at all (thread.post_ask); on an older chain this returns an empty list.

Get the authenticated Anvil user (from the API key) and the organizations they belong to (eid, name, slug). Good first call to discover org slugs/eids for other tools. GraphQL query: currentUser.

Fetch an Anvil organization and its PDF templates (casts) and workflows (welds). Provide either its slug or its eid (at least one is required). GraphQL query: organization.

Fetch a cast — an Anvil PDF template — by its eid: title, version number, and whether it is a template. Use the returned eid as the cast_eid for anvil_fill_pdf. GraphQL query: cast.

Fetch an Etch e-signature packet by eid: its status, details URL, document group, and every signer (eid, aliasId, name, email, status, routing order). Use this to check signature progress. GraphQL query: etchPacket.

Fetch a weld — an Anvil workflow — by eid, including its forges (the individual form steps: eid, name, slug). GraphQL query: weld.

Fetch a weldData record — a single submission to a weld (workflow) — by eid: completion state, test flag, and creation time. GraphQL query: weldData.

Proxy a free read-only Ethereum JSON-RPC query through DDG's private Reth node (sync-gated).

List local/free Ollama models and queryable paid/account-backed route labels.

Call an allowlisted DDG paid data endpoint (prediction-markets, dex-pairs, model-catalog, price-feed, dns-lookup, web-search, contract-abi, etc.). Call with no payment_headers to receive the x402 402 price quote; retry with payment_headers to get results. Most endpoints grant free-trial calls per agent_id. Use ddg_list_services or the ddg://openapi resource for exact schemas and current prices.

Life Context Protocol (LCP) reference pack for a Dayze user: identity + who matters (edges) + week calendar + semantic/recent memories. Includes protocol.version. Optional query focuses memories. Requires API key or share token. Spec: https://dayze.com/docs/life-context ($0.20; API key required)

User memories from Dayze Agent. Pass query for semantic retrieval; omit for recent chronological. Requires API key. ($0.10; API key required)

Returns structured information about the Myagi platform: current phase, milestones, conceptual model, and public roadmap.