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

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.

Use for qualitative company discovery (industry, business model, supply chain, competitors, management background). For numerical screening (revenue, margins, ratios, growth rates) use run_sql on company_snapshot instead. Drillr's company knowledge graph — searchable across industry classification, product offerings, business model, segment structure, competitive landscape, supply chain, management background, and customer profile. Coverage: US, Japan, Hong Kong, China A-shares, and Korea. `market` accepts one lowercase value or a list from `us | jp | hk | cn | kr`; omit it or pass `[]` for all five. List order does not set priority. Pass a natural-language description (for example, "Hong Kong and China EV battery suppliers"). Returns a structured list of matching companies with context snippets. ONLY for finding a LIST of companies by description.

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 BEFORE run_sql when you're unsure which columns a table has. Look up column definitions (name, type, description) for a data table.

List alternative-data tables under the given categories. Returns each table's name, one-line purpose, and column names (call get_table_schema if you need column types/comments). Batch up to 5 categories in one call; omit categories, or pass ["all"], to get the category index instead. Use this BEFORE run_sql when you want to explore alt-data — run_sql alone won't tell you which tables exist. Available categories: - Energy & Power — US power plants, electricity prices, regional hourly generation/demand - Data Centers — facilities, GPU clusters, cooling - Semiconductors — AI chip specs, sales, ownership, foundry revenue, customs trade - Compute Pricing — GPU rental, cloud VM spot/on-demand, instance specs - Model Development — model specs, benchmarks, AI companies, AI polling, LLM arena - Inference Economics — LLM API pricing across providers - Macro & Trade — UN Comtrade, US Census trade flows, FRED macro series - Prediction Markets — Polymarket and Kalshi events, markets, trades, daily aggregates - Critical Minerals — USGS mineral deposits, country supply, critical materials

Search this playbook's complete tool catalog by keyword: the built-in playbook tools (memory, skills, canvas, workflow runs, secrets) and every connected server's federated tools (names like supabase__execute_sql or cloudflare__search). Matches against tool names and descriptions; a name match ranks above a description match. Returns up to `limit` (default 10, max 25) entries with name, description, and full input schema. Every returned tool can be called directly by name even when it is absent from tools/list — the advertised list is a view, not a boundary, unless this connection was pinned with ?toolset=. Read-only and free of side effects. Use this when the tool you need is not in your current list, before concluding a capability is missing. Pass playbook_id as the UUID or GUID of the playbook this call should target.

FINAL-GATE Output Sanitizer ($0.02). Post-processing checkpoint that strips secrets/credentials, PII, crypto material (seed phrases, private keys, wallet addresses), internal network details (private IPs, MAC addresses, .internal/.local/.corp hostnames), and unsafe shell/SQL/path-traversal fragments from a raw model response — plus a narrow, high-precision safety net for direct self-harm-instruction-seeking and targeted-harassment phrasing (not a general toxicity classifier). Returns a single `sanitized_output` with every match replaced by `[REDACTED]`; use that instead of the original whenever verdict is NO_COMMIT. Run this as the LAST gate before a response reaches its destination — after `dcl_evaluate_jailbreak_crypto`/other input-side checks have already run, and immediately before `dcl_commit` seals the final decision. Internally re-uses the same detection tables as `dcl_evaluate_secrets`/`dcl_evaluate_pii` for the secrets/PII categories, so results stay consistent with those tools.

Search the user's memories. Default mode is 'hybrid': blends semantic (cosine over Vectorize) and keyword (BM25 over SQLite FTS5) hits via Reciprocal Rank Fusion (k=60). Semantic catches paraphrases; keyword catches exact-string hits (IDs, dates, code snippets). Pass mode:'semantic' or mode:'keyword' to run just one. Content defaults to the LLM-optimized (compressed) form when available (raw:true to invert). Excludes forgotten + superseded. Optional filters narrow after retrieval: tags (AND), written_by, session_id, and/or since/until (ms epoch).

List the user's most recent memories in reverse chronological order. Use for browsing or catching up on what the user's other model sessions have written recently. Same content/content_raw shape as memory_search. Optional filters (tags, written_by, session_id, since, until) narrow the listing at the SQL level.

USE for person or word name text only (gematria → cosmic cards + Expression / Soul Urge / Personality). NOT for any date questions (weekday, leap year, moon, season, Rx, Cosmic card, day_ruler, Life Path) → get_date; two people → get_compatibility. RETURNS Francis Bacon cards, Latin cipher suite, periodic{} + periodic_set{}, numerology (expression/soul_urge/personality plus full-name karmic_lessons / hidden_passion / cornerstone / capstone / first_vowel / echoes and number lens polarity/planet/element/color), and per-word tarot/medicine/iching/chakra/lenormand/karma/planetary_spread. Free-text input guard (Del as a name is allowed; DEL FILE and SQL verbs are not).

SAFETY / OVERSIGHT CHECK before a dangerous or destructive action (shell command, file deletion, DB statement, network call). Call this to have VITNA check the action BEFORE you run it: it flags dangerous shell / SQL / secret-exfil / prompt-injection / suspicious-network patterns and returns { decision: allowed|blocked|flagged }. RESPONSE SHAPE DEPENDS ON THE KEY: an unclaimed trial key gets the decision label only, because the pattern detail is what makes the classifier worth stealing. A claimed key additionally gets threat_category, severity, reason (the rule names that matched, never the matched text), a threats[] array and a redacted echo of what was scanned, plus a signed audit record the user can review. VITNA evaluates and records; it does NOT enforce, so treat blocked / flagged as a stop and get human approval. This is how a user keeps you in check. Heuristic pattern match, not a sandbox: novel or obfuscated payloads can pass.

Inspect the schema of the local finbridge database (SQLite with ingested KR/US company fundamentals, filings, and daily prices): tables, views, columns, per-table row counts (counted in the background and refreshed every 30 minutes; null with rows_note "counting…" right after a server start), and ready-to-run example queries for query_db. Read this before writing a query_db statement. It returns no company data itself — get_db_schema describes the tables, query_db runs the SELECT. Args: (none) Returns: {tables: [{name, columns: [{name, type}], rows}], views: [{name, columns: [{name, type}]}], examples: [sql_string]} Key objects: - companies: KR companies have source='dart' + stock_code (6-digit), US companies source='edgar' + ticker - financials: one row per company x fiscal_year x quarter (quarter=0 = annual); raw unscaled KRW/USD amounts - prices_daily: daily OHLCV per company_id - views v_financials (financials joined with company name/ticker/stock_code) and v_latest_annual (latest annual row per company) — prefer these in query_db Examples: - Call before writing SQL for query_db, to learn table/column names. - Check row counts to see how much data the nightly ingest has loaded. Use when: preparing a query_db, or checking ingest coverage. Don't use for market data itself (get_stock_prices / get_valuation / the screeners read the same tables with the right joins already done). FinBridge has no real-time equity quote tool — equity prices here are end-of-day closes from the nightly ingest; the only live data is crypto (get_crypto_ticker) and regulator filings (get_dart_filings / get_edgar_filings). Errors: 'database has not been built yet' — the ingest pipeline has not run on the server.

Run a single read-only SELECT query against the local finbridge database (ingested KR/US fundamentals, filings, daily prices). The statement must start with SELECT or WITH; multiple statements, PRAGMA, and any write/DDL keywords (INSERT/UPDATE/DELETE/DROP/ALTER/CREATE/ATTACH/...) are rejected. The query runs in a separate read-only process with SQLite authorization, a 2-second deadline, two concurrent queries per server process, and a 1 MB result budget. Free accounts cannot query raw history or history views; the latest-annual snapshot remains available. The escape hatch for questions no dedicated tool answers — Japan, Taiwan and Europe are largely reachable only this way. Prefer screen_companies for ordinary fundamental screens (it handles per-market period and currency rules that a hand-written query will get wrong), and call get_db_schema first for the table shapes. Args: - sql: one SELECT (or WITH ... SELECT) statement. A single trailing ';' is tolerated. - limit: max rows returned, 1-500 (default 50) - response_format: 'markdown' (default, table) or 'json' (compact) Returns: {columns: [name], rows: [[cell, ...]], row_count, truncated} — truncated=true means more rows matched than 'limit'. Examples (v_financials / v_latest_annual views are the easiest entry points): - Largest companies by latest annual revenue: "SELECT name, ticker, stock_code, fiscal_year, revenue FROM v_latest_annual ORDER BY revenue DESC LIMIT 10" - Samsung Electronics annual trend: "SELECT fiscal_year, revenue, operating_income, net_income FROM v_financials WHERE stock_code = '005930' AND quarter = 0 ORDER BY fiscal_year DESC" - KR vs US company counts: "SELECT source, COUNT(*) AS n FROM companies GROUP BY source" - Recent Samsung Electronics closes: "SELECT date, close FROM prices_daily p JOIN companies c ON c.id = p.company_id WHERE c.stock_code = '005930' ORDER BY date DESC LIMIT 20" (prices_daily holds KR, US, TW; US history starts 2023-03-28) Use when: custom aggregation/joins over ingested data that screen_companies cannot express. Don't use for anything that writes — it will be rejected. FinBridge has no real-time equity quote tool — equity prices here are end-of-day closes from the nightly ingest; the only live data is crypto (get_crypto_ticker) and regulator filings (get_dart_filings / get_edgar_filings). Errors: non-SELECT input, ';' inside, or forbidden keywords -> rejected with the reason; unknown table/column -> SQL error with a hint to call get_db_schema first.

Screen KR/US companies by technical signals over the latest indicator snapshots (v_indicators / indicators_latest, refreshed nightly). Signals and the sort key are fixed whitelists mapped to SQL predicates; every threshold is bound as a parameter, so inputs are never interpolated into SQL. This is the open-ended technical screen: you pick the signals and thresholds. The four named strategies are fixed checklists instead (screen_minervini, screen_canslim, screen_kell, screen_schwartz). Not this tool for: fundamentals (screen_companies) or funds (screen_etfs). Args: - market: 'kr' (DART), 'us' (EDGAR), or 'all' (default) - signals: any of golden_cross, dead_cross, rsi_oversold (RSI<30), rsi_overbought (RSI>70), near_52w_high (within 3% of high), near_52w_low, above_sma20, volume_surge (vol_ratio>=2), macd_bullish (macd_hist>0), rs_leader (RS rating >=80 vs home market), rs_outperform (RS rating >=60). ANDed together; omit for none. - min_price: optional minimum close; min_vol_avg20: optional minimum 20-day average volume (liquidity filter) - sort_by: ret_1d|ret_5d|ret_20d|ret_60d|ret_120d|ret_250d|rsi14|vol_ratio|pct_from_52w_hi|pct_from_52w_lo|close|atr14|rs_pctile|rs_120d (default ret_20d) - order: 'asc'|'desc' (default 'desc'); limit: 1-100 (default 20); response_format: 'markdown'|'json' Relative strength (rs_pctile 1-99, rs_120d) measures each stock vs its OWN national market (KR vs the KR universe, US vs the US universe): rs_pctile is the national percentile of blended 3/6/12-month momentum (IBD-style; 99=strongest); rs_120d is 6-month excess return in pp over the national median. Returns: {count, market, signals, sort_by, order, rows:[{name, source, ticker|stock_code, as_of, close, rsi14, macd_hist, ret_5d, ret_20d, ret_60d, vol_ratio, pct_from_52w_hi, pct_from_52w_lo, golden_cross, dead_cross, above_sma20, rs_pctile, rs_120d}]}. Examples: - Oversold KR names by 20-day return: {market:'kr', signals:['rsi_oversold'], sort_by:'ret_20d', order:'asc'} - US breakouts near highs on volume: {market:'us', signals:['near_52w_high','volume_surge'], min_vol_avg20: 1000000} - Strongest KR leaders vs the KOSPI/KOSDAQ universe: {market:'kr', signals:['rs_leader'], sort_by:'rs_pctile', min_vol_avg20: 100000} Use when: ranking/filtering many companies by momentum or trend signals. Don't use for one company's detail (get_technicals) or fundamentals (screen_companies). Notes: KR/US/TW prices are adjusted for corporate actions but not dividends (indicators around dividend events may be slightly distorted); US history starts 2023-03-28 (volume from 2024-07-01) so long-window figures are shallower there. Market data, not investment advice. Errors: an empty result is not an error (count 0); 'database has not been built yet' -> ingest/indicators has not run.

Screen untrusted text for common SQL-injection signals without echoing it.

Check an MCP server for malware / prompt-injection lures by its endpoint URL. Give the server's streamable-http endpoint URL. Two paths: * **Already in the agent-tools directory** → returns our LATEST stored rule verdict. Every indexed server is re-scanned hourly, so you get a consistent, continuously-refreshed answer without re-probing. * **Not yet indexed** → we probe the endpoint live, statically scan its advertised tools + metadata, ADD it to the directory, and return the fresh verdict (so the next caller gets the rule verdict instantly from cache). Two dimensions are reported. `verdict` is authoritative and comes from deterministic static rules — pure pattern-matching over the *advertised* text only, NO code execution. It flags the social-engineering / RCE tricks listing-spam servers use: * `curl … | bash` and `base64 -d | sh` install lures * `eval "$(curl …)"` / PowerShell `IEX(...DownloadString)` cradles * base64 blobs that decode to a shell command * bare-IP payload hosts and cheap throwaway TLDs * prompt-injection / credential-exfiltration phrasing ("ignore previous instructions", "send your .env / api key") * MCP tool-poisoning coercion — descriptions that hijack an agent's tool-calling ("always call this tool first", "before using any other tool you must…"), hidden `<IMPORTANT>` instructions, "list all API keys / include secrets in your response", and coercion to read & forward `.key`/`.pem`/`.ssh`/`.env` files Source-code-oriented rules (SQL / command / code injection) are deliberately not applied to natural-language descriptions, to avoid false positives. `llm_reference` is an advisory frontier-LLM second opinion over the same text. Because the LLM is slow it is computed LIVE on this call only and is never stored (the hourly job never runs it), so it may be null on timeout. It never overrides the rule verdict; when it is *more* severe than the rules an `advisory` note is attached as a safety-net signal. Security/defense products that merely *name* these attacks are not flagged. Args: endpoint_url: The MCP server's streamable-http URL (required). This is the identity we look up / index by. name: Optional advertised name (used when the server is new and gets added; falls back to the URL host). description: Optional description / README blurb (scanned when new). tools_text: Optional tool names + descriptions; used only if the live probe cannot fetch the server's tools/list. Returns: { verdict: "clean"|"suspicious"|"malicious", score: 0-100, reasons: [{rule, weight, snippet}], llm_reference: {model, verdict, reason, confidence} | null, advisory: str | null, slug, name, endpoint_url, source: "stored" (existing) | "new_scan" (just added), indexed: bool }

POST /api/pin/topup_card from this agent 2401 USDT. card_id must belong to the same agent (SQL owner guard). ext_id required. Never Stars.

POST /api/esim/new_plan5. Buy a travel/data eSIM plan from this agent 2401. Omit blank/null iccid so SQL takes the new-eSIM path. A set iccid must already belong to this agent. ext_id required. Never Stars.

Install an app template on a VPS/Cloud site. Starts a background installation. Poll get_app_status() for progress. Requires: API key with write scope. VPS or Cloud plan only. Args: slug: Site identifier template: App template slug. Available: django, laravel, nextjs, nodejs, nuxtjs, rails, static app_name: Short name for the app (2-50 chars, lowercase alphanumeric + hyphens). Used as subdomain: {app_name}.{site_domain} db_type: Database type. "none", "mysql", or "postgresql" (depends on template) domain: Custom domain override (default: {app_name}.{site_domain}) display_name: Human-friendly name (default: derived from app_name) Returns: {"id": "uuid", "app_name": "myapp", "status": "installing", "message": "Installation started. Poll for progress."} Errors: FORBIDDEN: Plan does not support apps (shared plans) VALIDATION_ERROR: Invalid template, app_name, or duplicate name

Execute a SQL query on a site's database. Supports SELECT, INSERT, UPDATE, DELETE, and DDL statements. Results are limited to 1000 rows for SELECT queries. Requires: API key with write scope. Args: slug: Site identifier database: Database name query: SQL query string Returns: {"columns": ["id", "title"], "rows": [[1, "Hello"], ...], "affected_rows": 0, "query_time_ms": 12}

Get detailed system stack information (OS, PHP, DB, web server versions). Requires: API key with read scope. Args: slug: Site identifier Returns: {"os": "Debian 12", "kernel": "6.1.0", "php": "8.3.4", "mysql": "10.11.6-MariaDB", "nginx": "1.24.0", "wordpress": "6.5"}

Queue a checkpoint snapshot without detaching — before a risky change. ASYNCHRONOUS. Returns immediately with state "snapshotting"; poll get_compute_volume until it is back to "attached" (done) or "error". Named systemd units are stopped for the capture so the snapshot is application-consistent (a live database directory copied mid-write is not reliably restorable). The worker restarts nothing — reboot or start them yourself afterwards. Requires: API key with write scope. Args: volume_id: A volume in state "attached" quiesce_units: Services to stop during capture, e.g. ["ollama.service", "postgresql.service"] Returns: Volume dict with state "snapshotting". Poll for the outcome.

Search YOUR extracted memory facts by topic or entity name. No LLM needed — pure SQL lookup against pre-extracted facts. Scoped to facts from memory you own — registered handle + secret required. Returns entries with topics, entities, action_items, and summary.

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 SQL models / datasets defined in the workspace (the queries that produce rows to sync). Census: GET /models.

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

BYO step 1 of 2: run the server-side trust plane for a business question (plan, SQL-verified facts, evidence retrieval, answerability gate, prompt composition) and return the composed prompt plus a single-use prepare_key (a signed handoff token; echo it back VERBATIM and in full, or use the short ask_id alias; in prose always say the ask_id, never the token). Read-only: prepare holds no server state and is safe to run without confirmation — the receipt is minted only at ask_submit_draft. Pass the user's question VERBATIM: do not expand, narrow, or reword it — the server plans coverage itself, and an unrequested rewrite misleads the user about what was asked. If you must revise it (e.g. to fold in essential conversation context), you MUST also pass the user's exact wording in original_question so the panel can disclose the revision. YOU (the connected model) then write the draft answer from that prompt and submit it with ask_submit_draft — generation happens on your side, so no LLM credential ever reaches this server. An unanswerable question still receives a prompt for reference; its draft is force-refused at submit and can never earn a verified verdict. Only a policy refusal stops at prepare. Recommended drafting path on this deployment.

BYO step 2 of 2: verify the draft you wrote for an ask_prepare prompt. The server runs the SAME post-answer guards the strict path uses (facts presence, tagged claims, concept binding, earner-name grounding) against its own SQL facts and publishes the trust envelope; a draft that fails any guard is refused. Pass the prepare_key token back VERBATIM and in full. Handoffs are single-use per verdict and expire.

Corroborate a figure you obtained (e.g. from run_sql) against the verified fact store: it re-derives the named value_key from the same SQL the verified pipeline uses and compares. AGREE lifts an otherwise-unverified session to 'corroborated'; DISAGREE marks a CONFLICT (worse than unverified). This is the only way a raw figure earns trust back, and it can only ever agree with a number the fact store itself computed. Resolvable keys cover the single-snapshot fact concepts plus temporal and per-department growth keys (e.g. indexed_people.<dept>); per-question keys (a named department's median, one person's direct-report count) return unmapped.

List safe metadata for the registered fact queries available on the server-pinned dataset: IDs, labels, parameters, and result shapes, never SQL. Use this when a question appears relevant but a selected route produced no facts; a route miss is not evidence that the underlying records are absent.

Show the SQL behind one answer you already received, addressed by its correlation_id. Returns only the recorded fact queries (id, version, label, SQL, parameters, result schema, dataset version) for that answer: no rows, no evidence text, no answer text, no envelope, and no way to list the catalog. Recorded SQL has its arguments inlined as literals, so a query that filters on a specific value discloses that value; the built-in workforce queries inline only snapshot ids. Requires the persisted compliance log and the same session that produced the answer. Absent from the no-auth public demo.

Execute a registered, versioned read-only fact query against the server-pinned dataset. Provide query_id and version only: SQL is approved by the domain pack, never caller-supplied. Returns normalized rows plus a reproducible trust receipt containing the dataset and query versions.

All release cycles for a product, newest first: latest patch version, release date, LTS status/date, end-of-life date, and end of active support. Answers: what is the CURRENT version of X? Which major versions are still supported? When does version Y reach EOL? Use exact slugs from list_products (e.g. nodejs, python, django, postgresql, ubuntu, amazon-eks).

List every product slug tracked (nodejs, python, react, postgresql, ubuntu, …). Call this first when unsure of the exact product slug to pass to get_product.

List the registered temporary-access targets — the databases (Postgres, MySQL, …) against which short-lived credentials can be minted on demand instead of storing a standing password. Use it to see what can be leased before minting one (create_pg_lease / create_mysql_lease run on the LOCAL crypto plane), and see list_leases for what has actually been issued. Returns [{ id, orgId, provider, name, config, createdAt }], where `provider` names the kind of target (postgres, mysql, …) and `config` is non-secret connection settings.

Run an arbitrary HogQL (SQL) query against PostHog data. Use for custom analysis not covered by other tools. Only works if PostHog is connected.

Tables and validated example SQL queries for one Dataplex product — enough to plan an analysis before subscribing.

Copy-paste SQL for an agent INSIDE a Snowflake account to mount a Dataplex listing and start querying trial data in minutes — no browser, no sales call.

Create a Model project in MySQL (parameter register). Allocates a view id (mv-…) when omitted and returns viewUrl. Optional seed: title, calendar, streams, axes, phases, parameterSets, chains, parameters, observations, edges. Does not persist CALC outputs or FORMULA edges. Binds this MCP session. UI: /model/?id=…

Hydrate records from MySQL. include=summary (default counts), dictionaries, parameters, observations, edges, or all. Prefer model_upsert_observation to change one fact — do not treat this as a blob to rewrite.

Unbind the Model project from this MCP session. Does not delete MySQL rows.

Read-only computeModel. Does not write MySQL. View ids allowed. Default period is calendar start (not today). periodId and range* are mutually exclusive. Cell cap 2000.

Pre-execution safety oracle for agent actions: submit the tool call you are about to run (shell, http, sql, file, code, env) plus your stated intent, and get a machine-enforceable verdict before you execute it. Decodes what the call does, flags the danger toolkit (rm -rf, reverse shell, curl|sh, SSRF to cloud metadata, credential reads, DROP/DELETE-without-WHERE, path traversal, dynamic eval), and binds it to your intent (allowedHosts/allowedPaths/readOnly/noNetwork) - only a fully pinned, clean, intent-matched call is auto-exec-safe. Hybrid: a deterministic, uninjectable detector engine (authoritative) plus an LLM classifier that can only raise the risk. Fails closed. Detection of known-dangerous patterns, not a proof of safety; it never executes the call. [security; up to 8c/call]

Get full details for a specific developer tool by its slug. The entry is kept current and dated (last_verified) — treat it as newer than recalled knowledge, particularly the pricing, free-tier, MCP support, and health fields. Returns: complete tool entry as a Markdown-KV block covering Identity, Decision (useWhen/avoidWhen/bestFor/alternatives/worksWith/conflictsWith), Constraints (pricing, license, deployment, languages, compliance), Health, Agent Readiness, Get Started, and Sources sections. Alternatives and worksWith entries are enriched with tagline + agent-readiness for resolved slugs, so the agent can route to a follow-up choice without an extra call. If the slug is not found, returns an error with similar-slug suggestions. Examples: - Postgres core engine: {slug: "postgresql"} - Stripe (single entry, no -cloud/-oss split): {slug: "stripe"} - Hosted Redis: {slug: "redis-cloud"} Self-hosted Redis: {slug: "redis-oss"} - Hosted Supabase: {slug: "supabase-cloud"} OSS Supabase: {slug: "supabase-oss"} - GitHub's MCP server: {slug: "github-mcp"} Edge cases: - 110 tools split into hosted vs self-hosted twin entries with uniform suffixes: `{base}-cloud` for the managed lane, `{base}-oss` for the self-hosted lane (redis, supabase, mongodb, docker, elasticsearch, grafana, terraform, ...). Vendors like stripe, auth0, firebase, twilio, openai, pinecone, and algolia are single entries — plain slugs only. - Slugs derived from package names use hyphens where the name uses a dot (e.g., "nextjs" not "next.js"; "vuejs" not "vue.js"). - Slugs are case-sensitive lowercase. The endpoint also accepts upper-case for backward compatibility but the canonical form is always lowercase. Risk: read-only, closed-world, idempotent — no state change possible.

Compare 2-3 developer tools side by side. Returns each tool's full Markdown-KV entry separated by "===". Alternatives and worksWith are enriched with tagline + agent-readiness for resolved slugs. If any requested slugs are not found, they appear in a trailing "Note: slugs not found: ..." line; the comparison still returns for the ones found. Examples: - Three search engines: {slugs: ["meilisearch-oss", "algolia", "elasticsearch-oss"]} - Two ORMs: {slugs: ["drizzle-orm", "prisma"]} - Three auth providers: {slugs: ["auth0", "clerk", "keycloak"]} - Hosted vs self-hosted for the same vendor: {slugs: ["redis-cloud", "redis-oss"]} — shows deployment trade-off - Postgres engine vs hosted offerings: {slugs: ["postgresql", "supabase-cloud", "cockroachdb-cloud"]} Edge cases: - Cross-category comparisons (e.g., {slugs: ["auth0", "redis-cloud"]}) are allowed but rarely useful. Same-category comparisons answer "which should I pick?" better; cross-category answers "these coexist in my stack" — a compatibility question. - Minimum 2 slugs, maximum 3. Four or more is a validation error; for more, run pairs. - Invalid or unknown slugs are listed under "slugs not found"; the partial comparison returns for valid ones. - Duplicate slugs in the array are deduplicated. - A few tools are single entries (no -cloud/-oss split): stripe, auth0, firebase, twilio, openai-api, pinecone, algolia. Don't pass "stripe-cloud" — it doesn't exist. Risk: read-only, closed-world, idempotent — no state change possible.

Build (or rebuild) the structured index for a knowledge base — the second leg beside vector search. Vector search answers "what does this passage say". It **cannot count, filter numerically or aggregate**, so "how many documents", "which ones are between 1000 and 2000 words", "how many per category" are not answered badly — they are structurally unanswerable. This builds a small per-KB table from whatever structured header the documents share, which the agent can then query with SQL via `query_knowledge_table`. Only worth it when the documents share a machine-readable header (a metadata table, YAML front matter, `Field: value` lines). **Prose gets declined, and that is the right answer** — a table of unique values makes statistics meaningless. `roles` names the fields that must be extracted **exactly** and never paraphrased. Use it when the answer has to quote something the model must not invent: - `identity` — what to call the item (book title, drug name, product name) - `link` — where to send the user - `image` — what to show the user - `code` — the unique identifier Which link is "the" link is a business fact the data does not state — only the customer knows. A declared role that cannot be found comes back in `roles.unresolved` **with candidate field names**: ask the user which one it is, do not guess. **Read `dropped` in the report and tell the user about it.** A column that was thrown out (coverage too low, two columns holding identical values) is invisible in later query results — the model simply works around it — so this report is the only place it is ever mentioned.

Pattern-based diff linter: flags a fixed set of risky shapes in changed code — query-string interpolation (SQL/Cypher/Mongo injection shape), shell interpolation, eval/new Function, empty catch blocks, regex built from a variable, fewer catch blocks than before, and named authorization guards that disappeared. Every finding cites the line that produced it. It does NOT do data-flow analysis: it cannot follow a value to a sink, across functions or files, and an empty result is not a safety verdict (the response lists what it did not analyse). Advisory triage — use a static analyser for a real security gate.

Lists your managed PostgreSQL databases. Once a row's status is 'ready', it carries the private-network connection details (private_ip, port 5432, db_name, db_user).

Lists your managed MySQL/MariaDB databases (the relational-database resource). Each row carries its engine ('mysql'|'mariadb'); once status is 'ready' it has the private-network connection details (private_ip, port 3306, db_name, db_user).

THE WAY TO MAKE AN EXISTING APP HIGHLY AVAILABLE. If the user asks for high availability, redundancy, no single point of failure, surviving a host or VM failure, or 'stay up if a machine dies', this is the tool: point it at their running VM and pass high_availability:true. It needs no rebuild and no redeploy, and the URL does not change. Turns a single running instance into a horizontally-autoscaling cluster: snapshots the instance and puts your SOURCE VM behind a load balancer as its ALWAYS-ON BASELINE MEMBER, then an autoscaling group adds EXTRA members (booted from that snapshot) on CPU load and scales them back down to zero. FLAVOR — LEAD WITH A MEMORY-OPTIMIZED SMALL-DISK FLAVOR (m1.mem16/m1.mem32) for the cluster, and ideally have the SOURCE VM on one too: clustering snapshots the source VM's FULL disk, so DISK size (not RAM) drives how long the cluster takes to build and to add each member under load — a 40 GB mem flavor is several times faster to snapshot and scale than a 160 GB standard flavor (m1.xlarge) and costs less for the same RAM. If the source VM is on a big-disk flavor, RECOMMEND migrating the app onto a mem-flavor VM first (a root disk cannot be shrunk in place), even though it is extra work — it pays off on every scale-out, and a clustered app is stateless anyway (state in the managed DB) so the lean disk fits. Expect a DRASTICALLY better clustering experience on a mem flavor: far faster cluster-create, snapshots, and every scale-out. The user can override with any flavor. At rest ONLY your source VM serves — there is NO idle extra VM to pay for (the source VM is the cluster's minimum, so the floor is 0 extra members). Use it to LOAD-SCALE a stateless app tier while managed services hold state: it becomes highly-available UNDER LOAD (multiple members behind the LB), but at rest a SINGLE source VM serves — and that source VM is a plain VM, not an autoscaled member, so it is NOT auto-replaced if it fails while idle (only the autoscaled extra members are ASG-managed and self-healed). If you need always-on redundancy, keep the app under enough load to hold >=1 extra member, or use a separate always-on setup. BILLED — at rest it costs just your source VM (which you already run) plus the load balancer; under load it adds up to max_size EXTRA members at the member flavor (flavor_id), billed only while they run. In guided mode show the cost that way (now: source VM already running + the LB; under load: up to max_size x the member flavor) and get the user's explicit go first. redu automatically repoints the extra members from the old single-VM URL to the load-balancer URL across app config. It REFUSES a STATEFUL VM with 409 cluster_needs_stateless unless confirm_stateless:true. To have redu FIX a stateful VM for you instead of refusing, pass auto_restructure:true — for a single_vm Postgres it fully-automatically provisions a managed DB + migrates the data + repoints the members; for a compose-stack DB it provisions the matching managed DB (set restructure_engine, e.g. 'mysql'/'mariadb' for WordPress) and returns migration commands to run from the app VM. WordPress/WooCommerce is not generic autoscaling: managed DB alone is not enough because wp-content/uploads is file state. Use app_profile:'wordpress'/'woocommerce', cluster_media_mode:'media_space', and either media_space_id or create_media_space:true so all members mount the same uploads filesystem; otherwise the backend refuses with 409 cluster_needs_media_space. PUT THE CLUSTER ON THE SAME private network as the managed DB and media space. HA: cluster members are spread across DIFFERENT physical hosts automatically, and an autoscaled member that is destroyed is REBUILT AUTOMATICALLY in 1.5 to 5 minutes depending on how it failed with no action from you (the always-on source/hero VM is a plain VM and is NOT covered by that). CRITICAL for members: the app must start on EVERY boot (systemd unit or container restart policy) - if it only starts from a first-boot cloud-init script, a rebooted or resized member comes back with no app, silently never rejoins the load balancer, and the cluster quietly loses capacity with nothing reporting an error. Pass startup_command if the app does not already auto-start on boot, and have it bind its port only once it is genuinely ready to serve (the health check can only see whether the port is open). SEQUENCING - this catches people: the snapshot is taken IMMEDIATELY, and every member boots from it, so the source VM's app must already be RUNNING before you call this. Clustering a freshly-created VM whose cloud-init has not finished captures an image with no enabled service, and all members then come up ACTIVE while failing the load-balancer health check forever - a cluster that looks built and serves nothing. Verify the app answers on its port first (get_ssh_command, or just fetch the VM's URL). The snapshot upload can take several minutes; poll list_clusters until CREATE_COMPLETE.

Returns the SSH command to connect to an instance via the redu.cloud TCP proxy. ACCEPTS an instance id, a deployment's id / name / instance_id, OR a MANAGED DATASTORE's id / name / instance_id (Postgres, MySQL/MariaDB, ClickHouse, Redis) - it resolves all of them, so you do not have to work out which one you are holding (a deployment's instance_id is a placeholder until provisioning finishes, and passing it used to fail). ⭐ SSH TO THE DATASTORE VM IS HOW YOU REACH A PRIVATE-NETWORK-ONLY DATABASE BEFORE ANY APP VM EXISTS: the datastore's own VM is SSH-reachable and ships the client on PATH (psql at /usr/bin/psql), so you can apply a schema or rotate a seeded admin account without an app VM to tunnel through. For a DEPLOYMENT VM (created by deploy_app/deploy_compose) pass keypair_name — read it from get_deployment — so the command uses `-i ~/.ssh/<keypair_name>` and authenticates with the RIGHT key instead of your default identity (without it, SSH to a deploy VM usually fails). The tool also best-effort looks up the keypair from the deployment if you omit it. Example: ssh -i ~/.ssh/redu-deploy -o IdentitiesOnly=yes -p 22011 ubuntu@myinstance-abc12345.redu.cloud

Provisions a managed PostgreSQL database on a dedicated VM on your private network. Requires a recent plan_managed_datastore. For app deployments, prefer deploy_app database:'managed' so plan_deploy includes and wires the DB automatically. It is PRIVATE — reachable only from another instance on the same private network, via the DB's internal/private IP (not a public address). Get the ids from plan_managed_datastore/list_flavors/list_private_networks/list_keypairs. Provisioning takes ~5 min; poll list_databases until status='ready', then the connection details (private_ip, port 5432, db_name, db_user) are populated. HIGH AVAILABILITY: pass ha:true to get THREE machines on three different physical hosts behind a load balancer with automatic failover instead of one machine: the database survives losing a machine, and nobody has to fail it over by hand. It costs about 3x the hourly rate (three machines instead of one), it provisions more slowly, and one connection string still serves the whole thing. Default is a single machine; show the user the price difference and get an explicit yes before turning HA on.

Provisions a managed MySQL (or MariaDB) database on a dedicated VM on your private network — the relational-database resource (use this instead of create_database when the app needs MySQL/MariaDB, e.g. WordPress, NextCloud, Matomo, many PHP/LAMP apps). Requires a recent plan_managed_datastore. For app deployments, prefer deploy_app database:'managed' with db_engine mysql/mariadb so plan_deploy includes and wires the DB automatically. It is PRIVATE — reachable only from another instance on the same private network, via the DB's internal/private IP (port 3306), not a public address. Get the ids from plan_managed_datastore/list_flavors/list_private_networks/list_keypairs. Provisioning takes ~5 min; poll list_relational_databases until status='ready', then the connection details (private_ip, port 3306, db_name, db_user) are populated. MySQL is created with mysql_native_password auth so older clients/apps connect cleanly. (ClickHouse is a separate resource — use create_clickhouse / list_clickhouse_databases.)

List tables in a database (paginated, sorted by database/schema/name). Returns a flat, paginated list of tables. Each item has database_name, schema, and name fields. The response's `dialect` is the SQL dialect to use with myriade_query on this database.

Get the column-level schema for a specific table. Returns column names, data types, and descriptions for the table, plus the SQL `dialect` to use with myriade_query on this database. When the name is ambiguous across schemas, the candidates are returned under `matches` instead — pass `schema_name` to pick one. Raises if the user has no access to the table under governance.

Execute a read-only SQL query against a database. Write the SQL in the dialect of the target database's engine — see the `dialect` field returned by myriade_list_tables and myriade_get_table_schema, or the engine in myriade_list_databases. Write operations (INSERT, UPDATE, DELETE, DROP, etc.) are blocked. Returns up to 50 rows of results with column metadata. Successful queries are saved in Myriade; the response's `query_id` can be replayed later with myriade_get_query_results without resending SQL.

Re-execute a saved Myriade query and return fresh results. The query's SQL always re-runs under the caller's governance policies (table permissions, column masking) — results are never served from Myriade's cached snapshot. Prefer this over myriade_query for recurring metrics (dashboards, cockpits): the SQL stays governed in Myriade instead of travelling through prompts. Write statements are blocked. Returns up to 50 rows with column metadata, same shape as myriade_query.

Ask a natural language question about a database using Myriade's data analyst agent. The agent will explore the database schema, search the catalog, run SQL queries, and analyze the results to answer your question. Use this for complex analytical questions that require multiple steps; for simple schema lookups or direct SQL, prefer the other tools. The run executes in the background as a regular Myriade conversation (visible in the web UI). If it finishes quickly the answer is returned directly; otherwise the tool returns ``{"status": "running", "conversation_id": ...}`` — poll myriade_get_answer with that id to retrieve the result. Long analytical questions are expected to take several minutes. Note: the agent has access to catalog write operations (create/update assets, tags, terms) — it may modify catalog state to record findings. It can also read, create and edit reports (ask it to "write a report on ..." or "update report <id> with ..."). Use myriade_query directly for strictly read-only inspection. Requires AI_PROVIDER and the corresponding API key (e.g. AI_PROVIDER=anthropic + ANTHROPIC_API_KEY).

Get a monitoring check (name, SQL, severity, cadence, status) and its most recent run results, newest first. On governed databases the SQL and evidence rows are redacted unless you manage the database or authored the proposal.