PCP (Project Context Protocol)

Standardize Context, Not Intelligence.

One Project Context. Every Contributor.

PCP (Project Context Protocol) is an open standard for preserving, organizing, and transferring project context so any contributor—human, AI, or automation—can continue a software project consistently, regardless of who or what takes over next.

Why PCP?

Software projects lose continuity every day.

Knowledge stays inside people's heads.

Important decisions disappear in chat histories.

Documentation becomes outdated.

AI assistants start from scratch because project context is fragmented.

New contributors spend valuable time rediscovering information that already exists.

As projects grow, context becomes scattered across documentation, source code, issue trackers, chats, and individual experience.

PCP exists to preserve project continuity.

🚀 Start Here

📖 New to PCP? Read our practical beginner guides:

• 🇹🇷 Türkçe Rehber (5 Dakikada PCP)

• 🇬🇧 PCP Explained for AI Developers

Related MCP server: Reverie

⚡ Quickstart (CLI & MCP)

1. Initialize Context

For fresh repositories:

npx @craftsolutions/pcp init --name "My Project"

Or smart-bootstrap from an existing codebase (auto-detects tech stack, package manager, and scripts):

npx @craftsolutions/pcp bootstrap

2. Verify Context Integrity (Linter)

npx @craftsolutions/pcp check

3. Pack Context for Web LLMs (ChatGPT, Claude.ai, DeepSeek)

# Copy token-optimized active context directly to clipboard (macOS)
npx @craftsolutions/pcp pack -a | pbcopy

# Or compile into a portable Markdown file
npx @craftsolutions/pcp pack -o context-bundle.md

4. Sync Directives to AI Editors (.cursorrules, CLAUDE.md, Copilot)

# Injects or updates PCP directives without touching your existing custom rules
npx @craftsolutions/pcp sync-rules

5. Connect to AI Assistants via MCP (Cursor / Claude / Antigravity)

Add this to your IDE's MCP configuration:

{
  "mcpServers": {
    "pcp": {
      "command": "npx",
      "args": ["-y", "@craftsolutions/pcp", "mcp"]
    }
  }
}

🔍 Why PCP vs Other Solutions?

Repository Guide

What is PCP?

PCP defines a shared Project Context standard.

Instead of teaching every AI system how your project works, PCP standardizes the information surrounding the project itself.

This enables:

• Humans

• AI assistants

• Autonomous agents

• Development tools

• Future contributors

to work from the same understanding of a project.

The Core Idea

Software projects should not depend on memory.

They should depend on shared context.

PCP creates a single, structured Project Context that survives:

• contributor changes

• AI model changes

• team growth

• long development pauses

• tooling evolution

One project.

One context.

Every contributor.

Core Principles

• Context over conversations

• Continuity over memory

• Concepts over files

• Open by design

• Human and AI collaboration

• Preserve knowledge, don't rediscover it

• Standardize context, not tools

How PCP Works

Contributor
      │
      ▼
Project Context
      │
      ▼
Next Contributor
      │
      ▼
Project Continuity

Every contributor reads from the same Project Context.

Every contributor leaves the project with better context than they found.

What PCP Is

PCP is:

• An open standard

• A Project Context Protocol

• A continuity-first approach to software development

• Human and AI friendly

• Technology independent

• Implementation independent

What PCP Is Not

PCP is not:

• an AI framework

• an agent framework

• a prompt library

• a project management tool

• a documentation platform

• a version control system

• a knowledge base application

PCP standardizes context, not intelligence, tools, or workflows.

Reference Implementation

This repository contains the official reference implementation of PCP.

The reference implementation uses Markdown documents to demonstrate the concepts defined by the specification.

Alternative implementations may use different file formats, databases, or storage systems, provided they preserve the required concepts defined by the specification.

The specification defines concepts.

Reference implementations demonstrate practical implementations.

Repository Structure

docs/           Specifications, guidelines, benchmarks, and schemas
context/        Living project context of PCP itself (Dogfooding)
cli/            Official Node.js CLI & Model Context Protocol (MCP) server
rfcs/           Design decisions and architectural proposals
reference/      Canonical reference implementation template
examples/       Real-world and example projects
assets/         Images and diagrams
scripts/        Development utilities

Project Status

🚀 v0.1.2 Production Ready & Public Release

PCP v0.1 specification is complete and published alongside its official Level 2/3 Reference Implementation, CLI tool (@craftsolutions/pcp), and native Model Context Protocol (MCP) server.

Roadmap

• Complete PCP Specification v0.1

• Publish Canonical Reference Context Template (reference/context-template)

• Release Official CLI MVP (init, check, status)

• Release Native MCP Server (pcp mcp) with 9 tools and 7 resources

• Publish to NPM Registry (@craftsolutions/pcp)

• Implement Phase 2 Developer Ergonomics (pack, sync-rules, bootstrap)

• Establish Enterprise Governance, Handshake & Autonomous Sync Protocols

• Verify Real-World Production Codebases (servis-planer-web, mobilservistakip.com.tr)

• VS Code / IDE Language Extension

• Community Ecosystem Listings (Glama, Awesome-MCP)

• PCP v1.0 Formal Standard Ratification

Vision

We believe software projects should be able to continue regardless of who—or what—takes over.

Project continuity should not depend on memory.

It should depend on a shared, structured, and portable Project Context.

Philosophy

Don't preserve conversations.

Preserve context.

License

MIT License.