Skip to main content
Glama

redeploy_service

Rebuild an existing Git-deployed service from its recorded repository and branch to pick up a new commit; follow the asynchronous call with wait_for_service.

Instructions

Use when: a git app needs a new commit. Asynchronous — follow with wait_for_service.

    Re-clones the repository and branch/tag the service was deployed from
    and rebuilds it, so picking up a new commit is one call with the service
    name alone. Use this instead of ``deploy_git`` when the service already
    exists — every coordinate (repo, ref, subdir, private-repo credential
    reference) is read back off the service. A service deployed from a
    folder/zip has no recorded source and is refused. ``dry_run=True`` returns
    the build/config plan diff (env key names only, values never). A
    non-dry-run response carries
    ``summary``, ``hints`` (never empty) and ``next_step`` — the structured
    follow-up call.
    

Input Schema

NameRequiredDescriptionDefault
nameYesName of an existing app deployed from Git; its recorded repo, ref, subdir and credential reference are re-read, so no coordinates are passed here.
dry_runNotrue = validate and return the plan (what would change) with zero writes; nothing is built, deployed or audited as a change.
idempotency_keyNoCaller-chosen key: a retry with the same key replays the first result instead of acting twice. Omit and a fresh key is minted per call, so each call acts.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.8/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden and does: it declares the call asynchronous and names the follow-up (wait_for_service), explains that repo/ref/subdir/credentials are re-read off the service, that folder/zip-deployed services are refused, that dry_run makes zero writes, and that a real run returns summary/hints/next_step.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the trigger condition and tightly written for the amount of behavior it covers. It is dense and slightly overstuffed with response-field detail, but no sentence is filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description supplies the async contract, the follow-up call, the dry-run semantics, the refusal case, and the shape of the response. That is enough for an agent to invoke it correctly on the first try.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3. The description still adds meaning beyond the schema: it explains why only a name is needed (coordinates are re-read), and that the dry-run diff shows env key names but never values, which the schema does not say.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a concrete verb pair (re-clone the recorded repo plus ref, then rebuild) against a named resource (an existing git-deployed service). It explicitly contrasts with the sibling deploy_git, so an agent can pick between them without opening either schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Leads with a 'Use when: a git app needs a new commit' condition, names the alternative ('use this instead of deploy_git when the service already exists'), and states an exclusion (services deployed from a folder/zip are refused). When-to-use, when-not-to-use and the alternative are all present.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.