Tool search 164,478 tools · 10,067 live servers

Retrieve previously stored memories, optionally filtered by search query and/or project. Call at the start of work on a known project to restore context: why decisions were made, known fixes, preferences. Example — GET https://ainetcafe.com/t/recall?query=<what+to+remember> (needs a workspace/key for durable memory)

Search the live web through a self-hosted SearXNG meta-search (aggregates dozens of engines, no tracking). Returns titles, URLs and snippets. Use when you need current information or sources. Example — GET https://ainetcafe.com/t/web_search?query=latest+MCP+spec

Convert a SQL statement from one dialect to another — mysql, postgres, sqlite, tsql, oracle, snowflake, bigquery, redshift, spark, hive, presto, trino, duckdb, clickhouse, databricks, doris, starrocks and more. Deterministic parser (sqlglot), not an LLM: the same input always produces the same output, and syntax errors come back with the exact line and column. Use it when migrating queries between databases or debugging dialect-specific syntax.

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 you log with so you recall the right person's memory. SCOPING: customer_id is B2B ONLY. On a B2B instance (user_context_isolation=strict) it is REQUIRED and a user_id on its own is an error. On a B2C instance (user_context_isolation=equals_customer) it is NOT accepted: the API rejects it with HTTP 400, customer-scoped retrieval does not exist there, and user_id is the whole identity. If you do not know which mode this instance is in, send user_id only and no customer_id; GET /api/v1/auth/whoami reports the mode as user_context_isolation.

Mint the canonical, vendor-neutral address (cell64) for a real-world place: the shared spatial identity every agent resolves to identically, so two models refer to the same ground instead of two descriptions of it. Also returns the topic-grouped inventory of bands and algorithms recallable there. For a first-class OBJECT identity (a bridge, a plot, a named place) rather than a raw cell, use emem_entity. Send EITHER `lat`+`lng` as numbers OR a free-text place; coordinates win when both arrive. `q`, `query` and `name` are all accepted spellings of `place`. A key this schema does not declare is reported in `_unrecognised_arguments`, so a typo answers about somewhere else rather than erroring. When to use: Use whenever the input refers to a real-world location and the next step needs the cell64 identifier or wants to know which bands are available before recalling. The response carries `data_at_this_cell` with three sub-fields: `live_bands_by_topic` (every band recallable here, grouped by topic such as flood_water_event_window, vegetation_condition, built_up_human_geography), `algorithms_for_topic` (composition recipes that fuse those bands into named scores), and `declared_but_no_materializer_at_this_responder` (cube slots reserved without a live connector). For the single-shot path that runs the full chain server-side and returns one packaged answer, use `emem_ask` instead. Example arguments: {"place":"Mount Everest"}

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.

Recall persisted memory by query. Alias of recall.

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" | "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` (6758.T), 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, China A-shares, and Korea. Tickers are US bare (AAPL), Japan `.T` (6758.T), Hong Kong `.HK` (00700.HK), A-shares `.SH`/`.SZ` (600519.SH), and Korea `.KS`/`.KQ` (005930.KS). financial_statements, company_snapshot, and price_volume_history span all five. Specialized tables may be narrower — 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.

Get pre-computed market intelligence for a specific stock, crypto, or ETF ticker. Supports 4 modes: (1) Snapshot (default) for the latest categorical state; (2) Historical snapshot by date; (3) Historical series with start and end dates; (4) Events by field and optional band, including aftermath fields on paid tiers, weekly trend_stage analysis, pattern setup states such as pattern_bull_flag and pattern_ascending_triangle, MA signal fields, trend_ma_crossover_event, MA distance lookbacks such as trend_distance_ma40, and stock-only fundamentals_free_cash_flow events. Add stats=true in event mode to return aggregate event-band and aftermath distributions instead of raw rows. Results can include freshness via as_of_date, same-candle OHLCV, market_cap, market_cap_tier, trend, momentum (including raw rsi, stochastic_k, stochastic_d alongside their zones, divergence_detected, divergence_type, stochastic_zone), volatility (including squeeze_active, squeeze_days), volume (including climax_detected, climax_type), patterns, support/resistance, levels (paid tiers), sector_context (rsi_zone, trend, agreement, asset_vs_sector_rsi), and stock-only fundamentals such as raw pe_ratio (latest ratio on or before the snapshot date; negative values preserved and unavailable values null), free_cash_flow, growth_zone, earnings_proximity, earnings_proximity_basis, analyst_consensus, valuation_percentile, and nested insider_activity when available. Raw momentum values (momentum.rsi 0-100, momentum.stochastic_k, momentum.stochastic_d) are the exact numbers behind their zones for all asset classes and both timeframes, null while lookbacks form; query zone transitions via momentum_rsi_zone / momentum_stochastic_zone, not the raw values. Summary keeps sibling _meta objects off by default; set meta=true or request explicit *_meta fields when paid-tier stability metadata is needed.

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, and price in EUR cents. The registry spans company data, compliance, finance, web intelligence, and developer tools. No API key required to search.

Read the current chain head — EVM block number or Solana slot — for a supported network. Free, read-only, no wallet needed. Use this to confirm a network is progressing before submitting a transaction, correlate off-chain events with on-chain height, or choose a safe starting point when scanning logs. Pass `chain` as one of: solana, solana-devnet, ethereum, sepolia, polygon, amoy, bsc, bsc-testnet, base, base-sepolia, tempo, tempo-testnet, arbitrum-one, monad, skale-base-sepolia. Omit `chain` (or pass `all`) to query every resolvable chain in one call.

Places, solar, and aerial-view lookups, paid per call directly from the caller's own wallet via the x402 protocol — no Abstraxn account needed. Pick one `action`: - text_search_full ($0.08): full-detail place text search. Requires `textQuery`. Optional `maxResultCount` (1-5, default 5), `excludeFields` (default ["photos"]), `pageToken`, `locationBias` ({circle:{center:{latitude,longitude},radius}}), `includedType`, `languageCode` (default "en"), `openNow`, `minRating` (0-5), `priceLevels`. - text_search_partial ($0.02): same as text_search_full but returns fewer fields per place — cheaper for quick lookups. Same parameters. - nearby_search_full ($0.08): full-detail search for places within a radius. Requires `locationRestriction` ({circle:{center:{latitude,longitude},radius (0-50000)}}) — do NOT send a bare top-level latitude/longitude/radius. Optional `includedTypes`/`excludedTypes` (max 50 each), `maxResultCount` (1-5, default 5), `excludeFields` (default ["photos"]), `languageCode` (default "en"), `rankPreference` (POPULARITY default, or DISTANCE). - nearby_search_partial ($0.02): same as nearby_search_full, fewer fields, cheaper. Same parameters. - place_details_full ($0.05): full details for one place. Requires `placeId` — the exact place id returned by an earlier text_search/nearby_search result; do not invent or guess it. Optional `excludeFields` (default ["photos"]), `languageCode` (default "en"). - place_details_partial ($0.02): same as place_details_full, fewer fields, cheaper. Same parameters. - solar_building_insights ($0.02): rooftop solar potential for one location. Requires `latitude` (-90..90) and `longitude` (-180..180). Optional `requiredQuality` (LOW/MEDIUM/HIGH, default HIGH). - solar_data_layers ($0.08): raw solar data layers for an area. Requires `latitude`, `longitude`. Optional `radiusMeters` (0.1-175, default 50), `view` (default "FULL_LAYERS"), `requiredQuality` (default HIGH), `pixelSizeMeters` (default 0.25, documented as one of 0.1/0.25/0.5/1.0 but not schema-enforced), `exactQualityRequired` (default false). - solar_rgb_image ($0.05): renders one of the solar_data_layers assets as a viewable image. Either `id` (the exact asset id already returned by an earlier solar_data_layers call — "Mode A"; do not invent or guess it) OR both `latitude` and `longitude` ("Mode B") is required — provide exactly one mode, not both. Optional `radiusMeters` (0.1-100, default 30, Mode B only), `layer` (default "rgb"), `month` (1-12), `hour` (0-23), `format` (png/jpeg, default png), `scale` (1-2, default 1), `crop` (default false), `quality` (1-100, default 85). - aerial_view_lookup_video ($0.01): check whether a rendered aerial-view video already exists / poll its render status. Exactly one of `address` or `videoId` is required — `videoId` must be the exact value returned by an earlier aerial_view_render_video call; do not invent or guess it. - aerial_view_render_video ($0.01): kick off rendering a new aerial-view video for an address. Requires `address`. Poll aerial_view_lookup_video with the returned videoId until ready. Pagination: text_search_full/partial and nearby_search_full/partial return `nextPageToken` when more results exist — repeat the ORIGINAL call (same textQuery / locationRestriction / etc.) with `pageToken` set to page further. `pageToken` must be the exact `nextPageToken` value from that earlier response — do not invent or guess it. excludeFields: colon-separated nested-path syntax trims nested response fields, e.g. "organization:technologies" excludes just that sub-field. All place-search/details actions default-exclude `photos` if `excludeFields` is omitted — pass `excludeFields: []` to include photos. Prices above are indicative — the exact charge for a given call is always whatever the live payment challenge specifies for that request. The first call (no `paymentPayload`) returns `paymentRequired`; retry with the same arguments plus `paymentPayload` to complete payment and get the real result.

Inspect the native publication-rights status for the China-economic observation surface. The reviewed default-deny policy does not authorize redistribution of current CFETS/ChinaMoney values, so this tool returns policy digest, UTC clocks, per-source decisions and zero published-record status only. It never reads or returns observation rows, empty row arrays, derived signals, or neutral replacements. Filters are validated for contract compatibility but cannot override source rights.

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. For headlines, briefings, or 'what's happening' asks, pass min_sources: 2 (or 3 for high signal) — the raw recency feed is dominated by single-outlet local stories without it. ONE call is normally enough: trust each event's corroboration (distinct outlets), confidence (0-1; 1.0 = fully corroborated), and sources list as-is, and present the top events directly, including each event's url as its link — do NOT call get_event per item or re-verify counts (only drill in when the user wants EVERY outlet's link for one story). The corpus spans 260+ global outlets and a five-year archive (history visible depends on tier).

Query the current state of any in-flight async operation by operation_id. WHEN TO USE: Use to poll the state of a pending_async operation when no webhook callback has arrived or to check progress. WHEN NOT TO USE: Do not poll more frequently than once per 10 seconds — use webhook delivery for real-time updates instead. COST: free - no key required LATENCY: ~50ms

Free screening of a name or entity against official sanctions lists, each fetched from the authority that issues it: the OFAC SDN list from the US Treasury (SDN.CSV plus ALT.CSV for alternate spellings), the EU consolidated financial sanctions list from the European Commission, and the UK Sanctions List from the FCDO. THE UN CONSOLIDATED LIST IS NOT SCREENED -- it carries no licence permitting commercial redistribution, so we do not claim it. ALWAYS check lists_screened on the response: it names the lists that actually ran ON THAT CALL, and a list that failed to load appears in sources_unavailable instead. reason_code is 'partial_screening' whenever any source was unavailable, never 'clear'. Returns screening_status ('hit' | 'clean' | 'candidates' | 'not_screened' -- branch on THIS, not on matched, because matched:false is also false when nothing could be screened), matched: bool, a list of matches with score, program, and source URL, and which lists were screened. Never fabricates a match or a clear -- if no match is found, explicitly names which lists were checked. Attaches a compliance_receipt: an Ed25519-signed, hash-bound record of what was checked, when, against which sources, and what it returned - verifiable OFFLINE against the public key published at https://hatchloop.dev/agents.md, so you can hand it to an auditor as evidence the check really ran. EXAMPLE USER QUERIES THAT MATCH THIS TOOL: user: "Screen this vendor before we pay them: ACME Trading LLC, Russia" -> call screen_sanctions({"name": "ACME Trading LLC", "country": "RU", "type": "entity"}) user: "Is Kim Jong-un on the OFAC list?" -> call screen_sanctions({"name": "Kim Jong-un", "country": "KP", "type": "person"}) user: "Run a sanctions check on this person before onboarding" -> call screen_sanctions({"name": "Ivan Petrov", "country": "RU", "type": "person"}) user: "Do a compliance check -- is this company sanctioned?" -> call screen_sanctions({"name": "Mahan Air", "country": "IR", "type": "entity"}) WHEN TO USE: Use before onboarding a counterparty, processing a payment, engaging a vendor, or doing any due-diligence step that requires knowing whether a person or entity appears on official sanctions lists. Essential for agents doing business formation, vendor qualification, payments onboarding, trade compliance, or any workflow where a sanctioned counterparty is a legal or reputational risk. WHEN NOT TO USE: Do not use as a substitute for full KYC/AML screening -- this covers sanctions lists only, not PEP (Politically Exposed Person) databases, adverse media, or credit risk. Do not treat a negative result as a compliance clearance; it is informational only. Do not use for bulk screening of large lists -- each call is a live API query. COST: free within the daily quota, then $0.02 per call LATENCY: ~2000ms

Search the public trust index of agent endpoints — FREE, no key. Returns, per endpoint, what its registry CLAIMS and separately what Agent Guild OBSERVED when it actually called it. Those are different things and are never merged: measured 2026-07-31, 92.9% of registry-listed agents report healthy and 33.9% complete a task. Example: guild_index(query="translation")

Start here, and act on it without leaving this session. Self-registration is free and needs no key. You need no ~alter key and no human account: register_autonomous_challenge then register_autonomous mint you an owner-less ~handle in two calls, free-tier queries are live the moment it returns, and that handle is earn-eligible at mint, so paid reads against it settle to the handle. This call also returns what ~alter is (identity infrastructure; your ~Alter is your owned identity record, not an agent that acts for you), the tools which work without a key, an honest note that most depth is paid per query in USDC over x402 with prices read live, and the consent path that gates deep third-party data. Free L0, no authentication required.

List the canonical trait vocabulary: 30 trait codes grouped by category (Adaptive Capacity, Cognitive Style, Interpersonal Orientation, Drive Architecture, Integrity & Trust) with a one-line semantic per code, plus the valid discovery contexts and the traits never returned about a third party. Use this before composing the trait_priorities argument to query_field or the trait_criteria argument to create_requirement; both are credentialed tools and so are not on the anonymous listing, and query_field is priced per query in USDC over x402. Returns definitions only, never any member's evidence. Static reference data. Free L0, no authentication required.

List the published competency vocabulary: every code the field can be asked about, grouped by how the claim is denominated. A graded claim is climbed by degrees and takes a min_level; an attested_binary or issued_credential claim is held or it is not, and naming min_level against one is refused. Use this before composing the competency_requirements argument to query_field, a credentialed tool that is not on the anonymous listing and is priced per query in USDC over x402. Returns definitions only, never any member's evidence. Free L0, no authentication required.

Get aggregate ~alter network figures. Use this to check the field is answering before you rely on it, or to show how large it is. Returns total identities, verified profiles, query volume and active agent count, as whole-network totals only; nothing here is attributable to any member, and no handle can be identified from it. Takes no parameters. Free L0, no authentication required.

Open a deck to its frontloaded hand — the cards that situation calls for, in order, with NO query needed. Give the deck `id` (from `decks`). Ideal for anticipating need: open 'water-safe', 'first-aid-far', 'grow-food', 'be-not-afraid', etc., and get the hand ready to read.

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

Ask the library to ACQUIRE something it does not hold (kind=missing, give query) or to EXPAND a thin card (kind=expand, give card_id). Opens a want on the AGENT PLANE — held separate on the desk until the next human who looks seconds it by asking for the same thing. Call this only when your principal genuinely needs what the keeping lacks; the same miss asked twice is one want asked twice. No requester identity is stored; queries are scrubbed before storage.

Candidate Engine step 1 — commit a COMPLETE raw candidate set BEFORE any evaluation. Give the query, the generator, the method, and EVERY raw candidate; weights ride verbatim as UNTRUSTED metadata (proposal_weight is never confidence and never ranks anything). Returns the committed set: a content-addressed candidate_set_id, the membership commitment hash (also sealed as a durable anchor), and per-candidate ids — all born quarantined. Nothing is verified here; that is the point: a set hashed before checking cannot be selectively disclosed after.

Query any openFDA dataset: drug adverse events (FAERS), drug labeling (SPL), drug recalls, food recalls, or medical device events. Pick the dataset with the dataset argument. Uses openFDA Lucene-style search syntax (e.g. "patient.drug.medicinalproduct:aspirin", "openfda.brand_name:tylenol"). License: openFDA CC0 1.0 Universal Dedication, FDA waiver of all copyright; commercial redistribution permitted.

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.

Search Partle's product catalog by name or description. CRITICAL SEARCH INSTRUCTION: Reason from the job to the product class first, then search with a descriptive product phrase (e.g. including substrate, material, or size class). DO NOT blindly search using the user's raw conversational words. Transform questions like 'what do I need to attach a mirror to a brick wall?' into a product phrase like 'heavy duty masonry wall anchor'. 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 name + 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``, ``name`` (plus a deprecated ``title`` mirror of it), ``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.

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.

Wash overlay on ingested PayAI/CDP/Agentic listings (PayAI not_indexed). 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 ingested listing overlay indexed by payTo. Solana wash overlay is the only wash graph. Base listings additionally carry high-confidence EIP-3009 corpus membership from x402_base_daily; they remain wash_unknown. Polygon listings carry wash_unknown. Query params — flagged_only, limit, source — mirror GET /v1/intel/x402-directory.

Search durable path memory (hot paths, surfaces, debugging notes) before doing a repo-wide search. Use a path-oriented query like "auth modal" or "signup route".

Query typed workspace knowledge — services, capabilities, patterns, environments, and workflows — for architecture-level orientation.

Decode a percent-encoded URL component into plain text when reading query parameters, path segments, or form values that contain escaped characters. Use when: - Decode this percent-encoded URL component - Convert %20-style escapes back to plain text - Recover the original string from an encoded query parameter Do not use when: - Percent-encode text for a URL (use url_encode) - Decode Base64 payloads (use base64_decode) - Parse HTML entities that are not URL percent-encoding

Apply encodeURIComponent-style percent-encoding so query parameters, path segments, or form values are safe to place in a URL. Use when: - Percent-encode this string for a query parameter - Make a path segment URL-safe with encodeURIComponent-style encoding - Encode special characters before inserting text into a URL Do not use when: - Decode a percent-encoded string (use url_decode) - Encode binary data as Base64 (use base64_encode) - Build or rewrite a full absolute URL structure beyond component encoding

Structured gear recommendations from a freeform natural-language query (e.g. 'best quilt for a PCT thru hike'). Runs the TrailWeights query planner: intent classification, brand-alias expansion, and compiled weight/price/category constraints. Returns the top catalog products with verified weights (with provenance and conflict flags), citations, and cottage-first buy URLs, plus the interpreted intent and applied filters. Optional weight cap (oz) and category filter.

Premium wallet payment activation agent for quote-only x402 buyers. It turns a target paid route, wallet runtime, route id, payTo/network expectations, receipt-gate requirement, and live quote intent signals into a buyer-owned activation plan, Node activation client, MCP payment activation config, Flowise payment activation node, and receipt gate policy without taking custody of private keys. GET variant for agents that prefer query parameters. Pay $2.90 per request with x402 exact USDC on Base or Solana when advertised. Canonical live prices: https://gpt55.558686.xyz/x402/live-prices.json.

Translate short text, messages, notes, and snippets to a requested target language for agent workflows, localization, bilingual support replies, and quick multilingual output. Standard quality tier uses gpt-5.6-luna; price is derived from official OpenAI relative token costs with a local margin and floor. GET variant for agents that prefer query parameters. Pay $0.00293 per request with x402 exact USDC on Base or Solana when advertised. Canonical live prices: https://gpt55.558686.xyz/x402/live-prices.json.

Fetch a public HTTP(S) URL and return status, final URL, title, meta description, canonical URL, Open Graph fields, and a short text sample. This deterministic endpoint does not call an upstream model. GET variant for agents that prefer query parameters. Pay $0.002 per request with x402 exact USDC on Base or Solana when advertised. Canonical live prices: https://gpt55.558686.xyz/x402/live-prices.json.

Fetch a public HTTP(S) URL and return cleaned readable text, title, final URL, status, and redirect details. This deterministic endpoint does not call an upstream model. GET variant for agents that prefer query parameters. Pay $0.002 per request with x402 exact USDC on Base or Solana when advertised. Canonical live prices: https://gpt55.558686.xyz/x402/live-prices.json.

Fetch a public HTTP(S) URL and return normalized links, anchor text, status, title, and redirect details. This deterministic endpoint does not call an upstream model. GET variant for agents that prefer query parameters. Pay $0.002 per request with x402 exact USDC on Base or Solana when advertised. Canonical live prices: https://gpt55.558686.xyz/x402/live-prices.json.

Read a public EVM wallet balance on Base or Ethereum and determine whether its Base USDC balance can cover a suggested $0.001 x402 payment. Returns a coherent provider snapshot, USDC runway, shortfall, native-gas presence, and a handoff to the full funding-readiness doctor without signing, broadcasting, or handling private keys. Balance-only readiness does not prove client, signing, spend-cap, or retry capability. GET variant for agents that prefer query parameters. Pay $0.001 per request with x402 exact USDC on Base or Solana when advertised. Canonical live prices: https://gpt55.558686.xyz/x402/live-prices.json.

Search the current immutable Ausca offer catalog by free-text query. Returns stable offer identities and revision digests without creating product or payment state.

Ask a question across every meeting you have imported as queryable, and get back ranked excerpts with the meeting they came from. This is the tool to use when the user refers to something that was said, agreed, or decided in a call -- 'what did we decide about pricing', 'who owned the migration', 'when did we say we would ship'. Returns 'searched_meetings' and 'private_meetings_skipped': meetings imported as private are encrypted and CANNOT be searched, so if searched_meetings is 0 an empty result means nothing was searched, NOT that the topic was never discussed. Use meetings_get to read a full transcript once you have found the right meeting. Costs $0.006 in USDC on Base, paid via the x402 protocol.

Store a transcript so it can be searched later. `visibility` is a required decision and cannot be guessed for you: 'queryable' stores plaintext, indexes it, and means this service can read it; 'private' stores ciphertext you encrypted yourself, which is unreadable here and therefore NEVER searchable. Send `transcript` for queryable and `ciphertext` for private -- the mismatched combinations are refused rather than silently doing the wrong thing. The first import into a namespace returns a namespace_token shown exactly once; save it or the namespace is unrecoverable. Costs $0.004 in USDC on Base, paid via the x402 protocol.

Fetch a single meeting by meeting_id, including its full transcript when it was imported as queryable. Use this after meetings_search has identified the meeting you want. A 'content_missing' status means the record exists but its stored text could not be found -- that is a broken record, not an empty meeting, so do not report it as one. Costs $0.002 in USDC on Base, paid via the x402 protocol.

Search marketplace products by free-text query, optional category, or seller. Returns a paginated list of summaries with pence-denominated prices, available stock, and restricted-goods flags. Pass a concise phrase, not a full sentence.

List the marketplace's category taxonomy. Optionally pass `slug` to scope to a subtree (e.g. 'electronics'). Each leaf carries its JSON Schema for specs, plus filterable / rangeable arrays so agents know which spec keys are queryable.

Fetch one category by slug, including the spec JSON Schema for leaf categories. Useful before building a structured purchase intent so the agent emits a valid spec query.

UCP 2026-04-08 catalog search over the engagement tiers. Returns UCP product objects in structuredContent. Call with no query for the whole catalog.

FREE local input and safety check before purchase. Accepts UBL/CII XML or a base64 ZUGFeRD/Factur-X PDF with exactly one embedded invoice XML plus buyer country, expected amount/currency and a trusted payee IBAN. It checks format, limits and required context, but does not reveal the paid decision or query VIES/sanctions. Subject to daily abuse protection.

Search Bluesky and Hacker News for every query; for a single public tag, additionally search Mastodon's anonymous tag timeline. Mastodon is not applicable to phrase search. Results are delivered only when every source promised for that query answers; a source failure is an uncharged error, never a partial paid result. Twitter/X and TikTok are deliberately excluded.

Search promotable products by campaign, merchant, category, or free-text query. Omit all filters to list ALL promotable products. Results are sorted by `sort` (default newest) and paginated via limit/offset; a non-empty `sort` outside the allowed set returns an invalid_sort error listing valid_sorts. Only products from billing-active merchants are returned. Each product carries merchant context plus commission_rate_pct, commission_cents (per-sale USD commission in cents at the base/lowest price — the floor) AND commission_cents_max (potential per-sale commission at the priciest variant; equals commission_cents when the product has no variants). Actual commission is on the real purchased variant. Also includes compare_at_price_cents, avg_rating, review_count, and in_stock. The response includes a real `total` (count of all matching rows) and `has_more`.