Connect MCP-capable AI clients to Primavera P6 schedules to browse, analyze, report, compare, simulate, and optionally edit P6 data with safety controls.
Browse projects, EPS, WBS, calendars, UDFs, activities, relationships, milestones, and schedule options.
Analyze critical paths, driving paths, float paths/origins/distribution, look-aheads, and project summaries.
Run DCMA 14-point health checks, logic/progress checks, dangling/redundant link checks, and health-check comparisons.
Produce S-curves, earned value, resource/cost summaries, grouped reports, and Excel dashboards.
Compare baselines/updates, validate CPM against P6 F9, run what-if scenarios, and perform Monte Carlo schedule risk.
Inspect, import, export, and analyze XER files, including XER-only mode without a P6 database.
Optionally edit durations, constraints, actuals, assignments, UDFs, relationships, schedule options, EPS, and deletes with dry runs, confirmation tokens, backups, edit logging, and schema/P6-running safeguards.
Manage backups/restores, review edit logs, diagnose configuration/database issues, use read-only SQL as a last resort, and search/install P6 skills from the skill shop.
Provides tools to analyze and optionally edit Primavera P6 schedules stored in a standalone SQLite P6 database, including schedule analysis, DCMA health checks, progress and cost summaries, comparisons, what-if scenarios, and guarded write operations.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@P6 MCP Run a DCMA health check on my P6 schedule"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP for Primavera P6 is a local Model Context Protocol (MCP) server that connects Claude, ChatGPT, Cursor, VS Code and any other MCP client to your Oracle Primavera P6 Professional schedules on Windows. It reads the P6 database itself (P6 Professional standalone, SQLite) or plain XER files and answers scheduling questions with real computations: critical path and driving path, total float, the DCMA 14-point check, look-ahead, baseline and update comparison, CPM what-if and Monte Carlo schedule risk. Unlike XER-only MCP servers, it can also write changes back to the P6 database: durations, logic, constraints, actuals, units and UDFs, each one previewed in a dry run, applied only after your confirmation, backed up first and recorded in an edit log.
MCP for Primavera P6 is an independent project. It is not affiliated with, endorsed or sponsored by Oracle. Oracle, Primavera and P6 are trademarks of Oracle and/or its affiliates.
Contents: What it does · Install · Connect your MCP client · Tools · Compared with XER-only servers · Safety · Privacy · P6 skills · FAQ · Troubleshooting
Ask your assistant "what drives the finish date?", "run a DCMA health check on the March update", "what changed since the last update?" or "what happens if procurement takes four more weeks?". The server computes the answer from the schedule; the model explains it. Dates and float come from P6's last schedule run (F9).
Schedule analysis: projects and EPS, WBS roll-ups, activities filtered by status, float, dates, activity codes or UDFs, relationships with the project's lag calendar rule, critical path (total float or longest path), driving path, float paths, where an activity's float comes from, float distribution, look-ahead windows.
Schedule quality: DCMA 14-point check with the project's own P6 thresholds, logic density and a weighted grade, comparison with earlier checks, out-of-sequence progress, dangling ends, redundant links.
Comparisons, what-if and risk: two updates or a baseline compared activity by activity and link by link,
with slip causes and float erosion; an integrity review of an update against the previous one (questions to
raise, not proof); a CPM engine checked against P6's F9 (p6_cpm_validate reports the match) for what-if
scenarios and Monte Carlo risk, run in memory and never written.
Progress and reporting: S-curves and earned value at the data date, resource and cost summaries, groups by status, WBS or code, and a one-page Excel dashboard with native charts.
XER files: inspect, import (new project, baseline, update), export, or analyse XER files alone in XER-only mode, without a P6 database or P6 installed.
Edits (off by default): durations, constraints, actual dates, physical % complete, resource assignment units, activity UDF values, relationships, schedule options, EPS, deletes, backups and restore.
Related MCP server: P6-MCP
MCP for Primavera P6 runs on Windows 10 or 11, next to P6 Professional. Nothing else to install: Python is bundled.
Download P6MCP-Setup-<version>.exe from
Releases and check it against
SHA256SUMS.txt (certutil -hashfile P6MCP-Setup-2.0.0.exe SHA256).
Run it. It installs for your Windows user only (no administrator rights) and, on its last page, offers to register the server with every MCP client it finds (Claude Desktop, Claude Code, Cursor, VS Code, LM Studio, Cline). Untick the ones you do not want.
MCP for Primavera P6 Settings opens. Under Database, pick your P6 database (suggestions come from P6's own connection list), click Test connection (read only), then Use this database, and Save. The server never picks a database by itself: until you do this, every tool answers "No database configured".
Restart your MCP client completely.
Release builds are not code signed yet: Windows SmartScreen may warn on first launch ("More info", "Run anyway").
Check the SHA-256 first. Other packages on the release page: a portable zip (no installation) and an
MCP bundle (.mcpb, server only) that Claude Desktop installs in one click; it is also the package listed in
the official MCP Registry as
io.github.nizarhamza/p6-mcp.
The installer and Settings > MCP clients write the client configuration for you: they add (or repair, or
remove) only the p6mcp entry, after a timestamped backup, keeping every other entry, comment and the file's
formatting. The manual steps below are for reference. In every snippet, replace <you> with your Windows user
name (or copy the snippet from Settings > MCP clients > Other clients, which fills in the real path).
Either let the installer register it, or double-click the .mcpb bundle (Settings > Extensions shows it; pick
the database there), or edit %APPDATA%\Claude\claude_desktop_config.json:
{
"mcpServers": {
"p6mcp": {
"command": "C:\\Users\\<you>\\AppData\\Local\\Programs\\P6 MCP\\p6mcp-server.exe",
"args": []
}
}
}Quit Claude Desktop completely (also from the notification area) and start it again. The P6 skills appear as prompts in the + menu.
The installer registers it in %USERPROFILE%\.cursor\mcp.json, or add the same mcpServers entry as Claude
Desktop above to that file. Cursor lists the tools under Settings > MCP.
The installer registers it in %APPDATA%\Code\User\mcp.json (VS Code Insiders: ...\Code - Insiders\User\mcp.json).
By hand, run MCP: Open User Configuration and add:
{
"servers": {
"p6mcp": {
"type": "stdio",
"command": "C:\\Users\\<you>\\AppData\\Local\\Programs\\P6 MCP\\p6mcp-server.exe",
"args": []
}
}
}Then open Copilot Chat in Agent mode and pick the tools from the tools menu.
ChatGPT cannot start a program on your PC, so there are two routes. Neither is tested by the maintainer yet: please report how it goes in an issue.
Codex (in the ChatGPT desktop app, or the Codex CLI) starts local MCP servers from
%USERPROFILE%\.codex\config.toml:
[mcp_servers.p6mcp]
command = 'C:\Users\<you>\AppData\Local\Programs\P6 MCP\p6mcp-server.exe'
args = []ChatGPT chat reaches MCP servers over HTTPS only. OpenAI's Secure MCP Tunnel runs a small client on your PC that starts the server (stdio command above) and forwards ChatGPT's requests to it, without opening an inbound port; you then add a custom MCP server in ChatGPT with Tunnel as the connection. It needs an OpenAI platform API key and a ChatGPT plan or workspace that allows custom MCP servers. The tool results then pass through OpenAI's service, like any ChatGPT conversation.
The installer registers Claude Code (%USERPROFILE%\.claude.json), LM Studio (%USERPROFILE%\.lmstudio\mcp.json)
and Cline as well. For Claude Code by hand:
claude mcp add --scope user p6mcp -- "$env:LOCALAPPDATA\Programs\P6 MCP\p6mcp-server.exe"Any other client that starts stdio servers takes the mcpServers snippet above. Clients that need HTTP can use
the local HTTP transport. From the command line (the installer uses the same commands):
& "$env:LOCALAPPDATA\Programs\P6 MCP\p6mcp-server.exe" clients list
& "$env:LOCALAPPDATA\Programs\P6 MCP\p6mcp-server.exe" clients register cursor
58 tools: 37 read-only (11 of them in the Basic profile), 2 that write a file, 18 write tools (off by default; a dry run, then your confirmation; a backup first) and 1 that changes the app's own settings. Generated from the code by tools/gen_docs.py.
Projects and structure
Tool | What it does | Access | Basic |
| Projects with data date, start, finish, status, baseline and EPS; filter by EPS | Read | yes |
| EPS tree with depth, path and project counts | Read | |
| One-call overview: dates, activity counts, critical counts, % complete by units, physical and duration, baseline variance and SPI | Read | yes |
| WBS tree in P6 order with roll-ups: activities, dates, float, units % and baseline planned % | Read | yes |
| Calendars with work week, hours per day and holiday exceptions | Read | |
| User defined fields (UDF columns) with how much each one is used | Read | |
| Schedule options of a project, of an XER file, or both side by side | Read |
Activities and relationships
Tool | What it does | Access | Basic |
| Search activities by name, Activity ID, WBS, status, total float, dates, activity code or UDF, with chosen columns | Read | yes |
| Everything about one activity: dates, durations, float, constraints, logic, resources, codes, UDFs, notebooks | Read | yes |
| Predecessors and successors of an activity, lags in hours and days | Read | yes |
| What starts, finishes or is in progress in the next weeks, critical work flagged | Read | yes |
| Milestones against the baseline: variance in working and calendar days, float, critical | Read |
Critical path and float
Tool | What it does | Access | Basic |
| Critical activities as the project defines them (total float or longest path) | Read | yes |
| The chain of driving predecessors behind an activity's dates, back to its root cause | Read | |
| Float paths of the last P6 schedule run, in P6 order | Read | |
| Where an activity's total float comes from: the successor chain that sets its late dates | Read | |
| Total and free float distribution by range | Read | yes |
Schedule quality
Tool | What it does | Access | Basic |
| DCMA 14-point check (the project's own P6 thresholds when set), critical path test, CPLI, BEI and a weighted score | Read | yes |
| Health check now against an earlier run: what got better or worse | Read | |
| Open starts and open finishes, each with a suggested link to close it | Read | |
| Links that are candidates for removal (transitive, duplicate, to completed work) | Read | |
| Out-of-sequence progress and status inconsistencies | Read |
Progress and reporting
Tool | What it does | Access | Basic |
| S-curve by month or week (units or cost) against the baseline, earned value at the data date | Read | |
| Activities, units and dates grouped by status, type, WBS level or activity code | Read | |
| Units and costs per resource, and activities per status | Read | |
| Excel project controls dashboard: one A3 page with charts, plus detail sheets | Writes a file |
Comparison, what-if and risk
Tool | What it does | Access | Basic |
| Two updates or a baseline compared activity by activity and link by link, with slip causes and float erosion | Read | |
| Review of an update against the previous one: changes a reviewer should question | Read | |
| Runs the built-in CPM engine and compares it with P6's last F9, activity by activity | Read | |
| What-if in memory: add or remove links, change durations or constraints, see the new finish | Read | |
| Monte Carlo schedule risk in memory: finish percentiles, on-time probability, criticality index | Read |
XER files
Tool | What it does | Access | Basic |
| Reads an XER file without importing it and runs the import pre-flight checks | Read | |
| Imports an XER as a new project, a baseline or an update of an existing project | Write | |
| Exports a project to an XER file, schedule options included | Writes a file |
Edits (off by default)
Tool | What it does | Access | Basic |
| Edits an activity: name, durations, constraint, actual dates, physical % complete | Write | |
| Sets budgeted, actual or remaining units of one resource assignment | Write | |
| Sets the units of many assignments in one all-or-nothing change | Write | |
| Sets or clears one activity UDF value | Write | |
| Sets or clears many activity UDF values in one change | Write | |
| Adds a relationship (FS, SS, FF, SF, with lag) | Write | |
| Adds many relationships in one all-or-nothing change | Write | |
| Changes the type or lag of a relationship | Write | |
| Changes many relationships in one change | Write | |
| Deletes a relationship | Write | |
| Deletes many relationships in one change | Write | |
| Writes a project's schedule options, or copies them from an XER file | Write | |
| Creates an EPS node | Write | |
| Deletes an activity and everything attached to it, as P6 does | Delete or replace | |
| Deletes one or more projects, as P6 does | Delete or replace |
Backups, log and diagnostics
Tool | What it does | Access | Basic |
| Takes a backup of the P6 database now | Write | |
| Lists the backups, automatic (before writes) and manual | Read | |
| Puts a backup back in place, after a safety backup of the current database | Delete or replace | |
| Every confirmed write, with its parameters, before and after values | Read | |
| Configuration, database, P6 version and P6 running state at a glance | Read | yes |
| Read-only SQL on the P6 database, as a last resort | Read |
Skill shop
Tool | What it does | Access | Basic |
| Searches the skill shop (ready-made P6 workflows shared on GitHub) | Read | |
| Shows one skill of the shop in full | Read | |
| Installs or updates a skill from the shop, after your confirmation | App settings |
Several MCP servers read Primavera P6 XER files; some can also edit an XER and export a new one to import back into P6. MCP for Primavera P6 works on the P6 Professional database itself, and reads XER files too.
MCP for Primavera P6 | Typical XER-file MCP server | |
Reads XER files | Yes: inspect, import, export, XER-only mode | Yes |
Reads the P6 Professional database directly (every project, baselines, EPS, codes, UDFs, schedule options) | Yes | No: export an XER first |
Writes changes back to P6 | Yes, into the database: open P6 and press F9 | No, or edits an XER you import again |
Preview, confirmation token, backup before each write, restore, edit log | Yes | Not applicable, or varies |
Refuses to write while P6 is running, or on an untested P6 schema | Yes | Not applicable |
CPM engine checked against P6's own F9 dates ( | Yes | Varies |
DCMA 14-point check with the thresholds set in P6 | Yes, DCMA defaults when none are set | Varies |
Excel dashboard, P6 skills (ready-made workflows) | Yes | Varies |
Installation | Windows installer with a Settings window; registers your MCP clients | Usually a Python package (pip, uvx) |
Runs on macOS or Linux | No: Windows only, like P6 Professional | Usually yes |
P6 EPPM, or P6 on SQL Server or Oracle | No | No (XER only) |
"Varies" means some XER servers do it and others do not: check the one you are looking at.
Tool profiles: Basic (11 read-only tools, suited to small local models) or Full (all 58).
Writes are off by default. With the Full profile and "Allow write operations", every write takes two calls: a dry run that shows the plan and returns a single-use confirmation token, then, after your explicit yes, the same call with that token. Deleting a project or an activity and restoring a backup also need a confirmation text. If the database changed in between, the write is refused.
A backup is taken before every write (with a retention you choose), writes are refused while P6 is running, and every write goes to the edit log with its parameters.
Writes are refused on a P6 schema version the server was not tested with, unless you trust it explicitly.
These rules are enforced by the server itself on every call, not only by the Settings window.
Writes go straight to the database and bypass P6's own application logic. The server updates the audit
fields (update_date, update_user, create_*) the way P6 does and never writes planned, early or late dates
or float: close P6 before writing, then open it and press F9. See SECURITY.md for the list of
what the write tools can change.
The server runs only on your PC: no cloud component, no telemetry. Its only network requests go to GitHub: the updates (releases of this repository), which you can turn off under Logs and updates, and the skill shop (reads of its public catalog when you open the Skill shop page or ask for it, at the first start of the Settings app for the core set, on Restore core skills, and with automatic updates on for newer skill versions), which you can turn off under Tools and safety (the core set then comes from the copy shipped with the app).
The data returned by the tools goes to the AI model your MCP client uses, which may be a cloud service. For confidential schedules, use a local model (for example in LM Studio).
P6 skills are ready-made workflows that chain the tools into one fixed report: weekly update review, schedule quality audit, safe update import, update integrity audit, schedule risk, delay what-if, baseline variance, Excel dashboard and more. They all come from the skill shop. At its first start the Settings app installs the core set from the shop (when GitHub cannot be reached, from the copy of the core set shipped with the app, updated from the shop later). Restore core skills (Skills or Skill shop page) installs the core set again: missing skills come back and edited ones get the shop's version. With automatic updates on (Logs and updates), the tray app also installs newer shop versions of your shop skills, except the ones you edited here: those show Update available on the Skill shop page, and Update asks before replacing your changes.
Most skills need the Full tool profile (the import also needs writes). MCP clients > Install skills writes
each one as an Agent Skills folder p6-<name> (a SKILL.md and its reference files);
the client's AI uses a skill when your request matches its description, and Claude Code also runs it as
/p6-<name>:
Client | Skills folder |
Claude Code, Cursor, VS Code / VS Code Insiders |
|
Cline |
|
Update skills refreshes them after an update or a change of the tool settings; Remove skills (and uninstalling) deletes only the files the app wrote. From the command line:
& "$env:LOCALAPPDATA\Programs\P6 MCP\p6mcp-server.exe" clients skills install --detectedThe server also offers them as MCP prompts: Claude Desktop lists them in the + menu, VS Code as
/mcp.p6mcp.<name>, Claude Code as /mcp__p6mcp__<name>. Claude Desktop has no skills folder: export a skill as
a zip file (Skills > Export) and upload it in Claude Desktop's settings to add it as a skill.
The Skills page of the Settings app lists them with whether the current tool settings offer them and where
they come from (Shop, Shop edited here, Yours). Turn a skill off, edit it, or add your own (New, or Copy to
my skills to start from a shop skill): a name, a title, a description that says what it does and when to use it
(clients pick a skill by it), inputs written as {input} in the instructions, the P6 tools to use, and up to 5
text reference files (checklists, thresholds, examples; never scripts). The P6 rules are appended to your
instructions. The Instructions page shows the instructions every client receives when it connects; turn
built-in lines off (the two-step write rule stays on) or add your own, such as "When you show an activity, write
it as Activity ID - Activity name". Click Save, then Update skills on the MCP clients page, and restart the MCP
client for the prompts.
The Skill shop page lists the P6 skills of the public catalog
nizarhamza/p6-mcp-shop: the core set maintained with the app and the
skills other users shared. Reading it needs no account; the app reads it only when you open the page or ask your
AI client (tools p6_shop_search, p6_shop_get and p6_shop_install, Full profile; an install shows the whole
skill first and needs your confirmation). Read a skill before installing it: it is instructions for the AI, and a
skill that uses write tools can change your schedule once you confirm the change. Turn the shop off under
Tools and safety.
To share one of your skills, select it on the Skills page and click Share on GitHub: the app copies the skill
to the clipboard and your browser opens the GitHub share form; sign in if asked (a free GitHub account is needed),
paste the skill in the Skill field and click Create (nothing is sent by the app itself). The maintainer reviews
it and, once approved, a GitHub Action checks it and publishes it in the catalog under the Apache-2.0 license.
Without a GitHub account, Export the skill to a zip file and send it; Import adds a zip (or any skill
folder with a SKILL.md and text files) after you review it.
By default each client starts its own server (stdio). Under Server you can switch to a local HTTP server, hosted by the notification area app, for clients that need HTTP or to share one server:
listens on 127.0.0.1 only (http://127.0.0.1:<port>/mcp), with a port check;
every request needs Authorization: Bearer <token>; the token lives in the Windows Credential Manager (shown
masked, copy, regenerate);
Host and Origin headers are checked to block DNS rebinding.
Ask for example "export the dashboard of DEMO-A to D:\Reports\DEMO-A.xlsx" (Full profile). The template is built
into the server: p6_export_dashboard reads the last F9 and writes a finished workbook (values and native Excel
charts, no formulas), so press F9 in P6 first. An existing file is replaced only when you say so (overwrite).
Sheet | Content |
Dashboard | One A3 landscape page, protected (no password) with its charts fixed: 7 cards (overall progress, critical and delayed activities, schedule variance, forecast completion, remaining duration, late milestones); S-curve; finish variance by level 1 WBS in working days; WBS progress (level 1) and level 2 progress, actual against baseline planned; milestones; critical and delayed activities |
Schedule Overview | Every activity under a band per WBS (opens folded to level 2): baseline, current and actual dates, % complete, labor units, original, remaining and actual durations |
Critical Path | The P6 float paths of the last F9, a bold line between paths (without stored paths: the activities with total float up to |
Reports | DCMA 14 checks, sources, settings and definitions |
Options: baseline (default the project baseline), baseline_dates (planned or current), milestones
(Activity IDs), near_critical_days (10: Delayed beyond it, At risk up to it), period (month or week),
prepared_by, revision, and for this export only company (shown in the sidebar) and colors
("primary,accent" in hex). Slip and variance are in working days, as P6 variance columns.
Under Database > Data source, choose XER files only, add one or more XER files and click Load and
check. The files are read into a private read-only copy; every read tool works on it. Load two updates of the
same schedule to compare them: a Project ID already used by the first file gets a ~2 suffix.
What is an MCP server for Primavera P6? MCP (Model Context Protocol) is the open standard AI assistants use to call tools. This server gives an assistant 58 tools that read and analyse Primavera P6 schedules, so you can ask questions in plain language and get answers computed from the schedule rather than guessed by the model.
Can the AI change my schedule? Only if you allow it. Writes are off by default; when on, each one is previewed in a dry run and applied only with a single-use token after your explicit yes, a backup is taken first, and P6 must be closed. Planned dates and float are never written: P6 computes them when you press F9.
Does my schedule leave my PC? The server runs locally and sends nothing anywhere. What the tools return goes to the AI model of your MCP client; with a cloud model that means its provider. For confidential projects use a local model, for example in LM Studio.
Which P6 versions and databases are supported? P6 Professional standalone (SQLite), tested with 25.12; other versions are read only until tested or trusted. XER files from P6 Professional 24.12 and from the server's own export. P6 EPPM and P6 Professional on SQL Server or Oracle are not supported.
Do I need P6 installed? Not for XER files: XER-only mode analyses them without P6 or a P6 database.
How does the DCMA 14-point check work?
p6_health_check runs the 14 DCMA checks on the last F9, with the thresholds set in P6's schedule check settings
for the project when they exist, else the DCMA defaults. The critical path test delays an activity in the
server's CPM engine and runs only when that engine matches P6's dates. See the
DCMA 14-point check guide.
Are the dates computed by the AI?
No. Dates and float come from P6's last schedule run. What-if and risk use the server's CPM engine, and
p6_cpm_validate shows how closely it matches P6's own dates on your project before you rely on it.
Which AI clients work? Claude Desktop, Claude Code, Cursor, VS Code, LM Studio and Cline are registered automatically; any MCP client that starts stdio servers or speaks Streamable HTTP works too. ChatGPT works through Codex or OpenAI's Secure MCP Tunnel (see ChatGPT).
Does it run on macOS or Linux? No. P6 Professional is a Windows program and the server is built for Windows 10 and 11.
Is it free? Yes, under the Apache License 2.0.
Component | Tested |
Windows | Windows 11 |
P6 Professional standalone (SQLite) | 25.12 (schema fingerprint in |
XER files | written by P6 Professional 24.12, and by the server's own export |
MCP clients | registration tested on sample configuration files of every client listed above; stdio and HTTP tested with the MCP Python SDK client; end-to-end use with each client is in the release checklist. Codex and the ChatGPT tunnel are not tested yet |
MCP SDK | mcp 2.3 (1.8 or later supported) |
"No database configured": open MCP for Primavera P6 Settings, select a database, Test connection, Use this database, Save.
A tool is "not available in the Basic profile": switch to Full under Tools and safety, Save, restart the client.
The client does not show the tools: restart it completely (also from the notification area), then check
MCP clients: the entry may need Repair. Ask the assistant to run p6_diagnose.
"P6 (PM.exe) is running": close P6 before a write.
"Unknown P6 schema": your P6 version was not tested; reads work. You can trust the schema under Database (after a backup).
HTTP server error: Server shows the last error (often a port in use: pick another one).
Logs: Logs and updates > Open log folder (%LOCALAPPDATA%\P6MCP\logs). Settings live in
%APPDATA%\P6MCP\config.json; backups, edit log and XER copies in %LOCALAPPDATA%\P6MCP.
Versions 1.x were called P6 MCP: the install folder, the program names and the settings folders keep that name, so updates and client registrations carry over.
Windows Settings > Apps > MCP for Primavera P6. The uninstaller removes the program, the p6mcp entries from your
MCP clients and the startup entry. Your settings, backups and logs are kept.
python -m venv .venv
.venv\Scripts\pip install -e .[dev]
.venv\Scripts\python -m pytest -q
.venv\Scripts\python -m p6mcp.settings_app # Settings window
.venv\Scripts\python tools\gen_docs.py # tool tables of README.md and site/llms.txt
.venv\Scripts\python tools\build_site.py # landing site pages from site-src/pages
.venv\Scripts\python tools\serve_site.py # preview site/ with its headers on http://127.0.0.1:8642Tests run on a synthetic P6 database and synthetic XER files built by the tests (tests/fixtures/make_db.py).
Never commit a real schedule, database, XER file or log. Building the installer and releasing:
docs/RELEASING.md. The landing site in site/ is generated from
site-src/pages by tools/build_site.py (a test fails when the two are out of step): edit the
sources, never the generated pages.
To contribute, start with an issue: see CONTRIBUTING.md and the code of conduct. Accessibility: ACCESSIBILITY.md.
Apache License 2.0. Copyright 2026 Nizar Hamza. See NOTICE.
Primavera and P6 are trademarks of Oracle. This project is not affiliated with or endorsed by Oracle.
Critical activities of the last P6 schedule run (F9), one page: {total, offset, returned, next_offset, rows, definition, mode_used, threshold_h, counts, schedule_state, note}. mode: project (default) follows the project setting (total float <= its hours threshold, or longest path); total_float uses that hours threshold; longest_path uses P6's driving path flag. float_threshold_days forces total float <= that many days (not with longest_path); min_float_days keeps only total float > that many days (days of each activity's calendar, not with longest_path): min_float_days=0 with float_threshold_days=10 lists the near critical activities. LOE and WBS summary activities are left out (even when P6 flags them), completed ones too unless include_completed=True. Order: total float then start, or float path order for the longest path. counts (open activities except LOE and WBS summary, any page): open, total_float, longest_path, negative_float; excluded_summary = LOE and WBS summary activities that meet the definition and the status filter but are not listed. fields= as in p6_query_activities.
Inputs: project (required), mode, limit, fields, +4 more.
Start here when a tool reports a configuration problem. Shows the server settings in force (database, tool profile, writes allowed, restart needed), the P6 schema and version detected, whether P6 is running, the backup and edit log folders. Works without a database.
Inputs: no named parameters.
Total and free float distribution of the open activities (not completed, LOE and WBS summary left out) of the last F9, in days of each activity's calendar. Buckets from edges_days (default -20, -10, -5, 0, 5, 10, 20, 44; 0 is always added): below the first edge, [a, b) below zero, exactly 0, (a, b] above zero, above the last edge, so every value falls in exactly one bucket (compared in hours, never rounded). Each bucket: total_float and free_float counts, their % of the activities, and samples (the sample_size lowest floats). no_value counts activities without a float; all_ranges_covered checks that bucket counts plus no_value equal the activities. stats: min, max, mean and median in days, total floats that are not whole days, negative, zero, critical (project definition). include_milestones=False leaves milestones out; wbs_name_contains and code_type / code_value / include_child_codes filter as in p6_query_activities (code_filter in the result, as there).
Inputs: project (required), code_type, code_value, edges_days, +4 more.
Full detail of one activity: the list fields (see p6_query_activities), secondary constraint, remaining, expected, suspend and resume dates, calendar (hours_per_day converts hours to days), WBS (wbs_code as in p6_list_wbs, wbs_path names), predecessors and successors (first 50 of each, with predecessor_count / successor_count; page further with p6_get_relationships), assignments (resource and role, quantities and costs as stored), activity codes, UDFs and notebooks (first 50 of each), lag_rule and schedule_state.
Inputs: project (required), task_code (required).
Relationships of an activity, one page: {total, offset, returned, next_offset, rows, lag_rule}. direction: pred, succ or both. Lag in hours (lag_h) and days (lag_d); lag_rule tells which calendar converts lag days (project schedule option, predecessor calendar by default).
Inputs: project (required), task_code (required), limit, offset, +1 more.
DCMA 14 point assessment of the last P6 schedule run (F9). checks: logic, leads, lags, long_lags, fs_links, hard_constraints, high_float, negative_float, high_duration, invalid_dates, resources, missed_tasks, critical_path_test (this server's CPM engine: the earliest lowest-float open task delayed 100 working days must move the project finish as much; not run when the engine does not match the F9, see p6_cpm_validate), cpli, bei; each {count, denominator, pct, threshold, pass, sample (15)}; then key_dates (information only: constraint dates against the must finish date, the work after them and each other; count = issues, pct = constraints with an issue). Open = not completed; LOE and WBS summary activities are left out, also as either end of a link; relationship checks count links whose successor is open. pct must stay at most the threshold, except fs_links (at least), cpli and bei (value at least), compared before rounding; pass is None when not evaluated. Thresholds: the project's Check Schedule settings (PROJPROP schedule_check, limits in hours) when stored, else DCMA defaults (limits 44 d of each calendar; resources has none: not evaluated unless thresholds= sets it); threshold_source says which. thresholds= overrides by check name (not critical_path_test); high_float_days sets the high float limit. lags and fs_links also give ladder_pairs (SS + FF between the same activities with the same lag) and their values without them (information). Logic exempts only the project start and finish milestones (listed); dangling starts and finishes (milestones left out, see p6_dangling) are information only. missed_tasks and bei need a baseline: baseline= (Project ID), else the project baseline; baseline_dates 'current' (actual, else early finish) or 'planned' (its planned finish); a task is missed when not finished or finished on a later day. duration_basis: remaining or original. cpli: working days of the project calendar (calendar days beside it). check= returns that check's full list of items as a page {total, offset, returned, next_offset, rows} with result (the check) instead of the whole report. A full run saves a snapshot for p6_health_check_compare (snapshot.id; save_snapshot=False skips it). The earlier top keys stay: no_predecessor, no_successor, hard_constraints, high_float, negative_float {count, sample}; leads_negative_lag, positive_lags, non_fs_links (links whose successor is open). checks.logic_density (after logic): links whose successor is open / open activities, value at least 1.5 (not in summary or score, which stay the DCMA 14). negative_float.worst and high_float.worst: the open activity with the lowest / highest total float {task_code, task_name, total_float_d}. weighted_score {points, grade, earned, max, checks {name: {weight, status pass / warn / fail / not_evaluated, earned}}}: logic_density 20, logic 20, critical_path_test 15, negative_float 15, high_float 10, hard_constraints 10, high_duration 5, leads 5, lags 5, fs_links 5; pass = the weight, warn = half (a failed at most check up to 2 x its threshold, a failed at least check down to 0.9 x it; no band for a zero threshold), fail = 0, not evaluated left out; points = earned / weight of the evaluated checks x 100; grade A >= 90, B >= 80, C >= 70, D >= 55, else F. engine_version: the CPM engine of the critical path test.
Inputs: project (required), check, limit, offset, +6 more.
Projects, one page: {total, offset, returned, next_offset, rows}. Row: Project ID, name, data date, planned start, scheduled finish, status (of the project WBS node), baseline_of, and the EPS node holding it: eps_id, eps_name, eps_path (EPS names from the top, joined with ' > '); all three None for a project outside every EPS node. EPS nodes are never listed; baselines only with include_baselines=True (baseline_of is set); exclude_templates=True leaves out the P6 template projects (status WS_Template, or no EPS node). eps= an EPS ID: the projects of that EPS node and of every EPS below it. order: 'project' (Project ID) or 'eps' (EPS tree order as p6_list_eps order='tree', then Project ID; projects outside every EPS node last).
Inputs: eps, limit, order, offset, +2 more.
WBS tree in P6 order (each node before its children), one page: {total, offset, returned, next_offset, rows, root}. Row: wbs_id, parent_wbs_id, depth (project node 0), wbs_code (as P6 shows it, e.g. 'PRJ.5.1'), wbs_short_name, wbs_name, children (direct), and with rollups=True the rollup of its whole subtree: activities, open (not completed, LOE and WBS summary left out), not_started, in_progress, completed, min_tf_d and negative_float (open activities, days of each calendar), start, finish (actual, else early), budget_units, actual_units (labor plus nonlabor), units_pct (actual / at completion, as P6 Units % Complete) and bl_planned_pct: baseline planned units at the data date / baseline budget units of the subtree, x 100 (the baseline's labor and nonlabor assignments placed by the Activity ID of the current activities, linear between their planned dates as p6_progress_curve and the dashboard; None without a baseline, a data date or baseline units). baseline= a Project ID (default: the project baseline); the result says which one (baseline). parent= starts at that WBS code, full or relative to the project node ('5.1'); max_depth counts levels below the start node. root repeats the start node (unplaced = activities outside the tree, when it is the project node).
Inputs: project (required), limit, offset, parent, +3 more.
Look-ahead of a project, one page: {total, offset, returned, next_offset, rows, window, weeks, data_date, counts, critical_definition, schedule_state, note}. The window starts at the data date (or from_date; a date alone starts at 00:00), lasts days= (default 14) or weeks= calendar days and is half-open [from, to). Listed: not started activities starting in it, open ones finishing in it, not started ones spanning it (start before, finish after), every in-progress activity (include_in_progress=False keeps those finishing in the window) and, with include_completed=True, completed ones whose actual dates overlap it. Open activities use their remaining dates (early when empty) of the last F9. LOE and WBS summary activities are left out. Each row has window: the categories it meets (in_progress, starting, finishing, spanning, completed), critical (open and critical under the project definition, as p6_critical_path), fcst_start (actual start, else remaining start), fcst_finish (actual finish when completed, else remaining finish) and start_week / finish_week: the week of the window holding that date (1 = the first 7 days from the window start, None outside the window; weeks lists each one's from and to). critical_only=True lists the critical ones only. counts gives the categories and critical over all pages. wbs_name_contains, code_type / code_value / include_child_codes and fields= as in p6_query_activities. Order: start, finish, Activity ID.
Inputs: project (required), days, limit, weeks, +10 more.
One-call overview of a project (values of the last F9): project (name, calendar), dates (data date, planned start, must finish by, scheduled finish, last schedule run, first start and last finish of the activities, scheduled finish minus must finish by in calendar days and in working days of the project calendar (None when it is unreadable)), activities (by status, by type, open, open milestones), relationships (successor in the project; from and to other projects), critical (counts of open activities, LOE and WBS summary left out, as p6_critical_path), percent_complete (primary = units: actual / at completion units, labor plus nonlabor, P6 Units % Complete as p6_list_wbs; p6_progress_curve gives % of the budget instead; physical: physical % weighted by budget units; duration; activities completed; units_vs_physical_mismatch: activities with units whose physical % and units % differ by more than 0.01 point), baseline (the project baseline, baselines attached, the one used: baseline= else the project baseline, its scheduled finish and data date; every key present, null without a baseline; finish variance = scheduled finish minus the baseline's scheduled finish in calendar days and in working days of the project calendar, baseline planned units % at the data date and spi_units = earned units / baseline planned units, earned value and linear spread as p6_progress_curve), counts (WBS, assignments, resources, calendars, code assignments) and schedule_state.
Inputs: project (required), baseline.
Search activities, one page: {total, offset, returned, next_offset, rows}, ordered by start (actual, else early) then Activity ID. status: TK_NotStart, TK_Active or TK_Complete. Dates as YYYY-MM-DD (finish_before includes that day). wbs_name_contains matches the name of the activity's own WBS node only, not its parents: for a whole branch use p6_list_wbs, or an activity code filter. Durations and float in days of each activity's calendar. code_type (activity code type name, e.g. 'Discipline'; the project's own type wins over an EPS or global one) keeps activities with a code of that type; code_value narrows it to a code by path ('CON.MEC'), short name ('MEC': every match) or name, with its child codes unless include_child_codes=False; code_filter tells what was matched. fields= keeps task_code plus the fields named, e.g. ['task_name', 'early_start_date', 'early_end_date', 'total_float_d'], for smaller pages. UDFs (user defined columns, p6_list_udfs): udf_filter = [{udf: label, op, value}], all to hold; op eq (default), ne, lt, le, gt, ge, contains (text), empty, not_empty; a date alone covers the whole day; udf_filter (info) tells what was used. udfs = labels added to each row as udfs {label: value} (None when empty).
Inputs: project (required), udfs, limit, fields, +12 more.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 11 tools
Each tool has a clearly distinct role: project/WBS listing, activity search/detail, relationship drilldown, critical path listing, float distribution, lookahead, project summary, DCMA health check, and diagnosis. Although several tools deal with schedules and float, their boundaries are explicit and unlikely to cause misselection.
All tools use the p6_ prefix and snake_case, making them predictable and readable. Most are verb_noun or resource_action style, while a few analytic/report tools are noun phrases such as p6_critical_path and p6_float_analysis, which is a minor deviation from a strict verb_noun pattern.
Eleven tools is well-scoped for a P6 scheduling analytics server. Each tool covers a meaningful slice of the domain without obvious filler or excessive breadth.
Core scheduling analysis is well covered, but the surface has notable gaps and dead references: p6_query_activities mentions p6_list_udfs, p6_health_check references p6_health_check_compare and p6_cpm_validate, and p6_list_projects mentions p6_list_eps, none of which are exposed. Resource, calendar, and baseline-focused listing tools are also absent.
AI-powered project controls tools for Primavera P6 and Primavera Unifier.
Forensic scheduling MCP for Primavera P6 (XER): AACE windows, DCMA-14, Monte Carlo, TIA.
Primavera P6 XER forensic scheduling: AACE windows, TIA, impacted as-planned, DCMA-14, Monte Carlo.
Project scheduling: Gantt chart, dependencies, baselines, reports and AI agents
