Port MCP Server

Um servidor MCP para Port.io que possibilita automações avançadas e interações em linguagem natural para desenvolvedores e aplicações de IA.

GitHub
16
Experimente este MCPPatrocinado

Documentação

⚠️ Este Repositório Não é Mais Mantido

[!WARNING] Este repositório foi descontinuado e não é mais mantido ou suportado ativamente. Nenhuma atualização adicional, correção de bugs ou patches de segurança serão fornecidos.

Migre para o Port's Remote MCP Server

Recomendamos fortemente que todos os usuários migrem para o Port's Remote MCP Server, que é a solução ativamente mantida e suportada.

O Remote MCP Server oferece paridade total de recursos e melhorias contínuas apoiadas pela equipe da Port.

Port MCP Server

O servidor MCP da Port IO é um servidor Model Context Protocol (MCP), permitindo automações avançadas e interações em linguagem natural para desenvolvedores e aplicações de IA.

O Que Você Pode Fazer Com o Port MCP

Encontre Informações Rapidamente

  • Obtenha detalhes de entidades - "Quem é o proprietário do serviço X?"
  • Verifique o status de plantão - "Quem está de plantão agora?"
  • Obtenha insights do catálogo - "Quantos serviços temos em produção?"

Analise Scorecards

  • Identifique pontos fracos - "Quais serviços estão falhando no nível ouro e por quê?"
  • Obtenha status de conformidade - "Mostre-me todos os serviços que não atendem aos nossos requisitos de segurança"
  • Melhore a qualidade - "O que preciso corrigir para alcançar o próximo nível do scorecard?"

Crie Recursos

  • Construa scorecards - "Crie um novo scorecard chamado 'Postura de Segurança' com níveis Básico, Prata e Ouro"
  • Defina regras - "Adicione uma regra que exija que os serviços tenham um proprietário de equipe para alcançar o nível Prata"
  • Configure portões de qualidade - "Crie uma regra que verifique se os serviços têm documentação adequada"

Gerencie Permissões e RBAC

  • Busque permissões de ações - "Quais são as configurações de permissão atuais para esta ação?"
  • Atualize políticas de ações - "Configure fluxos de aprovação para a ação de implantação"
  • Configure permissões dinâmicas - "Configure controle de acesso baseado em equipe para esta ação"

Estamos continuamente expandindo as capacidades do Port MCP. Tem uma sugestão? Adoraríamos ouvir seu feedback em nosso roadmap!

Instalação

Pré-requisitos

Antes de começar, você precisará de:

  1. Criar uma Conta Port (se você não tiver uma):

    • Visite Port.io
    • Cadastre-se para uma conta

  2. Obter Credenciais Port:

    • Navegue até seu painel Port
    • Vá para Configurações > Credenciais
    • Salve tanto o Client ID quanto o Client Secret

  3. Requisitos de Instalação:

    • Ou Docker instalado no seu sistema
    • OU gerenciador de pacotes uvx instalado

[!NOTE] Você também precisará fornecer sua região Port, que é EU ou US. Se não for fornecida, o padrão é EU.

Métodos de instalação

O Port MCP Server pode ser instalado usando dois métodos:

Instalação via Pacote (uvx)

Use nosso pacote oficial Port MCP server com uvx para instalação e gerenciamento fáceis.

Guia de Instalação Passo a Passo

  1. Crie um Ambiente Virtual Python (Recomendado)

    python -m venv venv

  2. Ative o Ambiente Virtual

    # On Linux/macOS:
source venv/bin/activate

# On Windows:
venv\Scripts\activate

  3. Instale o Gerenciador de Pacotes UV

    # Using Homebrew (macOS/Linux):
brew install uv

# Or using pip:
pip install uv

  4. Verifique a Instalação do UV

    which uv

  5. Defina as Variáveis de Ambiente Necessárias

    export PORT_CLIENT_ID="your_port_client_id"
export PORT_CLIENT_SECRET="your_port_client_secret"
export PORT_REGION="EU"  # or "US"

  6. Defina o Caminho do Python (se estiver usando ambiente virtual)

    export PYTHONPATH="/path/to/your/venv/bin/python"

  7. Execute o MCP Server

    uvx mcp-server-port --client-id your_port_client_id --client-secret your_port_client_secret --region EU --log-level DEBUG

  8. Verifique se o Servidor Está em Execução Você deve começar a ver logs do servidor. Você também pode verificar o arquivo de log:

    cat /tmp/port-mcp.log

Instalação via Docker

Use nossa imagem Docker oficial:

docker pull ghcr.io/port-labs/port-mcp-server:latest

Veja abaixo instruções detalhadas para cada cliente MCP.

Configurações adicionais

Você pode passar estes argumentos adicionais para configuração mais avançada:

Parâmetro de ConfiguraçãoFlag UVXVariável de Ambiente DockerDescriçãoValor Padrão
Nível de Loglog-levelPORT_LOG_LEVELControla o nível de saída de logERROR
Validação de APIapi-validation-enabledPORT_API_VALIDATION_ENABLEDControla se o esquema da API deve ser validado e falhar se não for válidoFalse

Uso com Claude Desktop

  1. Vá para Configurações > Desenvolvedor e clique em "Editar config".
  2. Edite o arquivo claude_desktop_config.json e adicione a configuração abaixo com base no método de instalação.
  3. Salve o arquivo e reinicie o Claude.
  4. Em um novo chat, verifique a seção Ferramentas e você verá as ferramentas disponíveis do Port.

Claude MCP Tools

Docker

[!TIP] Considere usar o caminho completo para o Docker (por exemplo, /usr/local/bin/docker) em vez de apenas docker. Você pode encontrar este caminho executando which docker no seu terminal. Usar o caminho completo ajuda a evitar problemas de resolução de PATH e garante comportamento consistente em diferentes ambientes de shell.

{
  "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>"
              }
    }
  }
}

uvx

[!NOTE] Se você quiser executar o comando a partir de um ambiente virtual Python, adicione uma variável PYTHONPATH ao objeto env com seu caminho, por exemplo, /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"
          }
      }
  }
}

Uso com Cursor

  1. Vá para Cursor > Configurações > Configurações do Cursor.
  2. Clique na aba MCP e em "Adicionar novo servidor MCP global".
  3. Edite o arquivo mcp.json e adicione a configuração abaixo com base no método de instalação.
  4. Salve o arquivo e retorne às Configurações do Cursor.
  5. Você verá o novo servidor Port e suas ferramentas disponíveis.

Cursor MCP Screenshot

Docker

[!TIP] Considere usar o caminho completo para o Docker (por exemplo, /usr/local/bin/docker) em vez de apenas docker. Você pode encontrar este caminho executando which docker no seu terminal. Usar o caminho completo ajuda a evitar problemas de resolução de PATH e garante comportamento consistente em diferentes ambientes de shell.

{
  "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>"
              }
    }
  }
}

uvx

[!NOTE] Se você quiser executar o comando a partir de um ambiente virtual Python, adicione uma variável PYTHONPATH ao objeto env com seu caminho, por exemplo, /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"
          }
      }
  }
}

Uso com VS Code

[!TIP] O VS Code pode descobrir automaticamente servidores MCP já instalados no Cursor e no Claude.

[!NOTE] Para instalação rápida, use os botões de instalação com um clique e selecione onde adicionar a configuração MCP. Certifique-se de substituir os placeholders pelas suas credenciais Port.

Instalação rápida Docker Instalação rápida uvx

Para instalação manual, siga estes passos:

  1. Vá para a Paleta de Comandos pressionando Cmd + Shift + P / Ctrl + Shift + P.
  2. Digite Preferences: Open User Settings (JSON) e pressione enter.
  3. Edite o arquivo settings.json e adicione a configuração abaixo sob mcp>servers.
  4. Use o Copilot no modo Agente, certifique-se de que o servidor está em execução e veja suas ferramentas Port disponíveis.

VS Code MCP Tools

Docker

[!TIP] Considere usar o caminho completo para o Docker (por exemplo, /usr/local/bin/docker) em vez de apenas docker. Você pode encontrar este caminho executando which docker no seu terminal. Usar o caminho completo ajuda a evitar problemas de resolução de PATH e garante comportamento consistente em diferentes ambientes de shell.

  "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>"
      }
  }

uvx

[!NOTE] Se você quiser executar o comando a partir de um ambiente virtual Python, adicione uma variável PYTHONPATH ao objeto env com seu caminho, por exemplo, /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>"
      }
  }

Uso com Neovim (mcphub.nvim)

Para usar o Port MCP Server no Neovim, use o plugin mcphub.nvim com uma das extensões LLM suportadas, como Avante ou CodeCompanion.

Uma vez instalado, adicione a configuração do servidor MCP do Port:

  1. Acesse a configuração dos servidores com o comando :MCPHub e navegue até a aba Config, ou abra o arquivo de configuração dos servidores diretamente, geralmente localizado em ~/.config/mcphub/servers.json.
  2. Adicione a configuração do Port MCP Server sob a seção mcpServers (veja abaixo).
  3. Salve o arquivo de configuração.
  4. Certifique-se de ter as variáveis de ambiente PORT_CLIENT_ID e PORT_CLIENT_SECRET definidas no seu ambiente Neovim.
  5. Reinicie os servidores abrindo a visualização MCPHub com :MCPHub e acionando o comando de reinicialização com R.
  6. Você deve ver o servidor em execução e acessível a partir da visualização MCPHub. Para verificar, use a ferramenta @mcp na sua extensão LLM. Por exemplo, prompt: @mcp list my blueprints.

Consulte a documentação do mcphub.nvim para mais detalhes sobre como usá-lo.

Exemplo de Configuração Docker para mcphub.nvim

[!NOTE] Certifique-se de ter as variáveis de ambiente PORT_CLIENT_ID e PORT_CLIENT_SECRET definidas com suas credenciais Port.

{
    "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": ""
            }
        }
    }
}

Exemplo de Configuração uvx para mcphub.nvim

[!NOTE] Certifique-se de ter as variáveis de ambiente PORT_CLIENT_ID e PORT_CLIENT_SECRET definidas com suas credenciais Port.

{
    "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"
            }
        }
    }
}

Ferramentas Disponíveis

Ferramentas de Blueprint

  1. get_blueprints

    • Recupere uma lista de todos os blueprints do Port
    • Entradas opcionais:
      • detailed (booleano, padrão: false): Retorna detalhes completos do esquema para cada blueprint
    • Retorna: Representação em texto formatado de todos os blueprints disponíveis

  2. get_blueprint

    • Recupere informações sobre um blueprint específico pelo seu identificador
    • Entradas obrigatórias:
      • blueprint_identifier (string): O identificador único do blueprint a ser recuperado
    • Entradas opcionais:
      • detailed (booleano, padrão: true): Retorna detalhes completos do esquema

  3. create_blueprint

    • Crie um novo blueprint no Port
    • Entradas obrigatórias:
      • Vários campos incluindo identificador, título, propriedades, etc.
    • Retorna: O objeto blueprint criado

  4. update_blueprint

    • Atualize um blueprint existente
    • Entradas obrigatórias:
      • identifier (string): O identificador único do blueprint a ser atualizado
      • Vários campos para atualizar
    • Retorna: O objeto blueprint atualizado

  5. delete_blueprint

    • Exclua um blueprint do Port
    • Entradas obrigatórias:
      • blueprint_identifier (string): O identificador único do blueprint a ser excluído
    • Retorna: Status de sucesso

Ferramentas de Entidade

  1. get_entities

    • Recupere todas as entidades para um determinado blueprint
    • Entradas obrigatórias:
      • blueprint_identifier (string): O identificador do blueprint para obter entidades
    • Entradas opcionais:
      • detailed (booleano, padrão: false): Retorna detalhes completos da entidade incluindo propriedades

  2. get_entity

    • Recupere informações sobre uma entidade específica
    • Entradas obrigatórias:
      • blueprint_identifier (string): O identificador do blueprint ao qual a entidade pertence
      • entity_identifier (string): O identificador único da entidade a ser recuperada
    • Entradas opcionais:
      • detailed (booleano, padrão: true): Retorna detalhes completos da entidade

  3. create_entity

    • Crie uma nova entidade para um blueprint específico
    • Entradas obrigatórias:
      • blueprint_identifier (string): O identificador do blueprint para criar a entidade
      • entity (objeto): Os dados da entidade seguindo o esquema do blueprint

  4. update_entity

    • Atualize uma entidade existente
    • Entradas obrigatórias:
      • blueprint_identifier (string): O identificador do blueprint ao qual a entidade pertence
      • entity_identifier (string): O identificador único da entidade a ser atualizada
      • entity (objeto): Os dados atualizados da entidade

  5. delete_entity

    • Exclua uma entidade
    • Entradas obrigatórias:
      • blueprint_identifier (string): O identificador do blueprint ao qual a entidade pertence
      • entity_identifier (string): O identificador único da entidade a ser excluída
    • Entradas opcionais:
      • delete_dependents (booleano, padrão: false): Se true, também exclui todas as dependências

Ferramentas de Scorecard

  1. get_scorecards

    • Recupere todos os scorecards do Port
    • Entradas opcionais:
      • detailed (booleano, padrão: false): Retorna detalhes completos do scorecard

  2. get_scorecard

    • Recuperar informações sobre um scorecard específico pelo seu identificador
    • Entradas obrigatórias:
      • scorecard_id (string): O identificador único do scorecard a ser recuperado
      • blueprint_id (string, opcional): O identificador do blueprint ao qual o scorecard pertence

  3. create_scorecard

    • Criar um novo scorecard para um blueprint específico
    • Entradas obrigatórias:
      • blueprint_id (string): O identificador do blueprint para o qual criar o scorecard
      • identifier (string): O identificador único do novo scorecard
      • title (string): O título de exibição do scorecard
      • levels (lista): Lista de níveis do scorecard
    • Entradas opcionais:
      • rules (lista): Lista de regras do scorecard
      • description (string): Descrição do scorecard

  4. update_scorecard

    • Atualizar um scorecard existente
    • Entradas obrigatórias:
      • blueprint_identifier (string): O identificador do blueprint ao qual o scorecard pertence
      • scorecard_identifier (string): O identificador único do scorecard a ser atualizado
      • Vários campos para atualizar (título, níveis, regras, etc.)
    • Retorna: O objeto scorecard atualizado

  5. delete_scorecard

    • Excluir um scorecard do Port
    • Entradas obrigatórias:
      • blueprint_identifier (string): O identificador do blueprint ao qual o scorecard pertence
      • scorecard_identifier (string): O identificador único do scorecard a ser excluído
    • Retorna: Status de sucesso

Ferramenta de Agentes de IA

  1. invoke_ai_agent
    • Invocar um agente de IA do Port com um prompt específico
    • Entradas obrigatórias:
      • prompt (string): O prompt a ser enviado ao agente de IA
    • Retorna: Status da invocação e mensagem do agente de IA

Desenvolvimento Local

Para desenvolver e testar novas funcionalidades localmente antes de publicar uma nova versão, você pode configurar seu cliente MCP (por exemplo, Cursor) para usar seu repositório clonado local.

Pré-requisitos

  1. Clone o repositório: Se você ainda não o fez, clone o repositório port-mcp-server para sua máquina local.
  2. Configure o ambiente:
    • Navegue até o diretório raiz do repositório clonado.
    • Execute make install. Este comando deve configurar um ambiente virtual (venv) e instalar todas as dependências necessárias.
    • Certifique-se de que o ambiente virtual foi criado (geralmente em um diretório .venv dentro do repositório).

Exemplo de Configuração

Abaixo está um exemplo de como você pode configurar seu servidor de desenvolvimento local. Você precisará substituir os caminhos de exemplo pelos caminhos reais do seu sistema.

Importante:

  • O command deve apontar para o executável Python dentro do ambiente virtual do seu repositório local.
  • O PYTHONPATH no objeto env deve apontar para o diretório raiz do seu repositório clonado.
{
  "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
      }
    }
  }
}

Após configurar isso, seu cliente MCP usará sua versão local do servidor, permitindo que você teste alterações do seu branch atual.

Feedback e Roadmap

Estamos melhorando continuamente o Port MCP e adoraríamos ouvir sua opinião! Compartilhe seus comentários e solicitações de recursos em nossa página de roadmap.

Solução de Problemas

Se você encontrar erros de autenticação, verifique se:

  1. Suas credenciais do Port estão configuradas corretamente nos argumentos.
  2. Você tem as permissões necessárias.
  3. As credenciais foram copiadas corretamente para sua configuração.

Licença

Este servidor MCP é licenciado sob a Licença MIT. Isso significa que você é livre para usar, modificar e distribuir o software, sujeito aos termos e condições da Licença MIT.