Skip to content
Back to search

mcp-jfrog

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

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/jfrog--mcp-jfrog/badge.svg)](/listings/jfrog--mcp-jfrog)

HTML

<a href="/listings/jfrog--mcp-jfrog"><img src="/api/listings/jfrog--mcp-jfrog/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Installing via Smithery

To install mcp-jfrog for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@jfrog/mcp-jfrog):

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

Prerequisites

- Node.js v18 or higher - Docker (if using Docker deployment, [See Docker Deployment](https://github.com/jfrog/mcp-jfrog/blob/main/README.md#docker) ) - A valid JFrog platform instance with appropriate permissions - Access to create and manage access tokens in your JFrog platform instance

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 558 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # ⛔ DEPRECATED — JFrog MCP Server (Experimental)
  2. > [!CAUTION]
  3. > # 🚨 THIS PROJECT IS DEPRECATED AND NO LONGER MAINTAINED 🚨
  4. >
  5. > **Do not use this repository for new or existing integrations.**
  6. >
  7. > 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.
  8. >
  9. > ### 👉 Use the official JFrog MCP Server instead:
  10. > ### **[https://jfrog.com/help/r/jfrog-integrations-documentation/jfrog-mcp-server](https://jfrog.com/help/r/jfrog-integrations-documentation/jfrog-mcp-server)**
  11. >
  12. > No further features, fixes, or security updates will be delivered to this repository. Any content below is preserved for historical reference only.
  13. ---
  14. [![smithery badge](https://smithery.ai/badge/@jfrog/mcp-jfrog)](https://smithery.ai/server/@jfrog/mcp-jfrog)
  15. Model Context Protocol (MCP) Server for the JFrog Platform API, enabling repository management, build tracking, release lifecycle management, and more.
  16. https://github.com/user-attachments/assets/aca3af2b-f294-41c8-8727-799a019a55b5
  17. ## ⚠️ Deprecation Notice
  18. **This project is deprecated and is no longer maintained by JFrog.**
  19. 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.
  20. 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.
  21. Please migrate to the official server:
  22. 👉 **[JFrog MCP Server — Official Documentation](https://jfrog.com/help/r/jfrog-integrations-documentation/jfrog-mcp-server)**
  23. ## Features
  24. - **Repository Management**: Create and manage local, remote, and virtual repositories
  25. - **Build Tracking**: List and retrieve build information
  26. - **Runtime Monitoring**: View runtime clusters and running container images
  27. - **Mission Control**: View associated JFrog Platform instances
  28. - **Artifact Search**: Execute powerful AQL queries to search for artifacts and builds
  29. - **Catalog and Curation**: Access package information, versions, vulnerabilities, and check curation status
  30. - **Xray**: Access scan artifacts summary, group by severity per artifact
  31. ## Tools
  32. <details>
  33. <summary><strong>Repository Management</strong></summary>
  34. 1. `check_jfrog_availability`
  35. - Check if JFrog platform is ready and functioning
  36. - Returns: Platform readiness status
  37. 2. `create_local_repository`
  38. - Create a new local repository in Artifactory
  39. - Inputs:
  40. - `key` (string): Repository key
  41. - `rclass` (string): Repository class (must be "local")
  42. - `packageType` (string): Package type of the repository
  43. - `description` (optional string): Repository description
  44. - `projectKey` (optional string): Project key to assign the repository to
  45. - `environments` (optional string[]): Environments to assign the repository to
  46. - Returns: Created repository details
  47. 3. `create_remote_repository`
  48. - Create a new remote repository in Artifactory to proxy external package registries
  49. - Inputs:
  50. - `key` (string): Repository key
  51. - `rclass` (string): Repository class (must be "remote")
  52. - `packageType` (string): Package type of the repository
  53. - `url` (string): URL to the remote repository
  54. - `username` (optional string): Remote repository username
  55. - `password` (optional string): Remote repository password
  56. - `description` (optional string): Repository description
  57. - `projectKey` (optional string): Project key to assign the repository to
  58. - `environments` (optional string[]): Environments to assign the repository to
  59. - Many other optional parameters for specific repository configurations
  60. - Returns: Created repository details
  61. 4. `create_virtual_repository`
  62. - Create a new virtual repository in Artifactory that aggregates multiple repositories
  63. - Inputs:
  64. - `key` (string): Repository key
  65. - `rclass` (string): Repository class (must be "virtual")
  66. - `packageType` (string): Package type of the repository
  67. - `repositories` (string[]): List of repository keys to include in the virtual repository
  68. - `description` (optional string): Repository description
  69. - `projectKey` (optional string): Project key to assign the repository to
  70. - `environments` (optional string[]): Environments to assign the repository to
  71. - Other optional parameters for specific repository configurations
  72. - Returns: Created repository details
  73. 5. `list_repositories`
  74. - List all repositories in Artifactory with optional filtering
  75. - Inputs:
  76. - `type` (optional string): Filter repositories by type (local, remote, virtual, federated, distribution)
  77. - `packageType` (optional string): Filter repositories by package type
  78. - `project` (optional string): Filter repositories by project key
  79. - Returns: List of repositories matching the filters
  80. 6. `set_folder_property`
  81. - Set properties on a folder in Artifactory, with optional recursive application
  82. - Inputs:
  83. - `folderPath` (string): Path to the folder where properties should be set
  84. - `properties` (object): Key-value pairs of properties to set
  85. - `recursive` (optional boolean): Whether to apply properties recursively to sub-folders
  86. - Returns: Operation result
  87. 7. `execute_aql_query`
  88. - Execute an Artifactory Query Language (AQL) query to search for artifacts, builds, or other entities in JFrog Artifactory
  89. - Inputs:
  90. - `query` (string): The AQL query to execute. Must follow AQL syntax (e.g., items.find({"repo":"my-repo"}).include("name","path"))
  91. - `domain` (optional string): The primary domain to search in (items, builds, archive.entries, build.promotions, releases)
  92. - `transitive` (optional boolean): Whether to search in remote repositories
  93. - `limit` (optional number): Maximum number of results to return
  94. - `offset` (optional number): Number of results to skip
  95. - `include_fields` (optional string[]): Fields to include in the results
  96. - `sort_by` (optional string): Field to sort results by
  97. - `sort_order` (optional string): Sort order (asc or desc)
  98. - Returns: Search results with metadata
  99. </details>
  100. <details>
  101. <summary><strong>Build Management</strong></summary>
  102. 8. `list_jfrog_builds`
  103. - Return a list of all builds in the JFrog platform
  104. - Returns: List of builds
  105. 9. `get_specific_build`
  106. - Get details for a specific build by name
  107. - Inputs:
  108. - `buildName` (string): Name of the build to retrieve
  109. - `project` (optional string): Project key to scope the build search
  110. - Returns: Build details
  111. </details>
  112. <details>
  113. <summary><strong>Runtime Management</strong></summary>
  114. 10. `list_jfrog_runtime_clusters`
  115. - Return a list of all runtime clusters in the JFrog platform
  116. - Inputs:
  117. - `limit` (optional integer): The maximum number of clusters to return
  118. - `next_key` (optional string): The next key to use for pagination
  119. - Returns: List of runtime clusters
  120. 11. `get_jfrog_runtime_specific_cluster`
  121. - Return a runtime cluster by ID
  122. - Inputs:
  123. - `clusterId` (integer): The ID of the cluster to retrieve
  124. - Returns: Cluster details
  125. 12. `list_jfrog_running_images`
  126. - List all running container images across runtime clusters with their security and operational status
  127. - Inputs:
  128. - `filters` (optional string): Filters to apply
  129. - `num_of_rows` (optional integer): Number of rows to return
  130. - `page_num` (optional integer): Page number
  131. - `statistics` (optional boolean): Whether to include statistics
  132. - `timePeriod` (optional string): Time period to query
  133. - Returns: List of running images
  134. </details>
  135. <details>
  136. <summary><strong>Access Control</strong></summary>
  137. 13. `list_jfrog_environments`
  138. - Get a list of all environments types in the JFrog platform with their details
  139. - Inputs:
  140. - Returns: List of environments
  141. 14. `list_jfrog_projects`
  142. - Get a list of all projects in the JFrog platform with their details
  143. - Inputs:
  144. - Returns: List of projects
  145. 15. `get_specific_project`
  146. - Get detailed information about a specific project in the JFrog platform
  147. - Inputs:
  148. - `project_key` (string): The unique key of the project to retrieve
  149. - Returns: Project details
  150. 16. `create_project`
  151. - Create a new project in the JFrog platform
  152. - Inputs:
  153. - `project_key` (string): Unique identifier for the project
  154. - `display_name` (string): Display name of the project
  155. - `description` (string): Description of the project
  156. - `admin_privileges` (object): Administrative privileges for the project
  157. - `storage_quota_bytes` (number): Storage quota in bytes (-1 for unlimited)
  158. - Returns: Created project details
  159. </details>
  160. <details>
  161. <summary><strong>Catalog and Curation</strong></summary>
  162. 17. `jfrog_get_package_info`
  163. - Get publicly available information about a software package
  164. - Inputs:
  165. - `type` (string): The type of package (pypi, npm, maven, golang, nuget, huggingface, rubygems)
  166. - `name` (string): The name of the package, as it appears in the package repository
  167. - `version` (optional string): The version of the package (default: "latest")
  168. - Returns: Package information including description, latest version, license, and URLs
  169. 18. `jfrog_get_package_versions`
  170. - Get a list of versions of a publicly available package with publication dates
  171. - Inputs:
  172. - `type` (string): The type of package (pypi, npm, maven, golang, nuget, huggingface, rubygems)
  173. - `name` (string): The name of the package, as it appears in the package repository
  174. - Returns: List of package versions with publication dates
  175. 19. `jfrog_get_package_version_vulnerabilities`
  176. - Get a list of known vulnerabilities affecting a specific version of an open source package
  177. - Inputs:
  178. - `type` (string): The type of package (pypi, npm, maven, golang, nuget, huggingface, rubygems)
  179. - `name` (string): The name of the package, as it appears in the package repository
  180. - `version` (optional string): The version of the package (default: "latest")
  181. - `pageSize` (optional number): Number of vulnerabilities to return per page (default: 10)
  182. - `pageCount` (optional number): Number of pages to return (default: 1)
  183. - Returns: List of vulnerabilities affecting the specified package version
  184. 20. `jfrog_get_vulnerability_info`
  185. - Get detailed information about a specific vulnerability, including affected packages and versions
  186. - Inputs:
  187. - `cve_id` (string): The CVE ID or vulnerability identifier to look up
  188. - `pageSize` (optional number): Number of vulnerabilities to return per page (default: 10)
  189. - `pageCount` (optional number): Number of pages to return (default: 1)
  190. - Returns: Detailed vulnerability information and affected packages
  191. 21. `jfrog_get_package_curation_status`
  192. - Check the curation status of a specific package version
  193. - Inputs:
  194. - `packageType` (string): The type of package (pypi, npm, maven, golang, nuget, huggingface, rubygems)
  195. - `packageName` (string): The name of the package, as it appears in the package repository
  196. - `packageVersion` (string): The version of the package, as it appears in the package repository
  197. - Returns: Curation status (approved, blocked, or inconclusive)
  198. </details>
  199. <details>
  200. <summary><strong>Xray</strong></summary>
  201. 22. `jfrog_get_artifacts_summary`
  202. - Get artifacts issues summary in a repository or build, categorized and counted by severity (Low, Medium, High, Critical, Unkown)
  203. - Inputs:
  204. - `paths` (string array): An array of paths to the artifacts from which to create the summary from
  205. - Returns: A summary based on vulnerability count per severity for each artifact in the provided array plus the total issues
  206. </details>
  207. ## Setup
  208. ### Installing via Smithery
  209. To install mcp-jfrog for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@jfrog/mcp-jfrog):
  210. ```bash
  211. npx -y @smithery/cli install @jfrog/mcp-jfrog --client claude
  212. ```
  213. ### Prerequisites
  214. - Node.js v18 or higher
  215. - Docker (if using Docker deployment, [See Docker Deployment](https://github.com/jfrog/mcp-jfrog/blob/main/README.md#docker) )
  216. - A valid JFrog platform instance with appropriate permissions
  217. - Access to create and manage access tokens in your JFrog platform instance
  218. ## Environment Variables
  219. - `JFROG_ACCESS_TOKEN`: Your JFrog access token (required)
  220. - `JFROG_URL`: Base URL for your JFrog platform (required)
  221. - `TRANSPORT`: Transport mode to use, set to 'sse' to enable SSE transport (default: stdio)
  222. - `PORT`: Port number to use for SSE transport (default: 8080)
  223. - `CORS_ORIGIN`: CORS origin allowed for SSE connections (default: '*')
  224. - `LOG_LEVEL`: Logging level: DEBUG, INFO, WARN, ERROR (default: INFO)
  225. - `MAX_RECONNECT_ATTEMPTS`: Maximum number of reconnection attempts for SSE server (default: 5)
  226. - `RECONNECT_DELAY_MS`: Base delay in milliseconds between reconnection attempts (default: 2000)
  227. ### JFrog Token (`JFROG_ACCESS_TOKEN`)
  228. To use this MCP server, you need to create a JFrog Access Token or use an identity token with appropriate permissions:
  229. For information on how to create a JFrog Token, please refer to the JFrog official documentations:
  230. - [Identity Tokens](https://jfrog.com/help/r/platform-api-key-deprecation-and-the-new-reference-tokens/introducing-jfrog-access-and-identity-tokens)
  231. - [Access Tokens](https://jfrog.com/help/r/jfrog-platform-administration-documentation/access-tokens)
  232. ### JFrog URL (`JFROG_URL`)
  233. Your JFrog platform instance URL (e.g. https://acme.jfrog.io)
  234. ### SSE Transport Features
  235. The SSE transport mode includes the following features:
  236. - **Connection Management**: Each SSE connection is tracked with a unique ID, allowing clients to maintain state across reconnection attempts.
  237. - **Structured Logging**: Detailed logs with timestamps, severity levels, and relevant contextual information.
  238. - **Connection Resilience**: Automatic reconnection attempts with exponential backoff if the server fails to start.
  239. - **Health Endpoint**: A `/health` endpoint that returns server status information.
  240. - **Connection Tracking**: Real-time tracking of active connections with periodic statistics logging.
  241. - **Performance Metrics**: Execution time tracking for tool operations and HTTP requests.
  242. When using SSE mode:
  243. 1. Clients should connect to the `/sse` endpoint, optionally providing a `connectionId` query parameter for session tracking.
  244. 2. Client requests should be sent to the `/messages` endpoint with the same `connectionId` as a query parameter.
  245. 3. The server will respond with server-sent events through the established SSE connection.
  246. Example client connection with connection ID:
  247. ```
  248. GET /sse?connectionId=client123
  249. ```
  250. Example client request:
  251. ```
  252. POST /messages?connectionId=client123
  253. Content-Type: application/json
  254. {
  255. "jsonrpc": "2.0",
  256. "method": "listTools",
  257. "id": 1
  258. }
  259. ```
  260. ### How to build
  261. Clone the repo to your local machine using `git clone` and `cd` into the project directory:
  262. ```bash
  263. git clone git@github.com:jfrog/mcp-jfrog.git
  264. cd mcp-jfrog
  265. ```
  266. Build as a Docker image:
  267. ```bash
  268. docker build -t mcp/jfrog -f Dockerfile .
  269. ```
  270. Build as an npm module:
  271. ```bash
  272. npm i && npm run build
  273. ```
  274. ## Usage
  275. <details>
  276. <summary><strong>Use with Cursor</strong></summary>
  277. Add the following to your `~/.cursor/mcp.json`:
  278. ### npm
  279. ```json
  280. {
  281. "mcpServers": {
  282. "MCP-JFrog": {
  283. "command": "npm",
  284. "args": [
  285. "exec",
  286. "-y",
  287. "github:jfrog/mcp-jfrog"
  288. ],
  289. "env": {
  290. "JFROG_ACCESS_TOKEN": "ACCESS_TOKEN",
  291. "JFROG_URL": "https://<YOUR_JFROG_INSTANCE_URL>"
  292. }
  293. }
  294. },
  295. "mcp-local-dev":{
  296. "command": "node",
  297. "args": [
  298. "/<ABSOLUT_PATH_TO>/mcp-jfrog/dist/index.js"
  299. ],
  300. "env": {
  301. "JFROG_ACCESS_TOKEN": "<ACCESS_TOKEN>>",
  302. "JFROG_URL": "<JFROG_URL>"
  303. }
  304. }
  305. }
  306. ```
  307. ### Docker
  308. ```json
  309. {
  310. "mcpServers": {
  311. "jfrog": {
  312. "command": "docker",
  313. "args": [
  314. "run",
  315. "--rm",
  316. "-i",
  317. "-e",
  318. "JFROG_ACCESS_TOKEN",
  319. "-e",
  320. "JFROG_URL",
  321. "mcp/jfrog"
  322. ],
  323. "env": {
  324. "JFROG_ACCESS_TOKEN": "<YOUR_TOKEN>",
  325. "JFROG_URL": "https://your-instance.jfrog.io"
  326. },
  327. "serverUrl": "http://localhost:8080/sse"
  328. }
  329. }
  330. }
  331. ```
  332. ### SSE Transport Mode
  333. To use the JFrog MCP Server with SSE transport mode (useful for web interfaces like Cursor's webview):
  334. ```json
  335. {
  336. "mcpServers": {
  337. "jfrog-sse": {
  338. "command": "docker",
  339. "args": [
  340. "run",
  341. "--rm",
  342. "-p",
  343. "8080:8080",
  344. "-e",
  345. "TRANSPORT=sse",
  346. "-e",
  347. "PORT=8080",
  348. "-e",
  349. "CORS_ORIGIN=*",
  350. "-e",
  351. "LOG_LEVEL=INFO",
  352. "-e",
  353. "MAX_RECONNECT_ATTEMPTS=5",
  354. "-e",
  355. "RECONNECT_DELAY_MS=2000",
  356. "-e",
  357. "JFROG_ACCESS_TOKEN",
  358. "-e",
  359. "JFROG_URL",
  360. "mcp/jfrog"
  361. ],
  362. "env": {
  363. "JFROG_ACCESS_TOKEN": "<YOUR_TOKEN>",
  364. "JFROG_URL": "https://your-instance.jfrog.io",
  365. "serverUrl": "http://localhost:8080/sse"
  366. }
  367. }
  368. }
  369. }
  370. ```
  371. 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).
  372. </details>
  373. <details>
  374. <summary><strong>Use with Claude Desktop</strong></summary>
  375. Add the following to your `claude_desktop_config.json`:
  376. #### Docker
  377. ```json
  378. {
  379. "mcpServers": {
  380. "jfrog": {
  381. "command": "docker",
  382. "args": [
  383. "run",
  384. "--rm",
  385. "-i",
  386. "-e",
  387. "JFROG_ACCESS_TOKEN",
  388. "-e",
  389. "JFROG_URL",
  390. "mcp/jfrog"
  391. ],
  392. "env": {
  393. "JFROG_ACCESS_TOKEN": "<YOUR_TOKEN>",
  394. "JFROG_URL": "https://your-instance.jfrog.io" // Your JFrog platform URL
  395. },
  396. "serverUrl": "http://localhost:8080/sse"
  397. }
  398. }
  399. }
  400. ```
  401. ### npm
  402. ```json
  403. {
  404. "mcpServers": {
  405. "MCP-JFrog": {
  406. "command": "npm",
  407. "args": [
  408. "exec",
  409. "-y",
  410. "github:jfrog/mcp-jfrog"
  411. ],
  412. "env": {
  413. "JFROG_ACCESS_TOKEN": "ACCESS_TOKEN",
  414. "JFROG_URL": "https://<YOUR_JFROG_INSTANCE_URL>"
  415. }
  416. }
  417. }
  418. }
  419. ```
  420. ### SSE Transport Mode
  421. For Claude Desktop with SSE transport:
  422. ```json
  423. {
  424. "mcpServers": {
  425. "jfrog-sse": {
  426. "command": "docker",
  427. "args": [
  428. "run",
  429. "--rm",
  430. "-p",
  431. "8080:8080",
  432. "-e",
  433. "TRANSPORT=sse",
  434. "-e",
  435. "PORT=8080",
  436. "-e",
  437. "CORS_ORIGIN=*",
  438. "-e",
  439. "LOG_LEVEL=INFO",
  440. "-e",
  441. "MAX_RECONNECT_ATTEMPTS=5",
  442. "-e",
  443. "RECONNECT_DELAY_MS=2000",
  444. "-e",
  445. "JFROG_ACCESS_TOKEN",
  446. "-e",
  447. "JFROG_URL",
  448. "mcp/jfrog"
  449. ],
  450. "env": {
  451. "JFROG_ACCESS_TOKEN": "<YOUR_TOKEN>",
  452. "JFROG_URL": "https://your-instance.jfrog.io",
  453. "serverUrl": "http://localhost:8080/sse"
  454. }
  455. }
  456. }
  457. }
  458. ```
  459. ```
  460. </details>
  461. ## License
  462. 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.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.