@typeship-ax/mcp
OfficialThis MCP server lets agents discover, inspect, and execute typeship API operations through a compact tool surface.
search_docs: Search the API's 44 generated operations and docs-site guides by query, with paginated results (15 per page).
read_docs: Read an operation's full reference by tool name or a docs-site guide page, including arguments, schemas, authentication, safety, and examples.
execute: Run an API operation by name with arguments keyed by parameter; destructive operations require
confirm: true.Read-only mode: Start with
--read-onlyorTYPESHIP_MCP_READ_ONLY=1to prevent any write operations.Schema-driven validation: Tool inputs come from the OpenAPI spec; unknown or mistyped arguments are rejected as a single
isErrorresult.Result control: Every tool supports a
fieldsparameter to keep only needed result keys, and results are capped at 64,000 characters (configurable viaTYPESHIP_MCP_MAX_RESULT_CHARS).Structured errors: Errors include a stable
codeandnext_stepsfor actionable recovery.Authentication and tool selection: Uses
TYPESHIP_TOKENfor credentials and supports exposing only a subset of tools via--toolsorTYPESHIP_MCP_TOOLS.
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., "@@typeship-ax/mcpSearch the docs for how to create an invoice and show the required schema."
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.
@typeship-ax/mcp
MCP server for typeship. API reference
Generated from the OpenAPI spec by typeship.
Zero runtime dependencies — built on the platform
fetchin Node 20+Agent-ready MCP — schema-derived tools, argument validation, read-only mode, and bounded results
Build from source
Run these commands in the downloaded or cloned package directory:
npm install
npm run buildRequires Node.js 20+. The package is ESM.
To run the local MCP server, configure your MCP client with node and the absolute path to dist/mcp.js, as shown below. The server communicates over stdio.
Related MCP server: openapi-mcp
Install a published package
Generation does not publish a package. Before using the registry command below, confirm name and version in package.json, publish under a name you control, and verify that release is available on npm.
npm install --global @typeship-ax/mcp@0.21.0MCP client requirements
Connect with your client's default settings. This server supports MCP 2025-11-25 and 2026-07-28 automatically; no protocol environment variables are required. After registering it, run claude mcp list to verify a Claude Code connection.
Connect after publishing
The npm connections below require @typeship-ax/mcp to be published under your package identity. To use downloaded source before publishing, use the local configuration in the next section. Hosted connections require a deployed server.
Authentication: provide TYPESHIP_TOKEN through the MCP client's environment or secret settings. Keep credential values out of URLs and command arguments.
For Cursor, merge a local or remote server entry from this README into mcpServers in .cursor/mcp.json, then enable the server in Cursor’s MCP settings.
Local
Claude Code:
claude mcp add typeship -- npx -y --package @typeship-ax/mcp typeship-mcpCodex:
codex mcp add typeship -- npx -y --package @typeship-ax/mcp typeship-mcp
Local · read-only
Claude Code:
claude mcp add typeship-readonly -- npx -y --package @typeship-ax/mcp typeship-mcp --read-onlyCodex:
codex mcp add typeship-readonly -- npx -y --package @typeship-ax/mcp typeship-mcp --read-only
Hosted
Claude Code:
claude mcp add --transport http typeship https://typeship.dev/mcpCodex:
codex mcp add typeship --url https://typeship.dev/mcp
Hosted · read-only
Claude Code:
claude mcp add --transport http typeship-readonly https://typeship.dev/mcp/readonlyCodex:
codex mcp add typeship-readonly --url https://typeship.dev/mcp/readonly
MCP server
A zero-dependency stdio server exposing a compact discovery surface: search_docs, read_docs, and execute. Read an operation before executing it to get its complete schema, example arguments, and safety classification. After building, add the local server to an MCP client:
{
"mcpServers": {
"typeship": {
"command": "node",
"args": [
"/absolute/path/to/package/dist/mcp.js"
],
"env": {
"TYPESHIP_TOKEN": "replace-with-your-credential"
}
}
}
}Replace the path with the absolute path to this package's built dist/mcp.js.
For Claude Code, you can register the local build from the shell configured above:
claude mcp add --transport stdio typeship -- node /absolute/path/to/package/dist/mcp.js
claude mcp listReplace the credential placeholder using the MCP client's secret storage when it has one. The local server reads TYPESHIP_TOKEN from its environment; credentials never belong in command arguments. If you also generated the CLI, its typeship login command stores credentials the local MCP server can reuse.
Tool input schemas are derived from the OpenAPI spec, so agents see real parameter types and required fields. Arguments are checked before anything reaches the API (unknown or mistyped ones come back as one isError result, nothing is dropped), every tool takes fields to keep only the result keys it needs, and errors carry a stable code and next_steps.
Add --read-only to args (or set TYPESHIP_MCP_READ_ONLY=1) for a server that cannot write, --tools generate,projects (or TYPESHIP_MCP_TOOLS) to expose a subset, and TYPESHIP_MCP_MAX_RESULT_CHARS to change the result size cap (64,000).
MCP Registry
server.json describes the npm executable and any hosted transports. Its dev.typeship/typeship identity matches package.json#mcpName.
Install the official mcp-publisher, publish this npm package first, then validate or publish the listing:
npm run mcp:validate
npm run mcp:publishAvailable Tools
3 toolsexecuteAInspect
Execute an API operation by name. Discover it with search_docs, then read_docs for its full schema, example, and safety classification. Destructive operations require confirm: true.
| Name | Required | Description | Default |
|---|---|---|---|
| confirm | No | Required and must be true for destructive operations. Omit for reads and ordinary writes. | |
| arguments | No | Operation arguments keyed by parameter name | |
| operation | Yes | Operation tool name returned by search_docs |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the critical behavioral rule that destructive operations require confirm:true and points to safety classification in read_docs. With only openWorldHint=false in annotations (which does not describe operation safety or side effects), the description carries the disclosure burden but covers only the destructive-confirmation aspect, not return behavior or general side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences with no redundancy: purpose, workflow, and safety caveat are packed tightly. The most important information is front-loaded, and every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a generic dispatch tool with no output schema, the description directs agents to read_docs for full schema, example, and safety, covering most missing context. It does not describe what the tool returns, but the read_docs pointer compensates for the most critical gaps in a multi-step discovery flow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so all three parameters are already described structurally. The description adds operational context (operation names come from search_docs; confirm applies to destructive operations) but does not elaborate argument shape beyond the schema, which is acceptable given full schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States it executes API operations by name, a clear verb-resource pair. References the search_docs → read_docs → execute flow, which distinguishes it from discovery/reading siblings, though the term 'operation' remains somewhat generic without a concrete example in the description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides an explicit workflow: discover with search_docs, then read_docs for full schema/example/safety classification, then execute. The destructive-operation confirm:true requirement also signals when caution is needed. It does not list explicit conditions for when not to use the tool, but the sequencing is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
read_docsARead-onlyIdempotentInspect
Read an operation's full reference (arguments, schemas, authentication, safety and example) by tool name, or a docs-site guide page.
| Name | Required | Description | Default |
|---|---|---|---|
| page | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already carry the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the description needs to add little here. It adds context about the tool returning reference content including authentication and safety details, which is helpful but describes the payload rather than behavioral traits like rate limits or response format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single efficiently worded sentence that front-loads the verb and resource, then packs the parameter semantics, then closes with the alternative page type. Zero filler and every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter, read-only tool with rich annotations and no output schema, the description is largely sufficient: it covers purpose, the accepted input values, and the nature of the content returned. Minor gaps remain, such as what the return format looks like and how guide pages are addressed, but nothing critical blocks correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate, and it does: 'by tool name, or a docs-site guide page' explains what values the single 'page' parameter accepts. It could go further by specifying expected format or how tool names are distinguished from guide page names, but for a one-parameter tool this is meaningful added semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb (Read) and resource (an operation's full reference or a docs-site guide page), which is clear and concrete. It distinguishes well from the siblings by implication — reading a reference rather than searching docs (search_docs) or executing (execute) — though it never explicitly names those alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage context is implied through the phrase 'by tool name, or a docs-site guide page,' which suggests when direct access is appropriate. However, there is no explicit guidance about when to use this tool instead of search_docs (e.g., when you already know the exact name vs. when you need to discover it), nor any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_docsARead-onlyIdempotentInspect
Search this API's 44 generated operations and, when a docs site is configured, its guides. Start here to find the operation you need.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | Page of reference matches (15 per page), default 1 | |
| query | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish read-only, idempotent, non-destructive behavior, so the description does not need to restate that. It adds useful scope context (closed set of 44 operations, guides only if configured), but it does not disclose result shape, pagination behavior, or what happens when no docs site is configured.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short, front-loaded sentences with no filler. Everything included is relevant, and the key scope ('search this API's operations') appears first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter search tool with read-only annotations, the description is nearly complete: it names the searchable corpus and gives the primary use case. It would be more complete if it mentioned the return format or result behavior, but this is not a critical gap given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema documentation covers only 'page' (50% coverage), and the description does not explicitly describe the 'query' parameter. However, the tool's purpose makes 'query' semantically obvious as the search term, and 'page' is already documented in the schema. The description adds value implicitly but does not compensate for the undocumented query parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('search'), a precise resource ('this API's 44 generated operations and, when configured, its guides'), and explicitly positions the tool as the entry point for finding the right operation. This makes it easy to distinguish from the sibling read_docs (read a known doc) and execute (run an operation).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Start here to find the operation you need' gives an explicit when-to-use signal, especially relative to the siblings. It does not explicitly state when not to use it or name the alternatives, but the positioning is clear enough for an agent to select it as the first step.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v0.19.0- First observed
execute - First observed
read_docs - First observed
search_docs
TDQS
Scored across 3 tools
Each tool has a clearly distinct role: search_docs finds operations, read_docs provides detailed reference material, and execute runs the operation. There is no meaningful overlap or ambiguity between them.
The naming follows a consistent snake_case verb pattern, with search_docs and read_docs using verb_noun. 'execute' is slightly less descriptive than 'execute_operation' but still fits the overall style.
Three tools is well-scoped for this server's purpose: discover, read, and execute API operations. Each tool earns its place and the count feels intentional rather than thin.
The tool surface fully covers the intended workflow: search to find an operation, read to understand it, and execute to run it. No obvious gaps exist for the stated domain.
Maintenance
Related MCP Connectors
Read-only MCP tools for AI agent discovery, structured resources, and NIULAI information.
Pay-per-use tool marketplace for AI agents. Search, price-check, and call APIs via MCP.
Your org's AI agents, tasks, runs, search, and brain files as MCP tools and resources.
Free public MCP for AI agents — 193 tools, 44 workflows. No API key.
Related MCP Servers
- FlicenseAqualityDmaintenanceExposes two MCP tools (discover and execute) that enable agents to query an OpenAPI schema via natural language and execute matched API operations.2-
- FlicenseNot gradedqualityDmaintenanceEnables agents to query real-time OpenAPI documentation of backend services, providing tools to list services, endpoints, and schemas via MCP.-

Hermai MCPofficial
AlicenseAqualityBmaintenanceEnables agent runtimes to look up, classify, and fetch Hermai schemas as MCP tools, including read-only data retrieval via hosted endpoints (with optional API key).536 npmAGPL 3.0- AlicenseAqualityBmaintenanceExposes OpenAPI/Swagger API documentation as MCP tools, enabling AI agents to search, inspect, and call API endpoints through natural language.517 npmMIT