⛔ DEPRECATED — JFrog MCP Server (Experimental)

> [!CAUTION]

> # 🚨 THIS PROJECT IS DEPRECATED AND NO LONGER MAINTAINED 🚨

>

> Do not use this repository for new or existing integrations.

>

> This experimental MCP server has been superseded by the official JFrog MCP Server, which is built, maintained, and supported by JFrog. The official server is secure, remotely hosted, production-ready, and receives ongoing updates, bug fixes, and security patches.

>

> ### 👉 Use the official JFrog MCP Server instead:

> ### **https://jfrog.com/help/r/jfrog-integrations-documentation/jfrog-mcp-server**

>

> No further features, fixes, or security updates will be delivered to this repository. Any content below is preserved for historical reference only.

Model Context Protocol (MCP) Server for the JFrog Platform API, enabling repository management, build tracking, release lifecycle management, and more.

https://github.com/user-attachments/assets/aca3af2b-f294-41c8-8727-799a019a55b5

⚠️ Deprecation Notice

This project is deprecated and is no longer maintained by JFrog.

It was originally created as an experimental project to demonstrate JFrog's capabilities with MCP and was never officially supported or verified by JFrog. It will not receive further updates, bug fixes, or security patches.

JFrog now provides an official, secure, and remotely hosted MCP server for seamless integration with the JFrog Platform. The managed MCP server is maintained by JFrog and is the recommended and only supported option going forward, offering enhanced security, reliability, and support.

Please migrate to the official server:

👉 **JFrog MCP Server — Official Documentation**

Features

• Repository Management: Create and manage local, remote, and virtual repositories
• Build Tracking: List and retrieve build information
• Runtime Monitoring: View runtime clusters and running container images
• Mission Control: View associated JFrog Platform instances
• Artifact Search: Execute powerful AQL queries to search for artifacts and builds
• Catalog and Curation: Access package information, versions, vulnerabilities, and check curation status
• Xray: Access scan artifacts summary, group by severity per artifact

Tools

Repository Management

1. `check_jfrog_availability`

2. `create_local_repository`

3. `create_remote_repository`

4. `create_virtual_repository`

5. `list_repositories`

6. `set_folder_property`

7. `execute_aql_query`

Build Management

8. `list_jfrog_builds`

9. `get_specific_build`

Runtime Management

10. `list_jfrog_runtime_clusters`

11. `get_jfrog_runtime_specific_cluster`

12. `list_jfrog_running_images`

Access Control

13. `list_jfrog_environments`

14. `list_jfrog_projects`

15. `get_specific_project`

16. `create_project`

Catalog and Curation

17. `jfrog_get_package_info`

18. `jfrog_get_package_versions`

19. `jfrog_get_package_version_vulnerabilities`

20. `jfrog_get_vulnerability_info`

21. `jfrog_get_package_curation_status`

Xray

22. `jfrog_get_artifacts_summary`

Setup

Installing via Smithery

To install mcp-jfrog for Claude Desktop automatically via Smithery:

npx -y @smithery/cli install @jfrog/mcp-jfrog --client claude

Prerequisites

• Node.js v18 or higher
• Docker (if using Docker deployment, See Docker Deployment )
• A valid JFrog platform instance with appropriate permissions
• Access to create and manage access tokens in your JFrog platform instance

Environment Variables

• `JFROG_ACCESS_TOKEN`: Your JFrog access token (required)
• `JFROG_URL`: Base URL for your JFrog platform (required)
• `TRANSPORT`: Transport mode to use, set to 'sse' to enable SSE transport (default: stdio)
• `PORT`: Port number to use for SSE transport (default: 8080)
• `CORS_ORIGIN`: CORS origin allowed for SSE connections (default: '*')
• `LOG_LEVEL`: Logging level: DEBUG, INFO, WARN, ERROR (default: INFO)
• `MAX_RECONNECT_ATTEMPTS`: Maximum number of reconnection attempts for SSE server (default: 5)
• `RECONNECT_DELAY_MS`: Base delay in milliseconds between reconnection attempts (default: 2000)

JFrog Token (`JFROG_ACCESS_TOKEN`)

To use this MCP server, you need to create a JFrog Access Token or use an identity token with appropriate permissions:

For information on how to create a JFrog Token, please refer to the JFrog official documentations:

• Identity Tokens

• Access Tokens

JFrog URL (`JFROG_URL`)

Your JFrog platform instance URL (e.g. https://acme.jfrog.io)

SSE Transport Features

The SSE transport mode includes the following features:

• Connection Management: Each SSE connection is tracked with a unique ID, allowing clients to maintain state across reconnection attempts.
• Structured Logging: Detailed logs with timestamps, severity levels, and relevant contextual information.
• Connection Resilience: Automatic reconnection attempts with exponential backoff if the server fails to start.
• Health Endpoint: A `/health` endpoint that returns server status information.
• Connection Tracking: Real-time tracking of active connections with periodic statistics logging.
• Performance Metrics: Execution time tracking for tool operations and HTTP requests.

When using SSE mode:

1. Clients should connect to the `/sse` endpoint, optionally providing a `connectionId` query parameter for session tracking.

2. Client requests should be sent to the `/messages` endpoint with the same `connectionId` as a query parameter.

3. The server will respond with server-sent events through the established SSE connection.

Example client connection with connection ID:

GET /sse?connectionId=client123

Example client request:

POST /messages?connectionId=client123
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "method": "listTools",
  "id": 1
}

How to build

Clone the repo to your local machine using `git clone` and `cd` into the project directory:

git clone git@github.com:jfrog/mcp-jfrog.git

cd mcp-jfrog

Build as a Docker image:

docker build -t mcp/jfrog -f Dockerfile .

Build as an npm module:

npm i && npm run build

Usage

Use with Cursor

Add the following to your `~/.cursor/mcp.json`:

npm

{
  "mcpServers": {
    "MCP-JFrog": { 
      "command": "npm",
      "args": [
        "exec",
        "-y",
        "github:jfrog/mcp-jfrog"
      ],
      "env": {
        "JFROG_ACCESS_TOKEN": "ACCESS_TOKEN",
        "JFROG_URL": "https://"
      }
    }
  },
  "mcp-local-dev":{
      "command": "node",
      "args": [
        "//mcp-jfrog/dist/index.js"
      ],
      "env": {
        "JFROG_ACCESS_TOKEN": ">",
        "JFROG_URL": ""
      }
    }
}

Docker

{
  "mcpServers": { 
    "jfrog": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "JFROG_ACCESS_TOKEN",
        "-e",
        "JFROG_URL",
        "mcp/jfrog"
      ],
      "env": {
        "JFROG_ACCESS_TOKEN": "",
        "JFROG_URL": "https://your-instance.jfrog.io"
      },
      "serverUrl": "http://localhost:8080/sse"
    }
  }
}

SSE Transport Mode

To use the JFrog MCP Server with SSE transport mode (useful for web interfaces like Cursor's webview):

{
  "mcpServers": { 
    "jfrog-sse": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-p",
        "8080:8080",
        "-e",
        "TRANSPORT=sse",
        "-e",
        "PORT=8080",
        "-e",
        "CORS_ORIGIN=*",
        "-e",
        "LOG_LEVEL=INFO",
        "-e",
        "MAX_RECONNECT_ATTEMPTS=5",
        "-e",
        "RECONNECT_DELAY_MS=2000",
        "-e",
        "JFROG_ACCESS_TOKEN",
        "-e",
        "JFROG_URL",
        "mcp/jfrog"
      ],
      "env": {
        "JFROG_ACCESS_TOKEN": "",
        "JFROG_URL": "https://your-instance.jfrog.io",
        "serverUrl": "http://localhost:8080/sse"
      }
    }
  }
}

Note: For SSE mode, you need to add the `serverUrl` parameter pointing to your SSE endpoint, and expose the port used by the server (-p 8080:8080).

Use with Claude Desktop

Add the following to your `claude_desktop_config.json`:

Docker

{
  "mcpServers": { 
    "jfrog": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "JFROG_ACCESS_TOKEN",
        "-e",
        "JFROG_URL",
        "mcp/jfrog"
      ],
      "env": {
        "JFROG_ACCESS_TOKEN": "",
        "JFROG_URL": "https://your-instance.jfrog.io" // Your JFrog platform URL
      },
      "serverUrl": "http://localhost:8080/sse"
    }
  }
}

npm

{
"mcpServers": {
    "MCP-JFrog": { 
      "command": "npm",
      "args": [
        "exec",
        "-y",
        "github:jfrog/mcp-jfrog"
      ],
      "env": {
        "JFROG_ACCESS_TOKEN": "ACCESS_TOKEN",
        "JFROG_URL": "https://"
      }
    }
  }
}

SSE Transport Mode

For Claude Desktop with SSE transport:

{
  "mcpServers": { 
    "jfrog-sse": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-p",
        "8080:8080",
        "-e",
        "TRANSPORT=sse",
        "-e",
        "PORT=8080",
        "-e",
        "CORS_ORIGIN=*",
        "-e",
        "LOG_LEVEL=INFO",
        "-e",
        "MAX_RECONNECT_ATTEMPTS=5",
        "-e",
        "RECONNECT_DELAY_MS=2000",
        "-e",
        "JFROG_ACCESS_TOKEN",
        "-e",
        "JFROG_URL",
        "mcp/jfrog"
      ],
      "env": {
        "JFROG_ACCESS_TOKEN": "",
        "JFROG_URL": "https://your-instance.jfrog.io",
        "serverUrl": "http://localhost:8080/sse"
      }
    }
  }
}

## License

This MCP server is licensed under the Apache License 2.0. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the Apache License 2.0. For more details, please see the LICENSE.md file in the project repository.