Introduction

The secureFlows MCP server

An MCP server is how an AI coding tool gets real, callable tools for your product — not just a long markdown file to memorize. secureFlows ships a hosted one so agents can build login URLs correctly, lint an integration before you ship it, and call the documented APIs without reinventing the wiring.

Why MCP servers exist

Large language models are excellent at sounding like they know your API. They are less excellent at remembering every redirect rule, every “never put the token here” anti-pattern, and every 403 carve-out that only shows up after you have already spent an afternoon debugging.

An MCP server (Model Context Protocol) is a small HTTP service that exposes named tools an AI client can discover and call. Instead of pasting OpenAPI into the chat and hoping, the agent can ask: “build me a correct login URL” or “lint these auth files” and get a structured answer.

Think of it as giving the agent a toolbox instead of a textbook. Textbooks get skimmed. Toolboxes get used.

Meme: Arthur looking unimpressed while Jane says MCP server, Arthur. Everyone must have one. — Not official product guidance. Official product guidance is below. The meme is just… culturally accurate.

If your workflow involves Cursor, Claude Code, or any other MCP-capable agent integrating secureFlows, pointing that agent at the hosted MCP endpoint is the supported path. You do not need to run npx, start a local Node process, or invent a subdomain.

What the secureFlows MCP server does

Two kinds of tools, one endpoint:

Static tools (no token)

Build hosted login and logout URLs the right way, and lint generated auth/session code for the mistakes that dominate real integrations. Useful before a session exists — which is exactly when most bugs are born.

Generated tools (need a token)

One tool per OpenAPI operation tagged ai-safe or ai-optional. Thin HTTP forwards to your secureFlows host. Handy for agents and automation that already hold a session, Firebase, or user token.

The server is stateless: it does not store your workspace secrets. Each call carries connection.host (and optional workspace / app id) plus whichever auth.* token the chosen tool needs. Product apps still talk to secureFlows HTTP APIs and hosted login directly — MCP is for agents helping you build and verify that integration.

Your users never see this. Your coding agent should. That is the whole product pitch in two sentences.

How to use it

Point the MCP client at the hosted URL on the same host as the product, path /mcp (Streamable HTTP — not stdio, not a separate subdomain):

Production	`https://www.secure-flows.com/mcp`
Staging	`https://secure-flows-staging.onrender.com/mcp`
Health	`GET …/mcp/health` → `{"ok":true}`

Example Cursor / MCP client config:

{
  "mcpServers": {
    "secureflows": {
      "url": "https://www.secure-flows.com/mcp"
    }
  }
}

While scaffolding, prefer the static tools over hand-building login/logout URLs. Before you call an integration done, run secureflows_lint_integration over all auth/session-related files in one call (some checks look for handling that may live in any of them), fix every error finding, and review needs_review by hand. Lint is a fast first pass — not a substitute for the Agent implementation checklist in SKILL.md.

Tools at a glance

secureflows_build_login_url — always /app/sessions/login, never the legacy /app/login; refuses the classic “dead JWT into fresh login” anti-patterns.
secureflows_build_logout_url — top-level redirect logout; refuses a post-logout redirect_uri that points at /callback or embeds session_token.
secureflows_lint_integration — static scan for forbidden constructs and missing required handling (token never cleared on signed-out, BILLING_GRACE_LOCK treated as logout, Continue CTA gated on session === null, and friends).
Generated OpenAPI tools — session / user / docs-search operations tagged for agents; require connection.host and the matching auth.* token (docs search needs no auth).

Where it is published

Agents and MCP clients discover tools through public GitHub repos, npm metadata, and the official MCP Registry. secureFlows is listed in all three — but the thing to configure is still the hosted URL above, not a local install.

Hosted endpoint	https://www.secure-flows.com/mcp (primary agent path; staging: `https://secure-flows-staging.onrender.com/mcp`)
Transport	MCP Streamable HTTP — `POST /mcp`; health at `GET /mcp/health`
MCP Registry	`io.github.michal-lefler/secureflows-mcp-server` on registry.modelcontextprotocol.io. The listing is a remote (Streamable HTTP) pointing at the hosted endpoint — not an npm `packages` install. Namespace is GitHub-backed (`io.github.michal-lefler/*`).
server.json	Lives in the public repo root; declares `"type": "streamable-http"` and `"url": "https://www.secure-flows.com/mcp"` — same URL agents should configure
npm package	secureflows-mcp-server (currently `0.2.0`) — versioned artifact and standalone Docker builds. Not the agent setup path; do not tell agents to `npx` this.
Public source	github.com/michal-lefler/secureflows-mcp-server — public MIT mirror for discovery (search, topics, registry namespace ownership, npm “Repository” link). Release v0.2.0
Security	Report issues via GitHub private vulnerability reporting on that repo, or [email protected]. See the repo’s `SECURITY.md`.
OpenAPI inputs	Session, user, and docs specs under /docs/openapi/ — only operations tagged `ai-safe` / `ai-optional` become generated tools
Routing	Same origin as the product; nginx proxies `/mcp` to the in-image Node process. See ROUTING.md.

If a directory site asks you to “install the MCP from npm,” smile politely and paste the hosted URL instead.

The MCP server sits next to two other public packages agents often find when searching for secureFlows:

secureflows-js (GitHub) — browser SDK used by the React starter
create-secureflows-app (GitHub) — scaffolds a working Vite + React integration

All three are MIT, point homepage at www.secure-flows.com, and ship public GitHub mirrors for discovery. Your app still integrates via hosted login + HTTP APIs; these packages and the MCP server are how humans and agents get there faster.

Where to go next

Building an app with an AI coding tool? SKILL.md is the agent’s contract. Prefer the human walkthrough at Integration Walkthrough when you are driving. For how MCP fits the single-host layout, see ROUTING.md.