Keryx — AI Gateway for your business

Key Features

Everything you need, in one place

Keryx unifies two modules — Next-Gen for LLM integration and Legacy for Apple Siri Shortcuts — into a single, modular system with a shared tool registry.

🤖

MCP Server

Model Context Protocol endpoint for direct communication with Claude, ChatGPT and other LLMs. Streamable HTTP transport in stateless mode — ideal for load balancing.

📋

OpenAPI 3.1 Schema

Automatically generated OpenAPI schema from Zod definitions. LLM agents read it to discover available functions and how to communicate with your platform.

📱

Siri Shortcuts

Generate Apple .shortcut files from URL and token. iOS users download the shortcut which executes an HTTP request with an Authorization header in one tap.

🔐

Security

Timing-safe authentication, CORS policy, rate limiting (100 req/min), input validation with Zod schema, and ScPL injection protection.

🐳

Docker-Ready

Multi-stage Dockerfile, non-root user, healthcheck endpoint. Runs with a single command: docker-compose up. Optimized for WSL2 and Proxmox.

⚙️

REST API

Every registered tool automatically gets a REST endpoint at /api/tools/<name>. Standard JSON request/response with validation and detailed errors.

Architecture

One registry, three surfaces

The heart of Keryx is the shared tool registry. Each tool is defined ONCE as a Zod schema + handler, and all three API surfaces are generated automatically from it.

Layer 1 — Definition

Tool Registry

src/core/registry.ts — central storage. Each tool has a name, Zod input schema, description, and handler function. Modules register tools on initialization.

Layer 2 — Generation

Automatic Exposure

Generated from the registry: OpenAPI 3.1 schema (GET /openapi.json), MCP tool list (POST /mcp), and REST routes (POST /api/tools/*).

Layer 3 — Modules

Next-Gen + Legacy

Each module lives in its own directory and registers tools independently. Adding a new tool = new Zod schema + handler, without touching the core code.

Layer 4 — Transport

Express HTTP server

Express 4 with CORS, rate limit, timing-safe auth middleware. Graceful shutdown (SIGTERM/SIGINT) for Docker/Kubernetes.

Principle

Single source of truth

OpenAPI schema and MCP server are built from the same definitions — they can never diverge.

            registry.ts
// Define tool once...
const myTool = {
  name: "create_shortcut",
  input: z.object({
    url: z.string().url(),
    token: z.string().min(1),
  }),
  handler: async (input) => {
    // ...generate shortcut
  }
};

// ...register once...
registry.register(myTool);

// ...appears EVERYWHERE:
// ✓ GET  /openapi.json
// ✓ POST /mcp
// ✓ POST /api/tools/create_shortcut
          

File Structure

src/
├── config/env.ts
├── core/
│   ├── registry.ts ← source of truth
│   └── openapi.ts
├── modules/
│   ├── nextgen/ (MCP, echo, status)
│   └── legacy/ (Siri Shortcuts)
├── server.ts
└── index.ts

API Endpoints

The complete API map

Method	Path	Auth	Description
GET	/healthz	Public	Health check for Docker / load balancer
GET	/openapi.json	Public	OpenAPI 3.1 schema for Claude / ChatGPT
POST	/mcp	Token	MCP Streamable HTTP (stateless)
POST	/api/tools/gateway_status	Token	Gateway status and tool list
POST	/api/tools/echo	Token	Echo message (connection test)
POST	/api/tools/create_shortcut	Token	Generate Apple Siri shortcut
GET	/api/shortcuts/:id	Public	Download .shortcut file (capability URL)

How it works in practice

From a click on the site to an iPhone shortcut

How does this actually look to your users? If you are not a developer, here is how the whole process goes — smoothly and without installing special apps.

Click on your site

The user is logged into your web app. You place a simple "Add to my iPhone" button. When clicked, your app silently sends an instruction and the user's token to Keryx.

Keryx does the magic

In a fraction of a second, Keryx packages those instructions and generates a native Apple shortcut file (.shortcut). Keryx then returns a secure download link for that file to your site.

Adding to the phone

The user's phone automatically downloads the file. The built-in Shortcuts app opens on the iPhone. The user simply confirms with "Add Shortcut" and that's it.

Who uses Keryx

Built for various needs

🧑‍💻

Web developers

Who want to expose their platform functionality to AI agents without writing an MCP server from scratch. Register a tool — and Claude uses it instantly.

🏢

Companies with internal tools

Self-hosted: data never leaves your infrastructure. Ideal for internal APIs that need to be accessible to voice assistants and LLMs.

📱

iOS users and automators

Generate Siri shortcuts that call your API with a single tap. The bearer token is embedded in the shortcut — no need to type any credentials.

🏠

Homelab enthusiasts

50MB Docker container, built-in healthcheck, runs on Proxmox/WSL2. Run it on your NAS or mini server and connect it with AI tools.

Pricing

Flexible plans for every business

Built on blazing-fast technology, Keryx allows us to offer premium service at minimal costs. Start for free and pay only when your business grows.

Free The Hook

$0 / month

Perfect for startups and small businesses to test the integration.

✓ All Keryx features
✓ Up to 1,000 AI interactions / month
✓ Website integration (MCP + Siri)
ℹ Subtle "Powered by Keryx.ai" branding

Get started for free

Why is Keryx Open-Source?

We play the transparency and security card. Because the system handles your API tokens, our code is always 100% public on GitHub so you can be completely certain there are no hidden actions. We don't sell secret code — we sell "Keryx as a Service" to those who want a worry-free, fully managed solution that runs 24/7.

Frequently Asked Questions

Questions and answers

Keryx is an open-source, self-hosted API gateway serving as a bridge between your web platform and AI assistants (Claude, ChatGPT, Siri). Instead of writing a separate integration for each AI agent, you register a tool once in Keryx — and it automatically appears as an MCP tool, OpenAPI operation, and REST endpoint.

No. Keryx is fully self-hosted — run it on your server, NAS, or even a Raspberry Pi. Your data never passes through third parties. All you need is Docker or Node.js ≥ 20.

MCP is an open protocol that enables LLM agents (like Claude) to discover and call external tools. Keryx implements an MCP server via Streamable HTTP transport in stateless mode — the agent sends a JSON-RPC request to /mcp and gets a tool list or executes an operation.

You send a POST request with a URL and a Bearer token to /api/tools/create_shortcut. Keryx generates an Apple .shortcut file (binary property list) containing the embedded HTTP request. You get a download link — the iOS user opens it, adds the shortcut, and with a single tap (or voice command) calls your API.

The token embedded in the shortcut is the token for your target API, not the Keryx gateway token. It is visible to anyone who downloads the .shortcut file — this is by design, because the shortcut must work autonomously. We recommend using tokens with limited permissions and a short lifespan. The download link expires after 10 minutes and contains an unguessable 128-bit ID.

Create a file in src/modules/, define a Zod schema for input, write a handler function, and call registry.register(myTool). Keryx automatically generates an OpenAPI schema, MCP tool and REST route. You don't need to touch the core code — see src/modules/nextgen/tools.ts as an example.

There is no technical limit. The registry is an in-memory Map populated on startup. With 100 tools, the OpenAPI schema is just a few KB. The MCP list is generated from the same registry. The only bottleneck would be memory for the shortcut store (configured via KERYX_SHORTCUT_STORE_MAX).

The easiest way: cp .env.example .env, set KERYX_API_TOKEN and PUBLIC_BASE_URL, then run docker-compose up -d. The container uses Node.js 20 Alpine, runs as a non-root user, with a built-in healthcheck.

MCP transport uses Streamable HTTP which can internally use SSE for streaming responses. However, Keryx works in stateless mode — each request is independent, with no long-lived connections. For real-time functions, a tool can integrate WebSockets in its handler.

Node.js ≥ 20 (ESM, "type": "module"). TypeScript 5.7+ in strict mode. For development, tsx (watch mode) is used, and for production it compiles to JavaScript with npm run build.

The shared registry is the central place where every tool is defined exactly once. From it, the OpenAPI schema, MCP tools, and REST routes are all generated. This means it is impossible for these three surfaces to diverge — if you add a parameter to the Zod schema, it automatically shows up everywhere. This eliminates an entire category of bugs.

The download link expires after KERYX_SHORTCUT_TTL_MS (default 10 minutes). After that, GET /api/shortcuts/:id returns 404 with the message "Shortcut not found or expired." The user can request a new shortcut. This prevents files from accumulating in memory.

Yes, for local development. If you leave KERYX_API_TOKEN empty in .env, authentication is disabled. In production, be sure to set a token — all protected endpoints require an Authorization: Bearer <token> header.

Yes. Keryx is designed for WSL2 and Proxmox environments. The Docker container uses Alpine Linux and has no platform-specific dependencies. It can also be run directly via Node.js on Windows, but the Docker approach is recommended.

Keryx is MIT licensed and open for contributions. Fork the repository, add a module or tool following the pattern in src/modules/nextgen/tools.ts, run npm run typecheck to check types, and open a Pull Request. Check TODO.md for planned features.

Absolutely not. Keryx runs on your server and processes requests in a fraction of a second. Because it is stateless and written in Node.js with asynchronous flows, it can handle a massive number of concurrent requests without blocking your main site.

No! That is the biggest advantage of Keryx. Shortcuts are built into every iPhone. Your user can communicate with your site using just their phone and voice, without you ever having to build and publish an app on the App Store.

Your main Keryx API token is hidden on your server. But your user's token (which they use to prove their identity when Siri makes a request) is embedded in the shortcut on their phone. This is their personal token, so they only control their own account with it.

Keryx is a 100% free and open-source project under the MIT license. There are no monthly subscriptions, no feature limits, and you can modify and use it in commercial projects.

The Next-Gen module (MCP and OpenAPI) works everywhere — on any LLM assistant (Claude, ChatGPT). However, the Legacy module is specifically designed to generate .shortcut files that work exclusively on iOS, iPadOS, and macOS devices.

You just need a server where you can run Docker (which is most modern servers). Alternatively, you can run it without Docker if you have Node.js version 20 or newer installed.

Systems like Zapier charge based on the number of tasks completed, store your users' data on their servers, and require setup by the user. Keryx lives on your server, is completely free unlimited, and shortcuts are generated automatically for each user.

No. Keryx does not have a database at all (it is stateless). Generated shortcuts are only stored temporarily in memory (RAM) until the user downloads them (maximum 10 minutes), after which they are irreversibly deleted. Your data remains yours.

Minimal. Our "shared registry" system guides you through creating a tool. It is enough to know a little TypeScript/JavaScript, define which fields your operation requires using the Zod library, and Keryx handles all the heavy lifting of the exposure architecture.

This is exactly why Keryx exists as a middleware! If changes occur, our open-source team will update Keryx's code. You just update your Keryx installation on your server, while the code of your main site remains absolutely untouched.