Port MCP Server

Un servidor MCP para Port.io que permite automatizaciones avanzadas e interacciones en lenguaje natural para desarrolladores y aplicaciones de IA.

GitHub
16
Prueba este MCPPatrocinado

Documentación

⚠️ Este Repositorio ya no se Mantiene

[!WARNING] Este repositorio ha sido deprecado y ya no se mantiene ni se soporta activamente. No se proporcionarán más actualizaciones, correcciones de errores ni parches de seguridad.

Migrar al Servidor MCP Remoto de Port

Recomendamos encarecidamente a todos los usuarios migrar al Servidor MCP Remoto de Port, que es la solución mantenida y soportada activamente.

El Servidor MCP Remoto ofrece paridad completa de funciones y mejoras continuas respaldadas por el equipo de Port.

Port MCP Server

El servidor MCP de Port IO es un servidor de Protocolo de Contexto de Modelo (MCP), que permite automatizaciones avanzadas e interacciones en lenguaje natural para desarrolladores y aplicaciones de IA.

Lo que Puedes Hacer con Port MCP

Encuentra Información Rápidamente

  • Obtén detalles de entidades - "¿Quién es el propietario del servicio X?"
  • Consulta el estado de guardia - "¿Quién está de guardia ahora mismo?"
  • Obtén información del catálogo - "¿Cuántos servicios tenemos en producción?"

Analiza Scorecards

  • Identifica puntos débiles - "¿Qué servicios están fallando para el nivel oro y por qué?"
  • Obtén estado de cumplimiento - "Muéstrame todos los servicios que no cumplen nuestros requisitos de seguridad"
  • Mejora la calidad - "¿Qué necesito corregir para alcanzar el siguiente nivel de scorecard?"

Crea Recursos

  • Construye scorecards - "Crea una nueva scorecard llamada 'Postura de Seguridad' con niveles Básico, Plata y Oro"
  • Define reglas - "Agrega una regla que requiera que los servicios tengan un propietario de equipo para alcanzar el nivel Plata"
  • Configura puertas de calidad - "Crea una regla que verifique si los servicios tienen documentación adecuada"

Gestiona Permisos y RBAC

  • Obtén permisos de acciones - "¿Cuáles son las configuraciones de permisos actuales para esta acción?"
  • Actualiza políticas de acciones - "Configura flujos de aprobación para la acción de despliegue"
  • Configura permisos dinámicos - "Configura control de acceso basado en equipos para esta acción"

Estamos expandiendo continuamente las capacidades de Port MCP. ¿Tienes una sugerencia? ¡Nos encantaría escuchar tus comentarios en nuestra hoja de ruta!

Instalación

Requisitos Previos

Antes de comenzar, necesitarás:

  1. Crear una Cuenta de Port (si no tienes una):

    • Visita Port.io
    • Regístrate para obtener una cuenta

  2. Obtener Credenciales de Port:

    • Navega a tu panel de control de Port
    • Ve a Configuración > Credenciales
    • Guarda tanto el ID de Cliente como el Secreto de Cliente

  3. Requisitos de Instalación:

    • Ya sea Docker instalado en tu sistema
    • O el gestor de paquetes uvx instalado

[!NOTE] También necesitarás proporcionar tu región de Port, que es EU o US. Si no se proporciona, el valor predeterminado es EU.

Métodos de Instalación

Port MCP Server se puede instalar usando dos métodos:

Instalación de Paquete (uvx)

Usa nuestro paquete oficial de Port MCP server con uvx para una instalación y gestión fáciles.

Guía de Instalación Paso a Paso

  1. Crea un Entorno Virtual de Python (Recomendado)

    python -m venv venv

  2. Activa el Entorno Virtual

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

# On Windows:
venv\Scripts\activate

  3. Instala el Gestor de Paquetes UV

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

# Or using pip:
pip install uv

  4. Verifica la Instalación de UV

    which uv

  5. Configura las Variables de Entorno Requeridas

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

  6. Configura la Ruta de Python (si usas entorno virtual)

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

  7. Ejecuta el Servidor MCP

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

  8. Verifica que el Servidor esté Ejecutándose Deberías comenzar a ver registros del servidor. También puedes verificar el archivo de registro:

    cat /tmp/port-mcp.log

Instalación con Docker

Usa nuestra imagen oficial de Docker:

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

Consulta a continuación las instrucciones detalladas para cada cliente MCP.

Configuraciones Adicionales

Puedes pasar estos argumentos adicionales para una configuración más avanzada:

Parámetro de ConfiguraciónFlag de UVXVariable de Entorno de DockerDescripciónValor Predeterminado
Nivel de Registrolog-levelPORT_LOG_LEVELControla el nivel de salida de registrosERROR
Validación de APIapi-validation-enabledPORT_API_VALIDATION_ENABLEDControla si el esquema de API debe validarse y fallar si no es válidoFalse

Uso con Claude Desktop

  1. Ve a Configuración > Desarrollador y haz clic en "Editar configuración".
  2. Edita el archivo claude_desktop_config.json y agrega la configuración a continuación según el método de instalación.
  3. Guarda el archivo y reinicia Claude.
  4. En un nuevo chat, revisa la sección de Herramientas y verás las herramientas disponibles de Port.

Claude MCP Tools

Docker

[!TIP] Considera usar la ruta completa a Docker (por ejemplo, /usr/local/bin/docker) en lugar de solo docker. Puedes encontrar esta ruta ejecutando which docker en tu terminal. Usar la ruta completa ayuda a evitar problemas de resolución de PATH y asegura un comportamiento consistente en diferentes entornos 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] Si deseas ejecutar el comando desde un entorno virtual de Python, agrega una variable PYTHONPATH al objeto env con su ruta, por ejemplo, /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 con Cursor

  1. Ve a Cursor > Configuración > Configuración de Cursor.
  2. Haz clic en la pestaña MCP y en "Agregar nuevo servidor MCP global".
  3. Edita el archivo mcp.json y agrega la configuración a continuación según el método de instalación.
  4. Guarda el archivo y regresa a Configuración de Cursor.
  5. Verás el nuevo servidor de Port y sus herramientas disponibles.

Cursor MCP Screenshot

Docker

[!TIP] Considera usar la ruta completa a Docker (por ejemplo, /usr/local/bin/docker) en lugar de solo docker. Puedes encontrar esta ruta ejecutando which docker en tu terminal. Usar la ruta completa ayuda a evitar problemas de resolución de PATH y asegura un comportamiento consistente en diferentes entornos 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] Si deseas ejecutar el comando desde un entorno virtual de Python, agrega una variable PYTHONPATH al objeto env con su ruta, por ejemplo, /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 con VS Code

[!TIP] VS Code puede descubrir automáticamente servidores MCP ya instalados en Cursor y Claude.

[!NOTE] Para una instalación rápida, usa los botones de instalación con un clic y selecciona dónde agregar la configuración MCP. Asegúrate de reemplazar los marcadores de posición con tus credenciales de Port.

Instalación rápida con Docker Instalación rápida con uvx

Para instalación manual, sigue estos pasos:

  1. Ve a la Paleta de Comandos presionando Cmd + Shift + P / Ctrl + Shift + P.
  2. Escribe Preferences: Open User Settings (JSON) y presiona enter.
  3. Edita el archivo settings.json y agrega la configuración a continuación bajo mcp>servers.
  4. Usa Copilot en modo Agente, asegúrate de que el servidor esté ejecutándose y ve sus herramientas disponibles de Port.

VS Code MCP Tools

Docker

[!TIP] Considera usar la ruta completa a Docker (por ejemplo, /usr/local/bin/docker) en lugar de solo docker. Puedes encontrar esta ruta ejecutando which docker en tu terminal. Usar la ruta completa ayuda a evitar problemas de resolución de PATH y asegura un comportamiento consistente en diferentes entornos 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] Si deseas ejecutar el comando desde un entorno virtual de Python, agrega una variable PYTHONPATH al objeto env con su ruta, por ejemplo, /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 con Neovim (mcphub.nvim)

Para usar Port MCP Server en Neovim, usa el plugin mcphub.nvim con una de las extensiones LLM compatibles, como Avante o CodeCompanion.

Una vez instalado, agrega la configuración del servidor MCP de Port:

  1. Accede a la configuración de servidores con el comando :MCPHub y navega a la pestaña Config, o abre el archivo de configuración de servidores directamente, generalmente ubicado en ~/.config/mcphub/servers.json.
  2. Agrega la configuración para Port MCP Server bajo la sección mcpServers (ver a continuación).
  3. Guarda el archivo de configuración.
  4. Asegúrate de tener las variables de entorno PORT_CLIENT_ID y PORT_CLIENT_SECRET configuradas en tu entorno de Neovim.
  5. Reinicia los servidores abriendo la vista de MCPHub con :MCPHub y activando el comando de reinicio con R.
  6. Deberías ver el servidor ejecutándose y accesible desde la vista de MCPHub. Para verificar, usa la herramienta @mcp en tu extensión LLM. Por ejemplo, solicita: @mcp list my blueprints.

Consulta la documentación de mcphub.nvim para más detalles sobre cómo usarlo.

Ejemplo de Configuración de Docker para mcphub.nvim

[!NOTE] Asegúrate de tener las variables de entorno PORT_CLIENT_ID y PORT_CLIENT_SECRET configuradas con tus credenciales de 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": ""
            }
        }
    }
}

Ejemplo de Configuración de uvx para mcphub.nvim

[!NOTE] Asegúrate de tener las variables de entorno PORT_CLIENT_ID y PORT_CLIENT_SECRET configuradas con tus credenciales de 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"
            }
        }
    }
}

Herramientas Disponibles

Herramientas de Blueprint

  1. get_blueprints

    • Recupera una lista de todos los blueprints de Port
    • Entradas opcionales:
      • detailed (booleano, predeterminado: false): Devuelve detalles completos del esquema para cada blueprint
    • Devuelve: Representación de texto formateado de todos los blueprints disponibles

  2. get_blueprint

    • Recupera información sobre un blueprint específico por su identificador
    • Entradas requeridas:
      • blueprint_identifier (cadena): El identificador único del blueprint a recuperar
    • Entradas opcionales:
      • detailed (booleano, predeterminado: true): Devuelve detalles completos del esquema

  3. create_blueprint

    • Crea un nuevo blueprint en Port
    • Entradas requeridas:
      • Varios campos incluyendo identificador, título, propiedades, etc.
    • Devuelve: El objeto blueprint creado

  4. update_blueprint

    • Actualiza un blueprint existente
    • Entradas requeridas:
      • identifier (cadena): El identificador único del blueprint a actualizar
      • Varios campos a actualizar
    • Devuelve: El objeto blueprint actualizado

  5. delete_blueprint

    • Elimina un blueprint de Port
    • Entradas requeridas:
      • blueprint_identifier (cadena): El identificador único del blueprint a eliminar
    • Devuelve: Estado de éxito

Herramientas de Entidad

  1. get_entities

    • Recupera todas las entidades para un blueprint dado
    • Entradas requeridas:
      • blueprint_identifier (cadena): El identificador del blueprint para obtener entidades
    • Entradas opcionales:
      • detailed (booleano, predeterminado: false): Devuelve detalles completos de la entidad incluyendo propiedades

  2. get_entity

    • Recupera información sobre una entidad específica
    • Entradas requeridas:
      • blueprint_identifier (cadena): El identificador del blueprint al que pertenece la entidad
      • entity_identifier (cadena): El identificador único de la entidad a recuperar
    • Entradas opcionales:
      • detailed (booleano, predeterminado: true): Devuelve detalles completos de la entidad

  3. create_entity

    • Crea una nueva entidad para un blueprint específico
    • Entradas requeridas:
      • blueprint_identifier (cadena): El identificador del blueprint para crear la entidad
      • entity (objeto): Los datos de la entidad siguiendo el esquema del blueprint

  4. update_entity

    • Actualiza una entidad existente
    • Entradas requeridas:
      • blueprint_identifier (cadena): El identificador del blueprint al que pertenece la entidad
      • entity_identifier (cadena): El identificador único de la entidad a actualizar
      • entity (objeto): Los datos actualizados de la entidad

  5. delete_entity

    • Elimina una entidad
    • Entradas requeridas:
      • blueprint_identifier (cadena): El identificador del blueprint al que pertenece la entidad
      • entity_identifier (cadena): El identificador único de la entidad a eliminar
    • Entradas opcionales:
      • delete_dependents (booleano, predeterminado: false): Si es true, también elimina todas las dependencias

Herramientas de Scorecard

  1. get_scorecards

    • Recupera todas las scorecards de Port
    • Entradas opcionales:
      • detailed (booleano, predeterminado: false): Devuelve detalles completos de la scorecard

  2. get_scorecard

    • Recupera información sobre un scorecard específico mediante su identificador
    • Entradas requeridas:
      • scorecard_id (string): El identificador único del scorecard a recuperar
      • blueprint_id (string, opcional): El identificador del blueprint al que pertenece el scorecard

  3. create_scorecard

    • Crea un nuevo scorecard para un blueprint específico
    • Entradas requeridas:
      • blueprint_id (string): El identificador del blueprint para el cual crear el scorecard
      • identifier (string): El identificador único para el nuevo scorecard
      • title (string): El título visible del scorecard
      • levels (list): Lista de niveles para el scorecard
    • Entradas opcionales:
      • rules (list): Lista de reglas para el scorecard
      • description (string): Descripción del scorecard

  4. update_scorecard

    • Actualiza un scorecard existente
    • Entradas requeridas:
      • blueprint_identifier (string): El identificador del blueprint al que pertenece el scorecard
      • scorecard_identifier (string): El identificador único del scorecard a actualizar
      • Varios campos para actualizar (título, niveles, reglas, etc.)
    • Devuelve: El objeto del scorecard actualizado

  5. delete_scorecard

    • Elimina un scorecard de Port
    • Entradas requeridas:
      • blueprint_identifier (string): El identificador del blueprint al que pertenece el scorecard
      • scorecard_identifier (string): El identificador único del scorecard a eliminar
    • Devuelve: Estado de éxito

Herramienta de Agentes de IA

  1. invoke_ai_agent
    • Invoca un agente de IA de Port con un prompt específico
    • Entradas requeridas:
      • prompt (string): El prompt a enviar al agente de IA
    • Devuelve: Estado de invocación y mensaje del agente de IA

Desarrollo Local

Para desarrollar y probar nuevas funcionalidades localmente antes de publicar una nueva versión, puedes configurar tu cliente MCP (por ejemplo, Cursor) para que use tu repositorio clonado local.

Requisitos Previos

  1. Clonar el repositorio: Si aún no lo has hecho, clona el repositorio port-mcp-server en tu máquina local.
  2. Configurar el entorno:
    • Navega al directorio raíz del repositorio clonado.
    • Ejecuta make install. Este comando debería configurar un entorno virtual (venv) e instalar todas las dependencias necesarias.
    • Asegúrate de que el entorno virtual esté creado (generalmente en un directorio .venv dentro del repositorio).

Ejemplo de Configuración

A continuación se muestra un ejemplo de cómo podrías configurar tu servidor de desarrollo local. Deberás reemplazar las rutas de marcador de posición con las rutas reales de tu sistema.

Importante:

  • El command debe apuntar al ejecutable de Python dentro del entorno virtual de tu repositorio local.
  • El PYTHONPATH en el objeto env debe apuntar al directorio raíz de tu repositorio 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
      }
    }
  }
}

Después de configurar esto, tu cliente MCP usará tu versión local del servidor, lo que te permitirá probar cambios desde tu rama actual.

Comentarios y Hoja de Ruta

Estamos mejorando continuamente Port MCP y ¡nos encantaría saber de ti! Comparte tus comentarios y solicitudes de funciones en nuestra página de hoja de ruta.

Solución de Problemas

Si encuentras errores de autenticación, verifica que:

  1. Tus credenciales de Port estén configuradas correctamente en los argumentos.
  2. Tengas los permisos necesarios.
  3. Las credenciales estén copiadas correctamente en tu configuración.

Licencia

Este servidor MCP está licenciado bajo la Licencia MIT. Esto significa que eres libre de usar, modificar y distribuir el software, sujeto a los términos y condiciones de la Licencia MIT.