Skip to main content
Glama

sync_chunks_tool

Backfill missing or stale note chunks for a large backlog in bounded batches; call repeatedly until the remaining count reaches zero.

Instructions

Backfill note_chunks for notes whose chunks are missing or stale — the dedicated tool for draining a large backlog (sync_index()'s own chunk backfill is capped small so it stays fast; see its docstring).

limit: max notes to process this call (default 200). Call repeatedly (the response says how many remain) until "remaining" reaches 0 — each call is its own bounded unit of work rather than one unbounded one, so a big backlog never turns a single call into an hours-long block (see PostgresStore.sync_chunks's docstring for the architecture debt this replaced, fixed 2026-09-04).

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
limitNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.4/5.0
Behavior4/5

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

With no annotations and a mutating backfill operation, the description discloses real behavioral traits: each call is a bounded unit of work, the response reports how many notes remain, and the loop-until-zero pattern prevents long blocks. It does not state permissions, idempotency, or failure behavior, and it outsources detail to 'docstring' references an agent cannot read.

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

Conciseness3/5

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

The primary purpose and the limit semantics are front-loaded and clear, but the parenthetical digressions about architecture debt and a fixed date (2026-09-04), plus two pointers to internal docstrings, do not help an agent decide or invoke anything.

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?

An output schema exists, so describing the return payload is unnecessary, and the description still usefully notes that the response carries a 'remaining' count to drive looping. For a one-parameter tool with no annotations, the main residual gap is mutation safety/permission context.

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 0%, so the description must carry the single parameter, and it does: 'max notes to process this call (default 200)' plus the interaction with repeated calls. It adds meaning beyond the bare integer/default in the schema, though it gives no guidance on choosing a smaller or larger limit.

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 specific verb+resource ('backfill note_chunks for notes whose chunks are missing or stale') and explicitly positions itself against sibling sync_index, whose own backfill is described as capped small. An agent can distinguish the two 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?

Explicitly names the condition for use ('draining a large backlog') and rules out the alternative ('sync_index()'s own chunk backfill is capped small so it stays fast'). It also gives the invocation protocol: call repeatedly until 'remaining' reaches 0.

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