Integrate your software catalog into every workflow: Introducing the Port MCP Server

June 3, 2025

Ready to start?

Integrate your software catalog into every workflow: Introducing the Port MCP Server
Listen to article
00:00 00:00

Just a few weeks ago we released our new AI-native capabilities in Port, enabling platform teams to create AI agents to help their users easily get answers about systems, service health, ownership, and more. Today, we are thrilled to announce we’re further extending and simplifying the ways users interact with Port and with the AI agents in Port using their favorite tools with the release of Port’s MCP (Model Context Protocol) server. 

As the first AI-native developer portal, we’re excited about the potential to change how software teams efficiently deliver software: 

  • Developers can search for information, ownership, and documentation, of course. But they can also take action, setting up a dev environment or promoting a service to a new environment, as their permissions allow
  • Security teams who want to define and display scorecards for security standards in Port now can simply ask for it in their favorite tool 
  • Governance teams — who may not log into Port, GitHub, or IDEs much at all — can still explore the status of projects using natural language from tools like Claude

And every user and their interaction with Port is governed by role-based access controls, whether they’re directly in Port or via AI agents or MCP. Port is our customers’ rich and constantly updated source of truth for software development, standards, and delivery and our new AI-native capabilities make it simpler for every stakeholder to collaborate.

A revolution in developer interactions

Port's MCP server enables tools that developers and other users rely on daily — tools like Cursor, VS Code, and Claude — to communicate directly with Port using natural language. Instead of manually tracking down details across many tools, or even logging into Port and searching through the software catalog, now a developer who is immersed in their IDE can directly ask, "Are there any new Jira tickets open for this service?" or “Who should I talk to if I want to integrate my service with the Payments service?” without breaking stride. 

In the past, LLMs and agents were confined to consuming static data or navigating complex API integrations. The advent of the MCP server liberates developers from these constraints. 

Now, their tools can access new, live data sources on the fly, allowing them to search their software catalog and create entities, scorecards, and more through natural language interactions. Platform teams stand to benefit, too, as they unlock enhanced context and automation for their users without the burden of pre-configuring and defining every possible question and answer scenario.

Harnessing the power of Port's rich software catalog

This is a particularly powerful capability for organizations with complex engineering organizations and many ongoing engineering projects. Port automatically captures and  maintains the current state of all software, services, teams, and standards. The AI agents platform teams are creating in Port empower their users to interact with Port to explore this rich data and act on it. 

With our MCP server, it’s now possible to create these interactions in third-party tools like Claude, Cursor, and VS Code to interact directly with Port, opening the door to real-time, contextual interactions driven by natural language.

Through intuitive natural language queries, users can navigate Port's blueprints and entities, discover ownership details, identify reusable components, and tap into expertise — all without needing an intricate understanding of Port's inner workings. The days of painstakingly tracking down information are numbered, as the Port catalog becomes a potent force multiplier in the quest for efficiency and innovation.

And it’s not just for developers. Wiz recently published a great example where a security team uses Claude to hone in on a service with a high-risk internet exposure issue. 

In the Wiz video, they end by creating a report for someone else. What if, instead, they can see if the issue is already being worked on by the software team that owns the app? Here’s an example of exactly that, using Port and Claude:

That handles one incident, but you likely want to create a scorecard in Port so your software teams know the standards expected of them and their current status in real time. Instead of poring through Port’s docs, you can now open Claude and tell it "Create a security scorecard for services based on the number of open vulnerabilities" and and you will receive a comprehensive response that guides you seamlessly through the process.

Pioneering open standards and beyond

In case you haven’t seen all the MCP hype (or have elected to ignore it till now), MCP is an open and emerging standard first developed by Anthropic that connects AI assistants to various tools and services, instead of requiring custom integrations for each one. The end user doesn’t have to do much more than connect their tools (MCP clients) to other tools that provide an MCP server — then, the new system essentially extends what the AI assistants in those tools can do and the information they can harness.

While agents using Port’s MCP server cannot yet execute actions, we’re filled with ideas. But we want to hear from you as we continue to explore these emerging standards and decide how they can help you and your teams. You can contribute directly to our roadmap by adding your own ideas or voting for others you like. 

Getting started with Port's MCP server

We invite you to embark upon this journey with us. To harness the power of Port's MCP server, you need:

Once you connect your tool to the Port MCP server, you can begin querying your catalog and building within Port through natural language, revolutionizing your development workflow.

This innovative technology is still in its early phases, and we are committed to refining the MCP server, enhancing its capabilities, and ensuring its seamless integration into your development environment. Your feedback is invaluable as we continue to extend the MCP server with additional action tools and enhancements. 

Together, we will shape the future of developer tools, making them more intuitive, powerful, and accessible than ever before. Welcome to the dawn of a new era in software development.

{{survey-buttons}}

Get your survey template today

By clicking this button, you agree to our Terms of Use and Privacy Policy
{{survey}}

Download your survey template today

By clicking this button, you agree to our Terms of Use and Privacy Policy
{{roadmap}}

Free Roadmap planner for Platform Engineering teams

  • Set Clear Goals for Your Portal

  • Define Features and Milestones

  • Stay Aligned and Keep Moving Forward

{{rfp}}

Free RFP template for Internal Developer Portal

Creating an RFP for an internal developer portal doesn’t have to be complex. Our template gives you a streamlined path to start strong and ensure you’re covering all the key details.

{{ai_jq}}

Leverage AI to generate optimized JQ commands

test them in real-time, and refine your approach instantly. This powerful tool lets you experiment, troubleshoot, and fine-tune your queries—taking your development workflow to the next level.

{{cta_1}}

Check out Port's pre-populated demo and see what it's all about.

Check live demo

No email required

{{cta_survey}}

Check out the 2025 State of Internal Developer Portals report

See the full report

No email required

{{cta_2}}

Contact sales for a technical product walkthrough

Let’s start
{{cta_3}}

Open a free Port account. No credit card required

Let’s start
{{cta_4}}

Watch Port live coding videos - setting up an internal developer portal & platform

{{cta_5}}

Check out Port's pre-populated demo and see what it's all about.

(no email required)

Let’s start
{{cta_6}}

Contact sales for a technical walkthrough of Port

Let’s start
{{cta_7}}

Open a free Port account. No credit card required

Let’s start
{{cta_8}}

Watch Port live coding videos - setting up an internal developer portal & platform

{{cta-demo}}
{{reading-box-backstage-vs-port}}
{{cta-backstage-docs-button}}

Example JSON block

{
  "foo": "bar"
}

Order Domain

{
  "properties": {},
  "relations": {},
  "title": "Orders",
  "identifier": "Orders"
}

Cart System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Cart",
  "title": "Cart"
}

Products System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Products",
  "title": "Products"
}

Cart Resource

{
  "properties": {
    "type": "postgress"
  },
  "relations": {},
  "icon": "GPU",
  "title": "Cart SQL database",
  "identifier": "cart-sql-sb"
}

Cart API

{
 "identifier": "CartAPI",
 "title": "Cart API",
 "blueprint": "API",
 "properties": {
   "type": "Open API"
 },
 "relations": {
   "provider": "CartService"
 },
 "icon": "Link"
}

Core Kafka Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Kafka Library",
  "identifier": "CoreKafkaLibrary"
}

Core Payment Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Payment Library",
  "identifier": "CorePaymentLibrary"
}

Cart Service JSON

{
 "identifier": "CartService",
 "title": "Cart Service",
 "blueprint": "Component",
 "properties": {
   "type": "service"
 },
 "relations": {
   "system": "Cart",
   "resources": [
     "cart-sql-sb"
   ],
   "consumesApi": [],
   "components": [
     "CorePaymentLibrary",
     "CoreKafkaLibrary"
   ]
 },
 "icon": "Cloud"
}

Products Service JSON

{
  "identifier": "ProductsService",
  "title": "Products Service",
  "blueprint": "Component",
  "properties": {
    "type": "service"
  },
  "relations": {
    "system": "Products",
    "consumesApi": [
      "CartAPI"
    ],
    "components": []
  }
}

Component Blueprint

{
 "identifier": "Component",
 "title": "Component",
 "icon": "Cloud",
 "schema": {
   "properties": {
     "type": {
       "enum": [
         "service",
         "library"
       ],
       "icon": "Docs",
       "type": "string",
       "enumColors": {
         "service": "blue",
         "library": "green"
       }
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "system": {
     "target": "System",
     "required": false,
     "many": false
   },
   "resources": {
     "target": "Resource",
     "required": false,
     "many": true
   },
   "consumesApi": {
     "target": "API",
     "required": false,
     "many": true
   },
   "components": {
     "target": "Component",
     "required": false,
     "many": true
   },
   "providesApi": {
     "target": "API",
     "required": false,
     "many": false
   }
 }
}

Resource Blueprint

{
 “identifier”: “Resource”,
 “title”: “Resource”,
 “icon”: “DevopsTool”,
 “schema”: {
   “properties”: {
     “type”: {
       “enum”: [
         “postgress”,
         “kafka-topic”,
         “rabbit-queue”,
         “s3-bucket”
       ],
       “icon”: “Docs”,
       “type”: “string”
     }
   },
   “required”: []
 },
 “mirrorProperties”: {},
 “formulaProperties”: {},
 “calculationProperties”: {},
 “relations”: {}
}

API Blueprint

{
 "identifier": "API",
 "title": "API",
 "icon": "Link",
 "schema": {
   "properties": {
     "type": {
       "type": "string",
       "enum": [
         "Open API",
         "grpc"
       ]
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "provider": {
     "target": "Component",
     "required": true,
     "many": false
   }
 }
}

Domain Blueprint

{
 "identifier": "Domain",
 "title": "Domain",
 "icon": "Server",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {}
}

System Blueprint

{
 "identifier": "System",
 "title": "System",
 "icon": "DevopsTool",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "domain": {
     "target": "Domain",
     "required": true,
     "many": false
   }
 }
}
{{tabel-1}}

Microservices SDLC

  • Scaffold a new microservice

  • Deploy (canary or blue-green)

  • Feature flagging

  • Revert

  • Lock deployments

  • Add Secret

  • Force merge pull request (skip tests on crises)

  • Add environment variable to service

  • Add IaC to the service

  • Upgrade package version

Development environments

  • Spin up a developer environment for 5 days

  • ETL mock data to environment

  • Invite developer to the environment

  • Extend TTL by 3 days

Cloud resources

  • Provision a cloud resource

  • Modify a cloud resource

  • Get permissions to access cloud resource

SRE actions

  • Update pod count

  • Update auto-scaling group

  • Execute incident response runbook automation

Data Engineering

  • Add / Remove / Update Column to table

  • Run Airflow DAG

  • Duplicate table

Backoffice

  • Change customer configuration

  • Update customer software version

  • Upgrade - Downgrade plan tier

  • Create - Delete customer

Machine learning actions

  • Train model

  • Pre-process dataset

  • Deploy

  • A/B testing traffic route

  • Revert

  • Spin up remote Jupyter notebook

{{tabel-2}}

Engineering tools

  • Observability

  • Tasks management

  • CI/CD

  • On-Call management

  • Troubleshooting tools

  • DevSecOps

  • Runbooks

Infrastructure

  • Cloud Resources

  • K8S

  • Containers & Serverless

  • IaC

  • Databases

  • Environments

  • Regions

Software and more

  • Microservices

  • Docker Images

  • Docs

  • APIs

  • 3rd parties

  • Runbooks

  • Cron jobs

Starting with Port is simple, fast and free.

Let’s start