projectlibre-mcp
Click on "Install 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., "@projectlibre-mcpsummarize the Gantt chart for my project"
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.
projectlibre-mcp
Read-only MCP server for
ProjectLibre .pod files. Lets Claude Code
(or any MCP client) find your project files, summarize Gantt charts, inspect
tasks, and analyze schedules — without opening ProjectLibre.
.pod parsing is done by MPXJ via JPype.
Requirements
Python 3.12+
Java 11+ on the PATH (required by MPXJ; e.g.
brew install --cask corretto)
Related MCP server: project-mcp
Setup
git clone https://github.com/augmdc/projectlibre-mcp.git
cd projectlibre-mcp
python3 -m venv .venv
.venv/bin/pip install -e .Register with Claude Code
From the repo directory:
claude mcp add --scope user projectlibre -- \
"$(pwd)/.venv/bin/python" -m projectlibre_mcp.serverRestart Claude Code and ask something like "Summarize my project Gantt chart". For other MCP clients, configure a stdio server with the same command.
Tools
list_projects()— find.podfiles under your search rootsget_project_summary(path)— dates, counts, % complete, top-level outlinelist_tasks(path, incomplete_only?, start_after?, finish_before?)— tasks with hierarchy, dates, and predecessorsanalyze_schedule(path, as_of?, horizon_days?)— overdue / upcoming / critical-path tasks
Configuration
POD_SEARCH_ROOTS— colon-separated directorieslist_projectsscans (default~/Desktop:~/Documents). Pass it at registration time withclaude mcp add --scope user --env POD_SEARCH_ROOTS="~/Projects" ....
Development
.venv/bin/pip install -e . pytest
.venv/bin/pytestSet POD_TEST_FILE=/path/to/some.pod to enable the smoke test against a real
file.
Limitations
Read-only. .pod is ProjectLibre's serialized-Java format; no library can
safely write it. Planned edit path: write MS Project XML for ProjectLibre to
open and re-save as .pod.
License
MIT
Available Tools
4 toolsanalyze_scheduleA
Report overdue, upcoming, and critical-path tasks for a .pod project.
Args: path: Absolute path to the .pod file. as_of: Reference date YYYY-MM-DD (default: today). horizon_days: Window for upcoming tasks (default 30).
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | ||
| as_of | No | ||
| horizon_days | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description indicates a read-only reporting behavior by listing key parameters (path, as_of, horizon_days). However, since no annotations are provided, the description could more explicitly state that no modifications are made. It adequately discloses the temporal scope and required input.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: one sentence for purpose followed by a clear argument list. No redundant information; every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description fully explains input parameters but omits details about the output format (e.g., whether it returns a list, summary, or structured data). Given no output schema, more context on return type would improve completeness. However, the description is adequate for basic understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates by explaining each parameter's purpose: path (absolute file path), as_of (reference date), horizon_days (window). The schema provides types but no descriptions, so the description adds significant meaning. It could further clarify default behavior for as_of when null.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it reports overdue, upcoming, and critical-path tasks for a .pod project. The verb 'Report' and specific task categories differentiate it from siblings like list_projects and list_tasks, which focus on listing rather than analytical reporting.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for schedule analysis but does not explicitly state when to use this tool versus alternatives like list_tasks or get_project_summary. No exclusions or direct comparisons are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_project_summaryA
Summarize a .pod project: dates, counts, completion, top-level outline.
Args: path: Absolute path to the .pod file (use list_projects to find it).
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes what the tool does (summarize) and what the output includes, but does not explicitly disclose whether it is read-only, side effects, or auth requirements. The verb 'summarize' strongly implies read-only, but explicit disclosure would improve transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences plus an args section. It is front-loaded with the main purpose, and every word contributes value. No redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema), the description is reasonably complete. It covers the tool's output nature (dates, counts, completion, outline) and provides guidance for the parameter. It does not detail the exact return format, but the description gives sufficient context for an AI agent to understand what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It provides a clear explanation for the 'path' parameter: 'Absolute path to the .pod file (use list_projects to find it).' This adds meaning beyond the schema's type and title, including a prerequisite hint. For a single parameter, this is effective.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Summarize') and resource ('.pod project'), and specifies the summary contents (dates, counts, completion, top-level outline). It is easy to understand, though it does not explicitly differentiate it from sibling tools; however, the sibling names are distinct enough to imply different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a helpful prerequisite hint ('use list_projects to find it') but does not explicitly state when to use this tool vs alternatives or any when-not conditions. Usage context is implied by the tool's purpose, but explicit guidance is lacking.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_projectsA
Find ProjectLibre .pod files under the configured search roots.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the tool finds files (read-only), but does not disclose any additional behavioral traits such as permissions, side effects, or return format. This is adequate for a simple listing tool but minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no unnecessary words. It is front-loaded with the verb and resource. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters, an output schema, and sibling tools listed, the description fully explains the tool's purpose. No additional information is needed for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so schema coverage is complete. The description does not need to add parameter meaning. Baseline 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool finds ProjectLibre .pod files under configured search roots. It uses a specific verb 'Find' and resource '.pod files', distinguishing it from sibling tools like analyze_schedule or list_tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for discovering project files, but it does not explicitly state when to use this tool versus siblings or provide any exclusions or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_tasksA
List tasks in a .pod project with hierarchy, dates, and predecessors.
Args: path: Absolute path to the .pod file. incomplete_only: Drop summary rows and tasks at 100%. start_after: Keep tasks starting on/after this date (YYYY-MM-DD). finish_before: Keep tasks finishing on/before this date (YYYY-MM-DD).
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | ||
| start_after | No | ||
| finish_before | No | ||
| incomplete_only | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It explains argument effects (e.g., incomplete_only drops rows) but does not disclose side effects, authentication needs, or read-only nature. Output schema compensates but description could be more explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is concise: one-sentence purpose followed by clear argument list. No fluff or repetition, every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given output schema, description doesn't need to detail return values. It covers all parameters and hints at output content. Missing explicit mention of read-only or performance characteristics, but still adequately complete for a listing tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but description provides detailed docstring for all 4 parameters (path, incomplete_only, start_after, finish_before), explaining their purpose and formats clearly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states verb 'List' and resource 'tasks in a .pod project', and specifies included data (hierarchy, dates, predecessors). Distinguished from siblings like list_projects and get_project_summary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Purpose implies usage for listing tasks, but description lacks explicit when-to-use or when-not-to-use guidance relative to siblings. No exclusion criteria or alternative tool mentions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
4 tool updates
v0.1.0- First observed
analyze_schedule - First observed
get_project_summary - First observed
list_projects - First observed
list_tasks
TDQS
Each tool has a distinct and clear purpose: file discovery (list_projects), project overview (get_project_summary), task listing with filters (list_tasks), and schedule analysis (analyze_schedule). There is no overlap or ambiguity among them.
All tool names follow a consistent verb_noun pattern using snake_case (list_projects, list_tasks, get_project_summary, analyze_schedule). This makes the naming predictable and easy to understand.
With 4 tools, the set is well-scoped for a ProjectLibre analysis server. Each tool serves a necessary function without being excessive or insufficient for common project management queries.
The tools cover the core analysis workflow: finding files, summarizing, listing tasks with filters, and performing schedule analysis. Minor gaps exist (e.g., no tool for detailed single-task info or resource data), but these do not hinder typical use cases for a read-only analytical server.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server for generating rough-draft project plans from natural-language prompts.
An MCP server that provides read access to your cloud storage providers, bank accounts and more.
2,000+ MCP servers read at source level. Know what one does before you connect. Free, no key.
Read-only MCP server for ClassQuill, a tutoring-business-management platform.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that gives LLMs read-only access to Microsoft Project Online (Project for the Web) via the Microsoft Graph API.24MIT
- AlicenseNot gradedqualityCmaintenanceMCP server that enables LLMs to read and analyze Microsoft Project schedules, including critical path, resources, and advanced construction planning layers (AWP and LPS) for work packages and Lean planning.MIT
- AlicenseNot gradedqualityDmaintenanceA read-only MCP server for PDF analysis that enables text extraction, image extraction, metadata retrieval, and text search via natural language.MIT
- FlicenseNot gradedqualityCmaintenanceRead-only MCP server for AI clients to browse and search project files securely, with configurable permissions, virtual paths, and key-based access.-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/augmdc/projectlibre-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server