Clarifyprompt Mcp

Optimize a prompt for a specific AI platform. Context-aware: auto-gathers workspace signals (CLAUDE.md / AGENTS.md / .cursorrules / package.json), resolves intent + category + recommended mode in a single analysis step, shapes the system prompt to the target model's capabilities, and grounds the rewrite in a priority-ordered Grounding Context. Supports 58+ platforms across 7 categories, plus custom registered platforms. Category, platform, and mode are all optional — the engine chooses sane defaults from the analysis.

List all available prompt optimization categories with platform counts including custom platforms

List available platforms for a category, including custom registered platforms.

List available output modes for prompt optimization

Register a new custom AI platform for prompt optimization.

Update a custom platform or add/override instructions on a built-in platform.

Remove a custom platform, or clear instruction overrides on a built-in.

Preview the ContextBundle (workspace rules, frameworks, target-model capabilities, resolved analysis, session history) without running optimization. Returns the same bundle that optimize_prompt would assemble.

List recent optimization traces from the local tracer. Summary only; use get_trace for full records.

Fetch the full trace for an optimization ID, including system prompt + output. Looks back 7 days by default.

Tell ClarifyPrompt whether an optimization's output was accepted, edited, or rejected. Feeds two loops: (1) the session ring buffer so accepted prior outputs are injected as few-shot examples into future similar prompts, and (2) the persistent memory layer via reflection — on accept/edit, ClarifyPrompt extracts atomic facts from the interaction and stores them; on reject, recent reflection facts from this session are invalidated. Reflection uses the same LLM you've configured; expect a 1–3s latency on local models.

Semantic search over the persistent memory store. Returns facts, pack chunks, and past optimizations ranked by vector similarity to the query. Useful for inspecting what ClarifyPrompt would retrieve for a given prompt, and for debugging curator decisions.

Explicitly add a fact to persistent memory. Use when the user says something the engine should remember across sessions (preferences, conventions, project facts). Complements `save_outcome` reflection, which extracts facts implicitly — this is the explicit, user-driven path. Returns the new fact id, which can be passed to `memory_forget` later.

Invalidate (soft-delete) a fact by its id. The fact is marked invalidated_at = now and won't appear in future memory_search or grounding, but its history is preserved (bi-temporal soft-delete). Use `memory_list_facts` first to find the id you want to forget.

List live (non-invalidated) facts in persistent memory, optionally filtered by scope and predicate. Sorted by most-recently-observed first. Useful for inspecting what the engine knows, or finding fact ids to forget.

Render a human-readable explanation of the Context Curator's decisions for the most recent (or a specified) optimization. Shows every candidate that was considered, whether it was selected or rejected, why, and how many tokens it used against the budget. Use this when an output felt off and you want to understand which grounding sources the engine chose.

Load a knowledge pack — a markdown document with optional YAML frontmatter — into the persistent memory store. The pack is chunked by heading, each chunk embedded, and made available for semantic retrieval during subsequent optimize_prompt calls. Packs can come from a local file path, an HTTPS URL, or be passed inline as raw markdown. Bundled packs + authoring guide: https://github.com/LumabyteCo/clarifyprompt-mcp/tree/main/packs

List knowledge packs currently loaded in the persistent memory store.

Remove a loaded knowledge pack (and all its chunks + embeddings) from the memory store.

Given an ambiguous draft prompt, return 1–3 targeted clarifying questions instead of guessing. Each question carries a `suggested_answer` you can accept verbatim to keep moving, an optional 2–4 quick-pick `options` list, and a `dimension` tag (audience/scope/format/length/tone/constraints/goal/platform). When the analyzer is highly confident AND the prompt is non-trivially long, the tool short-circuits with `clarificationNeeded: false` so callers can pipeline this in front of optimize_prompt without paying a latency tax on every call. Pass `force: true` to always generate questions. Pass `elicit: true` to collect answers interactively through the host's native form UI (MCP elicitation) instead of returning the raw questions — when the client supports it.

Optimize a prompt against EXPLICIT caller-provided grounding sources (a spec, a transcript excerpt, an RFC, an internal doc, etc.). Each source is pinned at the highest priority — above project rules, above pinned instructions — and tracked individually in the trace. Use this when you want the rewrite to cite specific material rather than letting the curator decide what's relevant. Requires at least one non-empty source; will error rather than silently fall through to optimize_prompt. Sources are capped at 4000 chars each so a single large paste can't dominate the budget.

LLM-as-judge for a prompt. Scores it 0–10 across 6 default dimensions (clarity, specificity, intent_alignment, format_fitness, length_appropriateness, plain_language) — or your own custom criteria — and returns per-dimension rationale + concrete suggestions, an overall score, and a verdict (`accept` / `revise` / `reject`). When the score is below `revise_threshold` (default 7.0), the tool also returns an `improvedPrompt` you can use as a drop-in replacement. Use it pre-flight (is this prompt good enough for the expensive model?), postmortem (was the prompt the cause of a bad output?), or to A/B-pick the best of N optimization variants. Pass `original_prompt` when critiquing an optimized version so the judge can verify intent was preserved.

Run the canonical ClarifyPrompt pipeline in ONE call: clarify (optional pre-stage) → ground OR optimize (core) → critique (optional post-stage) → optional auto-revise. Use this when you want the four-tool happy path without orchestrating five round-trips. Short-circuits if `pre_clarify` surfaces questions — caller answers and re-calls. When `sources` is non-empty the chain takes the strict ground_prompt branch; otherwise it goes through optimize_prompt. When `auto_revise` is true and critique returns a non-accept verdict with an improved rewrite, `final_prompt` is the rewrite. The `stages` array is a per-call audit log so callers can see exactly what ran.