Skip to main content
Glama

add_concepts

Batch-create multiple ontology nodes in one call to avoid repeated round-trips after a reviewed proposal yields many accepted candidates.

Instructions

Batch-create multiple nodes in one call — same per-row shape as add_concept. Use after analyze_repo_structure or another reviewed proposal flow when the agent has K accepted candidates from the user — replaces K×add_concept round-trips. Each row is processed independently: existing-slug / invalid-kind / missing-required-fields / non-object row shape / unknown row fields surface as { slug, ok: false, error } rows whose errors include a concepts[n] row label, single unknown-field rows include receivedField plus one-row unknownFields, multi unknown-field rows report every unknown field with nearest hints and Received fields: ..., and duplicate input slugs report the later concepts[n] row plus first-seen concepts[m] with structured rowName / firstSeenAt; the rest still land. A row whose normalized title matches an earlier landed row in the same batch still lands but carries a near-duplicate warningpatch_concept the earlier node instead of forking the same concept (duplicates are the #1 growing-vault failure mode). concepts[] order in the response matches the input. Cap = 50 per call (split into multiple batches for larger sets). NO atomic rollback — if you need all-or-nothing semantics use single add_concept calls. Invalid-only batches return no row-level write metadata and no top-level postWriteMaintenance. When at least one row changes the vault, the response includes one compact postWriteMaintenance (maintenance_plan) with count-safe byPhase / bySeverity / byKind queue buckets, action score, executable proposedAction, and current-page nextExecutableAction / nextReviewAction pointers for the final graph. Rows whose title is a bare file path follow the same rule as add_concept above. Prefer one capability node covering a directory plus a short elements: list over one row per file, unless each file's role differs in a stated sentence.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
conceptsYesArray of concept specs (max 50). Each row uses the same shape as `add_concept` input.

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
conceptsYes
postWriteMaintenanceNoCompact maintenance_plan summary for post-write follow-up. Bucket maps describe the remaining queue after the write.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.13.0

TDQS

A4.6/5.0
Behavior5/5

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

The description discloses an exhaustive set of behaviors beyond what annotations provide: per-row independent processing, detailed error formats with row labels, duplicate-slug handling with `rowName`/`firstSeenAt`, near-duplicate warnings, non-atomicity, cap of 50, response ordering, postWriteMaintenance semantics, and the bare-file-path rule. None of this is implied by the annotations (`readOnlyHint: false`, etc.), and there is no contradiction.

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?

The description is long but densely packed with necessary operational detail; every sentence earns its place. It is front-loaded with purpose and usage before diving into error handling and edge cases. Slightly verbose, but justified given the complexity of the batch operation.

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 complex mutation tool with 1 parameter but many edge cases, the description covers everything an agent needs to invoke correctly: accepted input shape, error propagation, duplicate handling, caps, atomicity, response contents, and best-practice guidance (prefer capability nodes). The presence of an output schema further reduces the burden, but the description still exceeds what is structurally implied.

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

Parameters3/5

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

The schema already provides 100% coverage: the `concepts` parameter is fully described with an array of objects, each field documented (slug, kind, title, body, path, labels, elements, capabilities) including patterns and max items. The description's 'same per-row shape as add_concept' adds marginal value, but the schema carries the semantic load. Baseline 3 is appropriate for this schema-rich situation.

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 a specific verb+resource ('Batch-create multiple nodes') and explicitly contrasts with its singular sibling `add_concept`, making its scope and distinction unmistakable. It also states the input shape mirrors `add_concept`, so an agent understands exactly what this tool does without opening the 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?

The description specifies exactly when to use it ('Use after `analyze_repo_structure` or another reviewed proposal flow... when the agent has K accepted candidates'), when to prefer the alternative ('if you need all-or-nothing semantics use single `add_concept` calls'), and even provides batching guidance for >50 items. This fully disambiguates usage from siblings.

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