Skip to main content
Glama

Get the graph of a ground

get_graph

Returns the tree(nodes), edges, apis, seasons, and bugs for one ground. The tree is the project's information-structure (IA) diagram — each node is a structural element (an object, or an action it performs), not a work-log entry. Node types follow the plant metaphor: trunk → limb → twig → leaf → vein. See resource umtri://rules/vocabulary. By default returns a summary view — nodes carry id/label/type/parent/season, plus a 200-char description excerpt, metadata.implements, placeholder/dormant flags (soft-deleted nodes are omitted). Pass view="full" only when you need timestamps, full descriptions, all metadata keys, or tags — that response is ~3× larger. For a large tree, read it in slices instead of all at once: rootId (+depth) for one trunk or limb; maxType for a layer (e.g. maxType="twig" = the skeleton without leaves/veins — a cheap overview); role for a cross-section; season for what was born in one season. Filters combine. Node ids come from the graph itself, so the standard drill-down is two calls: first get_graph with maxType="trunk" (or "limb") for a cheap skeleton, find the id you want, then call again with rootId set to it to get just that trunk/limb and its subtree. Control the heaviest field with descriptions: "none" drops descriptions for a pure structural overview, "excerpt" (default) gives a 200-char preview, "full" returns them verbatim when you drill into a limb. The summary response also carries shape (nodeCount, maxDepth, nodes-per-level, over-wide branches) so you can judge whether the tree is too deep or too wide without rebuilding it, a childCount on each branch node, and iaHints flagging structural smells. A bushy tree (mass at mid-levels) is healthy — don't over-nest sparse parents into twigs. Bugs default to active (open + in_progress) — pass bugStatus="all" to also see healed (resolved/closed) ones. Nodes may carry plan:true — these are the human's node-based brief (intent drawn as structure, not a prompt); read them as instructions and realize them (see umtri://rules/plan). When you slice (rootId/maxType/role/season), a connection with only ONE endpoint inside the slice is still returned, marked boundary:true, and its outside endpoint appears as a lightweight stub in externalNodes (id/label/type/role, external:true) — so cross-branch dependencies and calls never silently vanish from a slice. To follow one, call get_graph again with rootId set to that external id. The response also carries project.transplanting — when true the ground is still being transplanted (see umtri://rules/transplant): you may freely add/edit nodes in any season incl. past, and hard-delete import mistakes. project.seedMeta is the ground's intent when the human filled it in — goal, endDate, budget, audience. No tool writes it, so it is the human's own brief for what this tree is for: read it before you propose or reshape structure, and let it settle what belongs in the tree and what does not.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "slug": "<slug>"
    },
    "name": "get_graph"
  }
}

Input Schema

NameRequiredDescriptionDefault
roleNoCross-section by role (structure=trunk/limb/twig, object=leaf, action=vein). Parents may fall outside the result.
slugYesGround slug (from list_projects).
viewNosummary (default) for compact nodes; full for raw shape with all fields.
depthNoWith rootId: how many levels below the root to include (0 = just the root, 1 = root + direct children). Omit for the whole subtree.
rootIdNoScope to this node and its descendants — read one trunk or limb at a time. Get the id from a prior get_graph (e.g. maxType="trunk" for a cheap skeleton). Bugs are scoped to the subtree; edges/apis that cross the subtree boundary are still returned (boundary:true) with their outside endpoint in externalNodes.
seasonNoBorn-in delta — return only nodes that first appeared in this season (season id from list_seasons): what grew that season.
maxTypeNoLayer ceiling — return only nodes at this level or higher (trunk is highest). maxType="twig" yields the structural skeleton without leaves/veins. Great for a cheap overview before drilling in with rootId.
bugStatusNoWhich bugs to include. Default "active" = wild + chasing (open + in_progress) — resolved ones are healed erosion, noise on the tree. "wild" for the untouched only, "resolved" for healed, "all" for every bug. Raw DB statuses still work. Use list_bugs for richer bug queries (limit/order), get_bug for one you can name.
descriptionsNoHow much of each node/bug description to include in summary view: none (drop them — lightest structural read), excerpt (200-char preview, default), or full (verbatim). Ignored when view="full" (always verbatim).

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observed

TDQS

A4.9/5.0
Behavior5/5

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

With no annotations supplied, the description carries the full behavioral burden and does so thoroughly. It discloses default omissions (soft-deleted nodes omitted), default bug scoping (active = open + in_progress), response-size differences (~3x larger for view="full"), boundary edge behavior with externalNodes, shape/childCount/iaHints fields, plan:true node semantics, transplanting state, and seedMeta as the human's brief.

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 mostly earns its length given nine parameters, no output schema, and several non-obvious slicing behaviors. It is front-loaded with the return scope, though some guidance repeats the drill-down and boundary patterns and the dense single block could be easier to scan with clearer segmentation.

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 read tool with nine parameters, no annotations, and no output schema, the description is unusually complete. It explains return contents, default filtering, size tradeoffs, slicing strategies, boundary handling, bug status defaults, plan nodes, transplanting, and seedMeta, leaving little an agent would need to infer before calling it correctly.

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?

Although schema coverage is 100% and the schema already documents parameters, the description adds substantial meaning beyond it. It explains the practical difference between summary and full views, how rootId plus depth enables subtree slices, why maxType="twig" is a cheap overview, how role and season act as cross-sections, how filters combine, and what descriptions="none"/"excerpt"/"full" actually do.

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 and resource set: it returns the tree, edges, apis, seasons, and bugs for one ground. It also distinguishes the tree from work-log entries and explains that nodes follow the plant metaphor, so an agent can immediately tell this is the structural graph read rather than a bug, wiki, or impact tool.

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?

It gives explicit when-to-use guidance: default summary view, view="full" only when timestamps/full metadata/tags are needed, maxType for cheap skeletons, rootId for drill-down, and descriptions="none" for pure structural reads. It also names alternatives such as list_bugs for richer bug queries and get_bug for a single named bug, and describes the standard two-call drill-down pattern.

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.