Netzo is an operational ERP. Agents read and update a company's live records across sales and customers, purchasing and suppliers, inventory and warehouses, logistics, manufacturing, point of sale, services, HR and finance, and build reports, charts and documents from them. Access follows the signed-in user's module roles (OAuth) or an organization API key.
Netzo is an operational ERP. Agents read and update a company's live records across sales and customers, purchasing and suppliers, inventory and warehouses, logistics, manufacturing, point of sale, services, HR and finance, and build reports, charts and documents from them. Access follows the signed-in user's module roles (OAuth) or an organization API key.
Never invent field names or fabricate row data. Start with list_tables, then describe_table before reading or writing an unfamiliar table. If list_tables fails, quote its message and stop: the connection grants no tables (an authorization issue, not a connection failure). Read with find / count / get / aggregate. Pagination is { page, pageSize } (max 50), not limit/skip. Write only after describe_table. Prefer archive over delete. Destructive tools need confirm:true or elicitation. Quote locale labels (from list_tables, describe_table, fieldLabels) in backticks for the user; tool names, tableUid and row keys stay UIDs. For host UI use the Netzo Apps: find-table (columns), page-list / page-grid / page-gallery (cards), record-card (one row), kpi-stat (one number), chart (Netzo fetches and aggregates the data; never pass numbers). Files and PDFs: get_skill { name: "netzo-mcp-read", ref: "files" }. Netzo renders charts, PDFs and reports itself; do not look for another MCP for them.
SKILLS: before multi-step work (import, analyse, reconcile, triage, reports…), call list_skills, then get_skill with the matching name and follow it. Platform skills: netzo-mcp-discover, netzo-mcp-read, netzo-mcp-write, netzo-mcp-import, netzo-mcp-attach, netzo-reports-author.
Protocol
Pass100/10016 / 16 pts
Connection, authentication, and protocol compatibility.
The title clearly communicates the tool’s action and subject. Keep it concise.
Description98/100
Run any procedure without a dedicated tool: lifecycle and special actions (archive, approve, process, createInvoice, …), duplicate, and the read shape findReferences. Non-table procedures use the namespace as tableUid (pricing.resolve, compositions.ensure). Call `describe_table` first: its `actions` list each procedure with its policy and `data` fields. Record procedures take `id` (+ optional `data`); query procedures take only `data` as their input. Most procedures write: they change record state, may create related records (e.g. createInvoice), and some reach external services (e.g. fiscal stamping with the PAC); a state change such as approve may not be undoable. Consequential actions require confirm:true or elicitation. Returns the procedure result plus, for record procedures, `id`, `message`, `link`, and `next` (follow-up procedures this connection may run).
The description explains the capability, when to use it, and what to expect.
Inputs95/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
tableUid
The table UID from list_tables, or a namespace from list_tables `namespaces` (e.g. "pricing"), that owns the procedure.
Clear enough to supply this argument.
action
The procedure to run (e.g. "archive", "duplicate", "findAggregates"). Pick it from the procedures describe_table lists for this table or namespace.
Clear enough to supply this argument.
id
The id of the record the procedure acts on (from find or get). Omit for query and namespace procedures.
Clear enough to supply this argument.
data
Procedure input. For record procedures, the extra fields listed under the action in describe_table `actions`; for query and namespace procedures, the whole input.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
confirm
Required for destructive actions when the client lacks elicitation.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "action",
"title": "Run Procedure",
"description": "Run any procedure without a dedicated tool: lifecycle and special actions (archive, approve, process, createInvoice, …), duplicate, and the read shape findReferences. Non-table procedures use the namespace as tableUid (pricing.resolve, compositions.ensure). Call `describe_table` first: its `actions` list each procedure with its policy and `data` fields. Record procedures take `id` (+ optional `data`); query procedures take only `data` as their input. Most procedures write: they change record state, may create related records (e.g. createInvoice), and some reach external services (e.g. fiscal stamping with the PAC); a state change such as approve may not be undoable. Consequential actions require confirm:true or elicitation. Returns the procedure result plus, for record procedures, `id`, `message`, `link`, and `next` (follow-up procedures this connection may run).",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"action"
],
"properties": {
"id": {
"type": "string",
"description": "The id of the record the procedure acts on (from find or get). Omit for query and namespace procedures."
},
"data": {
"type": "object",
"description": "Procedure input. For record procedures, the extra fields listed under the action in describe_table `actions`; for query and namespace procedures, the whole input.",
"propertyNames": {
"type": "string"
},
"additionalProperties": true
},
"action": {
"type": "string",
"description": "The procedure to run (e.g. \"archive\", \"duplicate\", \"findAggregates\"). Pick it from the procedures describe_table lists for this table or namespace."
},
"confirm": {
"type": "boolean",
"description": "Required for destructive actions when the client lacks elicitation."
},
"tableUid": {
"type": "string",
"description": "The table UID from list_tables, or a namespace from list_tables `namespaces` (e.g. \"pricing\"), that owns the procedure."
}
}
},
"annotations": {
"readOnlyHint": false,
"openWorldHint": true,
"idempotentHint": false,
"destructiveHint": true
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description97/100
Compute totals over a find scope without paging rows. With `aggregates`: count / countDistinct / sum / min / max / average / weightedAverage, optionally per `groupBy` field. With `field`: the distinct values of one field. Use this for KPIs and breakdowns instead of summing `find` pages. Returns `total` (one value per aggregate) and, with `groupBy`, `groups` of { key, values }; with `field`, `values` (the distinct non-null values).
The description explains the capability, when to use it, and what to expect.
Inputs88/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
tableUid
The table UID from list_tables (e.g. "salesorders").
Clear enough to supply this argument.
query › pagination › page
Page number, starting at 1.
Clear enough to supply this argument.
query › pagination › pageSize
How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped.
Clear enough to supply this argument.
query › sort › items › id
The field to sort by: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › sort › items › desc
true sorts that field descending, false ascending.
Clear enough to supply this argument.
query › filters › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › filters › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › filters › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › or › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › or › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › or › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › not › items › field
The field the condition tests: a field UID from describe_table `fields`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › exists › items › relation
The related rows to test: a relation key from describe_table `relations` (e.g. "items").
Clear enough to supply this argument.
query › exists › items › field
The field UID on the related table that the condition tests.
Clear enough to supply this argument.
query › exists › items › operator
How the related field is compared with `value`.
Clear enough to supply this argument.
query › exists › items › value
What the related field is compared with, written as in filters.value.
Clear enough to supply this argument.
query › search › columns
Field UIDs to search in.
Clear enough to supply this argument.
query › search › value
The text to look for in those fields.
Clear enough to supply this argument.
query › with
Related rows to embed in each result, by relation key from describe_table `relations` (e.g. ["customer"]).
Clear enough to supply this argument.
query › dateRange › field
The date field UID the range applies to.
Clear enough to supply this argument.
query › dateRange › start
Earliest date to include (ISO 8601). Omit for no lower bound.
Clear enough to supply this argument.
query › dateRange › end
Latest date to include (ISO 8601). Omit for no upper bound.
Clear enough to supply this argument.
aggregates › items › op
The aggregate function applied to `value.var` (count needs no field).
Clear enough to supply this argument.
aggregates › items › value › var
Field UID to aggregate. Omit for count.
Clear enough to supply this argument.
aggregates › items › weight › var
Weight field UID. weightedAverage only.
Clear enough to supply this argument.
groupBy
Field UID to break the aggregates down by. Omit for one overall total.
Clear enough to supply this argument.
field
Field UID whose distinct values to list (use instead of aggregates).
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "aggregate",
"title": "Aggregate Records",
"description": "Compute totals over a find scope without paging rows. With `aggregates`: count / countDistinct / sum / min / max / average / weightedAverage, optionally per `groupBy` field. With `field`: the distinct values of one field. Use this for KPIs and breakdowns instead of summing `find` pages. Returns `total` (one value per aggregate) and, with `groupBy`, `groups` of { key, values }; with `field`, `values` (the distinct non-null values).",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid"
],
"properties": {
"field": {
"type": "string",
"description": "Field UID whose distinct values to list (use instead of aggregates)."
},
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional. Pagination is ignored."
},
"groupBy": {
"type": "string",
"description": "Field UID to break the aggregates down by. Omit for one overall total."
},
"tableUid": {
"type": "string",
"description": "The table UID from list_tables (e.g. \"salesorders\")."
},
"aggregates": {
"type": "array",
"items": {
"type": "object",
"required": [
"op"
],
"properties": {
"op": {
"enum": [
"count",
"countDistinct",
"sum",
"min",
"max",
"average",
"weightedAverage"
],
"type": "string",
"description": "The aggregate function applied to `value.var` (count needs no field)."
},
"value": {
"type": "object",
"required": [
"var"
],
"properties": {
"var": {
"type": "string",
"description": "Field UID to aggregate. Omit for count."
}
}
},
"weight": {
"type": "object",
"required": [
"var"
],
"properties": {
"var": {
"type": "string",
"description": "Weight field UID. weightedAverage only."
}
}
}
}
},
"minItems": 1,
"description": "What to compute, e.g. [{ op: \"sum\", value: { var: \"total\" } }]. Results are in the aggregated field's own units."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description98/100
Use a file staged by upload_file. mode "preview": run the blob field's document extractor and return the fields the file would establish (writes nothing). mode "slot": store the file in the record's blob field `uid` (e.g. a CFDI `xml`), replacing the file already there. mode "file": add the file to the record's files list as source evidence. Prerequisites: upload_file first, and update permission on the table for "slot" and "file". "slot" overwrites the file already in that field and cannot be undone; "file" consumes the staged upload, so it cannot be attached again. Which blob fields a table has is in describe_table. Returns the extracted fields (preview) or the updated record / file entry.
The description explains the capability, when to use it, and what to expect.
Inputs95/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
mode
"preview" reads the fields the file would set without writing; "slot" stores it in blob field `uid`; "file" adds it to the record's files list.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
stagingId
The stagingId returned by upload_file.
Clear enough to supply this argument.
uid
The same uid passed to upload_file.
Clear enough to supply this argument.
tableUid
The table UID (from list_tables) of the record the file belongs to.
Clear enough to supply this argument.
recordId
The id of the record to attach to, as returned by find or get. Needed for "slot" and "file"; not used by "preview".
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "attach_file",
"title": "Attach File",
"description": "Use a file staged by upload_file. mode \"preview\": run the blob field's document extractor and return the fields the file would establish (writes nothing). mode \"slot\": store the file in the record's blob field `uid` (e.g. a CFDI `xml`), replacing the file already there. mode \"file\": add the file to the record's files list as source evidence. Prerequisites: upload_file first, and update permission on the table for \"slot\" and \"file\". \"slot\" overwrites the file already in that field and cannot be undone; \"file\" consumes the staged upload, so it cannot be attached again. Which blob fields a table has is in describe_table. Returns the extracted fields (preview) or the updated record / file entry.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"mode",
"stagingId",
"uid",
"tableUid"
],
"properties": {
"uid": {
"type": "string",
"description": "The same uid passed to upload_file."
},
"mode": {
"enum": [
"preview",
"slot",
"file"
],
"type": "string",
"description": "\"preview\" reads the fields the file would set without writing; \"slot\" stores it in blob field `uid`; \"file\" adds it to the record's files list."
},
"filename": {
"type": "string",
"description": "Display name in the files list (\"file\" mode)."
},
"recordId": {
"type": "string",
"description": "The id of the record to attach to, as returned by find or get. Needed for \"slot\" and \"file\"; not used by \"preview\"."
},
"tableUid": {
"type": "string",
"description": "The table UID (from list_tables) of the record the file belongs to."
},
"stagingId": {
"type": "string",
"description": "The stagingId returned by upload_file."
}
}
},
"annotations": {
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": true
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description90/100
Count records in a table matching a find query (same filters as find). Returns how many records match the filters across all pages (not the records themselves).
The description explains the capability, when to use it, and what to expect.
Inputs88/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
tableUid
The table UID from list_tables (e.g. "customers").
Clear enough to supply this argument.
query › pagination › page
Page number, starting at 1.
Clear enough to supply this argument.
query › pagination › pageSize
How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped.
Clear enough to supply this argument.
query › sort › items › id
The field to sort by: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › sort › items › desc
true sorts that field descending, false ascending.
Clear enough to supply this argument.
query › filters › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › filters › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › filters › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › or › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › or › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › or › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › not › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › exists › items › relation
The related rows to test: a relation key from describe_table `relations` (e.g. "items").
Clear enough to supply this argument.
query › exists › items › field
The field UID on the related table that the condition tests.
Clear enough to supply this argument.
query › exists › items › operator
How the related field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › exists › items › value
What the related field is compared with, written as in filters.value.
Clear enough to supply this argument.
query › search › columns
Field UIDs to search in.
Clear enough to supply this argument.
query › search › value
The text to look for in those fields.
Clear enough to supply this argument.
query › with
Related rows to embed in each result, by relation key from describe_table `relations` (e.g. ["customer"]).
Clear enough to supply this argument.
query › dateRange › field
The date field UID the range applies to.
Clear enough to supply this argument.
query › dateRange › start
Earliest date to include (ISO 8601). Omit for no lower bound.
Clear enough to supply this argument.
query › dateRange › end
Latest date to include (ISO 8601). Omit for no upper bound.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "count",
"title": "Count Records",
"description": "Count records in a table matching a find query (same filters as find). Returns how many records match the filters across all pages (not the records themselves).",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid"
],
"properties": {
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional. Pagination is ignored for count."
},
"tableUid": {
"type": "string",
"description": "The table UID from list_tables (e.g. \"customers\")."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description96/100
Create a new record in a table. Call `describe_table` first to get the required createInput JSON Schema. Each call creates another record. Returns the created record plus `id`, `message`, `link`, and `next` (procedures this connection may run on it).
The description explains the capability, when to use it, and what to expect.
Inputs87/100
Input documentation gives an agent enough context to populate the arguments.
tableUid
The table UID from list_tables (e.g. "customers").
Clear enough to supply this argument.
data
Field values for the new record, keyed by field UID, as described by describe_table `createInput`.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "create",
"title": "Create Record",
"description": "Create a new record in a table. Call `describe_table` first to get the required createInput JSON Schema. Each call creates another record. Returns the created record plus `id`, `message`, `link`, and `next` (procedures this connection may run on it).",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"data"
],
"properties": {
"data": {
"type": "object",
"description": "Field values for the new record, keyed by field UID, as described by describe_table `createInput`.",
"propertyNames": {
"type": "string"
},
"additionalProperties": true
},
"tableUid": {
"type": "string",
"description": "The table UID from list_tables (e.g. \"customers\")."
}
}
},
"annotations": {
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description96/100
Permanently delete a record by id. This action is irreversible. Prefer archiving (using the action tool) when available. Requires confirm:true or a client with elicitation support.
The description explains the capability, when to use it, and what to expect.
Inputs94/100
Input documentation gives an agent enough context to populate the arguments.
tableUid
The table UID (from list_tables) the record belongs to.
Clear enough to supply this argument.
id
The id of the record to delete, as returned by find or get.
Clear enough to supply this argument.
confirm
Must be true when the client does not support elicitation.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "delete",
"title": "Delete Record",
"description": "Permanently delete a record by id. This action is irreversible. Prefer archiving (using the action tool) when available. Requires confirm:true or a client with elicitation support.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"id"
],
"properties": {
"id": {
"type": "string",
"description": "The id of the record to delete, as returned by find or get."
},
"confirm": {
"type": "boolean",
"description": "Must be true when the client does not support elicitation."
},
"tableUid": {
"type": "string",
"description": "The table UID (from list_tables) the record belongs to."
}
}
},
"annotations": {
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description96/100
Describe one table (or namespace) before reading or writing it. Always call this before creating or updating records. For a table, returns: `tableUid`, `label`, `description`, `moduleUid`, `moduleLabel`; `fields` (field UID, locale label, semantic type) and `semanticTypes`; `row` / `rowWithRelations` (JSON Schema of a row) and `createInput` / `updateInput` (JSON Schema, null when the table has none); `relations` (relation key for `with` on find/get → cardinality and related table); `allowedProcedures` / `procedures` (what this connection may call); `actions` (per-procedure description, policy and `action.data` input fields); `events` (what the table announces, which webhooks and notification templates subscribe to); and `information` (semantic table facts). For a namespace from list_tables (e.g. "pricing"), returns `namespace` and `procedures` (each with its summary and input JSON Schema).
The description explains the capability, when to use it, and what to expect.
Inputs97/100
Input documentation gives an agent enough context to populate the arguments.
tableUid
A table UID from list_tables `tables` (e.g. "customers"), or a namespace from list_tables `namespaces` (e.g. "pricing").
The title clearly communicates the tool’s action and subject. Keep it concise.
Description94/100
Query records from a table using filters, sort, pagination, and search. Returns `data` (the rows), `total` (all matches), and `fieldLabels` (locale label per field). Use `with` to load related rows. Pagination uses { page, pageSize } (pageSize capped at 50). Use `describe_table` first to discover available fields and relation keys.
The description explains the capability, when to use it, and what to expect.
Inputs94/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
tableUid
The table UID from list_tables (e.g. "customers").
Clear enough to supply this argument.
query › pagination › page
Page number, starting at 1.
Clear enough to supply this argument.
query › pagination › pageSize
How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped.
Clear enough to supply this argument.
query › sort › items › id
The field to sort by: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › sort › items › desc
true sorts that field descending, false ascending.
Clear enough to supply this argument.
query › filters › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › filters › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › filters › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › or › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › or › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › or › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › not › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › not › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › exists › items › relation
The related rows to test: a relation key from describe_table `relations` (e.g. "items").
Clear enough to supply this argument.
query › exists › items › field
The field UID on the related table that the condition tests.
Clear enough to supply this argument.
query › exists › items › operator
How the related field is compared with `value`.
Clear enough to supply this argument.
query › exists › items › value
What the related field is compared with, written as in filters.value.
Clear enough to supply this argument.
query › search › columns
Field UIDs to search in.
Clear enough to supply this argument.
query › search › value
The text to look for in those fields.
Clear enough to supply this argument.
query › with
Related rows to embed in each result, by relation key from describe_table `relations` (e.g. ["customer"]).
Clear enough to supply this argument.
query › dateRange › field
The date field UID the range applies to.
Clear enough to supply this argument.
query › dateRange › start
Earliest date to include (ISO 8601). Omit for no lower bound.
Clear enough to supply this argument.
query › dateRange › end
Latest date to include (ISO 8601). Omit for no upper bound.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "find",
"title": "Find Records",
"description": "Query records from a table using filters, sort, pagination, and search. Returns `data` (the rows), `total` (all matches), and `fieldLabels` (locale label per field). Use `with` to load related rows. Pagination uses { page, pageSize } (pageSize capped at 50). Use `describe_table` first to discover available fields and relation keys.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid"
],
"properties": {
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional."
},
"tableUid": {
"type": "string",
"description": "The table UID from list_tables (e.g. \"customers\")."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description97/100
Loads a Netzo workflow skill (markdown protocol) by name, or one of its references with `ref`. Call it before a multi-step task that matches a skill in the server instructions or list_skills, then follow it. Load a reference only when the skill body points to it. Returns the skill's markdown text, ending with the list of its references.
The description explains the capability, when to use it, and what to expect.
Inputs94/100
Input documentation gives an agent enough context to populate the arguments.
name
Skill name (e.g. "netzo-mcp-write"), or a `netzo://skills/{name}[/{ref}]` URI quoted in a skill.
Clear enough to supply this argument.
ref
Optional reference name listed by list_skills, e.g. "sequence".
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "get_skill",
"title": "Get Skill",
"description": "Loads a Netzo workflow skill (markdown protocol) by name, or one of its references with `ref`. Call it before a multi-step task that matches a skill in the server instructions or list_skills, then follow it. Load a reference only when the skill body points to it. Returns the skill's markdown text, ending with the list of its references.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"name"
],
"properties": {
"ref": {
"type": "string",
"description": "Optional reference name listed by list_skills, e.g. \"sequence\"."
},
"name": {
"type": "string",
"description": "Skill name (e.g. \"netzo-mcp-write\"), or a `netzo://skills/{name}[/{ref}]` URI quoted in a skill."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description96/100
Fetch a single record by its id. Returns the record fields at the top level (not an id/status/data envelope). Use `with` to include related rows. Call `describe_table` to discover available relation keys.
The description explains the capability, when to use it, and what to expect.
Inputs98/100
Input documentation gives an agent enough context to populate the arguments.
tableUid
The table UID (from list_tables) the record belongs to.
Clear enough to supply this argument.
id
The id of the record to fetch, as returned by find or a related record's foreign key.
Clear enough to supply this argument.
with
Related rows to embed, by relation key from describe_table `relations` (e.g. ["customer", "items"]).
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "get",
"title": "Get Record",
"description": "Fetch a single record by its id. Returns the record fields at the top level (not an id/status/data envelope). Use `with` to include related rows. Call `describe_table` to discover available relation keys.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"id"
],
"properties": {
"id": {
"type": "string",
"description": "The id of the record to fetch, as returned by find or a related record's foreign key."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed, by relation key from describe_table `relations` (e.g. [\"customer\", \"items\"])."
},
"tableUid": {
"type": "string",
"description": "The table UID (from list_tables) the record belongs to."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description97/100
Import many rows into one table. Run mode "validate" first: it reports per row whether it would create or update, and which rows have issues, without writing. Then run mode "commit" with the same input. A row with `id` updates that record. Otherwise `matchOn` (a unique key of the table, see describe_table) finds the record to update, and no match creates one, so re-running a commit does not duplicate records. Needs create and update on the table. Call describe_table first for field names. Commit overwrites the matched records' fields. Returns `summary` (row count per status) and `rows` (per row: index, status, id, issues).
The description explains the capability, when to use it, and what to expect.
Inputs95/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
tableUid
The table UID from list_tables to import into.
Clear enough to supply this argument.
rows
The source rows. Keys are field UIDs, or source column names when `mapping` is set. Send a large source as several calls.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
mapping
Field UID → source column name. Omit when row keys already are field UIDs.
Clear enough to supply this argument.
matchOn
Field UIDs of a unique key of the table (natural key) used to find the record a row updates. Omitted: rows with `id` update that record and every other row creates a new one, so a re-run can duplicate records.
Clear enough to supply this argument.
mode
"validate" writes nothing; "commit" creates and updates.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "import_records",
"title": "Import Records",
"description": "Import many rows into one table. Run mode \"validate\" first: it reports per row whether it would create or update, and which rows have issues, without writing. Then run mode \"commit\" with the same input. A row with `id` updates that record. Otherwise `matchOn` (a unique key of the table, see describe_table) finds the record to update, and no match creates one, so re-running a commit does not duplicate records. Needs create and update on the table. Call describe_table first for field names. Commit overwrites the matched records' fields. Returns `summary` (row count per status) and `rows` (per row: index, status, id, issues).",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"rows",
"mode"
],
"properties": {
"mode": {
"enum": [
"validate",
"commit"
],
"type": "string",
"description": "\"validate\" writes nothing; \"commit\" creates and updates."
},
"rows": {
"type": "array",
"items": {
"type": "object",
"propertyNames": {
"type": "string"
},
"additionalProperties": true
},
"maxItems": 500,
"minItems": 1,
"description": "The source rows. Keys are field UIDs, or source column names when `mapping` is set. Send a large source as several calls."
},
"mapping": {
"type": "object",
"description": "Field UID → source column name. Omit when row keys already are field UIDs.",
"propertyNames": {
"type": "string"
},
"additionalProperties": {
"type": "string"
}
},
"matchOn": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs of a unique key of the table (natural key) used to find the record a row updates. Omitted: rows with `id` update that record and every other row creates a new one, so a re-run can duplicate records."
},
"tableUid": {
"type": "string",
"description": "The table UID from list_tables to import into."
}
}
},
"annotations": {
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description97/100
Lists Netzo workflow skills: step-by-step protocols for multi-step work (import, analyse, triage, report authoring…). Returns `skills` (per skill: name, whenToUse, scope, intent, type, refs) and `count`. Load one with get_skill before starting that work.
The description explains the capability, when to use it, and what to expect.
Inputs94/100
Input documentation gives an agent enough context to populate the arguments.
scope
Only list skills of this domain (e.g. "mcp", "sales", "inventory"). Omit to list all skills.
The title clearly communicates the tool’s action and subject. Keep it concise.
Description97/100
Returns tables this connection can access (locale label, module, granted procedures), plus count, plus `namespaces` (non-table procedures such as pricing.resolve, run through `action`). Fails with the reason when the API key is missing or rejected, or has no table grants. An optional moduleUid that matches no granted table returns count 0 — that is not an error.
The description explains the capability, when to use it, and what to expect.
Inputs97/100
Input documentation gives an agent enough context to populate the arguments.
moduleUid
Module UID (e.g. "crm", "purchases") to list only that module's tables. Omit to list every table this connection can use.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "list_tables",
"title": "List Tables",
"description": "Returns tables this connection can access (locale label, module, granted procedures), plus count, plus `namespaces` (non-table procedures such as pricing.resolve, run through `action`). Fails with the reason when the API key is missing or rejected, or has no table grants. An optional moduleUid that matches no granted table returns count 0 — that is not an error.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"moduleUid": {
"type": "string",
"description": "Module UID (e.g. \"crm\", \"purchases\") to list only that module's tables. Omit to list every table this connection can use."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description93/100
Update an existing record by id. Call `describe_table` first to get the updateInput schema. Only include the fields you want to change; the values sent replace the stored ones. Returns the updated record plus `id`, `message`, `link`, and `next` (procedures this connection may run on it).
The description explains the capability, when to use it, and what to expect.
Inputs96/100
Input documentation gives an agent enough context to populate the arguments.
tableUid
The table UID (from list_tables) the record belongs to.
Clear enough to supply this argument.
id
The id of the record to update, as returned by find or get.
Clear enough to supply this argument.
data
The new field values keyed by field UID, as described by describe_table `updateInput`. Fields left out keep their value.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "update",
"title": "Update Record",
"description": "Update an existing record by id. Call `describe_table` first to get the updateInput schema. Only include the fields you want to change; the values sent replace the stored ones. Returns the updated record plus `id`, `message`, `link`, and `next` (procedures this connection may run on it).",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"id",
"data"
],
"properties": {
"id": {
"type": "string",
"description": "The id of the record to update, as returned by find or get."
},
"data": {
"type": "object",
"description": "The new field values keyed by field UID, as described by describe_table `updateInput`. Fields left out keep their value.",
"propertyNames": {
"type": "string"
},
"additionalProperties": true
},
"tableUid": {
"type": "string",
"description": "The table UID (from list_tables) the record belongs to."
}
}
},
"annotations": {
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description99/100
Stage a source file (PDF, XML, image, CSV, …) as base64 so it can be previewed or attached with attach_file. Staging does not link the file to any record. Returns `stagingId`. Max 10 MB.
The description explains the capability, when to use it, and what to expect.
Inputs84/100
Input documentation gives an agent enough context to populate the arguments.
uid
The blob field UID the file is for (e.g. "pdf", "xml"), or "file" for the files list.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "upload_file",
"title": "Upload File",
"description": "Stage a source file (PDF, XML, image, CSV, …) as base64 so it can be previewed or attached with attach_file. Staging does not link the file to any record. Returns `stagingId`. Max 10 MB.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"uid",
"filename",
"contentType",
"base64"
],
"properties": {
"uid": {
"type": "string",
"description": "The blob field UID the file is for (e.g. \"pdf\", \"xml\"), or \"file\" for the files list."
},
"base64": {
"type": "string",
"description": "File bytes, base64-encoded."
},
"filename": {
"type": "string",
"description": "Original file name, e.g. \"invoice-123.pdf\"."
},
"contentType": {
"type": "string",
"description": "MIME type, e.g. \"application/pdf\"."
}
}
},
"annotations": {
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description77/100
Render expandable panels (Nuxt UI Accordion). Pass items with label and content, or tableUid to find rows (max 25). Use for FAQs, grouped facts, and long field text. Prefer page-list for a stacked catalog.
The description explains the capability, when to use it, and what to expect.
Inputs94/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
items › items › label
Text in the panel header the user clicks to expand it.
Clear enough to supply this argument.
items › items › content
Text shown when the panel is expanded.
Clear enough to supply this argument.
tableUid
Table UID from list_tables whose rows become panels. Used only when items is omitted.
Clear enough to supply this argument.
query › pagination › page
Page number, starting at 1.
Clear enough to supply this argument.
query › pagination › pageSize
How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped.
Clear enough to supply this argument.
query › sort › items › id
The field to sort by: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › sort › items › desc
true sorts that field descending, false ascending.
Clear enough to supply this argument.
query › filters › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › filters › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › filters › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › or › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › or › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › or › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › not › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › not › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › exists › items › relation
The related rows to test: a relation key from describe_table `relations` (e.g. "items").
Clear enough to supply this argument.
query › exists › items › field
The field UID on the related table that the condition tests.
Clear enough to supply this argument.
query › exists › items › operator
How the related field is compared with `value`.
Clear enough to supply this argument.
query › exists › items › value
What the related field is compared with, written as in filters.value.
Clear enough to supply this argument.
query › search › columns
Field UIDs to search in.
Clear enough to supply this argument.
query › search › value
The text to look for in those fields.
Clear enough to supply this argument.
query › with
Related rows to embed in each result, by relation key from describe_table `relations` (e.g. ["customer"]).
Clear enough to supply this argument.
query › dateRange › field
The date field UID the range applies to.
Clear enough to supply this argument.
query › dateRange › start
Earliest date to include (ISO 8601). Omit for no lower bound.
Clear enough to supply this argument.
query › dateRange › end
Latest date to include (ISO 8601). Omit for no upper bound.
Clear enough to supply this argument.
labelField
Row field UID shown as each panel header (tableUid mode). Omitted: the first of name, label, sku, code, email or title, else the id.
Clear enough to supply this argument.
contentField
Row field UID shown as each panel body (tableUid mode). Omitted: description, notes or body, else a few of the row's fields.
Clear enough to supply this argument.
title
Heading above the accordion. When omitted: none for items, the table label for tableUid.
Clear enough to supply this argument.
type
Whether opening a panel closes the others ("single"). Omitted means "multiple".
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "accordion",
"title": "App: Accordion",
"description": "Render expandable panels (Nuxt UI Accordion). Pass items with label and content, or tableUid to find rows (max 25). Use for FAQs, grouped facts, and long field text. Prefer page-list for a stacked catalog.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"type": {
"enum": [
"single",
"multiple"
],
"type": "string",
"description": "Whether opening a panel closes the others (\"single\"). Omitted means \"multiple\"."
},
"items": {
"type": "array",
"items": {
"type": "object",
"required": [
"label",
"content"
],
"properties": {
"label": {
"type": "string",
"description": "Text in the panel header the user clicks to expand it."
},
"content": {
"type": "string",
"description": "Text shown when the panel is expanded."
}
}
},
"maxItems": 25,
"description": "Panels you write yourself. Omit to build panels from tableUid rows instead."
},
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional. pageSize is capped at 25."
},
"title": {
"type": "string",
"description": "Heading above the accordion. When omitted: none for items, the table label for tableUid."
},
"tableUid": {
"type": "string",
"description": "Table UID from list_tables whose rows become panels. Used only when items is omitted."
},
"labelField": {
"type": "string",
"description": "Row field UID shown as each panel header (tableUid mode). Omitted: the first of name, label, sku, code, email or title, else the id."
},
"contentField": {
"type": "string",
"description": "Row field UID shown as each panel body (tableUid mode). Omitted: description, notes or body, else a few of the row's fields."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description91/100
Fetch a record and render lifecycle stamp fields (*At) as a timeline. Use for archive, approve, and other stamp history on the row. Shows one entry per set stamp field (its name and timestamp), newest first.
The description explains the capability, when to use it, and what to expect.
Inputs96/100
Input documentation gives an agent enough context to populate the arguments.
tableUid
Table UID (from list_tables) of the record.
Clear enough to supply this argument.
id
The id of the record whose history to show, as returned by find or get.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "activity-timeline",
"title": "App: Show Record Timeline",
"description": "Fetch a record and render lifecycle stamp fields (*At) as a timeline. Use for archive, approve, and other stamp history on the row. Shows one entry per set stamp field (its name and timestamp), newest first.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"id"
],
"properties": {
"id": {
"type": "string",
"description": "The id of the record whose history to show, as returned by find or get."
},
"tableUid": {
"type": "string",
"description": "Table UID (from list_tables) of the record."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "alert-banner",
"title": "App: Show Alert",
"description": "Show a persistent callout with a headline and optional body text. Use for validation, prefer-archive-over-delete, and other in-iframe notices.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"title"
],
"properties": {
"color": {
"enum": [
"primary",
"secondary",
"success",
"info",
"warning",
"error",
"neutral"
],
"type": "string",
"description": "Tone of the notice: sets its color and icon, so match it to the message (e.g. error for a failed step). Omitted means warning."
},
"title": {
"type": "string",
"description": "The headline of the notice, e.g. \"Delete is permanent\"."
},
"description": {
"type": "string",
"description": "Body text under the headline explaining the notice. Omit to show the headline alone."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description98/100
Preview a write (action or delete) on a record and let the user confirm in the iframe. This tool only reads the record to build the preview; nothing changes until the user confirms, which calls delete or action with confirm:true. Prefer this over silent writes.
The description explains the capability, when to use it, and what to expect.
Inputs93/100
Input documentation gives an agent enough context to populate the arguments.
tableUid
Table UID (from list_tables) of the record.
Clear enough to supply this argument.
action
The procedure to confirm: one listed in describe_table `actions` (e.g. "approve"), or "delete".
Clear enough to supply this argument.
id
The id of the record the action applies to, as returned by find or get.
Clear enough to supply this argument.
fields › items › name
Key of this value in the action data, as listed in describe_table `actions`.
Clear enough to supply this argument.
fields › items › label
Label shown next to the input. Omitted means the field's locale label.
Clear enough to supply this argument.
fields › items › type
Input control to render. Omitted means text.
Clear enough to supply this argument.
fields › items › value
Initial value the user can change before confirming. Omitted: an empty text box, or an unchecked checkbox.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "approval-form",
"title": "App: Preview Record Action",
"description": "Preview a write (action or delete) on a record and let the user confirm in the iframe. This tool only reads the record to build the preview; nothing changes until the user confirms, which calls delete or action with confirm:true. Prefer this over silent writes.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"action",
"id"
],
"properties": {
"id": {
"type": "string",
"description": "The id of the record the action applies to, as returned by find or get."
},
"action": {
"type": "string",
"description": "The procedure to confirm: one listed in describe_table `actions` (e.g. \"approve\"), or \"delete\"."
},
"fields": {
"type": "array",
"items": {
"type": "object",
"required": [
"name"
],
"properties": {
"name": {
"type": "string",
"description": "Key of this value in the action data, as listed in describe_table `actions`."
},
"type": {
"enum": [
"text",
"select",
"checkbox"
],
"type": "string",
"description": "Input control to render. Omitted means text."
},
"label": {
"type": "string",
"description": "Label shown next to the input. Omitted means the field's locale label."
},
"value": {
"anyOf": [
{
"type": "string",
"minLength": 0,
"description": "Text or select value"
},
{
"type": "boolean",
"description": "Checkbox value"
}
],
"description": "Initial value the user can change before confirming. Omitted: an empty text box, or an unchecked checkbox."
},
"options": {
"type": "array",
"items": {
"type": "string"
},
"description": "Choices offered by a select input."
}
}
},
"description": "Extra inputs the user fills in; their values are sent as the action data."
},
"tableUid": {
"type": "string",
"description": "Table UID (from list_tables) of the record."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
Shorten the title to an action and subject; move usage details into the description.
Description95/100
Chart Netzo data. Netzo fetches the data itself under this connection's permissions — never pass numbers. Two modes: (1) aggregate (preferred for totals and breakdowns): set `aggregate.groupBy` and `aggregate.measures` (count / countDistinct / sum / min / max / average / weightedAverage); the chart data has the groupBy field plus one column per measure (`as`, default `{op}_{field}`, or `count`). (2) rows: omit `aggregate` to plot up to 50 records from `query` (scatter, timelines); larger scopes are sampled and flagged. `encodings` maps Flint channels (x, y, color, size, theta-like `size` for pie/donut, column, row…) to chart-data field names. Call describe_table first for field UIDs and semanticTypes. Returns the plotted data as text.
The description explains the capability, when to use it, and what to expect.
Inputs93/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
tableUid
Table UID from list_tables whose records are charted.
Clear enough to supply this argument.
chartType
How the data is drawn. Match it to the question: a line chart for a trend over time, bars to compare groups, pie or donut for shares of a whole.
Clear enough to supply this argument.
encodings
Channel → field name in the chart data, e.g. { "x": "status", "y": "sum_total" }. Pie/Donut: { "color": …, "size": … }.
Clear enough to supply this argument.
query › pagination › page
Page number, starting at 1.
Clear enough to supply this argument.
query › pagination › pageSize
How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped.
Clear enough to supply this argument.
query › sort › items › id
The field to sort by: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › sort › items › desc
true sorts that field descending, false ascending.
Clear enough to supply this argument.
query › filters › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › filters › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › filters › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › or › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › or › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › or › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › not › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › not › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › exists › items › relation
The related rows to test: a relation key from describe_table `relations` (e.g. "items").
Clear enough to supply this argument.
query › exists › items › field
The field UID on the related table that the condition tests.
Clear enough to supply this argument.
query › exists › items › operator
How the related field is compared with `value`.
Clear enough to supply this argument.
query › exists › items › value
What the related field is compared with, written as in filters.value.
Clear enough to supply this argument.
query › search › columns
Field UIDs to search in.
Clear enough to supply this argument.
query › search › value
The text to look for in those fields.
Clear enough to supply this argument.
query › with
Related rows to embed in each result, by relation key from describe_table `relations` (e.g. ["customer"]).
Clear enough to supply this argument.
query › dateRange › field
The date field UID the range applies to.
Clear enough to supply this argument.
query › dateRange › start
Earliest date to include (ISO 8601). Omit for no lower bound.
Clear enough to supply this argument.
query › dateRange › end
Latest date to include (ISO 8601). Omit for no upper bound.
Clear enough to supply this argument.
aggregate › groupBy
Field UID to group by (becomes a chart-data field).
Clear enough to supply this argument.
aggregate › measures › items › op
The aggregate function computed per group (count needs no field).
Clear enough to supply this argument.
aggregate › measures › items › field
Field UID to aggregate (omit for count).
Clear enough to supply this argument.
aggregate › measures › items › weight
Weight field UID (weightedAverage only).
Clear enough to supply this argument.
aggregate › measures › items › as
Chart-data column name (default `{op}_{field}`, or `count`).
Clear enough to supply this argument.
title
Heading shown above the chart.
Clear enough to supply this argument.
subtitle
Chart subtitle.
Clear enough to supply this argument.
chartProperties
Flint chart properties, e.g. { "interpolate": "monotone" } for line/area charts.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "chart",
"title": "App: Chart Data",
"description": "Chart Netzo data. Netzo fetches the data itself under this connection's permissions — never pass numbers. Two modes: (1) aggregate (preferred for totals and breakdowns): set `aggregate.groupBy` and `aggregate.measures` (count / countDistinct / sum / min / max / average / weightedAverage); the chart data has the groupBy field plus one column per measure (`as`, default `{op}_{field}`, or `count`). (2) rows: omit `aggregate` to plot up to 50 records from `query` (scatter, timelines); larger scopes are sampled and flagged. `encodings` maps Flint channels (x, y, color, size, theta-like `size` for pie/donut, column, row…) to chart-data field names. Call describe_table first for field UIDs and semanticTypes. Returns the plotted data as text.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"chartType",
"encodings"
],
"properties": {
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional. Rows mode pages at most 50 records."
},
"title": {
"type": "string",
"description": "Heading shown above the chart."
},
"subtitle": {
"type": "string",
"description": "Chart subtitle."
},
"tableUid": {
"type": "string",
"description": "Table UID from list_tables whose records are charted."
},
"aggregate": {
"type": "object",
"required": [
"groupBy",
"measures"
],
"properties": {
"groupBy": {
"type": "string",
"description": "Field UID to group by (becomes a chart-data field)."
},
"measures": {
"type": "array",
"items": {
"type": "object",
"required": [
"op"
],
"properties": {
"as": {
"type": "string",
"description": "Chart-data column name (default `{op}_{field}`, or `count`)."
},
"op": {
"enum": [
"count",
"countDistinct",
"sum",
"min",
"max",
"average",
"weightedAverage"
],
"type": "string",
"description": "The aggregate function computed per group (count needs no field)."
},
"field": {
"type": "string",
"description": "Field UID to aggregate (omit for count)."
},
"weight": {
"type": "string",
"description": "Weight field UID (weightedAverage only)."
}
}
},
"maxItems": 4,
"minItems": 1
}
},
"description": "Aggregate mode: one data point per group."
},
"chartType": {
"enum": [
"Scatter Plot",
"Regression",
"Connected Scatter Plot",
"Ranged Dot Plot",
"Strip Plot",
"Bar Chart",
"Grouped Bar Chart",
"Stacked Bar Chart",
"Lollipop Chart",
"Waterfall Chart",
"Gantt Chart",
"Bullet Chart",
"Histogram",
"Density Plot",
"ECDF Plot",
"Violin Plot",
"Boxplot",
"Pyramid Chart",
"Candlestick Chart",
"Line Chart",
"Sparkline",
"Bump Chart",
"Slope Chart",
"Area Chart",
"Streamgraph",
"Range Area Chart",
"Pie Chart",
"Donut Chart",
"Rose Chart",
"Radar Chart",
"Heatmap",
"Bar Table",
"KPI Card",
"Map",
"Choropleth"
],
"type": "string",
"description": "How the data is drawn. Match it to the question: a line chart for a trend over time, bars to compare groups, pie or donut for shares of a whole."
},
"encodings": {
"type": "object",
"description": "Channel → field name in the chart data, e.g. { \"x\": \"status\", \"y\": \"sum_total\" }. Pie/Donut: { \"color\": …, \"size\": … }.",
"propertyNames": {
"enum": [
"x",
"y",
"x2",
"y2",
"id",
"color",
"opacity",
"size",
"shape",
"strokeDash",
"column",
"row",
"latitude",
"longitude",
"radius",
"detail",
"group",
"open",
"high",
"low",
"close",
"angle",
"order",
"metric",
"value",
"goal"
],
"type": "string"
},
"additionalProperties": {
"type": "string"
}
},
"chartProperties": {
"type": "object",
"description": "Flint chart properties, e.g. { \"interpolate\": \"monotone\" } for line/area charts.",
"propertyNames": {
"type": "string"
},
"additionalProperties": true
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description89/100
Fetch rows from a table and render them as a data table (max 25 rows). Use when the user must compare columns. Prefer page-list, page-grid, or page-gallery for card layouts.
The description explains the capability, when to use it, and what to expect.
Inputs94/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
tableUid
Table UID from list_tables whose rows to show.
Clear enough to supply this argument.
query › pagination › page
Page number, starting at 1.
Clear enough to supply this argument.
query › pagination › pageSize
How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped.
Clear enough to supply this argument.
query › sort › items › id
The field to sort by: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › sort › items › desc
true sorts that field descending, false ascending.
Clear enough to supply this argument.
query › filters › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › filters › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › filters › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › or › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › or › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › or › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › not › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › exists › items › relation
The related rows to test: a relation key from describe_table `relations` (e.g. "items").
Clear enough to supply this argument.
query › exists › items › field
The field UID on the related table that the condition tests.
Clear enough to supply this argument.
query › exists › items › operator
How the related field is compared with `value`.
Clear enough to supply this argument.
query › exists › items › value
What the related field is compared with, written as in filters.value.
Clear enough to supply this argument.
query › search › columns
Field UIDs to search in.
Clear enough to supply this argument.
query › search › value
The text to look for in those fields.
Clear enough to supply this argument.
query › with
Related rows to embed in each result, by relation key from describe_table `relations` (e.g. ["customer"]).
Clear enough to supply this argument.
query › dateRange › field
The date field UID the range applies to.
Clear enough to supply this argument.
query › dateRange › start
Earliest date to include (ISO 8601). Omit for no lower bound.
Clear enough to supply this argument.
query › dateRange › end
Latest date to include (ISO 8601). Omit for no upper bound.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "find-table",
"title": "App: Find Table",
"description": "Fetch rows from a table and render them as a data table (max 25 rows). Use when the user must compare columns. Prefer page-list, page-grid, or page-gallery for card layouts.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid"
],
"properties": {
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional. pageSize is capped at 25 for this App."
},
"tableUid": {
"type": "string",
"description": "Table UID from list_tables whose rows to show."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description98/100
Find rows and nest them by a parent field (default parentId). Use for BOM, warehouse locations, or category trees. Returns `tableUid` and `items`: the top-level nodes, each with a `label` and nested `children`. When no row links to a parent, items is a flat list.
The description explains the capability, when to use it, and what to expect.
Inputs95/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
tableUid
Table UID from list_tables whose rows form the tree (e.g. a category table).
Clear enough to supply this argument.
query › pagination › page
Page number, starting at 1.
Clear enough to supply this argument.
query › pagination › pageSize
How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped.
Clear enough to supply this argument.
query › sort › items › id
The field to sort by: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › sort › items › desc
true sorts that field descending, false ascending.
Clear enough to supply this argument.
query › filters › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › filters › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › filters › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › or › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › or › items › operator
How the field is compared with `value`.
Clear enough to supply this argument.
query › or › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › not › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › not › items › operator
How the field is compared with `value`.
Clear enough to supply this argument.
query › not › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › exists › items › relation
The related rows to test: a relation key from describe_table `relations` (e.g. "items").
Clear enough to supply this argument.
query › exists › items › field
The field UID on the related table that the condition tests.
Clear enough to supply this argument.
query › exists › items › operator
How the related field is compared with `value`.
Clear enough to supply this argument.
query › exists › items › value
What the related field is compared with, written as in filters.value.
Clear enough to supply this argument.
query › search › columns
Field UIDs to search in.
Clear enough to supply this argument.
query › search › value
The text to look for in those fields.
Clear enough to supply this argument.
query › with
Related rows to embed in each result, by relation key from describe_table `relations` (e.g. ["customer"]).
Clear enough to supply this argument.
query › dateRange › field
The date field UID the range applies to.
Clear enough to supply this argument.
query › dateRange › start
Earliest date to include (ISO 8601). Omit for no lower bound.
Clear enough to supply this argument.
query › dateRange › end
Latest date to include (ISO 8601). Omit for no upper bound.
Clear enough to supply this argument.
parentField
Field UID holding each row's parent id. Omitted means parentId.
Clear enough to supply this argument.
labelField
Field UID shown as each node label. Omitted (or empty on a row): the first of name, label, sku, code, email or title, else the id.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "hierarchy-tree",
"title": "App: Hierarchy Tree",
"description": "Find rows and nest them by a parent field (default parentId). Use for BOM, warehouse locations, or category trees. Returns `tableUid` and `items`: the top-level nodes, each with a `label` and nested `children`. When no row links to a parent, items is a flat list.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid"
],
"properties": {
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional."
},
"tableUid": {
"type": "string",
"description": "Table UID from list_tables whose rows form the tree (e.g. a category table)."
},
"labelField": {
"type": "string",
"description": "Field UID shown as each node label. Omitted (or empty on a row): the first of name, label, sku, code, email or title, else the id."
},
"parentField": {
"type": "string",
"description": "Field UID holding each row's parent id. Omitted means parentId."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "kpi-stat",
"title": "App: KPI Stat",
"description": "Count records matching a query and render a single KPI number. Use for dashboard-style summaries. Shows the label and the number of matching records.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid"
],
"properties": {
"label": {
"type": "string",
"description": "Display label for the KPI."
},
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional. Filters for the count."
},
"tableUid": {
"type": "string",
"description": "Table UID from list_tables whose records are counted."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description86/100
Render a Markdown explanation in the host UI (headings, lists, bold, code). Use for how-to answers. Do not put charts, data tables, or card catalogs in the Markdown — use the chart app, or find-table, page-list, page-grid, page-gallery, or accordion.
The description explains the capability, when to use it, and what to expect.
Inputs88/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
content
The answer, written in Markdown.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "markdown-answer",
"title": "App: Show Answer",
"description": "Render a Markdown explanation in the host UI (headings, lists, bold, code). Use for how-to answers. Do not put charts, data tables, or card catalogs in the Markdown — use the chart app, or find-table, page-list, page-grid, page-gallery, or accordion.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"content"
],
"properties": {
"title": {
"type": "string",
"description": "Heading shown above the answer. Omit for none."
},
"content": {
"type": "string",
"description": "The answer, written in Markdown."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description81/100
Render a spotlight card gallery (Nuxt UI PageGrid + PageCard). Pass items, or tableUid to find rows (max 25). Use for visual browse. Do not pass remote image URLs (iframe CSP blocks them). Prefer page-grid for a plain catalog.
The description explains the capability, when to use it, and what to expect.
Inputs91/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
items › items › title
Headline of the card.
Clear enough to supply this argument.
items › items › description
Text under the card headline.
Clear enough to supply this argument.
tableUid
Table UID from list_tables whose rows to render. Used only when items is omitted.
Clear enough to supply this argument.
query › pagination › page
Page number, starting at 1.
Clear enough to supply this argument.
query › pagination › pageSize
How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped.
Clear enough to supply this argument.
query › sort › items › id
The field to sort by: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › sort › items › desc
true sorts that field descending, false ascending.
Clear enough to supply this argument.
query › filters › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › filters › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › filters › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › or › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › or › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › or › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › field
The field the condition tests: a field UID from describe_table `fields`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › exists › items › relation
The related rows to test: a relation key from describe_table `relations` (e.g. "items").
Clear enough to supply this argument.
query › exists › items › field
The field UID on the related table that the condition tests.
Clear enough to supply this argument.
query › exists › items › operator
How the related field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › exists › items › value
What the related field is compared with, written as in filters.value.
Clear enough to supply this argument.
query › search › columns
Field UIDs to search in.
Clear enough to supply this argument.
query › search › value
The text to look for in those fields.
Clear enough to supply this argument.
query › with
Related rows to embed in each result, by relation key from describe_table `relations` (e.g. ["customer"]).
Clear enough to supply this argument.
query › dateRange › field
The date field UID the range applies to.
Clear enough to supply this argument.
query › dateRange › start
Earliest date to include (ISO 8601). Omit for no lower bound.
Clear enough to supply this argument.
query › dateRange › end
Latest date to include (ISO 8601). Omit for no upper bound.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "page-gallery",
"title": "App: Page Gallery",
"description": "Render a spotlight card gallery (Nuxt UI PageGrid + PageCard). Pass items, or tableUid to find rows (max 25). Use for visual browse. Do not pass remote image URLs (iframe CSP blocks them). Prefer page-grid for a plain catalog.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"items": {
"type": "array",
"items": {
"type": "object",
"required": [
"title"
],
"properties": {
"title": {
"type": "string",
"description": "Headline of the card."
},
"description": {
"type": "string",
"description": "Text under the card headline."
}
}
},
"maxItems": 25,
"description": "Cards you write yourself. Omit to build cards from tableUid rows instead."
},
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional. pageSize is capped at 25."
},
"title": {
"type": "string",
"description": "Optional heading above the gallery."
},
"tableUid": {
"type": "string",
"description": "Table UID from list_tables whose rows to render. Used only when items is omitted."
},
"titleField": {
"type": "string",
"description": "Row field for the card title."
},
"descriptionField": {
"type": "string",
"description": "Row field for the card description."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description80/100
Render a responsive grid of title/description cards (Nuxt UI PageGrid). Pass items, or tableUid to find rows (max 25). Use for catalogs. Prefer page-gallery for spotlight cards, find-table for columns.
The description explains the capability, when to use it, and what to expect.
Inputs92/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
items › items › title
Headline of the card.
Clear enough to supply this argument.
items › items › description
Text under the card headline.
Clear enough to supply this argument.
tableUid
Table UID from list_tables whose rows to render. Used only when items is omitted.
Clear enough to supply this argument.
query › pagination › page
Page number, starting at 1.
Clear enough to supply this argument.
query › pagination › pageSize
How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped.
Clear enough to supply this argument.
query › sort › items › id
The field to sort by: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › sort › items › desc
true sorts that field descending, false ascending.
Clear enough to supply this argument.
query › filters › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › filters › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › filters › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › or › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › or › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › or › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › not › items › field
The field the condition tests: a field UID from describe_table `fields`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › exists › items › relation
The related rows to test: a relation key from describe_table `relations` (e.g. "items").
Clear enough to supply this argument.
query › exists › items › field
The field UID on the related table that the condition tests.
Clear enough to supply this argument.
query › exists › items › operator
How the related field is compared with `value`.
Clear enough to supply this argument.
query › exists › items › value
What the related field is compared with, written as in filters.value.
Clear enough to supply this argument.
query › search › columns
Field UIDs to search in.
Clear enough to supply this argument.
query › search › value
The text to look for in those fields.
Clear enough to supply this argument.
query › with
Related rows to embed in each result, by relation key from describe_table `relations` (e.g. ["customer"]).
Clear enough to supply this argument.
query › dateRange › field
The date field UID the range applies to.
Clear enough to supply this argument.
query › dateRange › start
Earliest date to include (ISO 8601). Omit for no lower bound.
Clear enough to supply this argument.
query › dateRange › end
Latest date to include (ISO 8601). Omit for no upper bound.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "page-grid",
"title": "App: Page Grid",
"description": "Render a responsive grid of title/description cards (Nuxt UI PageGrid). Pass items, or tableUid to find rows (max 25). Use for catalogs. Prefer page-gallery for spotlight cards, find-table for columns.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"items": {
"type": "array",
"items": {
"type": "object",
"required": [
"title"
],
"properties": {
"title": {
"type": "string",
"description": "Headline of the card."
},
"description": {
"type": "string",
"description": "Text under the card headline."
}
}
},
"maxItems": 25,
"description": "Cards you write yourself. Omit to build cards from tableUid rows instead."
},
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional. pageSize is capped at 25."
},
"title": {
"type": "string",
"description": "Optional heading above the grid."
},
"tableUid": {
"type": "string",
"description": "Table UID from list_tables whose rows to render. Used only when items is omitted."
},
"titleField": {
"type": "string",
"description": "Row field for the card title."
},
"descriptionField": {
"type": "string",
"description": "Row field for the card description."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description81/100
Render a stacked list of title/description cards (Nuxt UI PageList). Pass items, or tableUid to find rows (max 25). Use for record summaries. Prefer find-table when the user must compare columns.
The description explains the capability, when to use it, and what to expect.
Inputs93/100
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
items › items › title
Headline of the card.
Clear enough to supply this argument.
items › items › description
Text under the card headline.
Clear enough to supply this argument.
tableUid
Table UID from list_tables whose rows to render. Used only when items is omitted.
Clear enough to supply this argument.
query › pagination › page
Page number, starting at 1.
Clear enough to supply this argument.
query › pagination › pageSize
How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped.
Clear enough to supply this argument.
query › sort › items › id
The field to sort by: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › sort › items › desc
true sorts that field descending, false ascending.
Clear enough to supply this argument.
query › filters › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › filters › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › filters › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › or › items › field
The field the condition tests: a field UID from describe_table `fields`.
Clear enough to supply this argument.
query › or › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › or › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › not › items › field
The field the condition tests: a field UID from describe_table `fields`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › operator
How the field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › not › items › value
What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. ["a","b"].
Clear enough to supply this argument.
query › exists › items › relation
The related rows to test: a relation key from describe_table `relations` (e.g. "items").
Clear enough to supply this argument.
query › exists › items › field
The field UID on the related table that the condition tests.
Clear enough to supply this argument.
query › exists › items › operator
How the related field is compared with `value`.
Remove validation rules already expressed in this field’s schema; describe its meaning and usage instead.
query › exists › items › value
What the related field is compared with, written as in filters.value.
Clear enough to supply this argument.
query › search › columns
Field UIDs to search in.
Clear enough to supply this argument.
query › search › value
The text to look for in those fields.
Clear enough to supply this argument.
query › with
Related rows to embed in each result, by relation key from describe_table `relations` (e.g. ["customer"]).
Clear enough to supply this argument.
query › dateRange › field
The date field UID the range applies to.
Clear enough to supply this argument.
query › dateRange › start
Earliest date to include (ISO 8601). Omit for no lower bound.
Clear enough to supply this argument.
query › dateRange › end
Latest date to include (ISO 8601). Omit for no upper bound.
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "page-list",
"title": "App: Page List",
"description": "Render a stacked list of title/description cards (Nuxt UI PageList). Pass items, or tableUid to find rows (max 25). Use for record summaries. Prefer find-table when the user must compare columns.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"properties": {
"items": {
"type": "array",
"items": {
"type": "object",
"required": [
"title"
],
"properties": {
"title": {
"type": "string",
"description": "Headline of the card."
},
"description": {
"type": "string",
"description": "Text under the card headline."
}
}
},
"maxItems": 25,
"description": "Cards you write yourself. Omit to build cards from tableUid rows instead."
},
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional. pageSize is capped at 25."
},
"title": {
"type": "string",
"description": "Optional heading above the list."
},
"tableUid": {
"type": "string",
"description": "Table UID from list_tables whose rows to render. Used only when items is omitted."
},
"titleField": {
"type": "string",
"description": "Row field for the card title."
},
"descriptionField": {
"type": "string",
"description": "Row field for the card description."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "progress-meter",
"title": "App: Show Progress",
"description": "Render a 0–100 progress bar from a record (valueField / maxField) or from count vs max. Use for fill rate, capacity, and percent complete.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid"
],
"properties": {
"id": {
"type": "string",
"description": "The id of the record (from find or get) whose fields fill the bar. Omit to count records instead."
},
"max": {
"type": "number",
"description": "The count that fills the bar (count mode). Omitted means 100."
},
"color": {
"enum": [
"primary",
"secondary",
"success",
"info",
"warning",
"error",
"neutral"
],
"type": "string",
"description": "Tone of the bar. Omitted means primary."
},
"label": {
"type": "string",
"description": "Caption under the bar."
},
"query": {
"type": "object",
"properties": {
"or": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Any of these conditions may match."
},
"not": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "None of these conditions may match."
},
"sort": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"desc"
],
"properties": {
"id": {
"type": "string",
"description": "The field to sort by: a field UID from describe_table `fields`."
},
"desc": {
"type": "boolean",
"description": "true sorts that field descending, false ascending."
}
}
},
"description": "Sort order; earlier entries take precedence."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to embed in each result, by relation key from describe_table `relations` (e.g. [\"customer\"])."
},
"exists": {
"type": "array",
"items": {
"type": "object",
"required": [
"relation",
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field UID on the related table that the condition tests."
},
"value": {
"type": "string",
"description": "What the related field is compared with, written as in filters.value."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the related field is compared with `value`."
},
"relation": {
"type": "string",
"description": "The related rows to test: a relation key from describe_table `relations` (e.g. \"items\")."
}
}
},
"description": "A related row must match."
},
"search": {
"type": "object",
"required": [
"columns",
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The text to look for in those fields."
},
"columns": {
"type": "array",
"items": {
"type": "string"
},
"description": "Field UIDs to search in."
}
},
"description": "Full-text search."
},
"filters": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"operator",
"value"
],
"properties": {
"field": {
"type": "string",
"description": "The field the condition tests: a field UID from describe_table `fields`."
},
"value": {
"type": "string",
"description": "What the field is compared with, sent as text: numbers, true, false and null are converted. For IN / NOT IN pass a JSON array, e.g. [\"a\",\"b\"]."
},
"operator": {
"enum": [
"=",
"!=",
">",
">=",
"<",
"<=",
"LIKE",
"NOT LIKE",
"ILIKE",
"NOT ILIKE",
"IN",
"NOT IN",
"IS",
"IS NOT"
],
"type": "string",
"description": "How the field is compared with `value`."
}
}
},
"description": "Every condition must match."
},
"dateRange": {
"type": "object",
"required": [
"field"
],
"properties": {
"end": {
"type": "string",
"description": "Latest date to include (ISO 8601). Omit for no upper bound."
},
"field": {
"type": "string",
"description": "The date field UID the range applies to."
},
"start": {
"type": "string",
"description": "Earliest date to include (ISO 8601). Omit for no lower bound."
}
},
"description": "Keep only rows whose date field falls in this range (bounds inclusive)."
},
"pagination": {
"type": "object",
"required": [
"page",
"pageSize"
],
"properties": {
"page": {
"type": "number",
"description": "Page number, starting at 1."
},
"pageSize": {
"type": "number",
"description": "How many records one page holds; with `page` it selects which records are returned. Values above the server maximum are capped."
}
},
"description": "Which page to return."
}
},
"description": "Find query. Every field is optional. Used when the meter compares a count to max."
},
"maxField": {
"type": "string",
"description": "Numeric field UID giving the full amount (with id). Omitted means max."
},
"tableUid": {
"type": "string",
"description": "Table UID from list_tables to read the record from or count."
},
"valueField": {
"type": "string",
"description": "Numeric field UID giving the filled amount (with id). Omitted means value."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "record-card",
"title": "App: Show Record",
"description": "Fetch one record by id and render a description list of field values. Use for record summaries in the host UI.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"id"
],
"properties": {
"id": {
"type": "string",
"description": "The id of the record to show, as returned by find or get."
},
"with": {
"type": "array",
"items": {
"type": "string"
},
"description": "Related rows to include, by relation key from describe_table `relations`."
},
"tableUid": {
"type": "string",
"description": "Table UID (from list_tables) of the record."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
Shorten the title to an action and subject; move usage details into the description.
Description92/100
Fetch one record and render a display-only reference chip (table + label). Use when the user needs to see which ERP record is in play without the full row.
The description explains the capability, when to use it, and what to expect.
Inputs90/100
Input documentation gives an agent enough context to populate the arguments.
tableUid
Table UID (from list_tables) of the record.
Clear enough to supply this argument.
id
The id of the record to reference, as returned by find or get.
Clear enough to supply this argument.
labelField
Field to use as the chip label (default: name/code/id).
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "record-link",
"title": "App: Record Link",
"description": "Fetch one record and render a display-only reference chip (table + label). Use when the user needs to see which ERP record is in play without the full row.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"id"
],
"properties": {
"id": {
"type": "string",
"description": "The id of the record to reference, as returned by find or get."
},
"tableUid": {
"type": "string",
"description": "Table UID (from list_tables) of the record."
},
"labelField": {
"type": "string",
"description": "Field to use as the chip label (default: name/code/id)."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
The title clearly communicates the tool’s action and subject. Keep it concise.
Description92/100
Fetch a record field (default status) and render it as a status badge. Use for quote, order, and payment states. Shows the field's display value as a colored badge.
The description explains the capability, when to use it, and what to expect.
Inputs94/100
Input documentation gives an agent enough context to populate the arguments.
tableUid
Table UID (from list_tables) of the record.
Clear enough to supply this argument.
id
The id of the record whose state to show, as returned by find or get.
Clear enough to supply this argument.
field
Field UID holding the state. Omitted means status (or class when status is empty).
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "status-badge",
"title": "App: Show Record Status",
"description": "Fetch a record field (default status) and render it as a status badge. Use for quote, order, and payment states. Shows the field's display value as a colored badge.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"id"
],
"properties": {
"id": {
"type": "string",
"description": "The id of the record whose state to show, as returned by find or get."
},
"field": {
"type": "string",
"description": "Field UID holding the state. Omitted means status (or class when status is empty)."
},
"tableUid": {
"type": "string",
"description": "Table UID (from list_tables) of the record."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
No output schema is declared. Add one for structured results so clients can interpret returned fields.
Not declared
Original tool metadata
{
"name": "user-chip",
"title": "App: Show Contact Chip",
"description": "Fetch a person or entity record and render name, optional description, and initials. Use for assignees, customers, suppliers, and contacts.",
"inputSchema": {
"type": "object",
"$schema": "http://json-schema.org/draft-07/schema#",
"required": [
"tableUid",
"id"
],
"properties": {
"id": {
"type": "string",
"description": "The id of the person or entity record, as returned by find or get."
},
"tableUid": {
"type": "string",
"description": "Table UID (from list_tables) of the person or entity, e.g. \"customers\"."
},
"nameField": {
"type": "string",
"description": "Field UID shown as the name. Omitted: the first of name, label, sku, code, email or title, else the id."
},
"descriptionField": {
"type": "string",
"description": "Field UID shown as the second line (e.g. email or role). Omitted: the record's email, else its description, else no second line."
}
}
},
"annotations": {
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}
Loading score analytics…
Put your MCP to the test
A few tasks worth trying with this server, chosen from its reviewed tools. These have not been run.
01Get RecordFetch a single record by its id.
02List TablesReturns tables this connection can access (locale label, module, granted procedures), plus count, plus `namespaces` (non-table procedures such as pricing.res…
03Find RecordsQuery records from a table using filters, sort, pagination, and search.
04Describe TableDescribe one table (or namespace) before reading or writing it.
05List SkillsLists Netzo workflow skills: step-by-step protocols for multi-step work (import, analyse, triage, report authoring…).
Want to run these tasks against your MCP server with us?
Netzo setup, tools, quality score, publishing readiness, and alternatives.
How do I add Netzo to Claude, ChatGPT, or Cursor?
Add Netzo to Claude, ChatGPT, or Cursor by connecting its remote MCP URL in each client's MCP settings. In Claude, add a custom connector. In ChatGPT, add an MCP app. In Cursor, add an MCP server under Settings. The MCP URL is https://app.netzo.io/mcp.
Is Netzo MCP ready for ChatGPT and Claude?
As of October 15, 2026, Netzo scores 100/100 on Manufact's MCP publishing checklist. The scan meets ChatGPT publishing checks and meets Claude publishing checks. Passing these checks does not guarantee marketplace approval.
How clear is Netzo's MCP tool documentation?
As of October 15, 2026, Netzo scores 84/100 in Manufact's review of tool titles, descriptions, input and output schemas, and behavior annotations. The review covers 32 of 32 discovered tools. The quality score measures documentation clarity; runtime behavior and marketplace readiness require separate checks.
What are the best alternatives to Netzo?
As of October 20, 2026, alternatives to Netzo in financial-services on the Manufact MCP leaderboard include Contract-Factory — Sociétés & SIREN, Coverage Cat Insurance, Kavara Kirk, Perps Pulse, and CeylonCharts.
How can Netzo improve its MCP documentation?
markdown-answer is the lowest-scoring reviewed tool at 77/100. No output schema is declared. Add one for structured results so clients can interpret returned fields. Open its review for feedback and a copyable fix prompt, then rerun the documentation review after updating your tool metadata.
Not your MCP?
Review any public or OAuth MCP server for protocol compatibility, tool documentation, and ChatGPT and Claude publishing readiness. No account required.
