Claude Faf MCP Server: Persistent AI Project DNA

Overview

The Claude Faf MCP Server provides a lightweight, developer-focused backend for creating and maintaining persistent AI “project DNA” using the Model Context Protocol (MCP). It packages and synchronizes project context, tooling state, and metadata into the .faf format (IANA .faf format compatibility), making context sharable, versionable, and reproducible across sessions and systems.

The server is useful when you need a canonical, machine-readable context for agents, pipelines, or model sessions — for example, to persist prompt history, tool definitions, evaluation artifacts, and project metadata. By exposing a REST/CLI surface and a collection of build/score/sync tools, it helps teams keep model context stable, auditable, and portable.

Features

• Persistent project context stored in IANA .faf format for reliable serialization and exchange
• 33 built-in tools covering build, transform, scoring, import/export, and sync workflows
• HTTP REST API and optional CLI interface for automation and CI/CD
• Pluggable storage backends (local filesystem, S3-compatible stores)
• Project versioning and incremental sync to reduce transfer and recompute
• Tool-level hooks to run custom build or evaluation logic
• Configurable authentication and transport (API token, local-only mode)
• Export/import utilities for sharing .faf packages between environments

Installation / Configuration

Clone the repository and run with Docker or locally. The examples below assume the repo is available at https://github.com/Wolfe-Jam/claude-faf-mcp.

Install and run (local, Node/npm example):

git clone https://github.com/Wolfe-Jam/claude-faf-mcp.git
cd claude-faf-mcp
# install dependencies
npm install
# run the server
npm start

Run with Docker:

docker build -t claude-faf-mcp .
docker run -p 8080:8080 -e MCP_PORT=8080 -e MCP_DATA_DIR=/data claude-faf-mcp

Minimal configuration (mcp.config.json):

{
  "port": 8080,
  "dataDir": "./data",
  "storage": {
    "backend": "local",
    "localPath": "./data/faf"
  },
  "auth": {
    "mode": "token",
    "token": "changeme"
  }
}

Environment variables commonly supported:

• MCP_PORT — HTTP port (default 8080)
• MCP_DATA_DIR — root data directory for .faf projects
• MCP_AUTH_TOKEN — API token for authenticated routes

API quick check (curl):

# list available tools
curl -H "Authorization: Bearer $MCP_AUTH_TOKEN" http://localhost:8080/api/tools

# create a new project (POST with JSON body)
curl -X POST -H "Authorization: Bearer $MCP_AUTH_TOKEN" -H "Content-Type: application/json" \
  -d '{"id":"example-project","name":"Example Project"}' \
  http://localhost:8080/api/projects

Available Tools / Resources

The server ships a suite of 33 tools grouped by purpose. You can query the full list at the /api/tools endpoint. Common categories and example tools:

Each tool exposes a simple input/output contract: JSON in, JSON out. Tools can be executed via API, CLI, or chained in server-side workflows.

Use Cases

• Reproducible model experiments

  • Persist experiment prompts, toolchains, and evaluation metrics into a .faf package. Re-run experiments by reloading the same .faf to ensure identical context and tooling.

• Team-shared agent context

  • Store “project DNA” including persona, instructions, and utility tools. Team members and agent instances fetch the same .faf to ensure consistent behavior across deployments.

• CI/CD for prompt engineering

  • Integrate MCP server into CI pipelines: generate .faf artifacts on PRs, run score-runner to validate performance, and fail builds if regressions are detected.

• Multi-agent orchestration

  • Use sync-push and sync-pull to distribute consistent context to multiple agents or worker nodes, reducing drift and simplifying coordination.

• Migration and backup

  • Export .faf packages for backups or to migrate projects between environments (local → cloud, staging → production).

Example: Create and Export Project

1. Create a project:

curl -X POST -H "Authorization: Bearer $MCP_AUTH_TOKEN" -H "Content-Type: application/json" \
  -d '{"id":"invoice-parser","name":"Invoice Parser","meta":{"owner":"data-team"}}' \
  http://localhost:8080/api/projects

2. Add tools or artifacts (example: attach a manifest):

curl -X POST -H "Authorization: Bearer $MCP_AUTH_TOKEN" -H "Content-Type: application/json" \
  -d '{"projectId":"invoice-parser","manifest":{"version":"1.0","entries":[]}}' \
  http://localhost:8080/api/projects/invoice-parser/manifest

3. Export .faf package:

curl -H "Authorization: Bearer $MCP_AUTH_TOKEN" \
  http://localhost:8080/api/projects/invoice-parser/export -o invoice-parser.faf

Where to get it

Source and issues: https://github.com/Wolfe-Jam/claude-faf-mcp

For developers new to this tool: start by running the server locally, calling /api/tools to inspect what’s available, and creating a small project to export/import as a .faf package. The server is designed to integrate into automation and CI pipelines, so try wiring simple build-and-score flows first and iterate from there.