Skip to main content
Glama

oto_upload_url

Get a signed, single-use URL to push a big file into oto without passing it through the conversation. With a shell: curl -X PUT --data-binary @FILE '<url>'. Without one, give the URL to the user: it opens an upload form. If the file is already reachable (a link, a Drive file, a project file, a Gmail attachment), use oto_import instead: the server fetches it — as for a file you produced up to 256 KB ({kind:"content"}). Targets: datastore (CSV or NDJSON rows; key designates rows by that column), doc, project_file, image (public permanent URL, 2 MB). With neither a shell nor a user, send rows inline with data_write. The URL is signed, not encrypted: keep confidential names out of it.

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": {
      "target": "<target>"
    },
    "name": "oto_upload_url"
  }
}

Input Schema

NameRequiredDescriptionDefault
opNocreate
keyNodatastore: the column that DESIGNATES rows — an existing key value modifies its row, a new one creates it, no `upsert` needed. Omitted: the file matches on the table's declared key but ADDS (an existing value follows `upsert`).
_orgNo
kindNo
titleNo
doc_idNo
formatNo
targetYes
upsertNo`true` = MERGE when the key value already exists — for a write that ADDS (neither `id` nor `key=`), and for rows of one call that share a key value. A write that designates by `key=` needs no `upsert`. Every merge of a batch comes back in `fusions`. Without it, an adding write on an existing key, or two rows of one call on the same key, is REFUSED (`business_key_exists`). Refused on a table with no business key: there is nothing to merge on.
filenameNo
datastoreNo
parent_idNo
project_idNo
descriptionNo
content_typeNo
origine_overrideNo`origine_override=true` states that this call sets the `origine` layer (the value at the START, at import time) knowingly. Without it, writing an origin is refused. ⚠️ Nothing captures an origin automatically any more: `origine: "system"` was REMOVED on 2026-09-08, so writing the value alone keeps nothing — an overwrite is final. For a real IMPORT, prefer `donnees_d_origine=true`, which writes both versions — the current value and the origin — in the same gesture, at the moment the value enters. This parameter only says "I know I am setting that layer", and it applies to this call only. A cell without an `origine` layer has no known starting value: the absence of the layer says so, never a text in its place.
donnees_d_origineNo`donnees_d_origine=true` sets the FIRST version of the data (the origin) and marks the write as an import in the journal: this call brings data AS THE CLIENT HANDED IT OVER. Each cell gets its `origine` version frozen at the same time as its current value, carrying the same layers: put the provenance in `<field>.comment` and it lands in both. Use it for the import itself, NOT for enrichment — what an agent establishes is the current version. An origin already set is never overwritten (a re-import updates the current version and leaves the origin alone), and an empty cell gets nothing: the client handed over nothing there, which is not the same as handing over an empty value.

Schema Changelog

Changes observed during successful MCP inspections.

No schema history has been recorded yet.

TDQS

A4.2/5.0
Behavior4/5

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

With no annotations, the description carries the full behavioral burden and does substantial work: it discloses single-use scope, that the URL is signed but NOT encrypted (with a confidentiality consequence), that a shell PUT is the payload mechanism versus a user-facing upload form, and per-target limits such as the 2 MB public permanent URL for images. It omits URL expiry/lifetime and whether the PUT requires additional auth.

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

Conciseness4/5

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

Front-loaded with the core action, then the mechanics, then the alternative routing, then the security caveat. Nearly every clause earns its place, though the target inventory and the closing encryption note are compressed into dense em-dash constructions that take a second pass to parse.

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

Completeness3/5

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

A 17-parameter, no-annotation, no-output-schema tool demands more. The description covers the branching logic and target semantics well but never explains what the returned URL object contains, how long it lives, or how the many optional target-specific parameters (filename, title, doc_id, project_id, content_type) interact with each target.

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

Parameters3/5

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

Schema coverage is only 24% across 17 parameters, so the description must compensate. It does add meaning for the load-bearing ones — the four target values, datastore accepting CSV/NDJSON rows, and `key` designating rows by a column — but doc_id, project_id, parent_id, filename, title, kind, content_type, format and op are explained in neither place, so the gap remains large.

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: "Get a signed, single-use URL to push a big file into oto." The scope constraint ("without passing it through the conversation") further pins down what the tool is for, and the sibling it is not (oto_import) is named explicitly.

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 routing: already-reachable files (link, Drive, project file, Gmail attachment, or self-produced content under 256 KB) go to oto_import; with neither shell nor user, rows go inline via data_write. The shell vs. user branch is spelled out, so the agent knows which of the three paths to take.

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

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources