Skip to main content
Glama
606,552 tools. Updated 2026-09-24 08:53

"Docker container management for Windsurf IDE on Linux" matching MCP tools:

  • Update LLM instructions at the specified level. Required: level ('brain'|'personal_root'|'container'|'team'), instructions (string). Optional: id (integer, required for 'container' and 'team'), mode ('replace' default|'append'). The 'container' level updates personal containers only; to set instructions for a team, use level 'team' (team owners only). In 'replace' mode (default), the provided text overwrites existing instructions. In 'append' mode, the text is appended to existing instructions with a newline separator. Always read current instructions first before replacing to avoid losing existing content.
    Connector
    Destructive
    OAuth
  • Search Flevy's marketplace of consulting frameworks, PowerPoint templates, Excel financial models, business toolkits, and management case studies. Use this whenever a user needs a best-practice framework, methodology, template, financial model, or real-world case example on any business or management topic (strategy, digital transformation, supply chain, pricing, operational excellence, M&A, etc.). Returns up to 10 relevance-ranked recommendations across two content types: "document" (premium documents authored by management consultants) and "case_study" (management case studies). ALWAYS include each recommended item's url as a clickable link when you mention it in your reply — never reference a document without its link, because the link is the only way the user can open it. Each result carries a content_id for get_content_details. Filters: topic (single, or "topics" for documents covering ALL of several topics), author (list more documents from an author seen in results), filetype (including tier1_consulting_deck for McKinsey-style strategy decks), content_type. Topic-filtered responses also list related_topics to pivot to. Provide at least one of query, topic(s), or author; use list_topics to map user phrasing to a canonical topic.
    ConnectorNo auth
  • Perform a Linux package vulnerability audit using SecDB. ## What this tool does Analyzes the installed packages of a Linux system-identified by OS and OS version-and returns vulnerability information plus a Markdown summary. The audit results are based exclusively on the package list provided by the user. ## When to use this tool Use this tool when the user wants to determine: - whether installed packages contain known vulnerabilities - whether a host, VM, container, or base image is affected by security advisories - which packages require patching or upgrading If the user does not know the valid values for `os` or `version`, first call the `linux_os` tool to retrieve the exact supported combinations. ## Inputs - **os**: Linux distribution identifier supported by SecDB (use `linux_os` to obtain allowed values). - **version**: OS version or codename corresponding to the selected distribution. - **packages**: list of installed packages, **one per line**, generated using the appropriate system command: ### For RPM-based distributions (RHEL, CentOS, Rocky, Alma, SUSE) rpm -qa --qf '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' ### For DEB-based distributions (Ubuntu, Debian) dpkg-query -W -f='${Package} ${Version} ${Architecture}\n' ### For Alpine Linux apk list -I The raw output of these commands can be passed directly as the `packages` input (one package per line). ... python3 3.12.3-0ubuntu2.1 amd64 systemd 255.4-1ubuntu8.10 amd64 tmux 3.4-1ubuntu0.1 amd64 ... ## Outputs - **report**: structured objects describing the advisories affecting the audited packages. - **summary**: Markdown summary including total vulnerabilities, severity breakdown, and key findings. ## LLM usage guidelines - Never guess whether a package is vulnerable-always call this tool for Linux audits. - If `os` or `version` is unclear or missing, call `linux_os` and ask the user to choose a valid combination. - Normalize the package list to “one entry per line” if the user provides unstructured output. - The `summary` is already Markdown and can be shown directly. - Use `report` when deeper technical analysis is required.
    ConnectorNo auth
  • Get LLM instructions at the specified level. Call with level 'brain' early in conversations to learn user preferences. Optional: level ('brain'|'personal_root'|'container'|'team'), defaults to 'brain' if omitted or blank; the response echoes resolved_level and defaulted_level (true when the level was defaulted). Optional: id (integer, required for 'container' and 'team' levels). 'container' level takes a personal (or shared) container id and returns the full inheritance chain, outermost first; each entry carries a `level` field ('brain'|'personal_root'|'team'|'container'). Team container ids are not addressable here — read a team note's chain from notes-get, or the team's own instructions with level 'team'.
    ConnectorOAuth
  • Mint a PROJECT-scoped management token (`er_mcp_`) for MCP and REST; it cannot authenticate relay traffic. Use it after create_project to configure a fresh project, or for any project you already own. Attenuated by design: the scopes must be a subset of THIS management token's own grant (`read` is always included), expiry is mandatory (1–90 days, default 30, never "never"), and the minted management token (being project-scoped) can never mint management tokens itself. `spend` is human-granted only: no management token, of any scope, can mint one carrying it. Mint a spend-scoped token from the project's panel instead. Requires an ACCOUNT-scoped management token and the `config` scope. Returns the plaintext exactly once; only its hash is stored.
    ConnectorNo auth
  • Adds a new node (entity) to a live Trident document. The node appears immediately for all collaborators. Requires a valid editor access token. Before adding nodes: call open_document to understand the diagram layout and pick sensible positions; call get_document_summary to get all existing entity IDs so you can avoid duplicates. IMPORTANT: if this node belongs inside a container, pass node.container on THIS call — do NOT create the node without a container and reparent it later via update_node. Orphaned nodes appear immediately to all live collaborators and create unnecessary visual churn.
    ConnectorNo auth

Matching MCP Servers

  • F
    license
    A
    quality
    D
    maintenance
    Enables AI agents to retrieve the latest semantic version tags for container images from Docker Hub, GHCR, Quay, and other OCI registries, allowing them to pin specific versions for reproducible deployments.
    5
    -
  • A
    license
    A
    quality
    A
    maintenance
    A Linux system monitoring MCP server that provides real-time information on CPU, memory, disk, network, processes, Docker, security, and more via MCP tools.
    69
    MIT

Matching MCP Connectors

  • Does that Docker tag actually exist? Real tags, sizes and platforms, live from Docker Hub.

  • Security audit for docker-compose.yml — 25 checks: secrets, privileges, network, volumes, images.

  • Request an API key for a site YOU ARE RUNNING ON (challenge-response). ⚠ ONLY USE THIS IF YOU ARE EXECUTING INSIDE THAT SITE'S OWN CONTAINER. If you bought or ordered the site from somewhere else, this is the wrong tool: it returns "pending" and the pending never resolves, because the proof it asks for is a file you cannot reach. Use `get_checkout_status(checkout_id)` on the checkout that paid for the site — that hands over the site-scoped key over plain HTTP with no container access. The refusal and the pending response both name it under `alternative` when one is available. Two-step verification flow: 1. A claim token is written into that site's container, at the per-site path the response gives you in `claim_path` (mode 600, owner admin — readable only from on the container). Do not hardcode the path. 2. Read that file and call claim_api_key(token) within 1 hour Refused for sites on SHARED containers. One container there serves up to 40 customers behind one agent, so reading a file proves you are on the machine, not which customer you are — the token would authenticate the wrong thing. No authentication needed — the proof is reading the file from the container. Args: site_slug: The site identifier (your BorealHost site slug) Returns: {"status": "pending", "site_slug": "my-site", "expires_in_seconds": 3600, "claim_path": "/home/admin/.borealhost/.claim_token_my-site", "requires_container_access": true, "instructions": "Read the claim token and call claim_api_key()...", "alternative": {"checkout_id": "...", "command": "bh checkout status ..."}} Errors: VALIDATION_ERROR: Unknown site slug, no active subscription, shared container, or a key already exists (rotate it, never revoke it to reach this route). Carries `alternative` when another route works. RATE_LIMITED: Too many pending claim tokens
    ConnectorNo auth
  • Replace the ssh keys authorised for root on a persistent Linux machine. This is how you revoke: send the list without the key you want gone, and on a running machine it stops working immediately. Sending an empty list removes every key. Not a patch — whatever you send becomes the whole list, so read the current keys from scalix_computer_list first if you mean to add one.
    Connector
    Destructive
    No auth
  • Search a registry for packages matching q. registry=all fans out to npm, Docker Hub, and the VS Code Marketplace and merges the results. PyPI has no public search API, so registry=pypi returns 400 not_supported — look a PyPI package up by name via get_package instead. Results are normalized PackageSummary items (npm adds a relevance score; Docker adds isOfficial).
    ConnectorNo auth
  • THE APPLICATION'S OWN LOGS - what `docker logs`/`podman logs` would show for each container in a deployment. This is the tool for 'it deployed fine but it does not work': a 500, a crash loop, a failed DB connection, a missing env var all announce themselves here and NOWHERE else. ⛔ DO NOT use get_instance_logs for this. That returns the VM's SERIAL CONSOLE (kernel messages and cloud-init), which answers a question nobody debugging an app has - and on this platform it goes permanently silent once the machine finishes booting. build_log does not contain runtime output either; it stops when the build does. Default depth answers instantly from the VM's last report; a bigger `tail` or any `since` asks the VM for a fresh pull and takes up to ~15s. Secret-shaped values (PASSWORD=, TOKEN=, API_KEY=) are redacted in transit.
    ConnectorNo auth
  • Claim an API key using a claim token from the container. After calling request_api_key(), read the claim token from the path that call returned in `claim_path`, on that site's container, and pass it here. The token is single-use — once claimed, it cannot be used again. The API key is automatically activated for this MCP session. Args: claim_token: The claim token string read from the container file Returns: {"api_key": "bh_...", "key_prefix": "bh_...", "site_slug": "my-site", "scopes": ["read", "write"], "message": "API key created and activated..."} Errors: VALIDATION_ERROR: Invalid, expired, or already-claimed token
    ConnectorNo auth
  • Deploys a MULTI-CONTAINER app — a repo that ships docker-compose.yml / compose.yaml — onto ONE VM via podman-compose, and exposes one or more services at redu.cloud URLs. Use this instead of deploy_app when the repo is a compose stack. Same prereqs + source modes as deploy_app; always run plan_deploy first. PORT is the HOST port for the exposed service. DB: 'compose' uses the stack's own db container; 'managed' provisions a separate managed Postgres/MySQL/MariaDB VM and appends connection env. For WordPress/WooCommerce cluster intent, do not leave the compose db service/local uploads as state: pass app_profile, cluster_target:true, database:'managed', db_engine:'mariadb' or 'mysql', cluster_media_mode:'media_space', and either media_space_id or create_media_space:true. Redu writes an override file that points the WordPress service at managed DB env and mounts the media space into /var/www/html/wp-content/uploads. Poll get_deployment until ready.
    ConnectorNo auth
  • Add elements to, and edit campaign-level fields of, an existing **Channel-First / Native (N×N×N)** campaign — the one built with `create_native_structure_campaign` (channel.structureType=NATIVE, WizNativeAdContainer). This is the NATIVE counterpart of `add_and_edit_campaign_elements`: that tool edits Precision (1×1×1 / METADATA) campaigns; THIS tool edits Native (N×N×N) campaigns. CRITICAL: PICK THE TOOL BY THE CAMPAIGN'S STRUCTURE (not by user phrasing): • Native / Channel-First / Platform-First / N×N×N campaign → THIS tool (`add_and_edit_native_campaign_elements`). • Precision Optimization / 1×1×1 / METADATA campaign → `add_and_edit_campaign_elements`. Both tools guard: call THIS tool on a Precision/METADATA campaign and it returns an error telling you to use `add_and_edit_campaign_elements`, and vice-versa. So if you guess wrong, the error tells you the right one — no silent mis-write. If you don't know the structure, check the campaign first (its channels' structureType) or just try and follow the redirect. WHAT THIS TOOL DOES: - EDIT campaign-level fields: name, budgetGroup, startDate, endDate (same smart/partial semantics as the flat tool — only pushed when different / supplied). - ADD new containers: each channel's `containers[]` APPENDS new WizNativeAdContainers (one audience × an `ad_offers` list of {ad, offer} pairs each, same shape as `create_native_structure_campaign`). Existing containers are PRESERVED — the channel's current container list is re-POSTed with the new ones appended. - ADD bare target groups: each channel's optional `target_groups[]` (names) attaches targeting groups to the native channel without a full container (places targetingGroupId on a reused/appended ad-less container). - ATTACH negative keyword lists (Google Ads / Microsoft Ads only): the search channel block's optional `negative_keyword_lists[]` (names of EXISTING lists) attaches them channel-wide — valid with or without new containers. Names inside `containers[].negative_keyword_lists` are unioned in and applied at the same channel level. A name that doesn't resolve on the channel is reported in `errors[]`, never silently skipped. - EDIT existing containers (PER CONTAINER): each channel's optional `modify_containers[]` targets an existing container by `name` and, within it, deletes specific Ad—Offer rows (`remove_ads`), clears an offer from one ad while keeping it on the OTHER ads (`clear_offers_on_ads`), removes this container's audience / targeting group / keywords / exclusion (`remove_audience` / `remove_target_group` / `remove_keywords` / `remove_exclude_audience`), or deletes the whole container (`delete_container`). This is the surgical counterpart to the channel-wide remove_* tools — use it when an audience/offer/ad is shared across containers and you only want to touch one. Removing a group clears it on that one container; a group reused by other containers stays alive for them. WHAT THIS TOOL DOES NOT DO: - It does not switch a campaign's structure (that's fixed at creation). - For a change that spans ALL ads (remove an offer/ad everywhere it appears on the channel), use the channel-wide removal tools (remove_offers_from_campaign / remove_ad_from_campaign / remove_audiences_from_campaign / remove_target_groups_from_campaign / remove_keywords_from_campaign); `modify_containers` is only for a specific container/row. CONTAINER RULES (same as create_native_structure_campaign): - Each container is one audience × a LIST of (ad, offer) pairs (`ad_offers`, 1+). Group several ads/offers under one audience by adding pairs — e.g. 3 ads on the same offer = 3 pairs that repeat the same `offer` id. Send two containers only to run the audience as two separate ad-sets. - `audience` / `exclude_audience` / `target_group` are NAMES (resolved server-side); the `ad` / `offer` inside each `ad_offers` pair are integer IDs. - Audience names are resolved BEFORE anything is created: a container whose `audience` cannot be resolved is dropped with an error in `errors[]` that states whether retrying can help ("may still be matching") or not ("not available on this channel"); no keyword group or other element is left behind for a dropped container. - `audience` is REQUIRED for LinkedIn/Facebook/Instagram/Reddit; OPTIONAL for Google/Microsoft search containers (keyword-only is valid — provide `keywords`/`keyword_ids` instead). - Offer–channel lock still applies: a Lead Gen offer must be locked to the container's channel (LinkedIn→LINKEDIN, etc.); Google takes Landing Page offers only; Landing Page offers are universal. RESPONSE: same top-level shape as `add_and_edit_campaign_elements` (success, campaign_id, changes {renamed, budget_group_reassigned, schedule_updated}, added_summary per channel {containers, target_groups, negative_keyword_lists, and — when modify_containers is used — ads_removed, offers_cleared, containers_deleted, audiences_removed, target_groups_removed, keywords_removed, excludes_removed}, optimization_group, campaign_url, full_response). On partial failures, success=false plus `errors[]`; the rest of the edit still proceeds. EXAMPLE (append a LinkedIn container + rename): add_and_edit_native_campaign_elements(campaign_data={ "campaignId": 159490, "name": "Q3_ABM_Native_v2", "linkedin": {"containers": [ {"name": "VPs > Demo > Form", "audience": "VPs - NA", "ad_offers": [{"ad": 156502, "offer": 57538}]} ]} }) EXAMPLE (append a Google keyword-only container + bare target group): add_and_edit_native_campaign_elements(campaign_data={ "campaignId": 159490, "google": { "containers": [ {"name": "Incident Response", "ad_offers": [{"ad": 210804, "offer": 67269}], "keywords": ["incident response platform"], "negative_keyword_lists": ["Competitor Brands"]} ], "target_groups": ["Tech Decision Makers"] } }) EXAMPLE (ROW-LEVEL: drop the offer from ONE ad in a container, keep it on the other ads): add_and_edit_native_campaign_elements(campaign_data={ "campaignId": 159490, "facebook": {"modify_containers": [ {"container": "ICP > 3 creatives > TOF offer", "clear_offers_on_ads": ["Ungated-AI-in-Finance-v2-vert_FB"]} ]} }) EXAMPLE (PER-CONTAINER: delete one Ad—Offer row in one container; delete a whole other container): add_and_edit_native_campaign_elements(campaign_data={ "campaignId": 159490, "linkedin": {"modify_containers": [ {"container": "VPs > Demo > Form", "remove_ads": ["Old Creative A"]}, {"container": "Retired ad-set", "delete_container": True} ]} }) EXAMPLE (PER-CONTAINER: drop a reused audience from ONE container, keep it on the others): add_and_edit_native_campaign_elements(campaign_data={ "campaignId": 159490, "facebook": {"modify_containers": [ {"container": "ICP - A2", "remove_audience": True} ]} })
    Connector
    Destructive
    API key
  • Entry-point tool. Lists every tracking container the user can access across all connected servers. Each container is one tracked website or app. USE WHEN: - Starting any session — you need a container_id before calling get_report, get_summary, list_events, or list_sessions. - The user asks "which sites / accounts can I see?" or names a brand without giving a trc_ ID. - You need the server_name for multi-server setups. - **OAuth fallback path of the agent install contract** (https://www.tracklution.com/agent-install.md, Turn 4 Step 2) — after the user completes browser-OAuth, call this tool to enumerate the user's containers and resolve the (container_id, container_hash) pair you need for onboarding tools (get_installation_scripts, verify_and_score, create_login_link, ...). Match against the user's website URL via the `domain` field (compare by host name — `domain` may be `null` on freshly-created containers, skip those). Returns container IDs (trc_...), container hash (dashboard-URL identifier AND secret half of the dual-key auth-token cache lookup; pass as `container_hash` on every onboarding-tool call — may be `null` on legacy Laravel deploys that pre-date the field, in which case fall back to register_and_provision with auth_token + website_url), titles, domains, currency, timezone, and active status.
    ConnectorOAuth
  • Create/reuse an account and the first tracking container in one agent-safe call. For brand-new emails: the API creates the account, immediately emails the user a welcome / set-password link, and returns a 60-minute JWT in `data.auth._sensitive_access_token` so this agent can continue applying snippets and verifying events without further authentication. Hold the JWT only for this conversation and pass it back as `auth_token` on subsequent onboarding tool calls. After the user clicks the welcome email link, they finish setup and log into the dashboard. The response carries two informational flags for fresh registrations: `pending_user_activation: true` and `welcome_email_sent_to: <email>`. Surface the inbox-check instruction to the user verbatim when these are present. PROACTIVE auth_token: If you ALREADY have an `auth_token` (the user is signed in, or a previous turn returned one), pass it INSTEAD of `email`. With `auth_token` the call returns the existing-or-new container for that (user, website_url) pair — no `duplicate_account` error occurs. Do NOT pass `name` or `email` alongside `auth_token`; the server reads identity from the JWT. RECOVERY on `duplicate_account` (HTTP 409): the user already has a Tracklution account. Ask them to log in at https://app.tracklution.com (or request a fresh setup link at https://app.tracklution.com/account-recovery if they never finished the welcome flow), then re-run this tool with `auth_token` in memory. RECOVERY on `multi_client_ambiguous` (HTTP 409): the JWT-authed user has multiple companies (clients) and the requested `website_url` does not match any existing container. The server cannot pick a company on the user's behalf. Surface `next_action.reason` verbatim (it contains a dashboard URL) and EXIT — do NOT call any other MCP tool. The user finishes the container creation from their dashboard, then re-runs this tool with the same `website_url`, which returns the container created there. PERMISSIONS: for a signed-in user, creating a NEW container under an existing company requires admin permission on that company (`insufficient_permissions`, `details.required_permission = "admin"`); re-running for a website that already has a container under one of the user's companies returns that container when the user has view permission or higher on it (`details.required_permission = "view"` otherwise). In both denials, surface `errors[0].message` verbatim and stop. MULTI-SERVER SESSIONS: in a session connected to several servers the returned `next_action.args.server_name` names the server this container was created on; pass the returned `next_action` back verbatim. RECOVERY on `rate_limited` (HTTP 429): respect `retry_after_seconds` strictly. Never retry without backoff. If `errors[0].details.key` mentions `domain:<host>`, the cap is per-website-domain — a different `email` will NOT bypass it. The MCP server does NOT generate idempotency keys — the agent MUST supply `idempotency_key` (UUID v7 recommended). Every response includes `_request_id` in `structuredContent`.
    ConnectorOAuth
  • Set or clear a team member's role on a team container. Roles cascade to descendants unless a child has its own role. Caller must have admin role on the target container. Required: container_id (integer, must be a team container), user_id (integer, must be a member of the same team), role ('viewer' | 'editor' | 'admin' | 'inherit'). Use 'inherit' to delete an explicit role and fall back to the role inherited from an ancestor (or from team membership). Team owners are always admin and cannot be downgraded. Returns the user's resulting effective_role on that container.
    Connector
    Destructive
    OAuth
  • List the projects on your account (archived included), each with `id`, `slug`, `name`, `apiBaseUrl` and `archived`, plus `accountEmail` — the account this token authenticates as. Requires an ACCOUNT-scoped management token (one minted with no project) and the `read` scope. A PROJECT-scoped management token cannot call this: use it on its own project's tools instead.
    ConnectorNo auth
  • Export completed extractions as TMS/ERP-ready normalized line rows (one row per container / invoice line / package / goods line), newest first. Optional doc_type filter and max_rows cap. Corrected data wins over the original extraction. For CSV/XLSX files use GET /api/bol/export on the REST API.
    ConnectorNo auth
  • Deploy a long-running container service on Scalix Run from a container image. Creates a new service, or a new revision of an existing service with the same name, with health checks, a public HTTPS URL, and autoscaling between min_instances and max_instances (min 0 = scale-to-zero when idle). Billed per vCPU-hour while instances run. Roll back a bad revision with scalix_run_rollback.
    ConnectorNo auth
  • Build a container image on Control Plane from a GitHub or GitLab repository and push it to the org's private registry. No Docker daemon is involved: the service clones the repo, detects how to build it (Dockerfile when present), and always produces linux/amd64. Returns a buildId to read with get_image_build — the build keeps running after this call returns. ONLY repositories work here. To build a LOCAL FOLDER, tell the user to run `cpln image build --remote --dir PATH --name NAME:TAG` in their terminal — this server has no access to their filesystem. Building an existing NAME:TAG replaces that image. A private repository needs a one-time browser authorization per org; this tool returns the link when that is missing. Recommended reading before first use: get_cpln_skill("image") — the runbook for this tool family (read once per session).
    Connector
    Destructive
    OAuth
  • WORKFLOW: Step 1 of 4 - Start infrastructure design conversation Open an InsideOut V2 session and receive the assistant's intro message. The response contains a clean message from Riley (the infrastructure advisor) - display it to the user. ⚠️ Riley will ask questions - forward these to the user, DO NOT answer on their behalf. CRITICAL: This tool returns a session_id in the response metadata. You MUST use this session_id for ALL subsequent tool calls (convoreply, tfgenerate, tfdeploy, etc.). ⚠️ The session_id includes a ?token=... suffix (format: sess_v2_xxx?token=yyy) which is part of the session credential — without it, downstream tools fall back to a tokenless connect URL that 401s. Always pass session_id verbatim to subsequent tools and to the user; do NOT shorten, paraphrase, or strip the ?token= portion when summarizing the session in chat or in your own scratch notes. Use when the user mentions keywords like: 'setup my cloud infra', 'provision infrastructure', 'deploy infra', 'start insideout', 'use insideout', or similar intent to begin infra setup. OPTIONAL: project_context (string) - General tech stack summary so Riley can skip discovery questions and jump to recommendations. The agent should confirm this with the user before sending. Include whichever apply: language/framework, databases/services, container usage, existing IaC, CI/CD platform, cloud provider, Kubernetes usage, what the project does. Example: 'Next.js 14 + TypeScript, PostgreSQL, Redis, Docker Compose, deployed to AWS ECS, GitHub Actions CI/CD, ~50k MAU'. NEVER include credentials, secrets, API keys, PII, source code, or internal URLs/IPs -- only general metadata summaries useful to a cloud architect agent. IMPORTANT: source (string) - You MUST set this to identify which IDE/tool you are. Auto-detect from your environment: 'claude-code', 'codex', 'antigravity', 'kiro', 'vscode', 'web', 'mcp'. If unsure, use the name of your IDE/tool in lowercase. Do NOT omit this — it controls the 'Open {IDE}' button on the credential connect screen. OPTIONAL: github_username (string) - GitHub username for deploy commit attribution. Pre-populates the GitHub username field on the connect page. 💡 TIP: Examine workflow.usage prompt for more context on how to properly use these tools.
    ConnectorNo auth