LLM Tool Definition Converter

Paste a tool definition in Anthropic, OpenAI or MCP form. The source format is detected; add a first line of to: openai, to: anthropic or to: mcp to choose the target. Fields with no equivalent are named rather than dropped.

Paste below, or drop a file anywhere on this panel

Or drop a file anywhere on this panel. Nothing is uploaded: the analysis runs in this tab.

The answer appears here

Paste on the left and press Convert. Nothing leaves this tab.

Examples

Real input you can load into the tool above. Each one shows a different thing going wrong, because that is what the tool is for.

MCP annotations have nowhere to go

readOnlyHint and its siblings are how a client decides what needs confirmation, and no other format has them

to: anthropic
{
  "name": "delete_file",
  "description": "Delete a file. Use this when the user asks to remove one.",
  "inputSchema": { "type": "object", "properties": { "path": { "type": "string" } } },
  "annotations": { "destructiveHint": true, "idempotentHint": false }
}

strict without the conditions it requires

Strict mode needs additionalProperties: false on every object, and the request is rejected rather than the call

to: openai
{
  "name": "book",
  "description": "Book a seat. Call this once the user confirms.",
  "strict": true,
  "input_schema": {
    "type": "object",
    "properties": { "seat": { "type": "string" } },
    "required": ["seat"]
  }
}

Common mistakes

These are the ones that fail silently. The config is accepted, nothing raises an error, and the consequence arrives later.

  1. Assuming the formats differ only in nesting

    The envelope is a rename, and the guarantees are not portable. MCP annotations and `outputSchema` have no equivalent elsewhere, and `strict` has no equivalent in MCP.

    Instead:Check what was dropped after converting, and carry the missing metadata yourself if the calling side depends on it.

  2. Setting `strict: true` on an existing schema

    Strict mode also requires `additionalProperties: false` on every object and every property listed in `required`. The flag alone turns a working schema into a rejected request.

    Instead:Add both conditions, then check the schema with the strict mode checker before shipping.

  3. Expecting the schema to behave the same after conversion

    The JSON Schema is passed through byte for byte. What differs between the targets is which keywords each one enforces, and that is not visible in the document.

    Instead:Convert the envelope here, then validate the schema against the target's actual subset.

Three formats, one schema, and the fields that do not survive the trip

The formats differ in their envelope, not in the schema language. That makes conversion mechanical and makes the losses easy to miss, because the part that changes shape is not the part that matters.

The whole difference is one field name and one level of nesting

Anthropic puts the schema in input_schema beside the name. OpenAI nests name, description and parameters under a function object with type: "function" outside it. MCP uses inputSchema, camelCased. The JSON Schema inside is identical in all three.

input_schema against inputSchema is a silent failure

Because the two spellings differ only in case and an underscore, a tool copied from an Anthropic definition into an MCP server keeps the wrong one. The MCP client then sees a tool with no schema at all, tells the model it takes no arguments, and every call arrives empty. Nothing in the error mentions a field name.

MCP annotations have nowhere to go

readOnlyHint, destructiveHint, idempotentHint and openWorldHint are how an MCP client decides which calls need human confirmation. The other formats have no equivalent, so converting away from MCP drops the safety metadata. This tool names each one it drops rather than removing it quietly.

outputSchema is MCP-only

MCP lets a tool declare the shape of its result. The others describe inputs only, so a guarantee about what comes back becomes the caller's problem after conversion.

strict is a promise the target may not be able to keep

Setting strict constrains decoding to the schema, and it also imposes requirements: additionalProperties: false on every object, and every property listed in required. A schema that was merely advisory becomes a rejected request the moment strict is set, which is why this tool checks those two conditions when it sees the flag.

What this cannot see

Whether the schema is a good one, and whether the target enforces the keywords it contains. Conversion moves the document; it does not change which parts of it a given decoder honours. Run the result through the strict mode checker if the target uses constrained decoding, because the same schema is accepted in one mode and rejected in the other. Everything here happens in your browser against the text you paste.

More ai tools

LLM SSE Stream Decoder Reassemble the message from the wire LLM JSON Schema Strict Mode Checker What structured output will refuse LLM Context Window Planner Where the budget runs out LLM Prompt Caching Planner Where to put the breakpoint LLM API Cost Calculator The number that matches the invoice LLM Model Cost Comparison Two models, one workload, your rates LLM API Rate Limit Planner Which limit you hit first

Elsewhere on the site

Terraform Validator & Formatter Kubernetes YAML Generator Kubernetes YAML Validator AWS IAM Policy Validator & Analyzer