Skip to main content
Glama

build_template

Read-onlyIdempotent

Builds a verification template - a JSON Schema plus cross-field rules and bounds - from one to ten sample outputs of your service, by a fixed procedure (no model). Types, required fields and string formats come from what every sample contains; unique-id, a <= b, sum and non-negative/percentage rules are added only where every sample satisfies them; expectations lets you state required fields, unique array fields and ranges the samples cannot show. The response lists what was inferred and why (inferred), what the samples could not settle (uncertain), and a listing_patch ready to put on a listing. The finished template is checked against every sample and the call fails (template_rejects_sample) rather than return one that would reject them. Stores nothing. Deterministic. Free, no payment or account required.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
nameNoOptional title for the schema.
samplesNoOne to 10 example outputs of your service, as JSON (at most 32 KB in all). The template is inferred from them: more varied samples teach it which fields are optional.
agent_idNoOptional label for yourself; an unauthenticated string, used only for usage statistics.
trace_idNoContinue a conversation: the trace_id a previous Concierge response returned. Omit on the first call.
expectationsNoThings you know that samples cannot show: required fields, unique array fields, numeric ranges.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observed

TDQS

A4.5/5.0
Behavior5/5

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

Adds substantial context beyond the annotations: no model is used (fixed procedure), the operation is deterministic and stores nothing, it is free with no account, and crucially it fails with template_rejects_sample rather than returning a template that would reject the samples. This is exactly the kind of behavioral disclosure annotations cannot convey.

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 core purpose, then detail in a logical order (inputs, expectations, response, guarantees). It is a dense single block with minor redundancy ('no model' / 'Deterministic' / 'Stores nothing' cluster), but every sentence carries usable information.

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

Completeness4/5

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

No output schema exists, so the description correctly carries the return burden, naming `inferred`, `uncertain`, and `listing_patch`, plus the rejection failure mode. One small gap: all parameters are optional yet the text says 'from one to ten sample outputs', leaving the zero-sample case unaddressed.

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 description coverage is 100%, so the baseline is 3; the description adds value by explaining the inference logic (types/required/formats come from what every sample contains; rules added only where all samples satisfy them; more varied samples reveal optionality). It does not clarify the null/default behavior of `samples` or `trace_id` beyond the schema.

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 and artifact: 'Builds a verification template - a JSON Schema plus cross-field rules and bounds - from one to ten sample outputs.' It further specifies the inference procedure and differentiates itself from siblings like get_template and prepare_verification by describing exactly what is produced (inferred/uncertain/listing_patch).

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

Usage Guidelines4/5

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

Gives clear context for use: feed 1-10 sample outputs, and use `expectations` for things samples cannot show. However, it never explicitly states when to choose this over siblings such as get_template or prepare_verification, leaving the routing decision partly to inference.

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

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.