Skip to main content
Alpha: Enginy MCP is in active development. Expect tool coverage, interface behavior, and operational guidance to evolve.

​
What Enginy MCP is Alpha

Enginy MCP lets an AI assistant connect to your Enginy workspace and use Enginy actions safely through a shared tool layer. In plain English, that means the assistant can help with work like:
  • looking up contacts, companies, campaigns, and inbox threads
  • summarizing what is happening in Enginy
  • preparing updates or changes for a human to review
The hosted resource server is: 
https://openapi.enginy.ai/mcp
Behind the scenes, the server follows the same general remote-MCP model used by products like Linear and Notion:
  • Streamable HTTP transport instead of local stdio
  • OAuth 2.0 Authorization Code + PKCE for public clients
  • Short-lived bearer access tokens plus rotating refresh tokens
  • Workspace policy controls that cap what any user can grant
Enginy currently supports remote Streamable HTTP only. If your client only supports stdio, use a remote bridge such as mcp-remote or another client-side proxy that can speak remote MCP on your behalf.

​
How Enginy builds MCP tools Alpha

Enginy does not maintain a separate hand-written MCP catalog. Instead, the MCP server reads Enginy’s public API document and turns supported API operations into MCP tools. Today that means:
  • GET, POST, PATCH, PUT, and DELETE OpenAPI operations can become tools
  • the tool name comes from the OpenAPI summary when possible, with a method-and-path fallback if needed
  • path params are exposed as pathParams
  • query string params are exposed as query
  • JSON request bodies are exposed as body
  • the tool inherits its required scopes from the **Required scope:** metadata in the OpenAPI description
Enginy also exposes one native MCP tool:
  • mcp_whoami, which returns the authenticated user, client, and granted scopes

​
Advanced: what a tool call looks like Alpha

For OpenAPI-derived tools, the input shape is consistent: 
{
  "pathParams": {
    "id": "123"
  },
  "query": {
    "limit": 25,
    "includeArchived": false
  },
  "body": {
    "name": "Example"
  }
}
Only include the sections that the tool actually needs. A read-only list endpoint might use only query, while a mutation might need pathParams and body. Most users do not need to think about this. It is mainly useful if your team is debugging a client or building its own MCP experience.

​
Connection model Alpha

1

An admin turns MCP on for the workspace

In Enginy, an admin enables MCP, decides which callback URLs are allowed, and chooses the maximum permissions users are allowed to approve.
2

A user connects from an AI interface

Claude Code or another compatible interface is pointed at https://openapi.enginy.ai/mcp and starts the browser sign-in flow.
3

Enginy checks that the request is allowed

Enginy verifies the callback URL, the requested permissions, and any optional client-ID restrictions before allowing the connection.
4

The AI interface finishes sign-in

The interface exchanges the authorization result for access tokens. Those tokens are short-lived and are refreshed automatically when supported.
5

Every tool call is checked again

Each time the assistant tries to use Enginy, the server checks that the connection is still valid and that the requested action is allowed under the current workspace policy.

​
Admin controls vs user controls Alpha

Control surfaceWho owns itWhat it changes
MCP enabled/disabledWorkspace adminWhether the workspace can use Enginy MCP at all
Allowed redirect URIsWorkspace adminWhich OAuth callback URLs can complete authorization
Allowed OAuth client IDsWorkspace adminWhich client IDs are trusted if you choose to pin them
Policy scopesWorkspace adminThe maximum permission ceiling any user can grant
OAuth approvalIndividual userThe exact subset of scopes approved for that user connection
Connection revocationAdmin or system policy changesWhether a specific user connection or token chain remains valid

​
Important things to know Alpha

  • Write permissions also include the matching read permissions. For example, CONTACTS_WRITE also includes contact reads.
  • If a client asks for no explicit permissions, Enginy grants the full current workspace policy ceiling.
  • If an admin tightens the policy later, an existing connection may stop working until the user connects again with the new limits.
  • Enginy is a hosted remote MCP server, not a local stdio server.
  • Refresh-token reuse is treated as a security problem and revokes the connection.

Connect Claude Code (Alpha)

Start here if you want the clearest setup path for a non-technical team.

Clients & interfaces (Alpha)

See the setup options for Claude, Codex, Cursor, VS Code, ChatGPT, and other remote clients.

Client support matrix (Alpha)

Compare which interfaces are the safest first choice and which ones need more technical setup.

Supported tools (Alpha)

See the kinds of work Enginy MCP can help with today.

Example prompts (Alpha)

Use example prompts that work well for research, summaries, and human-reviewed changes.

Scope reference (Alpha)

Review the permission groups that decide what the assistant can read or change.

Security and troubleshooting (Alpha)

Learn the recommended security posture and how to debug the most common failures.

FAQ / known limitations (Alpha)

Get quick answers about current alpha constraints, unsupported assumptions, and when something is a bug.