LLM Tool & Function-Calling Schema Builder
One tool definition for every AI API, checked for strict mode before a model sees it.
Tool
Parameters
Import a definition
Export
Strict-mode checks
OpenAI Structured Outputs
Anthropic strict tool use
Check arguments
About the LLM Tool & Function-Calling Schema Builder
Design the tools an AI model can call — a name, a description that tells the model when to use it, and the parameters with their types, allowed values, required fields, nested objects and arrays — in a form or directly as JSON Schema. The same tool is exported in every format: OpenAI function tools (Responses and Chat Completions), Anthropic tool definitions with input_schema, Gemini function declarations and Model Context Protocol tools with inputSchema, plus TypeScript types, a Zod schema and a Pydantic model for your own code.
Paste a tool written for any of these APIs to convert it. Before a model sees the tool, the page lists what strict mode refuses — OpenAI’s Structured Outputs and Anthropic’s strict tool use each support only part of JSON Schema — and can make the schema strict-compatible for OpenAI in one click. Paste the arguments a model sent to see exactly why the call would be rejected. Everything runs offline in your browser.
How to use it
- Enter the tool’s name (letters, digits, underscores and dashes work everywhere) and a description that says what it does and when to use it.
- Add the parameters in the Form: a name, a type, a description, whether it is required, and — under More — allowed values, formats, limits and defaults. Objects and arrays get their own properties and items. Or switch to JSON Schema and write the schema.
- Already have a definition? Paste it under Import a definition and press Read: OpenAI, Anthropic, Gemini and MCP formats and plain JSON Schema are recognised.
- Pick an output — OpenAI, Anthropic, Gemini, MCP, TypeScript, Zod or Pydantic — and copy or download it. Tick Strict mode for OpenAI and Anthropic.
- Read Strict-mode checks; press Make strict-compatible for OpenAI to close every object and turn optional fields into required ones that may be null.
- Paste a model’s tool-call arguments under Check arguments to validate them against the schema.
Examples
get_weather(location: string, required; units: "celsius" | "fahrenheit")
OpenAI: { "type": "function", "name": "get_weather", "parameters": { … } }
Anthropic: { "name": "get_weather", "input_schema": { … } }"units" is optional (not in "required")
OpenAI strict mode: every property must be required — make "units" required with "type": ["string", "null"]
OpenAI’s Structured Outputs emulates optional values with a null type; Make strict-compatible does it for you.
{"units": "kelvin", "city": "Paris"}$ — Missing required property "location". · $.units — Must be one of: "celsius", "fahrenheit". · $.city — Property "city" is not allowed here.
Common uses
- Writing function-calling tools for an assistant or an agent without hand-writing JSON Schema.
- Moving tools between OpenAI, Anthropic, Gemini and an MCP server.
- Finding out why an API refuses a strict tool, or why a model’s arguments fail validation.
- Getting matching TypeScript, Zod or Pydantic types for the code that runs the tool.
The formats
- OpenAI Responses:
{ "type": "function", "name", "description", "parameters", "strict" }; Chat Completions puts the same fields under"function"(function calling). Names: letters, digits, underscores and dashes, up to 64 characters. - Anthropic:
{ "name", "description", "input_schema" }, plus"strict": truefor strict tool use (define tools); names up to 128 characters. - Gemini:
{ "functionDeclarations": [ { "name", "description", "parameters" } ] }, whereparametersis an OpenAPI 3.0 subset (types in capitals,nullable, noadditionalPropertiesor$ref) — orparametersJsonSchemawith plain JSON Schema (FunctionDeclaration). - MCP:
{ "name", "title", "description", "inputSchema" }with optional behaviour annotations (MCP tools); names of 1 to 128 letters, digits, underscores, hyphens and dots.
Strict mode
With strict mode, the model’s arguments are guaranteed to match the schema — but only a subset of JSON Schema is allowed. OpenAI requires "additionalProperties": false on every object and every property in required (optional values become a type with null), and does not support allOf, not, if/then/else, dependentRequired or dependentSchemas; formats are limited to date-time, time, date, duration, email, hostname, ipv4, ipv6 and uuid, and fine-tuned models also refuse length, pattern, range and item limits (supported schemas). Anthropic’s strict tool use refuses recursive schemas, numeric and string-length limits, array limits other than minItems of 0 or 1, and some regular-expression features, and allows 24 optional and 16 union-typed parameters across a request’s strict tools (JSON Schema limitations).
Checking arguments
Paste the arguments object a model returned, the JSON string Chat Completions puts in arguments, or a whole tool call: the page validates it against the parameters (JSON Schema draft 2020-12) and lists every problem with its path — a missing required property, a value outside the allowed list, a property the schema does not allow. Use it to debug a tool before you trust a model’s output, and to test edge cases you put in a description.
Limitations
- The form edits the common part of JSON Schema (types, enums, formats, limits, defaults, nested objects and arrays); schemas with $ref, anyOf, oneOf or allOf are edited as JSON, and every output still supports them.
- Strict-mode checks follow the providers’ published lists; a provider may still refuse a schema that is very large or complex.
- Gemini’s OpenAPI subset cannot express everything JSON Schema can: the notes list what was dropped, and parametersJsonSchema keeps it all.
- The TypeScript, Zod and Pydantic code covers the same subset; review it before you depend on it.
Privacy
Everything happens in your browser. What you enter or open here is not uploaded or stored by MySmartCoPilot.
Frequently asked questions
What should the description say?
What the tool does, when the model should use it (and when not), what each parameter means and what the tool returns. Anthropic’s guide calls detailed descriptions “by far the most important factor in tool performance”, and OpenAI’s asks for clear, detailed descriptions of the function and each parameter.
Why does strict mode want every property required?
OpenAI’s Structured Outputs makes the model produce every key it declares. To keep a value optional, require it and allow null — "type": ["string", "null"] — and treat null as “not given” in your code. Make strict-compatible for OpenAI does this for you.
Can I convert an OpenAI tool to an Anthropic or MCP tool?
Yes. Paste it under Import a definition, press Read, and choose the output you need. The parameters are the same JSON Schema in all of them; only the wrapper changes (Gemini’s parameters also change their types to capitals).
Is anything sent to an AI provider?
No. Nothing leaves your browser: the page builds, converts and validates the definitions on your device, offline.