Railyard MCP Server
The Railyard MCP server lets an MCP client read and write Railyard projects and organisations over stdio using a personal access token.
Identify the authenticated user and check server health/capabilities (
whoami,server_info).Browse organisations and projects, fetch full project documents, check project-name availability, and list export formats.
Create, update/overwrite, rename, delete, and move projects between organisations, with revision-safe updates.
Validate saved or inline projects and export them to JSON, NetBox, Nautobot, or Design Builder formats.
Generate deliverables such as build packs, cable/power schedules and labels, and DCIM bundles, optionally saving files locally.
Read and replace an organisation's shared device-type catalogue and device-role vocabulary.
Manage organisations: create, rename, and delete shared orgs.
Manage members and invitations: list members, change roles, remove members, invite/revoke invitations, list your own invitations, and accept them.
Read billing state and create Stripe Checkout or Customer Portal links for owners.
Writes require appropriate roles; destructive tools are flagged as destructive.
Provides billing integration by minting Stripe Checkout or Customer Portal URLs for an organisation owner to start or manage a subscription. It creates hosted-page links only and does not charge or modify subscriptions directly.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Railyard MCP Server Validate my 'DC1' project for design errors"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Railyard MCP server
A Model Context Protocol server that gives an MCP client (Codex, Claude Desktop, Claude Code, or any other) read and write access to your Railyard projects and organisations. It talks to a running Railyard backend over its REST API and authenticates with a personal access token (PAT).
It speaks MCP over stdio and is written in TypeScript against the official
@modelcontextprotocol/sdk.
Just want to install it? Jump to Install below, or follow the standalone INSTALL.md — get a token, paste one config block, verify with
whoami.
What it can do
Projects
Tool | Kind | Description |
| read | Projects in an org (id, name, slug, updated-at). |
| read | A project's full JSON document and revision ETag, by id or slug. |
| read | Whether a name is free in an org (and the slug it would get). |
| write | Create a new, empty project and save it. |
| write · destructive | Conditionally save a project via full-document PUT. Merges partial fields by default; can replace the whole document. |
| write | Change a project's name + URL slug. |
| write · destructive | Permanently delete a project. No undo. |
| write | Move a project into another org you can write to, optionally renaming it in the same step. |
Validation, export & deliverables — validation and the raw JSON export take either a saved
project (ref) or an inline project you have not saved yet. Deliverables are generated from a
saved project. None of them changes anything stored.
Tool | Kind | Description |
| read | Current server-side rack-layout/site and power findings for a saved or inline project; structural hierarchy/cabling errors are rejected first. |
| read | The export targets this build supports ( |
| read | Render a project into a format and return the files' content, unresolved placements and warnings. |
| read · may write local files | Generate a deliverable from a saved project: |
Organisations, members & billing
Tool | Kind | Description |
| read | The user your token authenticates as (id, email, name). |
| read | Server health: version, schema version, and whether persistence, auth and billing are configured. |
| read | Organisations you belong to — id, slug, role, plan, billing status. |
| write | Create a shared org; you become its owner. |
| write · destructive · owner | Delete a shared org and every project in it. No undo. |
| read | The org's shared device-type library and revision ETag. |
| write · destructive | Conditionally replace that library wholesale (not a merge). |
| read | The org's shared device-role vocabulary and revision ETag. |
| write · destructive | Conditionally replace the shared role vocabulary wholesale. |
| read | Roster: user id, email, role, joined-at. |
| write · owner | Change a member's role. |
| write · destructive · owner | Remove a member and drop their live sessions. |
| read · owner | An org's pending invitations. |
| write · owner | Invite an email at a role (within the plan's editor limit). |
| write · owner | Withdraw a pending invitation. |
| read | Invitations addressed to your email. |
| write | Accept one, joining that org. |
| read | Plan, status, seats, trial/period end, whether the subscription is current, and the org's entitlements. |
| write · owner | Mint a Stripe Checkout or Customer Portal URL to open in a browser. Creates a link only — it charges nothing. |
The destructive tools (update_project, delete_project, delete_org, set_org_catalog,
set_org_roles, remove_member) are annotated with the MCP destructiveHint, so clients that surface tool
safety hints will flag them.
Not exposed, deliberately. Personal-access-token management, account deletion and the starter-example claim are gated to an interactive browser session server-side — a token cannot drive them (see Auth model). The OAuth/magic-link routes and the Stripe webhook are not client-callable. Live collaboration is a WebSocket protocol rather than request/response, so it has no tool; see the caveat on concurrent edits below.
Org selection. Every org-scoped tool accepts an optional org argument (an org id,
slug, or name). When omitted it falls back to the RAILYARD_ORG environment variable,
and if that too is unset, to your first (personal) organisation. Slugs/names are resolved to
the org id the API needs (via GET /api/orgs) automatically.
Tool safety hints. Every tool declares the MCP readOnlyHint, destructiveHint,
idempotentHint and openWorldHint annotations. Reads are read-only. A write that removes,
replaces or overwrites stored data is destructive — including rename_project, which changes the
project's URL slug so links to the old one stop working; a purely additive write is not. A
protocol test pins each tool's hints, so a new tool cannot ship without a decision.
Returned text is data. Names, descriptions, labels, comments and error messages come from
people's Railyard workspaces. The server tells the client at start-up (MCP instructions) that
such text is user data, never instructions to follow.
Related MCP server: Linear MCP Server
Setup
1. Requirements
Node.js 20 or newer.
A Railyard account and personal access token. The server connects to
https://railyard.shby default. SetRAILYARD_BASE_URLonly when using a self-hosted or local backend with persistence and authentication enabled.
2. Mint a personal access token
Quick path:
npx -y railyard-mcp@0.2.1 authThat opens Railyard in your browser. Sign in, open User settings if needed, create a token,
and copy the ry_… secret. In headless environments, run npx -y railyard-mcp@0.2.1 auth --no-open
and copy the printed URL.
Manual path:
Sign in to Railyard in your browser.
Go to User settings → Personal access tokens.
Create a token, give it a name, and copy the
ry_…secret — it is shown once, at creation. The server only stores its hash; you cannot retrieve it again.
Treat this secret like a password (see Auth model below).
3. Install and build
Only needed to run from source (or to develop). If you install the published package
with npx -y railyard-mcp@0.2.1, skip this; npm fetches the packaged dist/ files for you.
cd railyard-mcp
npm install
npm run buildThis compiles src/ to dist/. The entry point is dist/index.js.
4. Configure the environment
Variable | Required | Meaning |
| yes | Your |
| no | Railyard base URL. Defaults to |
| no | Default org (id or slug) for org-scoped tools. |
You can smoke-test it from a shell:
RAILYARD_TOKEN=ry_xxx npm start
# (it waits on stdio for an MCP client; Ctrl-C to exit)Install
Pick your client and paste one config block. For a friendly step-by-step walkthrough see the standalone INSTALL.md; the essentials are below.
Two ways to run it:
Published (recommended):
npx -y railyard-mcp@0.2.1downloads and runs that exact version on demand — no clone, no build. Keep the@<version>pin and change it deliberately when you upgrade (npm view railyard-mcp versionshows the latest); see Verifying a release.From source (works today): run the built entry point directly with
node /absolute/path/to/railyard-mcp/dist/index.jsafternpm install && npm run buildin this repo (see Setup). Substitute thatcommand/argsin any snippet below.
The published package uses the hosted URL https://railyard.sh automatically. For a
self-hosted or local backend, add RAILYARD_BASE_URL with your own URL (for example,
https://railyard.internal.example or http://localhost:8080). The token goes with every
request, so plain http:// is refused unless the server is on this machine, and the client never
follows a redirect. RAILYARD_ORG is optional — add it to pin a default organisation.
Claude Desktop — one-click bundle (.mcpb)
The easiest path, no JSON. Open Claude Desktop → Settings → Extensions, then drag in
(or Install extension) the packaged railyard-mcp-<version>.mcpb bundle and fill in the token.
Leave the optional base URL at its hosted default unless you self-host. The bundle is built
from manifest.json and attached to each
GitHub release with checksums and a
signed build attestation — see Verifying a release.
Claude Desktop — manual config
Add the server under mcpServers in claude_desktop_config.json:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"railyard": {
"command": "npx",
"args": ["-y", "railyard-mcp@0.2.1"],
"env": {
"RAILYARD_TOKEN": "ry_your_token_here",
"RAILYARD_ORG": "my-team-slug"
}
}
}
}Restart Claude Desktop after editing. The Railyard tools then appear in the tools menu.
From source: replace the two command lines with
"command": "node", "args": ["/absolute/path/to/railyard-mcp/dist/index.js"].
Claude Code
Register it in one command:
claude mcp add railyard \
--env RAILYARD_TOKEN=ry_your_token_here \
-- npx -y railyard-mcp@0.2.1Check it with claude mcp list. Add --scope project to write a shared .mcp.json
instead of your user config (keep real tokens out of committed files). From source, swap
the trailing -- npx -y railyard-mcp@0.2.1 for -- node /absolute/path/to/railyard-mcp/dist/index.js.
A project-level .mcp.json takes the same shape as the Claude Desktop block above.
Codex CLI
Need Codex first? Install the Codex CLI:
curl -fsSL https://chatgpt.com/codex/install.sh | shRegister it in one command:
codex mcp add railyard \
--env RAILYARD_TOKEN=ry_your_token_here \
-- npx -y railyard-mcp@0.2.1Check it with codex mcp list. Run codex mcp --help to see the rest of the Codex MCP
commands. From source, swap the trailing -- npx -y railyard-mcp@0.2.1 for
-- node /absolute/path/to/railyard-mcp/dist/index.js.
codex mcp login railyard is only for MCP servers that advertise OAuth. Railyard currently
uses a PAT, so use npx -y railyard-mcp@0.2.1 auth to open Railyard in your browser, then paste
the resulting token into the RAILYARD_TOKEN env var above.
Cursor
Edit ~/.cursor/mcp.json (global) or .cursor/mcp.json (project), then enable
railyard under Settings → MCP:
{
"mcpServers": {
"railyard": {
"command": "npx",
"args": ["-y", "railyard-mcp@0.2.1"],
"env": {
"RAILYARD_TOKEN": "ry_your_token_here"
}
}
}
}Any other stdio MCP client
Launch this command with the environment set; the client speaks MCP to it over stdio:
command: npx
args: ["-y", "railyard-mcp@0.2.1"]
env: RAILYARD_TOKEN=ry_your_token_here
RAILYARD_ORG=my-team-slug # optionalPrefer not to commit real tokens. Keep
RAILYARD_TOKENin a private/user-scoped config, or inject it from your environment rather than checking it into a shared config file.
Verify
Run the whoami tool (or ask "who am I on Railyard?"). It returns your Railyard user
id, email and name — confirming the token and URL work. Then try list_projects.
Auth model — why a PAT
A personal access token is the right credential for an MCP server; a session cookie is not.
Non-interactive. An MCP server runs headless. It cannot complete an interactive SSO/OAuth or magic-link sign-in to obtain a session cookie, and a copied cookie is a short-lived, browser-bound artefact that expires and can't be rotated cleanly. A PAT is a long-lived credential minted for programmatic use — exactly this case.
It's the backend's intended programmatic credential. Railyard's API accepts
Authorization: Bearer ry_…on every org-scoped route as a first-class alternative to the browser session cookie. This server sends that header on every request.Safer blast radius by design. Railyard deliberately gates token management itself (creating or revoking PATs) behind an interactive browser session only — a PAT cannot mint or revoke tokens. So even if this server's token leaked, an attacker could not use it to create more tokens or lock you out of revoking it; you revoke it from the browser.
What the token carries. A PAT authenticates as you, across all your organisations, with your full role in each. There are no per-token scopes or expiry yet — so:
Treat the token like a password. Don't commit it, log it, or paste it into shared configs. This server never writes the token to its logs.
Scope it operationally. Only point this server at orgs you intend it to touch (set
RAILYARD_ORG, and be deliberate with write tools). Remember the token can still reach any org you belong to if a tool call names one.Rotate on suspicion. If a token may be exposed, revoke it in User settings → Personal access tokens and mint a new one. Revocation is immediate.
Future hardening (not built yet): per-token scopes (e.g. read-only, or org-restricted) and configurable expiry would let you hand this server a narrower credential. Today a PAT is all-or-nothing, which is why the guidance above matters.
How org access & errors map
X-Org-Idheader. Project-scoped calls send the resolved org id inX-Org-Id; the org-management routes carry it in the path instead. Either way the backend membership-checks it and returns 403 if the token's user isn't a member.Roles. Reads need any membership. Project writes need editor or owner — a viewer gets a 403. Managing the org itself (rename/delete, members, invitations, billing) is owner-only.
Organisation access policy. An organisation's owners can refuse personal access tokens there (403
org_tokens_disabled) or admit only accounts on their email domains (403org_email_domain_required). The token keeps working in your other organisations; the tool's error says which rule refused it. A read-only token gets 403token_read_onlyon any write.Billing. Designing and the raw JSON export are free on every plan, and a lapsed plan never makes a design read-only — it falls back to Community rules. On a server with billing on, a 402 refuses a paid feature or growth past a plan limit:
plan_required(for example a deliverable on Community) orplan_limit(a rack or editor limit). The tool result gives a plain message naming the plans that would allow it, and whether a Project Pass would, followed by the server'scodeand structured fields as JSON. A server with billing off (every self-hosted install) has no plan limits.Errors are readable. HTTP failures are surfaced as
isErrortool results with a plain message, e.g. "Forbidden (403): not a member of this organisation", "Conflict (409): a project with that name already exists", "Authentication failed (401): …".Upstream text is bounded. The server's message and structured fields are relayed with control and invisible formatting characters removed and their length capped. A response that is not a Railyard JSON error — a proxy's or captive portal's HTML page, say — is summarised by its status and never shown.
Redirects are errors. Requests never follow a redirect, so the token cannot be carried to another address; point
RAILYARD_BASE_URLat the server's finalhttps://address.
Notes & caveats
update_projectis a revision-safe whole-document save. The API's save endpoint is aPUTof the entire project JSON. To make partial edits safe,update_projectdefaults tomerge=true: it fetches the current document and shallow-merges the top-level keys you supply (so{racks:[…]}replaces only the racks). Passmerge=falseto replace the whole document, in which case you must provide a complete, valid project.get_projectreturns arevision; pass it toupdate_projectwhen the edit was derived from that read. The update is refused with 412 if something else saved first. Omitting it still performs a fresh conditional read immediately before saving.Shared catalogues and roles are revision-safe whole-array writes.
set_org_catalogandset_org_rolesreplace their entire arrays. Read the matching resource first, preserve every entry you still need, and pass its returnedrevisionto the set tool. A concurrent change is refused instead of being overwritten.Live collaboration. If a project is open in a live collaboration session in the app, coordinate with the people editing it. Revision checks prevent a stale MCP save from silently overwriting a newer room save, but they cannot decide whose intended change should win.
Export output is truncated. A large text artefact is cut off in the tool reply with an explicit marker (the byte count is always reported in full). A binary deliverable such as the build-pack PDF comes back as base64 only when small; pass
saveTotoexport_deliverableto write the complete files to a local directory (existing files are never overwritten).Deliverables need a plan on hosted Railyard. The build pack, schedules, labels, power report and the NetBox, Nautobot and Design Builder bundles need the Pro, Team or Partner plan, or a Project Pass on that estate, when the server has billing on. They are generated from the stored project, so an inline, unsaved
projectcan only be exported asjsonthere — save it first. Older servers without the deliverables route still export the DCIM formats through/api/export.export_projectnever silently drops data. A placement whosedeviceTypeRefmatches no catalogue entry comes back underunresolvedrather than vanishing; passplaceholders: trueto emit it as a placeholder device type so the row still imports.Schema. Documents use
schemaVersion: "1"and the backend rejects unknown top-level fields. The current shape includescontainers,containerTypes,deviceRoles,reviewDismissals, cabling and power data. Use theprojectobject returned byget_projectrather than the surrounding revision envelope as the update body.
For operators (publishing)
Releases are built and published by GitHub Actions, never from a laptop. Publishing remains an
explicit operator action: bump the version in package.json, manifest.json, the server's
version in src/index.ts and the pinned railyard-mcp@<version> in this README and
INSTALL.md (a test keeps them aligned), merge, then publish a GitHub release tagged
v<version>. .github/workflows/release.yml then:
re-runs the tests, coverage, type-check and audit on the tagged source, and checks the tag matches
package.jsonandmanifest.json;npm — publishes with
npm publish --provenance --access publicthrough npm trusted publishing (GitHub OIDC, so no npm token is stored anywhere), from thenpmenvironment;Claude Desktop bundle — packs
railyard-mcp-<version>.mcpbfrommanifest.jsonwith runtime dependencies only, writesSHA256SUMS, signs a build-provenance attestation for it, and attaches both files to the release.
One-time setup on npmjs.com: under the railyard-mcp package's Settings → Trusted
publishing, add GitHub Actions with repository railyard-sh/railyard-mcp, workflow
release.yml and environment npm; then set the package to require two-factor authentication
and disallow tokens. Add required reviewers to the npm environment in the repository settings
to gate each publish.
package.json ships only dist/, manifest.json, README.md, INSTALL.md and LICENSE (see its
files), and the prepare/prepublishOnly scripts rebuild dist/ so it is always fresh
on publish. The public package name is the unscoped railyard-mcp.
Verifying a release
# npm: registry signatures and the provenance attestation of the installed version
mkdir railyard-mcp-check && cd railyard-mcp-check
npm init -y >/dev/null && npm install --ignore-scripts railyard-mcp@0.2.1
npm audit signatures
# .mcpb: the checksum and the signed build attestation, from the release's assets
sha256sum -c SHA256SUMS # macOS: shasum -a 256 -c SHA256SUMS
gh attestation verify railyard-mcp-0.2.1.mcpb --repo railyard-sh/railyard-mcpVersions published before the release workflow (0.2.1 and earlier) carry npm's registry signature but no provenance attestation, and their bundles have no attestation.
Development
npm run build # compile once
npm run dev # compile on change (tsc --watch)
npm test # build and run API-contract tests
npm run test:coverage # enforce at least 80% line coverage (Node 22+)
npm run typecheck # type-check without emittingSource layout:
src/client.ts— the typed HTTP client. All auth (Authorization: Bearer), org resolution (X-Org-Id), revision preconditions (ETag/If-Match), and error mapping live here, in one place.src/auth.ts— hosted/self-hosted URL validation plus the explicit cross-platform browser helper used byrailyard-mcp auth.src/project.ts— the canonical empty project factory used bycreate_project.src/index.ts— the MCP server: tool definitions (zod schemas + annotations) and stdio wiring.
Available Tools
31 toolsaccept_inviteAccept an invitationA
Accept an invitation addressed to the token user's email, joining that organisation at the invited role. Returns the joined org. Refused (403) if the invitation was addressed to someone else, and (402) if the organisation's plan has lapsed or been downgraded since the invitation was sent.
Inputs: inviteId (required).
billing_manage_urlGet a Stripe billing linkA
Mint a Stripe hosted-page URL for the organisation's OWNER to open in a browser: action=subscribe opens Checkout to start a subscription, action=manage opens the Customer Portal to change the card, switch plan or cancel. This only creates a link — it does not charge anything or change the subscription; the owner completes or abandons that on Stripe's page. Requires the OWNER role and Stripe configured on the server (503 otherwise). action=subscribe conflicts (409) when a live subscription already exists — manage it instead; action=manage needs an existing billing account (400 before the first subscription).
Inputs: action (required), org.
check_project_nameCheck project name availabilityARead-only
Check whether a project name is free in an organisation (and see the URL slug it would get). Optionally exclude a project id so a rename that keeps its own name reads as available.
Inputs: name (required), org, exclude.
create_orgCreate organisationA
Create a new shared organisation; the token's user becomes its owner. Returns the org's id and slug, which other tools accept as org. Note that adding members to it needs a Team or Enterprise plan (see get_billing).
Inputs: name (required).
create_projectCreate projectA
Create a new, empty project with the given name and save it to the organisation. Returns the new project's id and URL slug. Fails with a conflict if the name is already taken in the org. (Write: requires the token user to have an editor/owner role in the org.)
Inputs: name (required), org.
delete_orgDelete organisation (DESTRUCTIVE)ADestructiveIdempotent
Permanently delete a shared organisation AND every project inside it. DESTRUCTIVE and NOT reversible. Requires the OWNER role. A personal organisation cannot be deleted (400). Move out any project you want to keep first (see move_project).
Inputs: org (required).
delete_projectDelete project (DESTRUCTIVE)ADestructiveIdempotent
Permanently delete a project and its entire estate. DESTRUCTIVE and NOT reversible — there is no undo. Any live collaboration sessions on it are dropped. (Write: editor/owner role required.)
Inputs: id (required), org.
export_projectExport projectARead-only
Export a project into a downstream format (see list_export_formats for the ids — e.g. nautobot-csv, netbox-csv, designbuilder-yaml, json) and return the generated files' content, plus any unresolved placements and warnings. A placement whose deviceTypeRef matches no catalogue entry is REPORTED, never silently dropped: set placeholders=true to emit it as a placeholder device type so the row still imports. Targets that need prerequisite objects return the whole ordered bundle, not just the headline table. Large files are truncated in the reply — the app's download gives the complete artefact.
Inputs: format (required), org, ref, project, +2 more.
get_billingGet billing stateARead-only
Read an organisation's plan and billing state: plan (individual/team/enterprise), status (trialing/active/past_due/canceled), seat count, trial end, current period end, whether it is currently entitled to edit (a lapsed org is read-only and its writes return 402), whether the caller may manage billing, and whether this server has Stripe self-serve configured at all. Any member may read it.
Inputs: org.
get_org_catalogGet shared device-type libraryARead-only
Read an organisation's shared device-type library — the catalogue of device types available to every project in the org, separate from each project's own catalogue. Returns the complete catalogue plus its revision; pass that revision to set_org_catalog. Any member may read it.
Inputs: org.
get_org_rolesGet shared device rolesARead-only
Read an organisation's shared device-role vocabulary. Returns the complete roles array and its revision; pass that revision to set_org_roles. Project-level deviceRoles are layered on top.
Inputs: org.
get_projectGet projectARead-only
Fetch a project's full JSON document and revision ETag, addressed by id or URL slug. The project contains the complete estate model, including the flexible container hierarchy, racks and placements, device roles, review dismissals, cabling and power. Pass revision to update_project when applying work derived from this response so concurrent changes are not overwritten.
Inputs: ref (required), org.
invite_memberInvite someone to an organisationAIdempotent
Invite an email address to join an organisation at a role (default editor), and email them the invitation where the server has mail configured. Requires the OWNER role, and a current Team or Enterprise plan — a personal or Individual-plan org cannot add members (402), and neither can one whose plan has lapsed. Re-inviting a still-pending email updates its role. An address that is already a member is refused (409).
Inputs: email (required), org, role.
list_export_formatsList export formatsARead-only
List the export targets this Railyard build supports — each format's id (what export_project takes), a one-line description, and the file extension it produces.
Inputs: no named parameters.
list_invitesList pending invitationsARead-only
List an organisation's pending invitations (email, role, when sent). Requires the OWNER role, since the list holds the addresses of people who are not members yet.
Inputs: org.
list_membersList organisation membersARead-only
List an organisation's members — user id, email, name, role (viewer/editor/owner) and when they joined. Any member may read the roster. The user id is what set_member_role and remove_member take.
Inputs: org.
list_my_invitesList my pending invitationsARead-only
List invitations addressed to the token user's own email — organisations they have been invited to but not yet joined. Pass an id from here to accept_invite.
Inputs: no named parameters.
list_orgsList organisationsARead-only
List the organisations the token's user belongs to, with each org's id, slug, role (viewer/editor/owner), plan and billing status. The id or slug is what you pass as the org argument to other tools.
Inputs: no named parameters.
list_projectsList projectsARead-only
List projects in an organisation (id, name, slug, last-updated time). Omit org to use the default organisation.
Inputs: org.
move_projectMove project to another organisationA
Move a project out of its current organisation into another one the token user can write to. toOrg is the destination org (id, slug or name); org is the source org it currently lives in (defaults as usual). Requires an editor/owner role in BOTH organisations. If the name is already taken in the destination the move conflicts (409) — pass name to rename the project as part of the move; check_project_name against toOrg tells you in advance.
Inputs: id (required), toOrg (required), org, name.
remove_memberRemove a member (DESTRUCTIVE)ADestructiveIdempotent
Remove a member from an organisation, revoking their access to all of its projects and dropping their live sessions at once. Requires the OWNER role. Removing the last owner is refused (409). The subscription's seat count is reconciled afterwards.
Inputs: userId (required), org.
rename_orgRename organisationA
Change an organisation's display name. Requires the OWNER role in it.
Inputs: org (required), name (required).
rename_projectRename projectA
Rename a project. Updates both its display name and its URL slug together, after checking the new name is unique in the org. Returns the new slug. (Write: editor/owner role required.)
Inputs: id (required), name (required), org.
revoke_inviteRevoke a pending invitationAIdempotent
Withdraw a pending invitation so it can no longer be accepted. Requires the OWNER role. Has no effect on someone who has already joined — use remove_member for that.
Inputs: inviteId (required), org.
server_infoServer infoARead-only
Report the Railyard server's health and capabilities: version, the project schemaVersion it understands, whether persistence (a database) and authentication are enabled, and whether Stripe billing is configured. Useful to confirm the server is reachable and which features exist.
Inputs: no named parameters.
set_member_roleChange a member's roleAIdempotent
Change an existing member's role in an organisation. Requires the OWNER role. Demoting the last remaining owner is refused (409) — promote someone else first. The member's live collaboration sessions are dropped so they reconnect with the new role.
Inputs: role (required), userId (required), org.
set_org_catalogReplace shared device-type library (DESTRUCTIVE)ADestructiveIdempotent
Replace an organisation's shared device-type library with the given array. DESTRUCTIVE: this is a whole-library write, not a merge — types absent from catalogue are removed. Read the current library with get_org_catalog and send it back with your additions plus its revision. The write fails rather than overwriting a concurrent change. Requires an editor/owner role.
Inputs: revision (required), catalogue (required), org.
set_org_rolesReplace shared device roles (DESTRUCTIVE)ADestructiveIdempotent
Replace an organisation's shared device-role vocabulary. This is a whole-array write: read it with get_org_roles, preserve the entries you still need, and pass back that response's revision. The write fails rather than overwriting a concurrent change. Requires an editor/owner role.
Inputs: roles (required), revision (required), org.
update_projectUpdate / overwrite project (DESTRUCTIVE)ADestructive
Save changes to an existing project via a full-document PUT. DESTRUCTIVE: the saved document REPLACES the stored one. By default (merge=true) the given project fields are shallow-merged over the current document (only the top-level keys you supply are replaced, e.g. pass just {racks:[…]} to swap the racks) — recommended. With merge=false, project is taken as the entire new document and must be a complete, valid project. The project's real id is always preserved. Concurrent browser or MCP saves are guarded by revision checks: a stale update is refused instead of overwriting newer work.
Inputs: id (required), project (required), org, merge, +1 more.
validate_projectValidate projectARead-only
Run the current Railyard server-side soft validation over a project: rack placement/site findings and power-model problems. Structurally invalid documents, including malformed hierarchy or cabling references, are rejected before this report. Each raw problem carries a severity, stable code, message and relevant rack or placement ids. Nothing is saved; the interactive app may group or dismiss eligible review findings separately.
Inputs: org, ref, project.
whoamiWho am IARead-only
Return the Railyard user the configured personal access token authenticates as (id, email, name). Use this to confirm the token works and which account it belongs to.
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 31 tools
Each tool maps to a distinct resource and action—org, project, member, invite, billing, catalog/roles, validation/export—so there is little risk of selecting the wrong one. The only close pair, list_invites and list_my_invites, is clearly differentiated by scope (org-owned vs token user's).
The vast majority follow a consistent verb_noun snake_case pattern (list_projects, set_member_role, accept_invite). Exceptions like whoami, server_info, and especially billing_manage_url break the pattern without causing real confusion.
At 31 tools, this sits well beyond the 25+ threshold for a single server and will require agents to manage a large option set. The broad API scope explains the size, but it is still heavier than ideal for an MCP tool surface.
The server covers full lifecycle CRUD for organisations and projects, plus membership/invitation management, org-level catalog/roles, billing, validation, and export. I don't see obvious dead ends: writes have matching reads, destructive operations have guards, and the billing flow links out to Stripe where needed.
Maintenance
Related MCP Connectors
Share one project context across ChatGPT, Claude, Telegram and any MCP client.
Model Context Protocol server for todo.vu task management and time tracking.
Project memory, documentation and controlled secret access for AI coding agents.
Model Context Protocol server for Studex tools, notifications, and profile integrations
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceFacilitates project management with the Linear API via the Model Context Protocol, allowing users to manage initiatives, projects, issues, and their relationships through features like creation, viewing, updating, and prioritization.418 npm6MIT
- AlicenseBqualityDmaintenanceEnables interaction with Linear's API for managing issues, teams, and projects programmatically through the Model Context Protocol.783 npm4MIT
- AlicenseNot gradedqualityDmaintenanceProvides access to Linear's issue tracking system through a standardized Model Context Protocol interface, allowing users to create, update, search, and manage issues, projects, and comments via natural language.578 npm1MIT
- AlicenseNot gradedqualityFmaintenanceEnables interaction with the Edgee API for managing organizations, projects, domains, components, users, invitations, and API tokens through the Model Context Protocol.15 npmApache 2.0