Skip to main content
Glama
Datris MCP Server

Datris MCP Server

propose_pipeline_schema

Preview a tested tap's rows and recommend a destination column type for each column before the pipeline exists, so you can confirm the schema and pass it to create_pipeline.

Instructions

Preview a tested tap's rows and recommend a destination column type for each column, BEFORE the pipeline exists. Uses the rows from the tap's last successful test (nothing is pushed) and runs the tap again only when none are held or a higher limit asks for more, then infers a type per column from the rows the tap actually produced. Recommendations are conservative: a column is typed only on strong evidence; otherwise it stays string with a visible reason — stringReason when a value blocked a type, note when too few non-null values were present (all-null or a thin sample). Call it after test_tap succeeds and before create_pipeline. Present the returned fields to the user as a table (column, recommended type, evidence) and ask them to confirm or change the types, or to pull more rows (call again with a higher limit). Then pass the confirmed list as schema_fields on create_pipeline — no sample content needed — and attach the tap with update_tap (target_pipeline). A failed test comes back verbatim (fix the tap first). Vector destinations (pgvector, qdrant, weaviate, milvus, chroma) and mongodb return typeGrid: false with a preview only — they have no column schema — for a vector destination go straight to create_pipeline with name and destination only; no checks, transformations or protection question (MongoDB stores documents as-is; create it with a few preview rows as a JSON content_text sample, filename ending in .json, never schema_fields). An older Datris server answers with a "server too old" error; then fall back to content_text on create_pipeline. Only a result whose status is schema_proposal is a proposal; anything else (a failed test, no rows, an error) means no schema and no table were shown to the user, so tell the user what failed in one or two plain sentences with the tool's stated next step, and do not ask the types question, do not call ask_user about types and do not mention a table. If this Datris instance's agent policy requires a person to approve this action, the call does NOT perform it: it returns status pending_approval with an approvalId. Tell the user it is waiting for approval in Datris, then poll get_approval with that id (pause with wait_seconds between polls) — do not re-issue the action.

Tool call template

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

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "tap": "<tap>",
      "destination": "<destination>"
    },
    "name": "propose_pipeline_schema"
  }
}

Input Schema

NameRequiredDescriptionDefault
tapYesName of the tap whose rows define the schema (create and test it first)
limitNoRows to preview and infer from (default 20). Raise it when the user wants more evidence.
reasonNoOptional one-line reason for this change, recorded in the platform's audit log and shown to anyone asked to approve it.
destinationYesThe destination the pipeline will use. Vector destinations and mongodb get a preview only (no type grid).

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.3/5.0
Behavior3/5

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

With no annotations, the description carries the full burden and does well: it discloses that nothing is pushed, that the tap is re-run only when no rows are held or a higher limit is requested, that inference is conservative with stringReason/note fallbacks, and the pending_approval/idempotency rules. The gap is that it never describes what a successful proposal payload looks like beyond naming `fields`, `stringReason`, `note` and `typeGrid` in passing, and there is no output schema to lean on.

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

Conciseness3/5

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

The purpose is front-loaded in the first sentence, but the body is a dense multi-clause run of policies (vector destinations, MongoDB JSON filename rules, status gating, approval polling) packed into very long sentences. Nothing is pure filler, yet it is hard to scan and several parenthetical asides could be tightened.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a four-parameter tool with no annotations and no output schema, the definition covers the success path, the non-proposal path, the approval path, and destination-specific exceptions. An agent has everything needed to call it, interpret status, and route the result onward to create_pipeline and update_tap.

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

Parameters4/5

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

Schema coverage is already 100%, so the bar is a baseline 3; the description adds real meaning on top by explaining that raising `limit` is what triggers re-running the tap for more rows and that `reason` is surfaced to approvers in the audit log. `tap` is clarified as the source of the rows and `destination` as the thing that decides whether a type grid is produced.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: preview a tested tap's rows and recommend a destination column type per column, before the pipeline exists. Explicitly distinguishes itself from siblings by timing ('BEFORE the pipeline exists', 'after test_tap succeeds and before create_pipeline') and from get_dest_types by grounding inference in actual tap rows.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit placement in the workflow (after test_tap succeeds, before create_pipeline) and names the alternatives for the special cases: vector destinations go 'straight to create_pipeline with name and destination only', MongoDB uses content_text instead of schema_fields, and an old server falls back to content_text. It also states what to do when no proposal results.

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

Deploy Server

Other Tools