Skip to main content
Glama
tejpalvirk

Project MCP Server

by tejpalvirk

buildcontext

Create and manage project knowledge graphs by adding entities, relationships, and observations. Organize projects, tasks, milestones, and team members while tracking dependencies, statuses, and priorities for structured project management.

Instructions

A versatile tool for constructing and enhancing your project management knowledge graph by adding new project elements, relationships, and observations.

When to use this tool:

  • Creating new project entities (projects, tasks, milestones, team members, etc.)

  • Establishing relationships between project elements (e.g., connecting tasks to projects, assigning team members)

  • Adding observations, properties, or metadata to existing project entities

  • Building the project management structure incrementally as your project evolves

  • Organizing and structuring project data within your management framework

  • Documenting project status, risks, and decisions

  • Tracking project dependencies and assignments

  • Creating comprehensive project timelines with connected elements

  • Setting status values for project entities

  • Assigning priorities to tasks and other entities

  • Defining task sequencing and dependencies

Key features:

  • Creates three distinct types of knowledge graph elements: entities, relations, and observations

  • Supports various project management entity types (projects, tasks, milestones, team members, etc.)

  • Validates entity and relation types against predefined standards for the project domain

  • Handles batch creation of multiple entities or relations in a single operation

  • Returns confirmation with details of created elements

  • Ensures proper data typing and structure for the project management knowledge graph

  • Enables comprehensive documentation of project structure and progress

  • Supports status and priority assignment through entity-relation model

  • Enables sequential task relationships through precedes relation

Parameters explained:

  1. type: The type of creation operation to perform

  • Accepts: "entities", "relations", or "observations"

  • Determines how the data parameter is interpreted

  1. data: The content to add to the knowledge graph (structure varies by type):

  • For "entities": An array of objects, each containing:

    • name: Unique identifier for the entity

    • entityType: One of the valid entity types for project management

    • observations: Array of strings containing properties or metadata about the entity

    • embedding: (Optional) Vector embedding for enhanced semantic search

  • For "relations": An array of objects, each containing:

    • from: Name of the source entity

    • to: Name of the target entity

    • relationType: The type of relationship between entities (e.g., "depends_on", "assigned_to", "has_status")

    • observations: (Optional) Array of strings with metadata about the relationship

  • For "observations": Either a single object or an array of objects:

    • Single object format:

      • entityName: Name of the entity to add observations to

      • observations: Array of strings with new observations to add

    • Array format:

      • Each object containing:

        • entityName: Name of the entity to add observations to

        • contents: Array of strings with new observations to add

Valid entity types:

  • project: Overall project container

  • task: Individual action items or work packages

  • milestone: Key project checkpoints

  • teamMember: Project team participants

  • risk: Potential project threats or issues

  • decision: Documented project decisions

  • resource: Project assets or materials

  • issue: Problems requiring resolution

  • dependency: Inter-element relationships

  • meeting: Project-related gatherings

  • document: Project files and documentation

  • stakeholder: Parties with interest in the project

  • status: Entity status (inactive, active, complete)

  • priority: Entity priority (low, high)

Valid relation types:

  • part_of: Entity belongs to another entity

  • depends_on: Task dependency relationship

  • assigned_to: Assignment relationship between tasks and team members

  • responsible_for: Ownership of project elements

  • created_by: Authorship relationship

  • leads_to: Sequential relationship

  • blocks: Impediment relationship

  • reports_to: Organizational hierarchy

  • collaborates_with: Collaborative relationship

  • decides_on: Decision-making relationship

  • impacts: Effect relationship

  • has_status: Links entity to its status (inactive, active, complete)

  • has_priority: Links entity to its priority (low, high)

  • precedes: Task precedes another task (for sequencing)

Status Values:

  • inactive: Work on the entity has not begun or is paused

  • active: Work is actively underway

  • complete: Work has been finished

Priority Values:

  • low: Lower priority item

  • high: Higher priority item

Return information:

  • JSON response indicating success or failure

  • For successful operations:

    • Success flag set to true

    • Details of created elements in the "created" field (for entities/relations) or info message for observations

  • For failed operations:

    • Success flag set to false

    • Error message describing the issue

Error handling:

  • Returns descriptive error messages for invalid inputs

  • Gracefully handles type mismatches and formatting errors

  • Rejects operations with invalid types

You should:

  • Use consistent naming conventions for entities to facilitate relationships and retrieval

  • Begin by creating projects before more specific project elements

  • Add detailed observations to entities to enhance context and searchability

  • Create relationships to build a comprehensive network of interconnected project data

  • Document project status and progress through has_status relations

  • Assign priorities to tasks using has_priority relations

  • Use the precedes relation to establish task sequences and dependencies

  • Assign specific team members to tasks using relations

  • Track project risks with detailed observations

  • Document decisions with context and rationale

  • Update entity observations regularly to reflect current project information

  • Check the operation result to confirm successful creation

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
dataYesData for the creation operation, structure varies by type but must be an array
typeYesType of creation operation: 'entities', 'relations', or 'observations'
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it creates three types of elements (entities, relations, observations), validates against standards, handles batch creation, returns confirmation details, ensures data typing, and includes error handling with descriptive messages. It covers creation operations comprehensively but could mention rate limits or authentication needs.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with sections like 'When to use', 'Key features', and 'Parameters explained', but it is overly verbose with repetitive lists (e.g., 14 entity types, 14 relation types). Some sentences could be condensed (e.g., the 'You should' section has redundant advice), reducing efficiency. It's front-loaded with purpose but includes unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (2 parameters, no output schema, no annotations), the description is highly complete. It covers purpose, usage, behaviors, parameters, valid types, return information, error handling, and best practices. It provides all necessary context for an AI agent to select and invoke the tool correctly, despite the lack of structured annotations or output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, but the description adds significant value beyond the schema. It explains the 'type' parameter with its three enum values and details the 'data' parameter's structure for each type, including nested objects, optional fields, valid entity/relation types, and status/priority values. This compensates for the schema's lack of nested object details and enriches parameter understanding.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose as 'constructing and enhancing your project management knowledge graph by adding new project elements, relationships, and observations.' It specifies the verb ('constructing and enhancing'), resource ('project management knowledge graph'), and distinguishes from siblings like 'deletecontext' (deletion) and 'loadcontext' (loading).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description includes an explicit 'When to use this tool' section with 12 bullet points covering scenarios like creating entities, establishing relationships, and adding metadata. It provides clear context for when to use this tool versus alternatives (e.g., for creation vs. deletion with 'deletecontext'), though it doesn't name specific sibling tools, it implies usage distinctions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Related Tools

Latest Blog Posts

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/tejpalvirk/project'

If you have feedback or need assistance with the MCP directory API, please join our Discord server