by port-labs
Provides a Model Context Protocol (MCP) server that enables advanced automations and natural language interactions for developers and AI applications, exposing tools for blueprints, entities, scorecards, and permission management.
Port MCP Server delivers an MCP endpoint that lets AI assistants and developers query and manipulate Port data using natural language. It exposes a rich set of tools for retrieving and managing blueprints, entities, scorecards, and RBAC policies, turning data into actionable intelligence.
uvx
.get_blueprints
, create_entity
, invoke_ai_agent
, etc., from your LLM or script.uvx
package, or local development via virtualenv.Q: Do I need to run the server locally?
A: No. You can use the public Docker image or the uvx
package, which runs the server on your machine.
Q: Which region should I set?
A: Set EU
or US
according to where your Port tenant is hosted; default is EU
.
Q: How do I change the log verbosity?
A: Use the --log-level
flag (or PORT_LOG_LEVEL
env var) with values like DEBUG
, INFO
, ERROR
.
Q: Can I disable API schema validation?
A: Yes, enable --api-validation-enabled
(or PORT_API_VALIDATION_ENABLED=true
).
Q: Is there a quick‑install button for VS Code?
A: Yes, the README provides one‑click URLs that add the Docker or uvx
configuration to VS Code’s MCP settings.
The Port IO MCP server is a Model Context Protocol (MCP) server, enabling advanced automations and natual language interactions for developers and AI applications.
We're continuously expanding Port MCP's capabilities. Have a suggestion? We'd love to hear your feedback on our roadmap!
Before you begin, you'll need:
Create a Port Account (if you don't have one):
Obtain Port Credentials:
Installation Requirements:
[!NOTE] You will also need to provide your Port region, which is either EU or US. If not provided, the default is EU.
Port MCP Server can be installed using two methods:
Use our official Port MCP server package with uvx for easy installation and management.
Create a Python Virtual Environment (Recommended)
python -m venv venv
Activate the Virtual Environment
# On Linux/macOS:
source venv/bin/activate
# On Windows:
venv\Scripts\activate
Install the UV Package Manager
# Using Homebrew (macOS/Linux):
brew install uv
# Or using pip:
pip install uv
Verify UV Installation
which uv
Set Required Environment Variables
export PORT_CLIENT_ID="your_port_client_id"
export PORT_CLIENT_SECRET="your_port_client_secret"
export PORT_REGION="EU" # or "US"
Set Python Path (if using virtual environment)
export PYTHONPATH="/path/to/your/venv/bin/python"
Run the MCP Server
uvx mcp-server-port --client-id your_port_client_id --client-secret your_port_client_secret --region EU --log-level DEBUG
Verify Server is Running You should start seeing logs from the server. You can also check the log file:
cat /tmp/port-mcp.log
Use our official Docker image:
docker pull ghcr.io/port-labs/port-mcp-server:latest
See below for detailed instructions on each MCP client.
You can pass these additional arguments for more advanced configuration:
Configuration Parameter | UVX Flag | Docker Environment Variable | Description | Default Value |
---|---|---|---|---|
Log Level | log-level |
PORT_LOG_LEVEL |
Controls the level of log output | ERROR |
API Validation | api-validation-enabled |
PORT_API_VALIDATION_ENABLED |
Controls if API schema should be validated and fail if it's not valid | False |
claude_desktop_config.json
file and add the below configuration based on the installation method.[!TIP] Consider using the full path to Docker (e.g.,
/usr/local/bin/docker
) instead of justdocker
. You can find this path by runningwhich docker
in your terminal. Using the full path helps avoid PATH resolution issues and ensures consistent behavior across different shell environments.
{
"mcpServers": {
"port": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e",
"PORT_CLIENT_ID",
"-e",
"PORT_CLIENT_SECRET",
"-e",
"PORT_REGION",
"-e",
"PORT_LOG_LEVEL",
"ghcr.io/port-labs/port-mcp-server:latest"
],
"env": {
"PORT_CLIENT_ID": "<PORT_CLIENT_ID>",
"PORT_CLIENT_SECRET": "<PORT_CLIENT_SECRET>",
"PORT_REGION": "<PORT_REGION>",
"PORT_LOG_LEVEL": "<PORT_LOG_LEVEL>"
}
}
}
}
[!NOTE] If you want to run the command from a virtual Python environment, add a
PYTHONPATH
variable to theenv
object with its path, e.g.,/path/to/your/venv/bin/python
.
{
"mcpServers": {
"Port": {
"command": "uvx",
"args": [
"mcp-server-port@0.2.8",
"--client-id",
"<PORT_CLIENT_ID>",
"--client-secret",
"<PORT_CLIENT_SECRET>",
"--region",
"<PORT_REGION>"
],
"env": {
"PORT_CLIENT_ID": "<PORT_CLIENT_ID>",
"PORT_CLIENT_SECRET": "<PORT_CLIENT_SECRET>",
"PORT_REGION": "<PORT_REGION>",
"PYTHONPATH": "/Users/matangrady/.venv-port-mcp/bin/python"
}
}
}
}
mcp.json
file and add the below configuration based on the installation method.[!TIP] Consider using the full path to Docker (e.g.,
/usr/local/bin/docker
) instead of justdocker
. You can find this path by runningwhich docker
in your terminal. Using the full path helps avoid PATH resolution issues and ensures consistent behavior across different shell environments.
{
"mcpServers": {
"port": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e",
"PORT_CLIENT_ID",
"-e",
"PORT_CLIENT_SECRET",
"-e",
"PORT_REGION",
"-e",
"PORT_LOG_LEVEL",
"ghcr.io/port-labs/port-mcp-server:latest"
],
"env": {
"PORT_CLIENT_ID": "<PORT_CLIENT_ID>",
"PORT_CLIENT_SECRET": "<PORT_CLIENT_SECRET>",
"PORT_REGION": "<PORT_REGION>",
"PORT_LOG_LEVEL": "<PORT_LOG_LEVEL>"
}
}
}
}
[!NOTE] If you want to run the command from a virtual Python environment, add a
PYTHONPATH
variable to theenv
object with its path, e.g.,/path/to/your/venv/bin/python
.
{
"mcpServers": {
"Port": {
"command": "uvx",
"args": [
"mcp-server-port@0.2.8",
"--client-id",
"<PORT_CLIENT_ID>",
"--client-secret",
"<PORT_CLIENT_SECRET>",
"--region",
"<PORT_REGION>"
],
"env": {
"PORT_CLIENT_ID": "<PORT_CLIENT_ID>",
"PORT_CLIENT_SECRET": "<PORT_CLIENT_SECRET>",
"PORT_REGION": "<PORT_REGION>",
"PYTHONPATH": "/Users/matangrady/.venv-port-mcp/bin/python"
}
}
}
}
[!TIP] VS Code can automatically discover MCP servers already installed in Cursor and Claude.
[!NOTE] For quick installation, use the one-click install buttons and select where to add the MCP configuration. Make sure to replace the placeholders with your Port credentials.
Docker quick installation uvx quick installation
For manual installation follow these steps:
Cmd + Shift + P
/ Ctrl + Shift + P
.Preferences: Open User Settings (JSON)
and press enter.settings.json
file and add the below configuration under the mcp
>servers
.[!TIP] Consider using the full path to Docker (e.g.,
/usr/local/bin/docker
) instead of justdocker
. You can find this path by runningwhich docker
in your terminal. Using the full path helps avoid PATH resolution issues and ensures consistent behavior across different shell environments.
"Port": {
"type": "stdio",
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e",
"PORT_CLIENT_ID",
"-e",
"PORT_CLIENT_SECRET",
"-e",
"PORT_REGION",
"ghcr.io/port-labs/port-mcp-server:latest"
],
"env": {
"PORT_CLIENT_ID": "<PORT_CLIENT_ID>",
"PORT_CLIENT_SECRET": "<PORT_CLIENT_SECRET>",
"PORT_REGION": "<PORT_REGION>"
}
}
[!NOTE] If you want to run the command from a virtual Python environment, add a
PYTHONPATH
variable to theenv
object with its path, e.g.,/path/to/your/venv/bin/python
.
"Port": {
"type": "stdio",
"command": "uvx",
"args": [
"mcp-server-port@0.2.8",
"--client-id",
"<PORT_CLIENT_ID>",
"--client-secret",
"<PORT_CLIENT_SECRET>",
"--region",
"<PORT_REGION>"
],
"env": {
"PORT_CLIENT_ID": "<PORT_CLIENT_ID>",
"PORT_CLIENT_SECRET": "<PORT_CLIENT_SECRET>",
"PORT_REGION": "<PORT_REGION>"
}
}
mcphub.nvim
)To use Port MCP Server in Neovim, use the plugin mcphub.nvim with one of the supported LLM extensions, such as Avante or CodeCompanion.
Once installed, add Port's MCP server configuration:
:MCPHub
and navigate to the Config tab, or open the servers config file directly, usually located at ~/.config/mcphub/servers.json
.mcpServers
section (see below).PORT_CLIENT_ID
and PORT_CLIENT_SECRET
set in your Neovim environment.:MCPHub
and triggering the restart command with R
.@mcp
tool in your LLM extension. For example, prompt: @mcp list my blueprints
.Check the mcphub.nvim documentation for more details on how to use it.
mcphub.nvim
[!NOTE] Make sure that you have the environment variables
PORT_CLIENT_ID
andPORT_CLIENT_SECRET
set with your Port credentials.
{
"mcpServers": {
"port": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e",
"PORT_CLIENT_ID",
"-e",
"PORT_CLIENT_SECRET",
"-e",
"PORT_REGION",
"ghcr.io/port-labs/port-mcp-server:latest"
],
"env": {
"PORT_REGION": "EU",
"PORT_CLIENT_ID": "",
"PORT_CLIENT_SECRET": ""
}
}
}
}
uvx
Configuration Example for mcphub.nvim
[!NOTE] Make sure that you have the environment variables
PORT_CLIENT_ID
andPORT_CLIENT_SECRET
set with your Port credentials.
{
"mcpServers": {
"port": {
"command": "uvx",
"args": [
"mcp-server-port@0.2.8",
"--client-id",
"PORT_CLIENT_ID",
"--client-secret",
"PORT_CLIENT_SECRET",
"--region",
"PORT_REGION"
],
"env": {
"PORT_CLIENT_ID": "",
"PORT_CLIENT_SECRET": "",
"PORT_REGION": "EU"
}
}
}
}
get_blueprints
detailed
(boolean, default: false): Return complete schema details for each blueprintget_blueprint
blueprint_identifier
(string): The unique identifier of the blueprint to retrievedetailed
(boolean, default: true): Return complete schema detailscreate_blueprint
update_blueprint
identifier
(string): The unique identifier of the blueprint to updatedelete_blueprint
blueprint_identifier
(string): The unique identifier of the blueprint to deleteget_entities
blueprint_identifier
(string): The identifier of the blueprint to get entities fordetailed
(boolean, default: false): Return complete entity details including propertiesget_entity
blueprint_identifier
(string): The identifier of the blueprint the entity belongs toentity_identifier
(string): The unique identifier of the entity to retrievedetailed
(boolean, default: true): Return complete entity detailscreate_entity
blueprint_identifier
(string): The identifier of the blueprint to create the entity forentity
(object): The entity data following the blueprint schemaupdate_entity
blueprint_identifier
(string): The identifier of the blueprint the entity belongs toentity_identifier
(string): The unique identifier of the entity to updateentity
(object): The updated entity datadelete_entity
blueprint_identifier
(string): The identifier of the blueprint the entity belongs toentity_identifier
(string): The unique identifier of the entity to deletedelete_dependents
(boolean, default: false): If true, also deletes all dependenciesget_scorecards
detailed
(boolean, default: false): Return complete scorecard detailsget_scorecard
scorecard_id
(string): The unique identifier of the scorecard to retrieveblueprint_id
(string, optional): The identifier of the blueprint the scorecard belongs tocreate_scorecard
blueprint_id
(string): The identifier of the blueprint to create the scorecard foridentifier
(string): The unique identifier for the new scorecardtitle
(string): The display title of the scorecardlevels
(list): List of levels for the scorecardrules
(list): List of rules for the scorecarddescription
(string): Description for the scorecardupdate_scorecard
blueprint_identifier
(string): The identifier of the blueprint the scorecard belongs toscorecard_identifier
(string): The unique identifier of the scorecard to updatedelete_scorecard
blueprint_identifier
(string): The identifier of the blueprint the scorecard belongs toscorecard_identifier
(string): The unique identifier of the scorecard to deleteinvoke_ai_agent
prompt
(string): The prompt to send to the AI agentFor developing and testing new functionalities locally before publishing a new version, you can configure your MCP client (e.g., Cursor) to use your local cloned repository.
port-mcp-server
repository to your local machine.make install
. This command should set up a virtual environment (venv) and install all necessary dependencies..venv
directory within the repository).Below is an example of how you might configure your local development server. You'll need to replace the placeholder paths with the actual paths on your system.
Important:
command
should point to the Python executable within your local repository's virtual environment.PYTHONPATH
in the env
object should point to the root directory of your cloned repository.{
"mcpServers": {
"port_local": {
"command": "/path/to/your/port-mcp-server/.venv/bin/python", // Replace with the actual path to the venv Python
"args": [
"-m",
"src",
"--client-id",
"<YOUR_PORT_CLIENT_ID>",
"--client-secret",
"<YOUR_PORT_CLIENT_SECRET>",
"--region",
"<YOUR_PORT_REGION>", // e.g., EU or US
"--log-level",
"DEBUG" // Or your preferred log level
],
"env": {
"PORT_CLIENT_ID": "<YOUR_PORT_CLIENT_ID>",
"PORT_CLIENT_SECRET": "<YOUR_PORT_CLIENT_SECRET>",
"PORT_REGION": "<YOUR_PORT_REGION>",
"PORT_LOG_LEVEL": "DEBUG",
"PYTHONPATH": "/path/to/your/port-mcp-server" // Replace with the actual path to your repository
}
}
}
}
After setting this up, your MCP client will use your local version of the server, allowing you to test changes from your current branch.
We're continuously improving Port MCP and would love to hear from you! Please share your feedback and feature requests on our roadmap page.
If you encounter authentication errors, verify that:
This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License.
Please log in to share your review and rating for this MCP.
{ "mcpServers": { "port": { "command": "docker", "args": [ "run", "-i", "--rm", "-e", "PORT_CLIENT_ID", "-e", "PORT_CLIENT_SECRET", "-e", "PORT_REGION", "-e", "PORT_LOG_LEVEL", "ghcr.io/port-labs/port-mcp-server:latest" ], "env": { "PORT_CLIENT_ID": "<PORT_CLIENT_ID>", "PORT_CLIENT_SECRET": "<PORT_CLIENT_SECRET>", "PORT_REGION": "<PORT_REGION>", "PORT_LOG_LEVEL": "<PORT_LOG_LEVEL>" } } } }
Discover more MCP servers with similar functionality and use cases
by danny-avila
Provides a customizable ChatGPT‑like web UI that integrates dozens of AI models, agents, code execution, image generation, web search, speech capabilities, and secure multi‑user authentication, all open‑source and ready for self‑hosting.
by ahujasid
BlenderMCP integrates Blender with Claude AI via the Model Context Protocol (MCP), enabling AI-driven 3D scene creation, modeling, and manipulation. This project allows users to control Blender directly through natural language prompts, streamlining the 3D design workflow.
by pydantic
Enables building production‑grade generative AI applications using Pydantic validation, offering a FastAPI‑like developer experience.
by GLips
Figma-Context-MCP is a Model Context Protocol (MCP) server that provides Figma layout information to AI coding agents. It bridges design and development by enabling AI tools to directly access and interpret Figma design data for more accurate and efficient code generation.
by mcp-use
Easily create and interact with MCP servers using custom agents, supporting any LLM with tool calling and offering multi‑server, sandboxed, and streaming capabilities.
by sonnylazuardi
This project implements a Model Context Protocol (MCP) integration between Cursor AI and Figma, allowing Cursor to communicate with Figma for reading designs and modifying them programmatically.
by lharries
WhatsApp MCP Server is a Model Context Protocol (MCP) server for WhatsApp that allows users to search, read, and send WhatsApp messages (including media) through AI models like Claude. It connects directly to your personal WhatsApp account via the WhatsApp web multi-device API and stores messages locally in a SQLite database.
by idosal
GitMCP is a free, open-source remote Model Context Protocol (MCP) server that transforms any GitHub project into a documentation hub, enabling AI tools to access up-to-date documentation and code directly from the source to eliminate "code hallucinations."
by Klavis-AI
Klavis AI provides open-source Multi-platform Control Protocol (MCP) integrations and a hosted API for AI applications. It simplifies connecting AI to various third-party services by managing secure MCP servers and authentication.