Skip to main content
Glama

query_records

GET records from a mock resource. params is an object of query parameters, all optional: exact filters (field=value), operator suffixes (price_gte, date_lte, name_like, status_ne), full-text q, _sort/_order (or _page/_limit for pagination), select (field projection, e.g. "name,price"), _expand=/_embed= relations. Failure simulation for testing: mock_status=503 forces that status, mock_delay=2000 adds latency (ms), mock_chaos=0.3 fails that fraction of requests randomly, mock_seq=503,503,200 serves a deterministic status sequence (fail twice then succeed — best for retry tests), mock_jitter=500 adds random latency, mock_envelope=data wraps the response. Pass id to fetch a single record. Defaults to _limit=25 — pass _limit explicitly for more (max 100 per page).

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
idNoSingle record id. Optional.
paramsNoQuery params as key→value. Optional.
projectYes
resourceYesResource name (e.g. products).

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observed

TDQS

A4.7/5.0
Behavior5/5

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

With no annotations present, the description carries the full burden — and it delivers: discloses pagination defaults (_limit=25, max 100 per page), fixed vs. random latency semantics, deterministic failure sequencing for retry tests, random chaos injection, and response-envelope wrapping. Exceptional disclosure for a mock tool.

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?

Highly dense single paragraph, but every clause carries unique semantic weight and the core read behavior is front-loaded before the mock controls. The mock parameters would read easier as a bulleted list, yet there is no filler or redundancy.

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?

For a 4-parameter tool with no annotations and no output schema, the description is complete: required vs optional params are clear, the param grammar is exhaustively specified, and defaults/limits are stated. Nothing an agent needs to call it correctly is missing.

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

Parameters5/5

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

Schema coverage is 75% and the project parameter is undocumented, but the description massively overcompensates: it documents the entire params-object DSL with concrete operator signatures (price_gte, date_lte, name_like, status_ne), sorting/pagination keys, the select projection syntax, relation expansion, and every mock-control parameter with exemplar values.

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?

The description opens with 'GET records from a mock resource' — a specific verb plus resource that immediately identifies the operation. The read orientation is clearly distinct from siblings like write_record and import_data, letting an agent route correctly without inspecting any sibling schemas.

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?

The comprehensive query-grammar documentation (filters, operators, sorting, pagination, projection, relations) leaves no ambiguity about how to construct read requests. It does not explicitly name alternatives or state when-not-to-use, though the GET verb and the write-natured siblings make the boundary obvious.

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.

Resources