prompt-improver-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@prompt-improver-mcpMake this self-contained: no, it still double-charges when Stripe retries the webhook. fix it"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
🪄 prompt-improver-mcp
Turn rough prompts into ones models answer well, using techniques from 23 research papers.
An MCP server and command-line tool. It reads your prompt together with the conversation it belongs to, works out what kind of task it is, and rewrites it with the techniques that fit, from LLaVA-CoT's staged reasoning to System 2 Attention and Chain-of-Verification. Every change names the paper it comes from.
Quick start · Usage · How it works · Techniques · FAQ
✨ What it does
You send a follow-up after an answer that didn't work:
Earlier: Our Stripe webhook handler sometimes charges customers twice. Here is handler.py: … Assistant: Wrap
charge()in a try/except and log failures so you can see what happens. You: no, it still double-charges when Stripe retries the webhook. fix it
On its own, "fix it" gives a model almost nothing to work with. prompt-improver notices that this is a correction of a code answer and makes the prompt self-contained: it brings back the earlier request and the code, quotes the answer that failed, and asks the model to diagnose what fell short instead of repeating it:
<context>
[earlier assistant response]
Wrap charge() in a try/except and log failures so you can see what happens.
</context>
<task>
Earlier request:
Our Stripe webhook handler sometimes charges customers twice. Here is handler.py:
```python
def on_event(evt):
if evt.type == "invoice.paid":
charge(evt.customer, evt.amount)
```
My feedback on your previous answer:
no, it still double-charges when Stripe retries the webhook. fix it
Work out specifically what fell short in the previous answer, keep what was correct, and fix the problem rather than repeating the earlier answer.
</task>
<approach>
- If a detail you need is missing, state the assumption you are making in one line, then answer under that assumption.
</approach>
<output_format>
Start with the direct answer or deliverable, then any explanation that is needed.
</output_format>Techniques applied: System 2 Attention · conversational query rewriting · textual-gradient correction (ProTeGi, Self-Refine) · Rephrase-and-Respond · principled instructions. This is the offline template draft, produced without any LLM. With a Claude API key, or a client that supports MCP sampling, an LLM does the full rewrite.
Why use it
🧵 It uses the conversation. It resolves "it" and "the above", carries earlier constraints forward, and turns "that's wrong" into explicit fixes.
🎯 It picks techniques per task. Images get grounded visual description and LLaVA-CoT stages, math gets Plan-and-Solve, factual questions get Chain-of-Verification, vague requests get Rephrase-and-Respond.
🧠 It knows reasoning models are different. Models with built-in thinking get a structured deliverable, not "think step by step" (see targets).
🔒 It keeps your intent. It never adds requirements you didn't ask for; any gap it fills is listed as an assumption you can override.
🔑 No API key needed. Without one, it hands a draft and instructions to the model you're already using. With a key, Claude does the rewrite.
📚 It cites its sources. Each technique comes with its paper and arXiv ID, and every ID was checked against arXiv.
Related MCP server: PromptArchitect MCP
🚀 Quick start
You need uv (it fetches Python for you) and git.
Try it from the command line, no setup:
uvx --from git+https://github.com/SMASH-Mash/prompt-improver-mcp prompt-improver "What does this chart show?" --imageAdd it to your AI client:
claude mcp add --transport stdio --scope user prompt-improver -- uvx --from git+https://github.com/SMASH-Mash/prompt-improver-mcp prompt-improver-mcpTo let Claude do the rewriting through the API, add your key. Put --env first: if it comes right before the server
name, the CLI reads the name as another variable.
claude mcp add --env ANTHROPIC_API_KEY=sk-ant-... --transport stdio --scope user prompt-improver -- uvx --from git+https://github.com/SMASH-Mash/prompt-improver-mcp prompt-improver-mcpCheck it with claude mcp list.
Edit claude_desktop_config.json: on macOS it is in ~/Library/Application Support/Claude/, on Windows in
%APPDATA%\Claude\. Then restart Claude Desktop.
{
"mcpServers": {
"prompt-improver": {
"command": "uvx",
"args": ["--from", "git+https://github.com/SMASH-Mash/prompt-improver-mcp", "prompt-improver-mcp"],
"env": { "ANTHROPIC_API_KEY": "sk-ant-..." }
}
}
}The env block is optional. If Claude Desktop can't find uvx, use its full path (which uvx on macOS/Linux,
where uvx on Windows).
Add to .vscode/mcp.json in your workspace, or to your user-level MCP configuration. VS Code supports MCP sampling,
so the rewrite can run on the chat model you already use (see the chat.mcp.serverSampling setting). No API key
needed.
{
"servers": {
"prompt-improver": {
"type": "stdio",
"command": "uvx",
"args": ["--from", "git+https://github.com/SMASH-Mash/prompt-improver-mcp", "prompt-improver-mcp"]
}
}
}Add to ~/.cursor/mcp.json, or to .cursor/mcp.json in a project:
{
"mcpServers": {
"prompt-improver": {
"command": "uvx",
"args": ["--from", "git+https://github.com/SMASH-Mash/prompt-improver-mcp", "prompt-improver-mcp"]
}
}
}It is a stdio server. The command is uvx and the arguments are
--from git+https://github.com/SMASH-Mash/prompt-improver-mcp prompt-improver-mcp.
To run it from a clone instead: uv run --directory /path/to/prompt-improver-mcp prompt-improver-mcp.
🧭 Usage
In chat, just ask:
Improve this prompt: … Improve my last message, then answer it.
The assistant calls improve_prompt and passes along the turns and context your prompt depends on (the server can't
see the conversation by itself).
As a slash command, which uses the server's improve prompt:
Client | Command |
Claude Code |
|
VS Code |
|
Run it with no argument to improve your most recent message. Claude Code splits slash-command arguments on spaces, so this is also the reliable way to pass a long prompt there.
From the command line. Use uvx --from git+https://github.com/SMASH-Mash/prompt-improver-mcp prompt-improver ...,
or put the prompt-improver command on your PATH with
uv tool install git+https://github.com/SMASH-Mash/prompt-improver-mcp:
prompt-improver "explain why my CNN overfits" # template draft, or the Claude API if a key is set
prompt-improver "fix it" --history chat.json --context notes.md # with conversation and context
prompt-improver "How many red cubes are behind the sphere?" --image --target standard
prompt-improver "summarize the paper" --technique verification --json # force techniques, JSON outputchat.json is a list of turns, oldest first: [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}].
Run prompt-improver --help for every option.
🔬 How it works
flowchart LR
A["Your prompt<br/>+ earlier turns<br/>+ context"] --> B["1 · Profile the task<br/>visual · math · code · factual<br/>follow-up · correction · ambiguity"]
B --> C["2 · Select techniques<br/>14 techniques · 23 papers"]
C --> D{"3 · Who rewrites?"}
D -->|"API key set"| E["Claude API<br/>+ optional Self-Refine"]
D -->|"client supports<br/>MCP sampling"| F["Your client's model"]
D -->|"otherwise"| G["Template draft +<br/>instructions for the host"]
E --> H["Improved prompt<br/>techniques + citations<br/>changes · assumptions<br/>clarifying questions"]
F --> H
G --> HProfile. Lexical signals classify the task (visual, math, code, factual, knowledge, multi-part, planning, writing). They also detect references to earlier turns, corrections of a previous answer, and how ambiguous the prompt is. A follow-up like "fix it" takes its task type from the turn it refers to.
Select. Rules map the profile to techniques in a fixed order: understand the request first (context, references, corrections), then reasoning structure, then verification and formatting.
Rewrite. The rewriter gets the inputs, the profile as suggestions, and a catalog of every technique. It follows two rules taken from the literature: never change the user's intent (BPO), and work through an explicit procedure (PE2). An optional Self-Refine pass critiques the rewrite and revises it.
Who does the rewriting
Backend | Used when ( | What happens |
Claude API | Anthropic credentials are visible to the server ( |
|
MCP sampling | No credentials, but the client supports sampling (e.g. VS Code) | Your client's own model does the rewrite. |
Host | Neither | A template draft built offline: the techniques applied as text, plus context chosen by BM25 to approximate System 2 Attention. It comes with |
Each result's backend_used field says which backend ran. Claude Code's documentation doesn't list MCP sampling, so
there it uses the API if you give it a key, and host mode otherwise.
Reasoning vs. standard targets
LLaVA-CoT trains a vision-language model to answer in four stages:
<SUMMARY> → <CAPTION> → <REASONING> → <CONCLUSION>. Asking for that format helps models that don't think
before answering. Models with built-in thinking (current Claude, OpenAI o-series, DeepSeek-R1) reason internally;
telling them to print their reasoning adds nothing, and on recent Claude models it can trigger refusals.
| For | Output structure |
| Models with built-in thinking | Approach → Evidence → Answer. No reasoning transcript requested. |
| Models without it, e.g. small open VLMs | The four LLaVA-CoT tags, plus explicit step-by-step cues |
For example, prompt-improver "How many red cubes are behind the sphere?" --image --target standard produces:
<task>
How many red cubes are behind the sphere?
</task>
<approach>
- First note what in the image matters for the question: the relevant objects, their attributes and how they relate
to each other, any visible text or numbers, and the region to focus on. If something you need is not visible or
legible, say so instead of guessing.
- Extract the relevant quantities and devise a plan, then carry out the plan step by step, checking each calculation.
</approach>
<output_format>
Answer in four stages, each wrapped in its tag (the Xu et al. 2024 format):
<SUMMARY>Restate the problem and outline how you will solve it.</SUMMARY>
<CAPTION>Describe the facts from the image that the answer depends on.</CAPTION>
<REASONING>Work through the solution step by step.</REASONING>
<CONCLUSION>Give the final answer only.</CONCLUSION>
</output_format>🧰 Tools
Tool | What it does |
| The full pipeline. Takes |
| Profiles the prompt and lists the techniques that would apply, with reasons, without rewriting. |
| The full catalog, with citations. |
The server also provides an improve prompt, the slash command described above.
{
"improved_prompt": "<task>…</task> …",
"backend_used": "anthropic | sampling | host",
"target": "reasoning",
"profile": { "task_types": ["code"], "references_history": true, "dissatisfied_with_previous": true, "ambiguity": "medium", … },
"techniques": [
{ "id": "failure_feedback", "name": "Textual-gradient correction from the previous response",
"citation": "Pryzant et al. 2023, arXiv:2305.03495; Madaan et al. 2023, arXiv:2303.17651",
"why": "the prompt corrects or retries a previous response" }
],
"changes": ["…"],
"assumptions": ["…"],
"clarifying_questions": ["…"],
"inference_tips": ["Self-Consistency: sample several independent answers and keep the majority … [arXiv:2203.11171]"],
"host_instructions": "only in host mode: how the calling model should finish the draft",
"notes": ["e.g. why a backend fell back"]
}📚 Techniques
id | Technique | Paper(s) | Applied when |
| System 2 Attention | Weston & Sukhbaatar 2023 · 2311.11829 | context or history is supplied |
| Conversational query rewriting | Ma et al. 2023 · 2305.14283; Deng et al. 2023 · 2311.04205 | the prompt refers to earlier turns |
| Textual-gradient correction | Pryzant et al. 2023 (ProTeGi) · 2305.03495; Madaan et al. 2023 (Self-Refine) · 2303.17651 | you're correcting a previous answer |
| Rephrase and Respond | Deng et al. 2023 · 2311.04205 | the prompt is short or vague |
| Selective clarification | Kuhn et al. 2022 (CLAM) · 2212.07769 | the prompt is highly ambiguous |
| Grounded visual description | Xu et al. 2024 (LLaVA-CoT) · 2411.10440; Mitra et al. 2023 (CCoT) · 2311.17076; Shao et al. 2024 (Visual CoT) · 2403.16999; Zhang et al. 2023 (Multimodal-CoT) · 2302.00923 | an image or video is involved |
| LLaVA-CoT stages | Xu et al. 2024 · 2411.10440 | visual or multi-step reasoning |
| Step-Back abstraction | Zheng et al. 2023 · 2310.06117 | knowledge-intensive questions |
| Plan-and-Solve | Wang et al. 2023 · 2305.04091 | math and calculation |
| Least-to-Most | Zhou et al. 2022 · 2205.10625 | multi-part or planning tasks |
| Chain-of-Verification | Dhuliawala et al. 2023 · 2309.11495 | factual or citation-heavy answers |
| Zero-shot chain-of-thought | Kojima et al. 2022 · 2205.11916; Wei et al. 2022 · 2201.11903 | reasoning tasks, |
| Re-reading (RE2) | Xu et al. 2023 · 2309.06275 | long context comes before the question |
| Principled instructions | Bsharat et al. 2023 · 2312.16171; Schulhoff et al. 2024 (The Prompt Report) · 2406.06608 | always |
Technique | Paper | Suggested for |
Self-Consistency | Wang et al. 2022 · 2203.11171 | short, checkable answers (math, multiple choice) |
LLaVA-CoT stage-wise search (SWIRES) | Xu et al. 2024 · 2411.10440 | staged answers from small or open VLMs |
Tree of Thoughts | Yao et al. 2023 · 2305.10601 | search-heavy puzzles and planning |
The rewriting procedure follows BPO (Cheng et al. 2023 · 2311.04155) and PE2 (Ye et al. 2023 · 2311.05661).
🔧 Configuration
All settings are optional environment variables, set in your client's MCP config or in the shell for the CLI.
Variable | Default | Effect |
| not set | Turns on the Claude API backend. |
|
| Force |
|
| The Claude model used for rewriting. |
|
| Reasoning effort for the API call: |
|
|
|
❓ FAQ
Only with an API key: one Claude API request per rewrite, plus one per refine_rounds. Without a key it makes no
API calls. Set PROMPT_IMPROVER_BACKEND=host to guarantee that, even if a key is in your environment.
No LLM was available to the server: no API key, and your client doesn't support MCP sampling. That's the normal case
in Claude Code without a key. The calling model finishes the draft by following host_instructions, using the
conversation it can see.
Yes. Any MCP client can use the server, and with sampling the rewrite runs on whatever model your client uses. For
models without built-in thinking, set target to standard. Only the API backend is Claude-specific.
uvx caches the package. Run uvx --refresh --from git+https://github.com/SMASH-Mash/prompt-improver-mcp prompt-improver --help
once to fetch the latest version. To pin a version, append @<commit-or-tag> to the git URL.
🧪 Limitations and roadmap
Heuristic profiling. Task detection and offline context selection are lexical. The LLM backends treat the profile as a suggestion and can override it. Host mode lists the context it left out, so the host can add it back.
Not yet evaluated. There's no benchmark yet showing how much the rewrites help. Planned: an eval set of prompts with graded answers, then optimizing the meta-prompt against it with APE (2211.01910) and OPRO (2309.03409).
Ideas: asking clarifying questions through MCP elicitation, and a hook that improves every prompt automatically.
🤝 Contributing
Issues and pull requests are welcome. See CONTRIBUTING.md for setup, the project layout, and how to add a technique.
git clone https://github.com/SMASH-Mash/prompt-improver-mcp && cd prompt-improver-mcp
uv sync --group dev && uv run pytest📝 Citing
If you use this in research, please cite the papers behind the techniques you rely on (linked above). To cite the tool itself:
@software{prompt_improver_mcp_2026,
author = {{Sayaad Muzahid Masfi}},
title = {prompt-improver-mcp: an MCP server for paper-grounded prompt rewriting},
year = {2026},
url = {https://github.com/SMASH-Mash/prompt-improver-mcp}
}📄 License
MIT. Built on the MCP Python SDK and the Anthropic Python SDK. The techniques belong to the authors of the papers above.
Available Tools
3 toolsanalyze_promptAnalyze a promptA
Profile a prompt's task type and list the techniques improve_prompt would apply, with citations, without rewriting anything.
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | Yes | The prompt to analyze, verbatim. | |
| target | No | reasoning | |
| context | No | ||
| history | No | ||
| has_image | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| profile | Yes | |
| techniques | Yes | |
| inference_tips | Yes | Inference-time techniques to consider; not part of the prompt text. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden and does disclose the key trait: it is a non-mutating inspection ('without rewriting anything') that produces cited output. It does not mention the effect of the 'target'/'has_image' inputs on behavior or any limits, so it is good but not exhaustive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence that names the action, the output, and the key constraint with zero filler. Every clause carries information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The existence of an output schema means return values need not be explained, and the non-mutation nature is covered. However, four of five parameters lack any semantic guidance and no annotations exist, so the agent lacks enough to confidently populate target/context/history/has_image.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 20% across 5 parameters, so the description must compensate and largely does not. It says nothing about 'target', 'context', 'history', or 'has_image', leaving the agent to guess how targeting the analysis or supplying conversation history changes the result.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource ('Profile a prompt's task type') plus the concrete artifact it returns ('list the techniques improve_prompt would apply, with citations'). It explicitly differentiates itself from its closest sibling by adding 'without rewriting anything', so an agent can distinguish it from improve_prompt without opening either schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'without rewriting anything' and the reference to improve_prompt imply the usage context: inspect/analyze before committing to a rewrite. It names the sibling tool, but it never states explicit when-to-use/when-not conditions or prerequisites (e.g. when to choose this over calling improve_prompt directly), leaving the routing partly to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
improve_promptImprove a promptA
Rewrite a prompt so a model answers it better, using techniques from the prompting literature: LLaVA-CoT staged reasoning, System 2 Attention context distillation, conversational query rewriting, Rephrase-and-Respond, Chain-of-Verification, Step-Back, Plan-and-Solve, Least-to-Most, and more. The server cannot see the conversation, so pass the current prompt verbatim plus the earlier turns and context it depends on. Returns the improved prompt, the techniques used (with paper citations), what changed, assumptions, and clarifying questions. If backend_used is 'host', improved_prompt is a template draft: finish it by following host_instructions.
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | Yes | The user's current prompt, verbatim. | |
| target | No | 'reasoning' for models with built-in thinking (Claude, o-series, R1): no visible chain-of-thought cues. 'standard' for models without it (e.g. small open VLMs): adds explicit step-by-step and LLaVA-CoT stage tags. | reasoning |
| backend | No | 'auto' uses the Claude API if credentials are available, else MCP sampling if the client supports it, else 'host' (a template draft for the calling model to finish). | auto |
| context | No | Other material the prompt depends on: files, documents, task background. | |
| history | No | Earlier conversation turns, oldest first, including previous assistant responses. | |
| has_image | No | True if the prompt will be sent with an image or video. | |
| techniques | No | Force exactly these techniques instead of automatic selection. Ids: context_distillation, self_contained_rewrite, failure_feedback, rephrase_expand, clarify, visual_grounding, step_back, plan_and_solve, least_to_most, staged_reasoning, verification, zero_shot_cot, re_reading, specificity_format | |
| refine_rounds | No | Self-Refine critique-and-revise rounds (Claude API backend only). |
Output Schema
| Name | Required | Description |
|---|---|---|
| notes | No | |
| target | Yes | |
| changes | Yes | |
| profile | Yes | |
| techniques | Yes | |
| assumptions | Yes | |
| backend_used | Yes | |
| inference_tips | Yes | |
| improved_prompt | Yes | |
| host_instructions | No | Set only when backend_used is 'host': the improved_prompt is a template draft, and these are the steps the calling model should take to finish it. |
| clarifying_questions | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden, and it discloses meaningful behavior: the statelessness constraint, the four-part return payload, and the degraded 'host' path where improved_prompt is only a template requiring host_instructions. It omits cost/latency, credential requirements, and determinism concerns, so it is strong but not exhaustive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads the purpose, then moves through usage constraint, return shape, and edge case in four dense sentences. The long list of nine-plus technique names is the one slightly bloated element, though it justifies the tool's scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the return explanation is a bonus rather than a requirement, and the description goes further by covering the host-backend edge case the schema only implies. For an 8-parameter tool with one required field, nothing needed to call it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description still adds value by tying prompt/context/history together into one verbatim-passing rule and by naming 'backend_used' and the host-draft fallback, giving the backend parameter practical meaning beyond the enum values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The opening sentence gives a concrete verb and object ('Rewrite a prompt so a model answers it better') and names the concrete technique families applied, so the agent knows exactly what the tool produces. It never differentiates itself from the sibling 'analyze_prompt', so the boundary is left to the name alone.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives clear operational guidance for invocation: 'The server cannot see the conversation, so pass the current prompt verbatim plus the earlier turns and context it depends on.' That is a real usage condition an agent must know. It stops short of naming analyze_prompt/list_techniques as alternatives or saying when not to call it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_techniquesList techniquesA
List every technique the improver knows, with the papers behind it.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. 'List' correctly implies a non-mutating read and 'with the papers behind it' adds return-content context beyond the schema, but nothing is said about permissions, data freshness, or result size, so a low-risk listing tool is only partially covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler; the scope statement and the payload hint both earn their place. Nothing to trim.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read tool with an output schema already documenting return values, the description only needs to establish what is listed and that papers accompany each technique, which it does. The gap is the absence of any note on how this catalog relates to the sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate. The schema has an empty properties object and no semantics are needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('List') and resource ('every technique the improver knows') and adds scope detail ('with the papers behind it') that hints at the payload. It is clearly distinct from the sibling mutation-style tools improve_prompt and analyze_prompt, though it never names or contrasts them explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies a discovery/inventory use case but gives no explicit when-to-use guidance or conditions for preferring it over improve_prompt or analyze_prompt. An agent can infer it is a read-only catalog lookup, but the routing is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v0.1.0- First observed
analyze_prompt - First observed
improve_prompt - First observed
list_techniques
TDQS
Scored across 3 tools
improve_prompt (rewrites) and analyze_prompt (profiles without rewriting) are clearly distinct, and list_techniques serves a global reference role. However, analyze_prompt's output (techniques improve_prompt would apply) partially overlaps with list_techniques' output, so the two informational tools could be mildly confused.
All three tools follow a strict verb_noun snake_case pattern: improve_prompt, analyze_prompt, list_techniques. The convention is predictable and readable throughout.
Three focused tools perfectly match the narrow purpose of a prompt-improvement server; each covers a distinct facet (rewrite, analyze, reference) with no filler or redundancy.
The surface covers the core lifecycle of improving, analyzing, and discovering techniques for a prompt. Minor gaps exist: no way to apply/configure specific techniques selectively or manage a history of improved prompts, but these are workable omissions.
Maintenance
Related MCP Connectors
A prompt engineer you talk to. It writes prompts, sharpens yours, and keeps them on your shelf.
Turns rough requests into sharp Role/Task/Context/Format prompts. Thai and English.
Turns vague automation requests into tool stacks, prompts, QA checks, and human boundaries.
Sourced, citable definitions of prompting and LLM techniques, with relations and primary sources.
Related MCP Servers
- AlicenseBqualityDmaintenanceAnalyzes, refines, and optimizes prompts for AI assistants by fixing grammar, improving clarity, applying best practices like chain-of-thought and few-shot learning, and scoring prompt quality across multiple dimensions.330 npmMIT
- FlicenseAqualityCmaintenanceRefines and improves AI prompts using workspace-aware context from your project's tech stack, structure, and dependencies. Includes tools to analyze prompt quality and generate well-structured prompts from raw ideas.4209 npm5-
- AlicenseNot gradedqualityCmaintenanceRefines and optimizes prompts for LLMs through adaptive questioning and intelligent clarification workflows. Supports multiple AI providers (Google, OpenAI, Anthropic, Groq, Qwen) with interactive prompt enhancement and targeted modifications.17MIT
- AlicenseNot gradedqualityDmaintenanceAutomatically enhances user prompts by applying expert-level prompt engineering techniques tailored to technical, creative, or analytical content types. It provides visual feedback on applied optimizations to ensure higher quality, structured, and more comprehensive AI responses.1MIT