Your country

Tools that support it use your country for local currency, number formats, units and paper size. Your choice is saved only in this browser.

Type a name or a two-letter code. Use the up and down arrow keys to move through the countries, Enter to choose one and Escape to close.

LLM Tool & Function-Calling Schema Builder

One tool definition for every AI API, checked for strict mode before a model sees it.

Developer No upload Works offline Free, no sign-up

Tool

Letters, digits, underscores and dashes work with every provider.
Models read it to decide when to call the tool.

Parameters

    Import a definition

    Export

     

      Strict-mode checks

      OpenAI Structured Outputs

        Anthropic strict tool use

          Check arguments

            Next steps

            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

            1. 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.
            2. 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.
            3. 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.
            4. Pick an output — OpenAI, Anthropic, Gemini, MCP, TypeScript, Zod or Pydantic — and copy or download it. Tick Strict mode for OpenAI and Anthropic.
            5. 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.
            6. Paste a model’s tool-call arguments under Check arguments to validate them against the schema.

            Examples

            One tool, two formats
            Input
            get_weather(location: string, required; units: "celsius" | "fahrenheit")
            Result
            OpenAI: { "type": "function", "name": "get_weather", "parameters": { … } }
            Anthropic: { "name": "get_weather", "input_schema": { … } }
            Why strict mode refuses a schema
            Input
            "units" is optional (not in "required")
            Result
            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.

            A rejected call
            Input
            {"units": "kelvin", "city": "Paris"}
            Result
            $ — 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": true for strict tool use (define tools); names up to 128 characters.
            • Gemini: { "functionDeclarations": [ { "name", "description", "parameters" } ] }, where parameters is an OpenAPI 3.0 subset (types in capitals, nullable, no additionalProperties or $ref) — or parametersJsonSchema with 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.

            Quick answers and tool search

            Type to search tools or to get a quick answer, for example 18% of 2500. Use the up and down arrow keys to move through the results, Enter to choose, and Escape to close.