Support JSON schema in addition to zod

[psclkhoury]

Why dont you add support for jsonschema in addition to zod. A lot of projects already have jsonshemas defined and you are converting internally from zod to jsonschema.

[ThomasAribart]

I guess this is for type-safety/devX. However there are tools for type inference like https://github.com/ThomasAribart/json-schema-to-ts.

[tianlinle]

I'm also looking forward to JSON-Schema. @ThomasAribart It's not for type-safety, it's the same goal as zod. Right now I'm using ajv to validate any JSON data by JSON-Schema. Tool calling in most LLMs is using JSON-schema to describe the args of a function, so I think it's helpful if MCP also can support JSON-Schema in addition to zod.

[finom]

After creating vercel/mcp-handler#65 and digging thru the source codes I found this repository. I'm using @vercel/mcp-adapter and all I have is JSON Schema. My attempts to convert it to Zod were unsuccessful.

It seems like the SDK supports Zod 3 only with legacy zod-to-json-schema, even though there is a plenty of libraries, including Zod 4, Valibot and other libraries that implement Standard Schema and their own toJSONSchema first-, second-, or 3rd-party implementation. IMO, such an important SDK should be JSON Schema-first, instead of one-legacy-library-first, even though Zod 3 is still maintained.

Ajv has a nice TypeScript library that might be a great fit to support JSON Schemas. At this case the SDK can support basically all modern validation libraries, instead of one specific version of one specific library.

[Rutledge]

+1 for JSON Schema support. I'm currently blocked by this when using Stainless-generated MCP
tools.

Stainless (and many other code generators) produce plain JSON schemas from OpenAPI specs.
When these are passed to server.tool(), the MCP SDK tries to run zodToJsonSchema() on
them, which fails because they're already JSON schemas, not Zod schemas.

This results in:

• Parameters not showing up in MCP Inspector
• Tools receiving undefined for all parameters
• The actual parameter schema appearing in the wrong place (e.g., in annotations instead of
  inputSchema)

Supporting plain JSON schemas would enable:

1. Code-generated tools from OpenAPI specs
2. Integration with existing JSON Schema tooling
3. Compatibility with other validation libraries beyond Zod

Related issue in Vercel adapter: vercel/mcp-handler#65

[priolo]

+1 for JSON Schema support.
Transforming from JSON Schema to ZOD is not easy.

[emaciel10]

Completely agreed, going from json schema to a clean zod schema has been a pain for us so having MCPServer work with just json schema would be great!

[bahatron]

We use https://github.com/sinclairzx81/typebox for types, the runtime object is a normal valid jsonschema object. Would be nice to be able to give it valid jsonschema coming from typebox

[logseq-cldwalker]

We're using this library from clojurescript and already have json schemas created by https://github.com/metosin/malli. We'd love to be able to reuse these json schemas without having to maintain a separate zod version of them

[dan-kwiat]

I agree it would be nice to have the option of using JSON Schema in the helpers registerTool, registerPrompt etc. and I'd be happy to implement it. But FYI you can already work with JSON Schema through the low-level server:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
import {
  ListToolsRequestSchema,
  CallToolRequestSchema,
} from "@modelcontextprotocol/sdk/types.js"

const server = new McpServer(
  {
    name: "example-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {
        listChanged: false,
      },
    },
  }
)

server.server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "echo",
        title: "Echo Tool",
        description: "Echoes back the provided message",
        inputSchema: {
          type: "object",
          properties: {
            message: {
              type: "string",
              description: "The message to echo back",
            },
          },
          required: ["message"],
        },
        outputSchema: {
          type: "object",
          properties: {
            echo: { type: "string", description: "The echoed message" },
          },
          required: ["echo"],
        },
      },
    ],
  }
})

server.server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name !== "echo") {
    throw new Error(`Unknown tool: ${request.params.name}`)
  }

  const args = request.params.arguments as any

  // Validate args against inputSchema here

  const output = { echo: `Tool echo: ${args.message}` }

  return {
    content: [{ type: "text", text: JSON.stringify(output) }],
    structuredContent: output,
  }
})