MCP server intelligence profile

claude-faf-mcp Server

.FAF (Foundational AI-context Format) with 50+ tools - Only Persistent project context that integrates seamlessly with Claude Desktop workflows. Officially merged (#2759) Anthropic MCP server

HybridWolfe-Jam
Awaiting current scanNpm · 5.22.1

The selected current version does not yet have completed public verification. Unknown does not mean clean or vulnerable.

1Distribution channel
12Independently observed tools
0Linked remote endpoints
AvailableVersion intelligence

Detailed security scan evidence is not public for this MCP yet. Public identity, registry metadata, and independently observed protocol inventory remain available.

Install and connect

Installation and connection instructions are shown only when supported by retained package, repository, or endpoint evidence.

Install claude-faf-mcp from npm

Install exact version 5.22.1. No verified executable entrypoint is available, so use the package documentation to launch it.

npm install --save-exact claude-faf-mcp@5.22.1

Identity

Canonical slugclaude-faf-mcp-54146bf0DeploymentHybrid
Canonical packagenpm:claude-faf-mcpRepositoryWolfe-Jam/claude-faf-mcp
First published—Latest release—
Last security verification—Classification confidence82%
PublicationDraftOfficial distributionNot verified

Distributions

ChannelIdentifierCurrent versionVersionsSource
npmclaude-faf-mcp5.22.1109Repository

Current release

PackageVersionPublished / observedInventorySecurity scan
npmclaude-faf-mcp5.22.1CurrentSep 5, 202612 toolsSucceeded · 3 resources · 2 promptsEvidence restricted
Enterprise protection

Continuously monitor this MCP for security risk

Independently scan the exact version your agents use, receive alerts when its risk changes, and investigate every finding with retained version evidence.

  • Independent exact-version security scans
  • Continuous release and vulnerability monitoring
  • Risk-change alerts with capability context
  • Historical evidence and API exports
Custom pricingContact salesTailored to your organization, integrations, data needs, and support requirements.

Current version evidence

No public current-version evidence is available yet.

Current protocol inventory

2025-06-18Negotiated protocol
claude-faf-mcpServer-reported name
3Capability groups
Aug 21, 2026Observed

Tools 12

ToolCategoryAnnotationsRisk
faf_aboutExplain what the FAF format is — project DNA for AI — with its IANA registration, version, and connected platforms. Returns format metadata and the available MCP bridges. Use this when someone asks what FAF is or how it connects to other AI tools.
Input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
Annotations
{
  "title": "About FAF",
  "readOnlyHint": true,
  "destructiveHint": false,
  "openWorldHint": false
}
—Read onlyNon-destructiveClosed world—
faf_autoScan your manifests (package.json, Cargo.toml, pyproject.toml, go.mod…) and fill the project.faf stack slots from real dependencies — no hardcoded defaults. Returns what was detected and the updated score. Use this for the technical context; use faf_go for the human 6Ws it can't detect,
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "description": "Project path. Sets session context for subsequent calls."
    },
    "force": {
      "type": "boolean",
      "description": "Force overwrite existing files"
    }
  },
  "additionalProperties": false
}
Annotations
{
  "title": "Auto-detect Context",
  "readOnlyHint": false,
  "destructiveHint": false,
  "openWorldHint": false
}
—WritesNon-destructiveClosed world—
faf_benchProve the .faf earns its place — measure how much the context is worth, on THIS repo, falsifiably. Questions derive from the project.faf's own populated slots (the .faf is the answer key), so grading is mechanical — no judge, no rubric. action=questions returns the answer-key-safe question set; action=grade takes your answers WITHOUT the .faf (cold) and WITH it (faf), grades both, and returns the cold→with-faf lift with a ✪ receipt. The delta is the product; the cold number belongs to the absence of context, never to FAF.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "description": "Project path (optional — current directory if omitted)."
    },
    "action": {
      "type": "string",
      "enum": [
        "questions",
        "grade"
      ],
      "description": "questions = get the answer-key-safe question set to answer; grade = submit cold + with-faf answers to score the delta. Default: questions."
    },
    "cold": {
      "type": "object",
      "description": "action=grade: answers produced WITHOUT the .faf (general repo knowledge only). Map of question number → answer string.",
      "additionalProperties": {
        "type": "string"
      }
    },
    "faf": {
      "type": "object",
      "description": "action=grade: answers produced WITH the project.faf in context. Map of question number → answer string.",
      "additionalProperties": {
        "type": "string"
      }
    },
    "coldTokens": {
      "type": "number",
      "description": "action=grade (optional): tokens spent answering cold."
    },
    "fafTokens": {
      "type": "number",
      "description": "action=grade (optional): tokens spent answering with the .faf."
    },
    "model": {
      "type": "string",
      "description": "action=grade (optional): the model that produced the answers."
    }
  },
  "additionalProperties": false
}
Output schema
{
  "type": "object",
  "description": "Question set (action=questions) or the cold→with-faf grading + ✪ receipt (action=grade).",
  "properties": {
    "action": {
      "type": "string"
    },
    "version": {
      "type": "string"
    },
    "qsetHash": {
      "type": "string",
      "description": "Hash of the question set — rides the receipt; same .faf reproduces it."
    },
    "protocol": {
      "type": "string",
      "description": "in-session — answers are self-reported by the agent under test."
    },
    "total": {
      "type": "number",
      "description": "Number of questions in the set."
    },
    "questions": {
      "type": "array",
      "description": "action=questions only — NEVER includes the answer key.",
      "items": {
        "type": "object",
        "properties": {
          "n": {
            "type": "number"
          },
          "path": {
            "type": "string",
            "description": "The .faf slot this question probes."
          },
          "question": {
            "type": "string"
          }
        }
      }
    },
    "cold": {
      "type": "object",
      "description": "action=grade — score WITHOUT context (absence baseline).",
      "properties": {
        "correct": {
          "type": "number"
        },
        "total": {
          "type": "number"
        },
        "misses": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Slots missed (paths only — no answer key)."
        }
      }
    },
    "faf": {
      "type": "object",
      "description": "action=grade — score WITH the .faf.",
      "properties": {
        "correct": {
          "type": "number"
        },
        "total": {
          "type": "number"
        },
        "misses": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      }
    },
    "delta": {
      "type": "number",
      "description": "with-faf minus cold — the product."
    },
    "receipt": {
      "type": "object",
      "description": "✪ receipt — sha256 over the canonical projection; third-party verifiable.",
      "properties": {
        "projection": {
          "type": "string"
        },
        "hash": {
          "type": "string"
        }
      }
    }
  }
}
Annotations
{
  "title": "AI-Grounding Benchmark",
  "readOnlyHint": true,
  "destructiveHint": false,
  "openWorldHint": false
}
—Read onlyNon-destructiveClosed world—
faf_contextSet or show the active project path that subsequent faf_ calls resolve against. Returns the current context path. Call this once at the start of a session so the other tools target the right project.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "description": "Set active project path. If omitted, shows current context."
    }
  },
  "additionalProperties": false
}
Output schema
{
  "type": "object",
  "description": "The active project context and whether a project.faf lives there.",
  "properties": {
    "active": {
      "type": "string",
      "description": "Absolute path of the active project"
    },
    "hasFaf": {
      "type": "boolean",
      "description": "Whether a project.faf (or .faf) was found there"
    },
    "filename": {
      "type": [
        "string",
        "null"
      ],
      "description": "The .faf filename, if found"
    },
    "changed": {
      "type": "boolean",
      "description": "True if this call set a new context, false if it only reported"
    }
  },
  "required": [
    "active",
    "hasFaf",
    "changed"
  ],
  "additionalProperties": true
}
Annotations
{
  "title": "View Context",
  "readOnlyHint": true,
  "destructiveHint": false,
  "openWorldHint": false
}
—Read onlyNon-destructiveClosed world—
faf_doctorDiagnose a project.faf: report empty or weak slots, common issues, and how to fix each. Returns a prioritized checklist. Use this when faf_score is below target and you need to know why.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "description": "Project path. Sets session context for subsequent calls."
    }
  },
  "additionalProperties": false
}
Output schema
{
  "type": "object",
  "description": "Health check: an overall verdict plus per-check diagnostics with fixes.",
  "properties": {
    "health": {
      "type": "string",
      "description": "Overall verdict: ok | warning | error"
    },
    "checks": {
      "type": "number",
      "description": "Number of checks run"
    },
    "errors": {
      "type": "number",
      "description": "Count of error-level findings"
    },
    "warnings": {
      "type": "number",
      "description": "Count of warning-level findings"
    },
    "diagnostics": {
      "type": "array",
      "description": "Per-check results",
      "items": {
        "type": "object",
        "properties": {
          "status": {
            "type": "string",
            "description": "ok | warning | error"
          },
          "message": {
            "type": "string"
          },
          "fix": {
            "type": "string",
            "description": "Suggested fix, if any"
          }
        },
        "required": [
          "status",
          "message"
        ]
      }
    }
  },
  "required": [
    "health",
    "checks",
    "diagnostics"
  ],
  "additionalProperties": true
}
Annotations
{
  "title": "Diagnose Issues",
  "readOnlyHint": true,
  "destructiveHint": false,
  "openWorldHint": false
}
—Read onlyNon-destructiveClosed world—
faf_etchRemember a decision, gotcha, or win across sessions by writing it to the project soul (.fafm). Returns the stored memory's id. Use this to persist something an AI should recall later; use faf_recall to read them back.
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "The memory to remember — capture the why (decision/gotcha/win)"
    },
    "id": {
      "type": "string",
      "description": "Stable id — re-etching the same id updates in place (dedup)"
    },
    "type": {
      "type": "string",
      "enum": [
        "project",
        "reference",
        "user",
        "feedback"
      ],
      "description": "Memory category"
    },
    "priority": {
      "type": "string",
      "enum": [
        "ephemeral",
        "standard",
        "high",
        "critical"
      ],
      "description": "Recall ranks by priority then recency"
    },
    "tags": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Tags (e.g. decision, gotcha, win) for filtering + recall coupling"
    },
    "path": {
      "type": "string",
      "description": "Project path. Sets session context for subsequent calls."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}
Output schema
{
  "type": "object",
  "description": "The etched fact + soul state.",
  "properties": {
    "etched": {
      "type": "object",
      "properties": {
        "text": {
          "type": "string"
        },
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "type": {
          "type": [
            "string",
            "null"
          ]
        },
        "priority": {
          "type": "string"
        },
        "tags": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "timestamp": {
          "type": "string"
        }
      }
    },
    "soul": {
      "type": "string",
      "description": "Path to soul.fafm"
    },
    "total": {
      "type": "number",
      "description": "Total memories in the soul"
    },
    "namepoint": {
      "type": "string"
    }
  },
  "required": [
    "etched",
    "soul"
  ],
  "additionalProperties": true
}
Annotations
{
  "title": "Etch Memory",
  "readOnlyHint": false,
  "destructiveHint": false,
  "openWorldHint": false
}
—WritesNon-destructiveClosed world—
faf_goThe friendly front door — "let's go, tell me about your idea." Asks the human the 6Ws (goal, why, who, what, where, when) that can't be auto-detected, then applies them to project.faf. If no project.faf exists yet, faf_go bootstraps it first (creates it, sources the stack) so you go from nothing to the 6Ws in one step. Returns the Table-of-8 to confirm/answer, or applies the answers you pass back. Use faf_auto for the technical stack on its own.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "description": "Project path. Sets session context for subsequent calls."
    },
    "answers": {
      "type": "object",
      "description": "Answers to apply. Keys are field paths (e.g., \"project.goal\", \"human_context.why\"), values are the answers. If provided, applies answers and returns new score.",
      "additionalProperties": {
        "type": "string"
      }
    }
  },
  "additionalProperties": false
}
Annotations
{
  "title": "Guided Setup",
  "readOnlyHint": false,
  "destructiveHint": false,
  "openWorldHint": false
}
—WritesNon-destructiveClosed world—
faf_initCreate a new project.faf with a name, goal, and language. Returns the file path and starting score. Won't overwrite an existing file — use faf_auto to fill the stack from your manifests, or faf_go for the human 6Ws.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "description": "Project path or name. Smart resolution: \"my-app\" finds ~/Projects/my-app OR ~/Code/my-app. Full paths like ~/Projects/app or /Users/me/code/app work too. Omit to use current directory."
    },
    "force": {
      "type": "boolean",
      "description": "Overwrite existing project.faf if it exists"
    }
  },
  "additionalProperties": false
}
Annotations
{
  "title": "Initialize .faf",
  "readOnlyHint": false,
  "destructiveHint": false,
  "openWorldHint": false
}
—WritesNon-destructiveClosed world—
faf_recallRecall memories from the project soul (.fafm), ranked by priority then recency, filtered by query/tags/type. Returns the matching entries. Use this to surface past decisions; use faf_etch to add new ones.
Input schema
{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Case-insensitive substring match on memory text (optional)"
    },
    "tags": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Filter by tag intersection"
    },
    "type": {
      "type": "string",
      "description": "Filter by memory type"
    },
    "minPriority": {
      "type": "string",
      "enum": [
        "ephemeral",
        "standard",
        "high",
        "critical"
      ],
      "description": "Priority floor (default ephemeral)"
    },
    "limit": {
      "type": "number",
      "description": "Max memories to return"
    },
    "path": {
      "type": "string",
      "description": "Project path. Sets session context for subsequent calls."
    }
  },
  "additionalProperties": false
}
Output schema
{
  "type": "object",
  "description": "Ranked memories from the soul.",
  "properties": {
    "memories": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "text": {
            "type": "string"
          },
          "id": {
            "type": [
              "string",
              "null"
            ]
          },
          "type": {
            "type": [
              "string",
              "null"
            ]
          },
          "priority": {
            "type": "string"
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "timestamp": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    },
    "total": {
      "type": "number",
      "description": "Number returned"
    },
    "soulTotal": {
      "type": "number",
      "description": "Total memories in the soul"
    },
    "soul": {
      "type": "string"
    }
  },
  "required": [
    "memories",
    "total"
  ],
  "additionalProperties": true
}
Annotations
{
  "title": "Recall Memory",
  "readOnlyHint": true,
  "destructiveHint": false,
  "openWorldHint": false
}
—Read onlyNon-destructiveClosed world—
faf_scoreScore a project.faf and return its 0–100% AI-readability, tier, and per-slot breakdown, via the deterministic Mk4 engine. Use this for a quick status check; use faf_doctor when you need to diagnose and fix what's missing.
Input schema
{
  "type": "object",
  "properties": {
    "details": {
      "type": "boolean",
      "description": "Include detailed breakdown and improvement suggestions"
    },
    "path": {
      "type": "string",
      "description": "Project path. Sets session context for subsequent calls."
    }
  },
  "additionalProperties": false
}
Output schema
{
  "type": "object",
  "description": "Structured AI-readiness score, single-sourced from faf-cli.",
  "properties": {
    "score": {
      "type": "number",
      "description": "AI-readiness score, 0-100"
    },
    "tier": {
      "type": "string",
      "description": "Tier name for this score (e.g. Bronze, Trophy)"
    },
    "populated": {
      "type": "number",
      "description": "Active slots that are filled"
    },
    "empty": {
      "type": "number",
      "description": "Active slots still empty"
    },
    "ignored": {
      "type": "number",
      "description": "Slots marked slotignored (inactive for this app_type)"
    },
    "active": {
      "type": "number",
      "description": "Slots active for this app_type"
    },
    "total": {
      "type": "number",
      "description": "Total slots"
    },
    "nextTier": {
      "type": [
        "object",
        "null"
      ],
      "description": "Next tier above the current score, or null at top tier",
      "properties": {
        "name": {
          "type": "string"
        },
        "threshold": {
          "type": "number"
        }
      }
    },
    "inherited": {
      "type": "boolean",
      "description": "True if the score is attested from a source repo (app_type: about)"
    },
    "hasFaf": {
      "type": "boolean",
      "description": "Whether a readable, valid project.faf was scored"
    },
    "path": {
      "type": "string",
      "description": "Path that was scored"
    },
    "parity": {
      "type": "object",
      "description": "Determinism parity receipt — an engine-agnostic hash any conformant scorer reproduces for this exact file. Third-party verifiable: sha256(projection) === parityHash.",
      "properties": {
        "spec": {
          "type": "string",
          "description": "Parity spec id, e.g. faf-parity/v1"
        },
        "algo": {
          "type": "string",
          "description": "Hash algorithm (sha256)"
        },
        "scorer": {
          "type": "string",
          "description": "The single deterministic source the score comes from"
        },
        "producedBy": {
          "type": "string",
          "description": "Which wrapper emitted this receipt (metadata, not hashed)"
        },
        "sourceSha256": {
          "type": "string",
          "description": "SHA-256 of the raw .faf bytes"
        },
        "parityHash": {
          "type": "string",
          "description": "sha256(projection) — identical across any conformant engine"
        },
        "projection": {
          "type": "string",
          "description": "The exact canonical string that was hashed (for verification)"
        }
      },
      "required": [
        "spec",
        "parityHash",
        "sourceSha256",
        "projection"
      ]
    }
  },
  "required": [
    "score",
    "tier",
    "hasFaf"
  ],
  "additionalProperties": true
}
Annotations
{
  "title": "AI-Readiness Score",
  "readOnlyHint": true,
  "destructiveHint": false,
  "openWorldHint": false
}
—Read onlyNon-destructiveClosed world—
faf_syncSync project.faf into CLAUDE.md as a faf-managed block, and optionally into AGENTS.md (agents), .cursorrules (cursor), GEMINI.md (gemini), and .github/copilot-instructions.md (copilot) — or all of them (all). Updates each block in place — it never overwrites your file. Use this after editing project.faf so every AI tool sees the latest context.
Input schema
{
  "type": "object",
  "properties": {
    "agents": {
      "type": "boolean",
      "description": "Also sync to AGENTS.md (OpenAI/Codex format)"
    },
    "cursor": {
      "type": "boolean",
      "description": "Also sync to .cursorrules (Cursor IDE format)"
    },
    "gemini": {
      "type": "boolean",
      "description": "Also sync to GEMINI.md (Google Gemini format)"
    },
    "copilot": {
      "type": "boolean",
      "description": "Also sync to .github/copilot-instructions.md (GitHub Copilot)"
    },
    "all": {
      "type": "boolean",
      "description": "Sync to ALL formats: CLAUDE.md + AGENTS.md + .cursorrules + GEMINI.md + .github/copilot-instructions.md"
    },
    "path": {
      "type": "string",
      "description": "Project path. Sets session context for subsequent calls."
    }
  },
  "additionalProperties": false
}
Annotations
{
  "title": "Sync .faf to CLAUDE.md (+ any AI format)",
  "readOnlyHint": false,
  "destructiveHint": false,
  "openWorldHint": false
}
—WritesNon-destructiveClosed world—
faf_trustAttest a project.faf's integrity: its validity, score, and a deterministic parity hash any conformant engine reproduces. Returns the ✪ receipt. Use this to prove a score is genuine and untampered.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "description": "Project path. Sets session context for subsequent calls."
    }
  },
  "additionalProperties": false
}
Output schema
{
  "type": "object",
  "description": "Trust attestation: validity, score, and a third-party-verifiable determinism parity receipt.",
  "properties": {
    "valid": {
      "type": "boolean",
      "description": "Whether the project.faf is readable and valid"
    },
    "hasFaf": {
      "type": "boolean",
      "description": "Whether a project.faf was found"
    },
    "score": {
      "type": "number",
      "description": "AI-readiness score, 0-100"
    },
    "tier": {
      "type": "string",
      "description": "Tier name for this score"
    },
    "path": {
      "type": "string",
      "description": "Path that was attested"
    },
    "sourceSha256": {
      "type": "string",
      "description": "SHA-256 of the raw .faf bytes"
    },
    "reason": {
      "type": "string",
      "description": "Why validation failed, when valid is false"
    },
    "parity": {
      "type": "object",
      "description": "Determinism parity receipt (same shape as faf_score.parity).",
      "properties": {
        "spec": {
          "type": "string"
        },
        "algo": {
          "type": "string"
        },
        "scorer": {
          "type": "string"
        },
        "producedBy": {
          "type": "string"
        },
        "sourceSha256": {
          "type": "string"
        },
        "parityHash": {
          "type": "string"
        },
        "projection": {
          "type": "string"
        }
      },
      "required": [
        "spec",
        "parityHash",
        "sourceSha256",
        "projection"
      ]
    },
    "receipt": {
      "type": "object",
      "description": "The ✪ trust receipt — render-identical, self-verifying score+parity artifact.",
      "properties": {
        "spec": {
          "type": "string"
        },
        "seal": {
          "type": "string",
          "description": "Quiet-ladder glyph for this score (✪ at Trophy)"
        },
        "subject": {
          "type": "string"
        },
        "score": {
          "type": "number"
        },
        "tier": {
          "type": "string"
        },
        "tests": {
          "type": [
            "object",
            "null"
          ],
          "description": "Optional test attestation"
        },
        "issued": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "spec",
        "seal",
        "subject",
        "score"
      ]
    }
  },
  "required": [
    "valid",
    "hasFaf"
  ],
  "additionalProperties": true
}
Annotations
{
  "title": "Trust Attestation",
  "readOnlyHint": true,
  "destructiveHint": false,
  "openWorldHint": false
}
—Read onlyNon-destructiveClosed world—

Resources 3

  • Current FAF Contextclaude-faf://context

    Current project FAF context and metadata

  • FAF Status Summaryclaude-faf://status

    Project health and AI readiness status

  • FAF Working Directoryfile:///home/runner/target

    File system access for FAF operations

Resource templates 0

  • None observed.

Prompts 2

  • /faf/faf

    Relentless pursuit of a verified 100% — FAF does all it can, you do only what only you can. One source of truth for every AI, every MD. FAF defines. MD instructs. AI codes.

  • /faf-bench/faf-bench

    Prove the .faf earns its place — run the AI-grounding benchmark honestly, in two passes (cold, then with the .faf), and report the cold→with-faf delta with a ✪ receipt. The delta is the product.

Remote endpoints

EndpointTransportAuthenticationHealthObserved
No verified remote endpoint is linked.

claude-faf-mcp Server questions

How do I install claude-faf-mcp Server?

Install the selected package version with: npm install --save-exact claude-faf-mcp@5.22.1

What tools does claude-faf-mcp Server provide?

claude-faf-mcp Server exposed 12 tools during independent protocol observation, including faf_about, faf_auto, faf_bench, faf_context, faf_doctor, faf_etch, faf_go, faf_init, and others.

Is claude-faf-mcp Server secure?

The selected current version does not yet have completed public verification. Unknown does not mean clean or vulnerable.

Explore related MCP server guides

Curated product and capability guides containing this catalog record.

Official vs Community MCP Servers

Let’s talk about MCP security.

Share your details and our security team will contact you.