Click on "Install 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., "@BetterPrompt MCP Improve my prompt: explain quantum computing to a 5-year-old"
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.
Related MCP server: AI Validation MCP Server
BetterPrompt MCP is a Model Context Protocol (MCP) server that enhances user requests using advanced prompt engineering techniques. It exposes a single, powerful tool that transforms simple requests into structured, context-rich instructions tailored for optimal AI model performance.
Instead of manually crafting detailed prompts, BetterPrompt MCP converts your requests into expertly engineered prompts that get better results from AI models.
Before & After Example
Without BetterPrompt:
"Write a function to calculate fibonacci numbers"
With BetterPrompt Enhancement:
"You are a world-class AI assistant with expertise in advanced prompt engineering techniques from top AI research labs like Anthropic, OpenAI, and Google DeepMind.
Your task is to provide an exceptional response to the following user request:
"Write a function to calculate fibonacci numbers"
Please enhance your response by:
Analyzing the intent and requirements behind this request
Applying appropriate prompt engineering techniques to ensure maximum effectiveness
Adding clarity, specificity, and structure to your approach
Including relevant context and constraints for comprehensive understanding
Ensuring optimal interaction patterns for complex reasoning tasks
Specifying the most appropriate output format for the task
Defining clear success criteria for high-quality results
Structure your response with clear headings, detailed explanations, and examples where appropriate. Ensure your answer is comprehensive, actionable, and directly addresses all aspects of the request."
Install and run via npx:
npx -y betterprompt-mcpOr add to your MCP client configuration:
{
"mcpServers": {
"betterprompt": {
"command": "npx",
"args": ["-y", "betterprompt-mcp"]
}
}
}Most MCP clients work with this standard config:
{
"mcpServers": {
"betterprompt": {
"command": "npx",
"args": ["-y", "betterprompt-mcp"]
}
}
}Pick your client below. Where available, click the install button; otherwise follow the manual steps.
Click a button to install:
Fallback (CLI):
code --add-mcp '{"name":"betterprompt","command":"npx","args":["-y","betterprompt-mcp"]}'Click to install:
Or add manually: Settings → MCP → Add new MCP Server → Type: command, Command: npx -y betterprompt-mcp.
Click to install:
Or manually: Program → Install → Edit mcp.json, add the standard config above.
Install button: TODO – no public deeplink available yet.
Manual setup:
Open Continue Settings → open JSON configuration
Add mcpServers entry:
{
"mcpServers": {
"betterprompt": {
"command": "npx",
"args": ["-y", "betterprompt-mcp"]
}
}
}Restart Continue if needed.
Click to install:
Or manually: Advanced settings → Extensions → Add custom extension → Type: STDIO → Command: npx -y betterprompt-mcp.
Install via CLI:
claude mcp add betterprompt npx -y betterprompt-mcpAdd to claude_desktop_config.json using the standard config above, then restart Claude Desktop. See the MCP quickstart:
Model Context Protocol – Quickstart
Follow the Windsurf MCP documentation and use the standard config above.
Follow the Gemini CLI MCP server guide; use the standard config above.
Docs: Configure MCP server in Gemini CLI
Open Qodo Gen chat panel → Connect more tools → + Add new MCP → Paste the standard config above → Save.
Create or edit ~/.config/opencode/opencode.json:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"betterprompt": {
"type": "local",
"command": ["npx", "-y", "betterprompt-mcp"],
"enabled": true
}
}
}enhance-requestTransforms user requests into world-class AI-enhanced prompts using advanced prompt engineering techniques.
Input:
request (string, required): The user request to transform into an enhanced AI prompt
Output: AI-enhanced prompt with structure, context, and clear instructions.
Example Usage:
{
"name": "enhance-request",
"arguments": {
"request": "Write a function to calculate fibonacci numbers"
}
}Request:
{
"name": "enhance-request",
"arguments": {
"request": "Explain quantum computing"
}
}Enhanced Result:
"You are a world-class AI assistant with expertise in advanced prompt engineering techniques from top AI research labs like Anthropic, OpenAI, and Google DeepMind.
Your task is to provide an exceptional response to the following user request:
"Explain quantum computing"
Please enhance your response by:
Analyzing the intent and requirements behind this request
Applying appropriate prompt engineering techniques to ensure maximum effectiveness
Adding clarity, specificity, and structure to your approach
Including relevant context and constraints for comprehensive understanding
Ensuring optimal interaction patterns for complex reasoning tasks
Specifying the most appropriate output format for the task
Defining clear success criteria for high-quality results
Structure your response with clear headings, detailed explanations, and examples where appropriate. Ensure your answer is comprehensive, actionable, and directly addresses all aspects of the request."
BetterPrompt MCP leverages the MCP Sampling API to enhance user requests:
When you call the enhance-request tool, the server sends a sampling request to your MCP client
Your client uses its configured LLM to enhance the prompt using advanced prompt engineering techniques
The enhanced prompt is returned to you for use with any AI model
This approach has several benefits:
No API keys required - uses your client's existing LLM configuration
Leverages the most capable model available in your client
Works with any MCP-compatible client (Claude Desktop, VS Code, Cursor, etc.)
Always up-to-date with the latest prompt engineering techniques
betterprompt-mcp/
├── src/
│ └── index.ts # Main server implementation
├── tests/ # Test files and verification scripts
├── dist/ # Compiled output (generated)
├── package.json # Dependencies and scripts
├── tsconfig.json # TypeScript configuration
└── README.md # DocumentationBuild:
npm run buildWatch (dev):
npm run watchFormat:
npm run format
npm run format:checkTest:
npm run test:comprehensiveWe use ESLint + Prettier to keep the codebase consistent.
Run the linter locally: npm run lint
Apply autofixes: npm run lint -- --fix or npm run lint:fix
Run the CI-oriented lint (JSON output): npm run lint:ci (produces artifacts/lint-report.json)
Autofix auto-commit policy: safe, formatting-only autofixes are auto-committed using scripts/lint-autofix-and-commit.sh. The script uses a conservative heuristic (small change threshold) and will abort auto-commit when changes appear large or potentially behavior-affecting; in such cases open a PR for human review.
MIT License
For questions or issues, open an issue on GitHub or contact the author via GitHub profile.
Aung Myo Kyaw (GitHub)
Analyzes a user request to provide insights about its complexity, intent, and optimization recommendations.
This tool helps users understand:
Request complexity level (simple, moderate, complex, expert)
Detected intents (explanation, analysis, creation, problem-solving, etc.)
Suggested optimization strategies
Domain detection and recommendations
Useful for understanding how BetterPrompt would approach optimizing a particular request.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | No | Known domain or field (optional) | |
| request | Yes | The user request to analyze |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as side effects, rate limits, or read-only nature. It only describes the analysis output without mentioning boundaries or constraints.
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?
The description is moderately concise and uses bullet points for clarity. However, it redundantly lists the insights after stating them, slightly reducing efficiency.
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 input schema covers all parameters. Without an output schema, the description partially compensates by listing the types of insights (complexity, intent, strategies), but it lacks precise format or field details, making it incomplete for agents needing exact return structure.
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 coverage is 100%, with both parameters (request, domain) described in the schema. The description repeats the schema's descriptions without adding significant new meaning, so it meets the baseline but does not exceed it.
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 clearly states the tool analyzes user requests to provide insights on complexity, intent, and optimization recommendations. It lists specific outputs and distinguishes itself from sibling tools (betterprompt, quick-enhance) by focusing on analysis rather than enhancement, as indicated by the mention of understanding how BetterPrompt would optimize.
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 use for analyzing requests before optimization, stating it helps understand how BetterPrompt would approach a request. However, it does not explicitly exclude alternative use cases or provide when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Transforms user requests into world-class, optimized prompts using advanced prompt engineering techniques.
This tool applies multiple optimization strategies including:
Chain-of-Thought reasoning for step-by-step thinking
Few-shot learning with relevant examples
Role-based prompting with expert personas
Context enhancement and output formatting
Self-consistency for complex problems
Perfect for enhancing any request, from simple questions to complex tasks, ensuring maximum AI performance and response quality.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | No | Specific domain or field for specialized optimization (optional) | |
| context | No | Additional context or background information for the request (optional) | |
| request | Yes | The original user request to be optimized (required) | |
| creativity | No | Level of creativity to encourage (default: high) | high |
| constraints | No | Specific constraints or requirements (optional) | |
| desiredTone | No | Desired tone for the response (optional) | |
| outputFormat | No | Desired format for the response (default: conversational) | conversational |
| targetAudience | No | Target audience for the response (optional) | |
| includeExamples | No | Whether to include relevant examples in the optimized prompt (default: true) | |
| optimizationLevel | No | Level of optimization to apply (default: advanced) | advanced |
| enableChainOfThought | No | Enable chain-of-thought reasoning instructions (default: true) | |
| enableSelfConsistency | No | Enable multiple reasoning paths for complex problems (default: false) | |
| enableContextEnhancement | No | Enable context enrichment and structure enhancement (default: true) | |
| enableRoleBasedPrompting | No | Enable expert role assignment for enhanced authority (default: true) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully convey behavioral traits. It describes the transformation and strategies but does not mention safety, side effects, or whether the tool is read-only. It lacks disclosure of important behavioral aspects like output details or limitations.
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?
The description is concise and front-loaded with the main purpose. The second paragraph lists techniques efficiently without redundancy. Every sentence contributes meaning, and the structure is clear.
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?
Given the complexity (14 parameters, no output schema), the description explains the purpose and techniques but does not detail how parameters interact or what the output format is. It states the output is an 'optimized prompt', which is adequate but could be more specific.
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?
All 14 parameters have descriptions in the schema (100% coverage), so the tool description adds limited value beyond the schema. However, the description provides context about the strategies (e.g., chain-of-thought), which aligns with parameters like enableChainOfThought, adding some semantic value.
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 clearly states the tool transforms user requests into optimized prompts using specific techniques. However, it does not differentiate from sibling tools like 'analyze-request' or 'quick-enhance', leaving ambiguity about when to use this tool versus alternatives.
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 says 'Perfect for enhancing any request', implying universal applicability, but provides no explicit guidance on when to use this tool versus siblings or when not to use it. No exclusion criteria or context is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Quickly enhances a user request with basic optimizations for immediate improvement.
This is a lightweight version of the full BetterPrompt optimization, perfect for:
Quick improvements without extensive processing
Simple requests that need minor enhancements
When you want faster results with good quality
Applies essential optimizations like clarity improvements, structure enhancement, and basic context enrichment.
| Name | Required | Description | Default |
|---|---|---|---|
| tone | No | Desired tone (optional) | |
| request | Yes | The user request to quickly enhance |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes optimizations like clarity improvements and structure enhancement, but no details on exactly what changes are made or any side effects. With no annotations, the burden is higher, and the description is only moderately transparent.
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?
Well-structured with a clear opener and bullet points. Concise but could be slightly tighter; every sentence adds value.
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?
Adequately covers purpose, usage, and basic behavior for a simple tool. Missing details on return format or error handling, but sufficient given the tool's simplicity.
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 coverage is 100%, and the description adds no extra meaning beyond the schema definitions for 'request' and 'tone'. Baseline score of 3 is appropriate.
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?
Clearly states it enhances a user request with basic optimizations. The name 'quick-enhance' and description specify it as a lightweight version compared to 'betterprompt', distinguishing it from siblings.
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?
Explicitly lists use cases: quick improvements, simple requests, faster results. Implies it's an alternative to 'betterprompt' but lacks explicit when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool has a distinct purpose: analyze-request provides insights, betterprompt does full optimization, and quick-enhance offers a lighter version. No ambiguity.
Names are inconsistent: 'analyze-request' uses verb-noun with hyphen, 'betterprompt' is a single word brand name, and 'quick-enhance' is adjective-verb. No consistent pattern.
Three tools cover the core workflow of analysis, full optimization, and quick enhancement—well-scoped and reasonable for a prompt optimization server.
The tool surface covers the main use cases: analyze, full optimize, and quick optimize. Minor gaps (e.g., no prompt comparison or advanced settings) exist but are not critical.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Turns rough requests into sharp Role/Task/Context/Format prompts. Thai and English.
MCP server for generating rough-draft project plans from natural-language prompts.
Turns vague automation requests into tool stacks, prompts, QA checks, and human boundaries.
Talk to your public-facing AI from any MCP client — Claude, ChatGPT, Cursor, Cline, Windsurf.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/AungMyoKyaw/betterprompt-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
