Perforce P4 MCP Server

What is Perforce P4 MCP Server about?

A Model Context Protocol server that bridges AI‑enabled tools with the Perforce P4 version‑control system, allowing programs to query and manipulate P4 entities such as files, changelists, shelves, workspaces, jobs, and code reviews.

How to use Perforce P4 MCP Server?

1. Install – download the pre‑built binary for macOS or Windows from the GitHub releases page, or build from source using the provided build.sh / build.bat scripts.
2. Configure – set the required P4 environment variables (P4PORT, P4USER, P4CLIENT) or reference a P4CONFIG file.
3. Start the server – run the executable with desired flags, e.g.:

   ./p4-mcp-server --readonly --allow-usage
   

4. Add to MCP client – add a server entry in the client’s MCP configuration JSON, specifying the absolute path to the binary and any needed environment variables.
5. Interact – use supported query and modify tools via the client’s MCP interface to read or change Perforce data.

Key features of Perforce P4 MCP Server

• Comprehensive read/write coverage for files, changelists, shelves, workspaces, jobs, and reviews.
• Built‑in code‑review workflow support (discovery, voting, state transitions, commenting, participant management).
• Read‑only mode by default with explicit --readonly flag to enable writes safely.
• Toolset toggling via --toolsets to enable only needed categories.
• Robust logging to logs/ and optional, consent‑gated telemetry (--allow-usage).
• Cross‑platform binaries for macOS and Windows; Docker execution option for Linux/macOS.
• Flexible Docker configuration allowing host‑name matching and client‑root mounting for workspace operations.

Use cases of Perforce P4 MCP Server

• AI‑assisted code completion – language models can query file contents, history, and annotations to provide context‑aware suggestions.
• Automated code review bots – bots can list pending reviews, post comments, and vote on changes programmatically.
• Workspace automation – scripts can create, switch, or delete workspaces and reconcile files without manual p4 commands.
• CI/CD integration – pipelines can fetch changelist metadata, submit shelves, or trigger review transitions.
• Metrics and dashboards – collect usage statistics (when consented) to monitor review activity and server health.

FAQ from the Perforce P4 MCP Server

Q: Do I need Python installed? A: Only when building from source. Pre‑built binaries run without any Python runtime.

Q: Can I run the server on Linux? A: Direct binaries are provided for macOS and Windows. Linux users can build from source or use the Docker image.

Q: Is data sent to Perforce? A: No file contents or personal data are transmitted. Telemetry (when enabled) only includes anonymous usage counts and server version.

Q: How do I enable write operations? A: Omit the --readonly flag when starting the server and ensure the P4 user has appropriate permissions.

Q: What if my workspace has a host restriction? A: When using Docker, set the container hostname to match the workspace’s Host: field and mount the workspace root at the exact path inside the container.

Features

• Comprehensive P4 integration: Read/write tools across files, changelists, shelves, workspaces, jobs, reviews, and server information
• Code review workflows: P4 Code Review support for review discovery, voting, state transitions, commenting, and participant management
• Safety first: Read-only mode by default, ownership checks, explicit confirmation for destructive deletes.
• Flexible toolsets: Configure which tool categories to enable: files, changelists, shelves, workspaces, jobs and reviews.
• Robust logging: Application and session logging to the logs/ directory.
• Optional telemetry: Consent-gated usage statistics. Disabled by default.
• Cross platform: Supported on macOS and Windows with pre-built binaries.

Prerequisites

• P4 Server access: Connection to a P4 Server with proper credentials
• Authentication: Valid P4 login (ticket-based or password)

System Requirements

Component	Supported Versions
Operating Systems	Windows 10+macOS 12+Ubuntu 20.04+
Perforce P4 Server	2025.2 (earlier versions untested)
Python	3.11+ (required only for building from source)

Local P4 MCP Server installation

Download the appropriate binary for your operating system:

• macOS: p4-mcp-server-mac.zip
• Windows: p4-mcp-server-win.zip

Extract and use the executable directly. No Python installation is required.

# Windows
unzip p4-mcp-server-2025.2.0.zip
cd p4-mcp-server-2025.2.0
./p4-mcp-server.exe --help

# macOS
tar -xzf p4-mcp-server-2025.2.0.tgz
cd p4-mcp-server-2025.2.0
./p4-mcp-server --help

Requirements:

• Python 3.11+ (with Tkinter)

Build:

• macOS: chmod +x build.sh && ./build.sh package
• Linux: chmod +x build.sh && ./build.sh package
• Windows: build.bat package

Output:

• macOS: p4-mcp-server-<version>.tgz
• Windows: p4-mcp-server-<version>.zip

Run the P4 MCP Server from a Docker container with STDIO transport, allowing MCP clients to manage the container lifecycle.

Note: Docker-based execution is currently supported on macOS and Linux only.

Prerequisites

• Docker installed and running
• Valid P4 credentials and access to a P4 server

Build the Docker Image

cd /path/to/p4mcp-server
docker build -t p4-mcp-server .

Configure MCP Client

Add the following to your mcp.json:

{
    "servers": {
        "perforce-p4mcp-docker": {
            "command": "docker",
            "args": [
                "run", "-i", "--rm",
                "--hostname", "your-hostname",
                "-e", "P4PORT=ssl:perforce.example.com:1666",
                "-e", "P4USER=your_username",
                "-e", "P4CLIENT=your_workspace",
                "-v", "/Users/your_username/.p4tickets:/root/.p4tickets:ro",
                "p4-mcp-server"
            ]
        }
    }
}

Configuration Options

Flag	Description
-i	Interactive mode (required for STDIO)
--rm	Remove container when stopped
--hostname	Match workspace host restriction
-e P4PORT	P4 server address
-e P4USER	P4 username
-e P4CLIENT	Workspace name
-v	Mount P4 tickets file

Authentication

Using P4 tickets:

# macOS/Linux
-v /Users/your_username/.p4tickets:/root/.p4tickets:ro

Note: Use the full path to your tickets file (not ~). After running p4 login, restart the MCP server to pick up the new ticket.

Using a password:

-e P4PASSWD="your_password"

Workspace Host Restrictions

⚠️ Important: Docker containers have their own hostname, which differs from your local machine. If your P4 workspace is restricted to a specific host, operations like sync will fail.

To resolve this, set the container hostname to match your workspace's host restriction:

--hostname your-hostname

To find your workspace host name:

# macOS/Linux
p4 client -o your_workspace | grep "^Host:"

Mounting Client Root for Write Operations

⚠️ Important: By default, the Docker container cannot access your local workspace files. For write operations like sync, submit, or reconcile, you must mount your client root directory into the container at the same path.

Add a volume mount for your client root:

-v /path/to/your/client/root:/path/to/your/client/root

Example configuration with client root mounted:

{
    "servers": {
        "perforce-p4mcp-docker": {
            "command": "docker",
            "args": [
                "run", "-i", "--rm",
                "--hostname", "your-hostname",
                "-e", "P4PORT=ssl:perforce.example.com:1666",
                "-e", "P4USER=your_username",
                "-e", "P4CLIENT=your_workspace",
                "-v", "/Users/your_username/.p4tickets:/root/.p4tickets",
                "-v", "/path/to/client/root:/path/to/client/root",
                "p4-mcp-server"
            ]
        }
    }
}

To find your client root:

p4 client -o your_workspace | grep "^Root:"

Note: The mount path inside the container must match the client root path exactly, as P4 tracks files by their absolute paths.

MCP client configuration

Note: In all configuration examples below, if P4CONFIG is set, you do not need to set any environment variables in the env block. The server will use the configuration from the specified P4CONFIG file instead.

{
 "mcpServers": {
    "perforce-p4-mcp": {
       "command": "/absolute/path/to/p4-mcp-server",
       "env": {
       },
       "args": [
          "--readonly", "--allow-usage"
       ]
    }
  }
}

See the JetBrains AI Assistant VCS Integration documentation for detailed configuration steps.

See the Claude Code MCP docs for more information.

{
  "mcpServers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

See the Cursor MCP documentation for more information.

{
  "mcpServers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

See the Eclipse MCP documentation for more information.

{
  "servers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

See the Kiro MCP documentation for more information.

{
  "mcpServers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

See the VS Code documentation for more information. Add the following to your VS Code MCP settings:

{
  "servers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

See the Windsurf MCP documentation for more information.

{
  "mcpServers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

P4 environment variables

• P4PORT - P4 Server address. Examples: ssl:perforce.example.com:1666, localhost:1666
• P4USER - Your P4 username
• P4CLIENT - Your current P4 workspace. Optional, but recommended

Supported arguments

• --readonly - Control write operations.

  • If present, uses read-only mode. Safe for exploration and testing.
  • If missing, enables write operations. Requires proper permissions on your P4 Server.

• --allow-usage - Allow usage statistics.

  • If present, allows anonymous usage statistics collection.
  • If missing, disables all usage statistics.

• --toolsets - Specify which tool categories to enable.

  • Available: files, changelists, shelves, workspaces, jobs, reviews
  • Default: All toolsets enabled.

Required configurations

• Use absolute paths for the command field in all configurations.
• Ensure environment variables are properly set for each host.
• Different hosts may have different argument parsing. Refer to the host's documentation.

P4 configuration

User configuration

Example setup

# Windows (PowerShell)
$env:P4PORT = "ssl:perforce.example.com:1666"
$env:P4USER = "your_username"
$env:P4CLIENT = "your_workspace"

# macOS (Bash)
export P4PORT="ssl:perforce.example.com:1666"
export P4USER="your_username"
export P4CLIENT="your_workspace"

Admin configuration

Manage access through group-level and user-level server properties. These follow a strict order of precedence:

• User-level properties override group properties.
• Group-level properties are evaluated in the order of their sequence number (set with -s).
• If no property applies, MCP remains enabled unless explicitly disabled.

Master switch (global disable)

To disable MCP for all users:

p4 property -a -n mcp.enabled -v false

To re-enable group/user-based control, delete the global property first:

p4 property -d -n mcp.enabled

To prevent access for all members of a specific group:

p4 property -a -n mcp.enabled -v false -g noaccessgroup

You can set multiple group restrictions the same way.

When a user belongs to multiple groups with conflicting settings, sequence order (-s) determines which settings apply.

Lower sequence numbers are evaluated first.

Example:

p4 property -a -n mcp.enabled -v false -s1 -g noaccessgroup
p4 property -a -n mcp.enabled -v true  -s2 -g accessgroup

In this example, accessgroup overrides noaccessgroup because it is evaluated later.

To block a specific user regardless of group membership:

p4 property -a -n mcp.enabled -v false -u noaccessuser

User-level properties always override group-level settings.

Example: Even if noaccessuser is in accessgroup (where MCP is enabled), the user property takes precedence and MCP is disabled.

Important notes

• mcp.enabled acts as the main switch.

• Avoid global properties (-a without -u or -g) unless you absolutely need to disable MCP for everyone.

Available tools

Query tools (read operations)

• Actions:
  • server_info - Get P4 version, uptime, and configuration
  • current_user - Get current user information and permissions
• Use cases - Server diagnostics, user verification, connection testing

• Actions:
  • list - List all workspaces (optionally filtered by user)
  • get - Get a detailed workspace specification
  • type - Check workspace type and configuration
  • status - Check workspace sync status
• Parameters: workspace_name, user, max_results
• Use cases: Workspace discovery, configuration review, status checking

• Actions:
  • get - Get detailed changelist information (files, description, jobs)
  • list - List changelists with filters (status, user, workspace)
• Parameters: changelist_id, status (pending/submitted), workspace_name, max_results
• Use cases: Code review, history tracking, changelist analysis

• Actions:
  • content - Get file content at a specific revision
  • history - Get file revision history and integration records
  • info - Get file basic details (type, size, permissions)
  • metadata - Get file metadata (attributes, filesize, etc.)
  • diff - Compare file versions (depot-to-depot or mixed)
  • annotations - Get file annotations with blame information
• Parameters: file_path, file2 (for diff), max_results, diff2 (boolean)
• Use cases: Code analysis, file comparison, history tracking, blame analysis

• Actions:
  • list - List shelved changes by user or globally
  • diff - Show differences in shelved files
  • files - List files in a specific shelf
• Parameters: changelist_id, user, max_results
• Use cases: Code review, work-in-progress tracking, collaboration

• Actions:
  • list_jobs - List jobs associated with a changelist
  • get_job - Get detailed job information and status
• Parameters: changelist_id, job_id, max_results
• Use cases: Defect tracking, requirement traceability, project management

• Actions:
  • list - List all reviews with optional filtering
  • dashboard - Get current user's review dashboard (my reviews, needs attention)
  • get - Get detailed review information
  • transitions - Get available state transitions for a review
  • files_readby - Get files read status by users
  • files - Get files in a review (with optional version range)
  • activity - Get review activity history
  • comments - Get comments on a review
• Parameters:
  • review_id - Review ID (required for get, transitions, files_readby, files, comments, activity)
  • review_fields - Comma-separated fields to return (e.g., "id,description,author,state")
  • comments_fields - Fields for comments (default: "id,body,user,time")
  • up_voters - List of up voters for transitions
  • from_version, to_version - Version range for files action
  • max_results - Maximum results (default: 10)
• Use cases: Code review discovery, review status tracking, comment retrieval, review activity monitoring

Modify tools (write operations)

• Actions - create, update, delete, switch
• Parameters - name, specs (WorkspaceSpec object with View, Root, Options, etc.)
• Requires - Non-read only mode, appropriate permissions
• Use cases - Environment setup, workspace maintenance, branch switching

• Actions - create, update, submit, delete, move_files
• Parameters - changelist_id, description, file_paths
• Safety - Ownership checks, confirmation for destructive operations
• Use cases - Code submission, work organization, file grouping

• Actions - add, edit, delete, move, revert, reconcile, resolve, sync
• Parameters - file_paths, changelist, force, mode (for resolve operations)
• Resolve modes - auto, safe, force, preview, theirs, yours
• Use cases - File editing, conflict resolution, workspace synchronization

• Actions - shelve, unshelve, update, delete, unshelve_to_changelist
• Parameters - changelist_id, file_paths, target_changelist, force
• Use cases - Temporary storage, code sharing, backup before experiments

• Actions - link_job, unlink_job
• Parameters - changelist_id, job_id
• Use cases - Defect tracking integration, requirement linking

• Actions:
  • create - Create a new review from a changelist
  • refresh_projects - Refresh project associations
  • vote - Vote on a review (up, down, clear)
  • transition - Change review state (needsRevision, needsReview, approved, committed, rejected, archived)
  • append_participants - Add reviewers/groups to a review
  • replace_participants - Replace all participants
  • delete_participants - Remove participants from a review
  • add_comment - Add a comment to a review
  • reply_comment - Reply to an existing comment
  • append_change - Add a changelist to an existing review
  • replace_with_change - Replace review content with a changelist
  • join - Join a review as a participant
  • leave - Leave a review
  • archive_inactive - Archive inactive reviews
  • mark_comment_read / mark_comment_unread - Mark individual comment read status
  • mark_all_comments_read / mark_all_comments_unread - Mark all comments read status
  • update_author - Change the review author
  • update_description - Update review description
  • obliterate - Permanently delete a review
• Parameters:
  • review_id - Review ID (required for most actions)
  • change_id - Changelist ID (required for create, append_change, replace_with_change)
  • description - Review description
  • reviewers, required_reviewers - Lists of reviewer usernames
  • reviewer_groups - Reviewer groups with requirements
  • vote_value - Vote value: up, down, clear
  • version - Review version for voting
  • transition - Target state: needsRevision, needsReview, approved, committed, approved:commit, rejected, archived
  • jobs, fix_status, cleanup - Job linking and cleanup options for transitions
  • users, groups - Structured participant data for append/replace/delete
  • body - Comment body text
  • task_state - Comment task state: open, comment
  • notify - Notification mode: immediate, delayed
  • comment_id - Comment ID for replies or marking read/unread
  • context - Comment context (file, line numbers, content, version)
  • not_updated_since, max_reviews - Filters for archive_inactive
  • new_author, new_description - Values for update actions
• Use cases: Code review workflow, review state management, collaborative commenting, participant management, review cleanup

• Parameters - operation_id, source_tool, user_confirmed
• Safety - Requires explicit user confirmation, logs all operations
• Supported Resources - Changelists, workspaces, shelves
• Use cases - Cleanup operations, resource management

Logging and usage data

Logging system

Log locations:

• Application log: logs/p4mcp.log - Main server operations and errors
• Session logs: logs/sessions/*.log - Individual session activities are recorded only when the --allow-usage is specified in the server's startup arguments.

Usage data

Privacy-first approach:

• Disabled by default: No data collection without explicit consent
• Consent-gated: First-run prompt for telemetry permission
• Transparent: Clear explanation of data collected
• Revocable: Easy opt-out at any time

Data collected (if consented):

• Tool usage frequency (anonymized)
• Error rates and types (no personal data)
• Performance metrics
• Feature adoption statistics
• P4 server version

Data not collected:

• File contents or names
• P4 Server details except version
• User credentials or personal information
• Specific project information

Control:

• Usage data is only collected if the --allow-usage argument is provided at startup.

Troubleshooting

Server startup issues

Symptoms: OS cannot find or execute the binary; error includes ENOENT or "No such file or directory". Solutions:

1. Check the path: Make sure the command field uses the correct absolute path for your OS:
   • macOS/Linux: /absolute/path/to/p4-mcp-server
   • Windows: C:\absolute\path\to\p4-mcp-server.exe
2. Ensure the binary exists and is executable:
   • macOS/Linux:

     ls -l /absolute/path/to/p4-mcp-server && chmod +x /absolute/path/to/p4-mcp-server
     

   • Windows:

     dir C:\absolute\path\to\p4-mcp-server.exe
     

3. On Windows, ensure the binary is not blocked:
   • Right-click the .exe file, select Properties, and if present, click Unblock.

Connection issues

Symptoms: Cannot connect to P4 Server
Solutions:

1. Verify the P4PORT environment variable: echo $P4PORT (macOS) or echo $env:P4PORT (Windows)
2. Test the direct connection: p4 info
3. Check server availability: ping perforce.example.com
4. Verify the port and protocol (ssl: prefix for SSL connections).

Symptoms: SSL trust errors when connecting
Solutions:

1. Trust the server: p4 trust -f -y
2. Check trust status: p4 trust -l
3. For persistent issues, verify the SSL configuration.

Authentication problems

Symptoms: Authentication failures
Solutions:

1. Log in to P4: p4 login -a
2. Check login status: p4 login -s
3. Verify the user exists: p4 users -m 1 your_username
4. For persistent issues, check password or use ticket-based authentication.

Symptoms: Login failures
Solutions:

1. Reset the password through P4 administrator.
2. Use ticket-based authentication: p4 login -a
3. Verify the username is correct: p4 info

Workspace issues

Symptoms: Workspace not found errors
Solutions:

1. List the available workspaces: p4 clients
2. Verify the P4CLIENT environment variable.
3. Create a workspace if needed: p4 client workspace_name
4. Check the workspace ownership: p4 client -o workspace_name

Symptoms: Files are outside the workspace mapping
Solutions:

1. Check the client view: p4 client -o workspace_name
2. Update the workspace mapping to include the required paths.
3. Use p4 where file_path to check the mapping.

Permission errors

Symptoms: Insufficient permissions for operations
Solutions:

1. Check the file ownership: p4 opened file_path
2. Verify the user permissions: p4 protects file_path
3. Ensure proper group membership.
4. For admin operations, verify admin permissions.

Symptoms: Exclusive lock conflicts
Solutions:

1. Check who has the file open: p4 opened file_path
2. Contact the user to resolve conflicts.
3. Admin can force operations if necessary.

Performance issues

Symptoms: Long response times
Solutions:

1. Use the max_results parameter to limit the query size.
2. Use specific file paths instead of wildcards.
3. Check network connectivity to P4.
4. Monitor server performance.

Symptoms: High memory usage
Solutions:

1. Reduce max_results for large queries.
2. Process files in batches.
3. Restart the MCP server periodically for long-running sessions.

Tool execution

Symptoms: Conflict with built-in or other MCP tools Solutions:

1. Disable any built-in or conflicting MCP server tools in your environment or configuration.
2. Ensure the P4 MCP server tools are properly registered and enabled.
3. Restart the MCP server after applying configuration changes to load the correct tools.

Symptoms: Invalid context or outdated session history Solutions:

1. Provide a P4-related context when writing prompts.
2. Start a new session if the existing session is old or contains conflicting prompt history.

Common error patterns

1. Authentication: Ensure valid login before MCP operations.
2. Workspace mapping: Verify client views include target files.
3. Permissions: Check user and file permissions for write operations.
4. Network: Verify connectivity for remote P4 Servers.

Getting help

1. Check the logs: Always check logs/p4mcp.log first.
2. Test P4: Ensure p4 info works before troubleshooting MCP.
3. Report issues to the community: Report issues with log excerpts and environment details.

Support

Perforce P4 MCP Server is a community supported project and is not officially supported by Perforce. Pull requests and issues are the responsibility of the project's moderator(s); this may be a vetted individual or team with members outside of the Perforce organization. Perforce does not officially support these projects, therefore all issues should be reported and managed via GitHub (not via Perforce's standard support process).

Contributions

We welcome contributions to the P4 MCP Server project.

License

This project is licensed under the MIT License. See LICENSE for details.

Third-Party Notices

This project includes third-party components. Their licenses and attributions are listed in THIRD-PARTY-NOTICES.