"A server that can run Docker Compose commands to manage containers" matching MCP tools:

• analyze_track

  StudioSphere Pulse — Audio Intelligence

  Run audio analysis on a public audio URL. Requires estimate_cost to be called first (job_estimate_id). Requires PULSE_API_KEY. Before calling, you MUST confirm with the user that they have a lawful basis to submit this audio for analysis. For a user-requested folder, project, playlist, or batch, one confirmation can cover every track in that scope. Returns job_id — poll get_job_status for results.

  Connector

• preview_fact_verification

  OpenAccountants

  AUTHENTICATED (approved accountants). Dry-run of submit_fact_verification — IDENTICAL arguments, but writes NOTHING. Returns whether the change would apply and any reviewer `warnings`, so you can see the automated reviewer's take (e.g. 'that citation looks like a placeholder') before committing. Then call submit_fact_verification to apply.

  Connector

• strale_ping

  Strale - 290+ API capabilities for AI agents

  Checks that the Strale API is reachable and the MCP server is running. Call this before a series of capability executions to verify connectivity, or when troubleshooting connection issues. Returns server status, version, tool count, capability count, solution count, and a timestamp. No API key required.

  Connector

• ping

  Nordic Financial MCP

  Connectivity check that confirms the Nordic MCP server process is responding. Use this at the start of a session to verify the server is reachable before making other calls. Do not use as a proxy for database health — the server can respond while the Qdrant vector database is temporarily unavailable. To confirm data availability, call search_filings directly. Returns: A greeting string: "Hello {name}! Nordic MCP server is running."

  Connector

• me.validation_history

  AI Design Blueprint Doctrine

  Pro/Teams — return the authenticated user's architect.validate run history with the Blueprint Readiness Score (0-100), letter grade (A-F), and tier (draft, emerging, production_ready). Three lookup modes: (1) `run_id=<id>` returns a SINGLE run with the full persisted result_json — use this to RECOVER a result when your MCP client tool-call timed out before architect.validate returned. The run completes server-side and persists; the run_id is surfaced in the first progress notification of every architect.validate call so you have the recovery handle even when your client gives up early. (2) `repository=<name>` returns the full per-run trend for that repository plus a regression diff between the latest two runs. (3) No arguments returns one summary per repository the user has validated, sorted by most recent. Use modes (2) or (3) BEFORE calling architect.validate again on the same repository — they tell you which principles regressed since the last run, so you can focus the new review on what is actually changing. Auth: Bearer <token>. Pro or Teams plan required.

  Connector

• koreanpulse_about

  koreanpulse

  Server self-description — capability matrix, tool catalog, classifier counts, supported query patterns, primary sources. Free tier. Use this tool when an agent first connects and needs the capability matrix to decide whether this server can answer the user's question, or when the user asks "what can koreanpulse do" or "what data sources does this MCP server provide". Returns a structured dict that downstream agents can ingest directly.

  Connector

• prepare_upload

  mcp

  Returns the LOCAL shell commands to package your working directory and upload it for an upload-mode deploy (no git, no PAT). Run them in the user's terminal, capture `source_token` from the upload's JSON response, then call deploy_app with that source_token (omit repo). The upload authenticates AUTOMATICALLY with a short-lived ticket minted from your MCP credential — NO API key needed in the command and nothing secret is printed (it falls back to needing $REDU_API_KEY only if minting is unavailable). Excludes node_modules/.git/.venv/build output and .env by default; honors .gitignore when is_git_repo=true.

  Connector

• pricetik_hotel_watch_rate

  mcp-server

  Subscribe to a rate alert that fires when the best nightly rate for a PriceTik hotel property and stay window hits or drops below your target. A free API key is required (the watch is owned by your PriceTik account). When `webhookUrl` is omitted, the alert delivers via your PriceTik account — email + the pricetik.com dashboard — which is the right choice for end users in a chat client (no server endpoint needed). Supply an HTTPS `webhookUrl` only for developer/partner integrations that host their own endpoint. Free tier allows up to 3 active alerts; Pro+ raises the cap and unlocks webhook + auto-book delivery. Defaults expiresAt to checkIn minus 48 hours when omitted so abandoned alerts auto-expire ahead of the trip date. Pass an `Idempotency-Key` header to make retries safe (24-hour replay window). Manage alerts via pricetik_webhook_list, pricetik_webhook_delete, and pricetik_webhook_deliveries.

  Connector

• deploy_compose

  mcp

  Deploys a MULTI-CONTAINER app — a repo that ships a docker-compose.yml / compose.yaml (app + its own db/redis/worker containers) — onto ONE VM via podman-compose, and exposes ONE service at https://<name>-<id>.redu.cloud. Use this instead of deploy_app when the repo is a compose stack rather than a single Dockerfile. SAME prereqs + source modes as deploy_app: run check_deploy_prerequisites (network_id + keypair_name), then GIT (`repo`, +git_token for private) or UPLOAD (prepare_upload → source_token). PORT: pass the HOST port the exposed service publishes (the LEFT side of its `ports:` mapping) — redu probes + proxies that exact port; pass `service` to name which service it is (plan_deploy detects both). DB: 'compose' (default) uses the stack's own db service (self-contained); 'single_vm'/'managed' provision a Postgres/MySQL and APPEND its conn env (DATABASE_URL/PG*/MYSQL_*) to the project .env — your compose must REFERENCE those vars to use it (we never rewrite your compose file). Build+provision can take 4-40 min (it pulls/builds every service — heavy ClickHouse/Kafka stacks are slow); poll get_deployment until status='ready', and on failure read build_log (it captures podman-compose logs). TIPS: (1) prefer the project's PREBUILT published images — swap any `build:` block for the published `image:` tag (building from source on the VM is less reliable). (2) redu injects APP_URL/PUBLIC_URL (= the app's public URL) into the env — map the app's own URL/cookie-domain var (SERVER_URL/NEXTAUTH_URL/…) to ${PUBLIC_URL}. (3) multi-surface apps (dashboard + API on separate ports) → pass `expose:[{port,service},…]`, each gets its own URL. (4) if the stack needs a ONE-TIME DB migrate/prepare before it serves (Rails `rails db:prepare`, Django `migrate`, Prisma `migrate deploy` — e.g. Lago), pass `migrate_command` (+ `migrate_service`); without it the stack deploys to 'ready' but 502s on real use because the schema is missing. ALWAYS run plan_deploy first and confirm the plan + cost with the user.

  Connector

• list_public_docker_providers

  OctoPerf

  [Docker] List the public OctoPerf Cloud Docker providers shared across all workspaces. Use these when `list_docker_providers_by_workspace` returns an empty list. Returns each provider's id, name, type (always PUBLIC), available regions, and enabled flag. The `url` deep-link is empty because public providers are not bound to a specific workspace. Pick one to feed into `validate_virtual_user` (providerId + region).

  Connector

• convert_to_terraform

  Control Plane

  Convert a Control Plane resource manifest (YAML or JSON) into the equivalent Terraform (HCL). The manifest is first DRY-RUN VALIDATED against the API (no resource is created) — if it fails validation you get the error instead of HCL, so the returned Terraform always corresponds to a schema-valid resource. Pass `gvc` when the kind is GVC-scoped (workload, identity, volumeset). Set `generateImports` to also return ready-to-run `terraform import` commands. To convert an EXISTING resource instead of a manifest, use export_terraform.

  Connector

• agents_chat_start

  Camber - Remote Agentic Data Science

  Start a Camber agent chat. This is the tool to use for chatting with an agent. Agent runs can take minutes — longer than MCP tool timeouts allow (Claude Desktop cannot extend them). So this tool does NOT wait for the reply: it submits the message and returns immediately with a `conversation_id` and a clickable `chat_url`. The agent keeps working on the server after this returns. **You MUST follow up, the reply is NOT in this tool's result:** 1. After calling this tool you MUST tell the user the work is in progress and share the `chat_url` so they can watch it live. 2. Then immediately call the **`agents_chat_status`** tool with the returned `conversation_id` to get the agent's reply. That tool checks twice over 30 seconds, if the latest status is `running`, call it again. MUST NOT end your turn until `agents_chat_status` returns status `idle` (done) or `failed`. **One run per conversation:** continuing a `conversation_id` that is still `running` fails with a "still generating a response" error. Either wait and retry after `agents_chat_status` reports it finished, or call again with `stop=true` to interrupt the current run and send the new message.

  Connector

• switch_dannet_server

  dannet

  Switch between local and remote DanNet servers on the fly. This tool allows you to change the DanNet server endpoint during runtime without restarting the MCP server. Useful for switching between development (local) and production (remote) servers. Args: server: Server to switch to. Options: - "local": Use localhost:3456 (development server) - "remote": Use wordnet.dk (production server) - Custom URL: Any valid URL starting with http:// or https:// Returns: Dict with status information: - status: "success" or "error" - message: Description of the operation - previous_url: The URL that was previously active - current_url: The URL that is now active Example: # Switch to local development server result = switch_dannet_server("local") # Switch to production server result = switch_dannet_server("remote") # Switch to custom server result = switch_dannet_server("https://my-custom-dannet.example.com")

  Connector

• manage_fuses

  Name Whisper — ENS Intelligence Layer

  Manage fuses on a wrapped ENS name. Fuses are permission bits that can be permanently burned to restrict what can be done with a name. Three modes: 1. **read** — Check which fuses are currently burned on a name 2. **burn_owner_fuses** — Burn fuses on a name you own (CANNOT_UNWRAP must be burned first) 3. **burn_child_fuses** — As a parent, burn fuses on a subname (e.g. burn PARENT_CANNOT_CONTROL on sub.parent.eth) Owner-controlled fuses: - CANNOT_UNWRAP — prevents unwrapping (MUST be burned first before any other fuse) - CANNOT_BURN_FUSES — prevents burning additional fuses - CANNOT_TRANSFER — prevents transfers - CANNOT_SET_RESOLVER — prevents resolver changes - CANNOT_SET_TTL — prevents TTL changes - CANNOT_CREATE_SUBDOMAIN — prevents creating new subnames - CANNOT_APPROVE — prevents approving operators Parent-controlled fuses (for subnames): - PARENT_CANNOT_CONTROL — parent permanently gives up control over the subname - CAN_EXTEND_EXPIRY — allows the subname owner to extend their own expiry WARNING: All fuse burning is IRREVERSIBLE. Fuses expire when the name expires.

  Connector

• get_skill

  civilquants

  Paid tier only. Fetch a senior-QS skill methodology by slug (see list_skills) and APPLY it to the user's documents — the returned body is the system instruction for you to run the methodology on the customer's tokens; CivilQuants does not run inference. Paid callers get the full methodology; anonymous/free callers get a TIER_INSUFFICIENT upsell body; a rejected token gets an INVALID_TOKEN re-authenticate body. The document-heavy skills assume you can chunk/parse the customer's files and render a Word pack locally — that needs a code-execution client (Claude Code / Codex / VS Code) and the pack from get_document_pipeline; on a chat connector you can still read and reason with the methodology. Sign up at https://civilquants.com/pricing. Example: get_skill(skill="tender_risk_assessment").

  Connector

• regulations_get_document

  federal-regulations-mcp-server

  Fetch one Federal Register document by its FR document number — full metadata (title, type, agencies, abstract, action, effective/comment dates, RINs) plus the cross-source handles that make this a workflow server. The output carries the docket ID (chain into regulations_get_docket or regulations_find_comments) and the affected CFR parts (chain into regulations_get_cfr_section). Set include_full_text only when the rule body itself is needed — final rules can run tens of thousands of words.

  Connector

• get_verifier

  Goodeye

  Read a verifier's full definition (criterion, calibration examples, judge config); user-scoped verifiers only. ``verifier_id`` accepts a verifier UUID string or an accessible user-scope name. Any caller who can reach the verifier can read it: the owner, and workflow grantees at any role (a view/exec grantee can read, not only run). Platform ``system:...`` aliases and system verifier UUIDs are never returned (NotFound): system rows are run-only and their internal config never surfaces through list, get, deploy, or revoke. Defaults to the current version; pass ``version`` to pin. Returns the full deploy-time payload (``criterion``, ``input_contract``, ``input_fields``, ``few_shot_examples``, ``judge_model_config``, ``reasoning_field_description``) plus ``config_hash`` (canonical-JSON SHA-256 over the config) so callers can detect drift across versions. A verifier you have no access to (and any revoked one) surfaces as NotFound. Platform-managed verifiers are run-only and never returned here.

  Connector

• list_bench_docker_logs

  OctoPerf

  [Runtime] Snapshot of the Docker container logs produced by an OctoPerf load test — the same lines the web UI streams on the running-bench logs panel. Use this to diagnose launch failures (image pull errors, provider quotas, missing project files, agent boot crashes) when `get_bench_result` reports `state=ERROR` or the run is stuck in PREPARING / INITIALIZING. Returns one entry per log line with `date`, `level` (INFO / WARN / ERROR), and `message`. The server resolves the BenchResult's batchId internally — pass the `benchResultId`, not the batchId. No incremental cursor; the upstream API always returns the full log set, sort/filter client-side.

  Connector

• gtm_job

  Vaaya

  Program the GTM scheduler — durable, multi-step jobs that run on a thin server tick even when no agent is connected (multi-day workflows, standing watches, refreshes). action='schedule' creates one: { name, steps:[...], max_cost_cents?, related_segment_id?, related_lead_id?, start_at? }. Each step is either { type:'service', service, action, params, max_price_cents? } (a paid/free dispatcher call — poll signals, enrich, find) or { type:'reasoning', goal } (a bounded brain-grounded generation that records a decision). Steps run in order; a failed step or the budget cap PAUSES the job. Jobs NEVER send — manual-first holds. action='list' / 'get' { id } / 'cancel' { id }.

  Connector

• dashboard-get

  hjarni

  Get an overview of the Second Brain: counts of notes, containers, tags, and inbox items, plus recent_notes (the 5 most recently created personal notes) and recent_changes (the 5 most recently edited notes across ALL spaces — personal, teams, and shared containers — newest edit first). Use recent_changes to orient at the start of a conversation on what changed lately everywhere. No parameters required.

  Connector