Cross-platform MCP server with oRPC?

[unnoq]

Cross-platform MCP server with oRPC?

[tunnckoCore]

absolutely 🙌

[mi3lix9]

Creating a unified API that functions as an OpenAPI or MCP server for AI would be a great idea.

[tunnckoCore]

Btw, seems like i forgot to link one basic converter that i did back then

https://gist.github.com/tunnckoCore/f98c037f46a23f2da9f3018a08af1355

@mi3lix9 @unnoq

not sure if it still works. it should if you didn't changed the fundamentals too much (eg. ~orpc) - the problem tho, may be the updates to McpServer from their sdks.

[unnoq]

No breaking change, so it should work

[codybrouwers]

Thanks for this @tunnckoCore, I came up with something similar that works really well!

import type { ServerOptions } from '@modelcontextprotocol/sdk/server';
import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { type AnyRouter, call, type InferRouterInitialContext, isProcedure } from '@orpc/server';
import * as Sentry from '@sentry/nextjs';
import * as z4 from 'zod/v4';
import { jsonSchemaObjectToZodRawShape } from 'zod-from-json-schema';

type ToolConfig = Parameters<McpServer['registerTool']>[1];
type ToolHandler = Parameters<McpServer['registerTool']>[2];

/**
 * Convert a Zod v4 schema to a Zod v3 schema by converting it to a JSON schema and then to a Zod v3 schema.
 *
 * Necessary because the @modelcontextprotocol/sdk only supports Zod v3,
 * so we need to convert the Zod v4 schema to a Zod v3 schema.
 *
 * Can be removed once https://github.com/modelcontextprotocol/typescript-sdk/pull/869 is merged
 */
function convertToZodV3Schema(v4Schema: z4.ZodType | undefined): ToolConfig['inputSchema'] | undefined {
    if (!v4Schema) return undefined;

    const jsonSchema = z4.toJSONSchema(v4Schema, {
        target: 'openapi-3.0',
        unrepresentable: 'any',
    });
    return jsonSchemaObjectToZodRawShape(jsonSchema as unknown as z4.ZodJSONSchema) as unknown as ToolConfig['inputSchema'];
}

/**
 * Check if a value is an indexable object and not null
 */
function isIndexable(val: unknown): val is Record<string, unknown> {
    return typeof val === 'object' && val !== null;
}

/**
 * Convert a router to MCP tools by walking the router and converting each procedure to an MCP tool.
 */
export function convertRouterToMcpTools<T extends AnyRouter>(router: T) {
    const tools = new Map<string, { config: ToolConfig; createHandler: (context: InferRouterInitialContext<T>) => ToolHandler }>();
    const serverOptions: ServerOptions = {};

    function walkRouter(node: AnyRouter, path: string[] = []) {
        if (!isIndexable(node)) return;

        for (const [key, value] of Object.entries(node)) {
            if (!isIndexable(value)) {
                continue;
            }

            if (isProcedure(value)) {
                const { route, inputSchema, meta } = value['~orpc'];

                if (meta.mcp !== true) {
                    continue;
                }

                const name = [...path, key].join('_');
                const zodV3InputSchema = convertToZodV3Schema(inputSchema);

                tools.set(name, {
                    config: {
                        title: name,
                        description: route.description || route.summary || undefined,
                        inputSchema: zodV3InputSchema,
                    },
                    createHandler: (context) => async (args) => {
                        try {
                            const result = await call(value, args, {
                                context,
                            });
                            return {
                                content: [{ type: 'text', text: JSON.stringify(result) }],
                            };
                        } catch (error) {
                            Sentry.captureException(error);
                            return {
                                isError: true,
                                content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
                            };
                        }
                    },
                });
            } else {
                walkRouter(value, [...path, key]);
            }
        }
    }
    walkRouter(router);
    return { tools, serverOptions };
}

[tunnckoCore]

@codybrouwers great, looks great! I will try it.

[ethan-huo]

I am looking forward to this; exposing the orpc code as CLI and MCP is very important.

[unnoq]

OpenAPI MCP server is a temporary solution: https://github.com/janwilmake/openapi-mcp-server