Dev Portal MCP server

Uses: Dev Portal

How it works

A Dev Portal MCP server can work in one of three modes:

Public read-only: If Dev Portal login is disabled, the MCP server exposes public content to any agent, with no authentication step.
Authenticated read-only: If Dev Portal login is enabled and write operations are disabled, a developer must authenticate and authorize the connection before their agent can browse anything, but the agent can only read what’s already published.
Authenticated read-write: If Dev Portal login is enabled and write operations are also enabled, an authenticated agent can additionally create and manage applications and register APIs to them on the developer’s behalf.

An agent can only see what its developer can already see. If RBAC or visibility settings restrict a developer from a page, API, or specification, the MCP server doesn’t expose it to that developer’s agent either. Conversely, if a developer can access a restricted page, the MCP server will also expose it to their agent.

When write operations are enabled, an agent can handle the administrative side of application registration: creating an application, registering APIs to it, and updating it. Agents can never generate application’s credentials themselves. A developer must always create the application’s credentials, then share them with the agent separately if the agent needs to actually call the APIs it discovers.

How much of Dev Portal’s content an agent can reach, and whether it needs to authenticate first, depends on Dev Portal login combined with the Dev Portal AI settings:

Dev Portal login	MCP server	Write operations	What an agent can do
Disabled	Enabled	N/A	Read-only access to Dev Portal’s public pages, APIs, and specifications. No authentication step is required to connect.
Enabled	Enabled	Disabled	The agent must authenticate before it can access anything through the MCP server, including public content. After it’s connected, it can read whatever its developer can see.
Enabled	Enabled	Enabled	The agent must authenticate before it can access anything through the MCP server, including public content. After it’s connected, it can read whatever its developer can see. The agent can also create, read, and update applications and register APIs to them on the developer’s behalf. A human must still generate the application’s credentials.

Available MCP tools

The Dev Portal MCP server exposes the following tools to a connected agent. Which tools an agent can call depends on whether Dev Portal authentication is required and whether write operations are enabled.

Tool	Auth required	Read/write
`list_apis`	No	Read
`get_api_actions`	No	Read
`list_api_documents`	No	Read
`fetch_api_document`	No	Read
`list_api_specs`	No	Read
`fetch_api_spec`	No	Read
`fetch_api_spec_raw`	No	Read
`list_api_version_specs`	No	Read
`fetch_api_version_spec`	No	Read
`fetch_api_version_spec_raw`	No	Read
`list_portal_pages`	No	Read
`portal_api_render_page`	No	Read
`get_portal_form`	No	Read
`list_applications`	Yes	Read
`get_application`	Yes	Read
`create_application`	Yes	Write
`update_application`	Yes	Write
`delete_application`	Yes	Write
`list_application_auth_strategies`	No	Read
`list_application_registrations`	Yes	Read
`get_application_registration`	Yes	Read
`create_application_registration`	Yes	Write
`delete_application_registration`	Yes	Write

Generate an MCP server from Dev Portal

There are two settings you can use to manage AI settings on your Dev Portal:

Only AI settings enabled: When just the AI settings are enabled, this displays an option to open an API in Claude or ChatGPT. Some LLMs will block this if you aren’t using a custom Dev Portal domain because bots aren’t allowed on *.kongportals.com domains.
AI settings and MCP server are enabled: This also displays the option to open the API in Claude or ChatGPT, but also allows developers to connect to the MCP server via URL, VS Code, or Cursor.

You can also optionally enable write operations to let agents manage applications on a developer’s behalf.

In the Konnect sidebar, expand Dev Portal and click Portals.
Click your Dev Portal.
Click the Settings tab.
Click the AI Settings tab.
Enable AI Settings.
Enable MCP Server.
(Optional) Enable MCP server write operations to let agents manage applications on a developer’s behalf.
Click Save changes.

Connect an agent to a Dev Portal MCP server

Once an admin enables the MCP server for Dev Portal, a developer connects their own agent or IDE to it from their Dev Portal account:

Log in to Dev Portal (required whenever Dev Portal login is enabled).
Connect in one of the two following ways:
- Connect directly from an individual API’s dropdown menu. This includes options like Copy MCP server, Connect to Cursor, and Connect to VS Code, scoped to just that API.
- Go to your profile menu and click Account. Click About connections. This shows two ways to connect, depending on your MCP client:
  - OAuth 2.0: This is for clients that support automatic discovery. Add Dev Portal’s MCP server to the client, and it fetches Dev Portal’s OAuth protected resource metadata, discovers the authorization server’s endpoints, and starts an OAuth 2.0 Authorization Code flow with PKCE.
  - MCP Server: This is for clients that need a direct URL, such as Claude Desktop custom connectors. Copy the MCP server URL (for example, https://<your-dev-portal-domain>/api/v3/mcp) and add it to your client as a custom MCP server.
After adding the MCP server, you need to authenticate. This typically opens your browser so you can log in to Dev Portal and complete authorization, but the exact process varies across MCP clients.
If the agent needs to actually call the APIs it discovers, the developer must still separately generate the application’s credentials and share them with the agent.

Once connected, a developer might prompt their agent with something like:

“What APIs are published to this portal?”
“Show me the documentation for the Payments API.”
“Create a real-time weather forecasting application from these APIs”
“Register an application for the Payments API.” (requires write operations to be enabled)

FAQs

What’s the difference between the AI settings toggle and the MCP server toggle for Dev Portal?

These are two separate settings, each configured in Dev Portal:

AI settings only: Developers can open a published API’s documentation directly in a supported LLM client to read it. This doesn’t create an MCP server or give an agent tool access to Dev Portal.
AI settings and MCP server enabled: Developers can additionally connect an agent to Dev Portal’s MCP server, giving the agent tool access to browse and (depending on configuration) act on published content, scoped to what that developer can already see.

Do agents need to log in to use a Dev Portal MCP server?

It depends on whether Dev Portal login is enabled, not just on the MCP server or AI settings toggles:

If Dev Portal login is disabled, the MCP server serves public content without any authentication step.
If Dev Portal login is enabled, the developer must log in and authorize the connection before the agent can access any content through the MCP server, including content that would otherwise be public. There’s no combination of settings that allows an agent to skip this step while Dev Portal login is on.

Authorizing the connection only authenticates the agent’s MCP session, it doesn’t hand over API credentials. If the agent needs to actually call the APIs it discovers (not just read their documentation), the developer must still separately generate the application’s credentials and share them with the agent.