rinoxRinox
Log inTry free
New · MCP server generation

Wrap any security platform
as agent-callable tools.

Rinox generates production-ready Model Context Protocol (MCP) servers — a single deployable file that exposes a platform's API as typed tools your AI agent can call. Pick a platform, describe what the agent should do, get the server.

Generate an MCP serverBrowse the library
● Python or TypeScript● 24 platforms● MCP IRON verified
●  The artifact

A complete server, not a stub.

Every generation returns runnable code, a README with the exact config snippet, and a typed tool manifest — ready to drop into Claude Desktop or any MCP-compatible agent.

01

Runnable server

A single-file MCP server over stdio, in Python (mcp SDK) or TypeScript (@modelcontextprotocol/sdk). Real tools, real auth, real error handling.

02

README + config

Install steps, the claude_desktop_config.json snippet, and every environment variable documented. Set vars, run, connect.

03

Typed tool manifest

Each tool comes with a strict JSON Schema, a read/write flag, and a one-line description — so agents and reviewers both know exactly what it does.

misp_mcp_server.py
# misp_mcp_server.py — generated by Rinox
import os
from mcp.server import Server
from mcp.server.stdio import stdio_server

MISP_URL = os.environ["MISP_URL"]
MISP_KEY = os.environ["MISP_API_KEY"]
ALLOW_WRITES = os.environ.get("RINOX_ALLOW_WRITES") == "true"

server = Server("rinox-misp")

@server.list_tools()
async def list_tools():
    return [SEARCH_ATTRIBUTES, GET_EVENT, ADD_ATTRIBUTE, ...]

@server.call_tool()
async def call_tool(name, args):
    if name == "add_attribute" and not ALLOW_WRITES:
        return error("writes disabled — set RINOX_ALLOW_WRITES=true")
    ...
claude_desktop_config.json
{
  "mcpServers": {
    "misp": {
      "command": "python",
      "args": ["misp_mcp_server.py"],
      "env": {
        "MISP_URL": "https://misp.internal",
        "MISP_API_KEY": "your-key-here",
        "RINOX_ALLOW_WRITES": "false"
      }
    }
  }
}
●  The pipeline

Planned before it's written. Verified before it ships.

STEP 01

Plan the tool surface

A planner commits to the full manifest — tool names, typed input schemas, and read/write flags — before any code is generated, so the surface can’t drift mid-stream.

STEP 02

Generate in parallel

A shared scaffold and each tool handler are generated concurrently (per-tool fan-out), then assembled into one server — with a single-shot fallback if assembly fails.

STEP 03

Grade and repair

Structural checks plus a semantic judge score the server against the MCP IRON standard, with up to two targeted repairs and a manifest-vs-code cross-check.

●  The standard

The MCP IRON
standard.

Eight rules that separate a toy wrapper from a server you'd let an autonomous agent run against production. Every generation is graded against them before it leaves the API.

Generate one now
RULE 1
Typed input schemas
Strict JSON Schema with typed properties, a required array, and additionalProperties:false. No free-form passthrough.
enforced
RULE 2
Env-based auth
Credentials and base URLs read from environment variables — never tool parameters, never hardcoded.
enforced
RULE 3
Write gating
Destructive tools are non-read-only and gated behind RINOX_ALLOW_WRITES, returning a structured error when disabled.
enforced
RULE 4
Structured errors
API failures are caught and returned as MCP results with isError:true. No unhandled exceptions reach the agent.
enforced
RULE 5
Tool granularity
One tool per logical operation — search_*, get_*, list_*, create_*, contain_* — not one mega-tool.
enforced
RULE 6
Server boilerplate
Full MCP SDK registration: tools/list handler, tools/call dispatcher, and stdio transport.
enforced
RULE 7
Pagination
Large result sets expose a limit plus a cursor or page token so agents page instead of flooding context.
enforced
RULE 8
Rate-limit awareness
Retry-After is honored and 429s back off within bounds, so agents don’t hammer the upstream API.
enforced
●  FAQ

MCP servers, answered.

  • What is an MCP server?

    A Model Context Protocol (MCP) server exposes an external system’s capabilities as typed tools that an AI agent can call. Rinox generates one that wraps a security platform’s REST API — so an agent can search, fetch, and act on that platform through well-defined tools instead of raw HTTP.

  • Which languages can Rinox generate?

    Python (via the official mcp SDK) or TypeScript (via @modelcontextprotocol/sdk). Python is the default. Both run over stdio and drop straight into claude_desktop_config.json or any MCP-compatible agent framework.

  • How does Rinox keep generated servers safe?

    Credentials and base URLs come from environment variables, never tool parameters or hardcoded values. Destructive tools are flagged non-read-only and gated behind a RINOX_ALLOW_WRITES env var that returns a structured error when writes are disabled. Inputs use strict typed JSON Schemas with additionalProperties:false to block free-form passthrough.

  • Is the output verified?

    Yes. Every server passes structural validation and a semantic judge against the eight-rule MCP IRON standard, with up to two targeted repair attempts. A post-repair check cross-references the advertised tool manifest against the code so no tool is exposed without a handler.

Give your agent real tools.

Free to start. No credit card. A deployable MCP server in under 30 seconds.

Generate an MCP server