Skip to main content
Tools in Reminix are served via the Model Context Protocol (MCP). You define tools using @reminix/runtime or reminix-runtime, serve them alongside your agents, and any MCP-compatible client can discover and call them.

​
Defining tools

import { z } from "zod"
import { tool, serve } from "@reminix/runtime"

const weather = tool("get-weather", {
  description: "Get current weather for a city",
  inputSchema: z.object({
    location: z.string().describe("City name"),
    units: z.enum(["celsius", "fahrenheit"]).default("fahrenheit"),
  }),
  handler: async ({ location, units }) => {
    return { temperature: 72, condition: "sunny" }
  },
})

serve({ tools: [weather] })

​
Schema generation

How input schemas are generated differs by language:
Type hints are automatically converted to JSON Schema. Parameter descriptions are extracted from the function docstring (Google style and NumPy style are both supported).
@tool
async def search(query: str, max_results: int = 10) -> list[dict]:
    """Search for documents.

    Args:
        query: The search query string.
        max_results: Maximum number of results to return.
    """
    ...
This generates:
{
  "type": "object",
  "properties": {
    "query": { "type": "string", "description": "The search query string." },
    "max_results": { "type": "integer", "description": "Maximum number of results to return.", "default": 10 }
  },
  "required": ["query"]
}
Use Zod to define inputSchema (recommended). Descriptions, defaults, and optionality are all preserved. You can also provide an outputSchema.
import { z } from "zod"

const search = tool("search", {
  description: "Search for documents",
  inputSchema: z.object({
    query: z.string().describe("The search query string"),
    max_results: z.number().int().default(10).describe("Maximum number of results"),
  }),
  handler: async ({ query, max_results }) => {
    // ...
  },
})

​
Tools + agents together

You can serve tools and agents from the same process. Pass both to serve(). 
serve({ agents: [bot], tools: [weather, search] })

​
MCP compatibility

When deployed, your tools are automatically served via the MCP protocol. Any MCP-compatible client can connect and discover them, including:
  • Claude (Anthropic)
  • Cursor
  • Windsurf
  • ChatGPT (OpenAI)
  • Custom MCP clients
  • Other Reminix agents that consume tools
MCP is an open standard for connecting AI models to tools and data sources. Your Reminix tools work with any client that speaks MCP, not just Reminix itself.

​
Connecting an MCP client

Your project’s MCP endpoint is one URL. All tools in the project are discoverable through it: 
https://api.reminix.com/mcp
Authenticate with a Project API Key or Personal Access Token in the Authorization header: 
Authorization: Bearer reminix_sk_...
Pick your client below — each one has its own config file location and JSON shape, but they all point at the same endpoint.
Edit the MCP config file:
  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json
{
  "mcpServers": {
    "reminix": {
      "url": "https://api.reminix.com/mcp",
      "headers": {
        "Authorization": "Bearer reminix_sk_..."
      }
    }
  }
}
Restart Claude Desktop. Your tools appear in the tool picker (the slider icon) on the next conversation.
Cursor reads MCP servers from ~/.cursor/mcp.json (global) or .cursor/mcp.json in your project (local).
{
  "mcpServers": {
    "reminix": {
      "url": "https://api.reminix.com/mcp",
      "headers": {
        "Authorization": "Bearer reminix_sk_..."
      }
    }
  }
}
Open Cursor Settings → MCP to verify the server connected. Your tools become available to the Composer agent.
Edit ~/.codeium/windsurf/mcp_config.json:
{
  "mcpServers": {
    "reminix": {
      "url": "https://api.reminix.com/mcp",
      "headers": {
        "Authorization": "Bearer reminix_sk_..."
      }
    }
  }
}
Reload Windsurf (Cmd+Shift+P → Reload Window). The tools appear in Cascade.
Add the server with one CLI command:
claude mcp add --transport http reminix https://api.reminix.com/mcp \
  --header "Authorization: Bearer reminix_sk_..."
Verify with claude mcp list. The tools are available in any subsequent Claude Code session.
Reminix exposes a standard streamable HTTP MCP endpoint, so any client built with the official MCP SDK works. The shape is:
  • URL: https://api.reminix.com/mcp
  • Transport: streamable HTTP
  • Auth: Authorization: Bearer reminix_sk_... header
Use a Personal Access Token (reminix_pat_...) plus an X-Project header if you need to access multiple projects from the same client.
Use a Project API Key for any single-project setup. Use a PAT plus the X-Project header if one client needs to reach tools across multiple projects.

​
Next steps

Python: Creating Tools

Full guide to defining and deploying tools with Python.

TypeScript: Creating Tools

Full guide to defining and deploying tools with TypeScript.