Which integrations are available for this server?

Provides direct API integration for prompt refinement using Google's Gemini models (2.0 Flash, 1.5 Pro), enabling LLM-powered prompt optimization and analysis. Provides direct API integration for prompt refinement using OpenAI models (GPT-4o, GPT-4o-mini, GPT-4 Turbo), enabling LLM-powered prompt optimization and analysis. Provides session store support for distributed multi-instance deployments and caching of refined prompts to improve performance.

How do I use PromptTuner MCP?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@PromptTuner MCP refine this prompt to make it clearer and more effective" 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.

PromptTuner MCP

by j0hanz

Overview Schema Related Servers Score Discussions

TypeScript

Remote

PromptTuner MCP

npm version License Node.js Version

PromptTuner MCP is an MCP server that fixes and boosts prompts using OpenAI, Anthropic, or Google Gemini.

What it does

Validates and trims input prompts (enforces MAX_PROMPT_LENGTH).
Wraps the prompt as JSON inside sentinel markers (sanitizing markers, bidi control chars, and null bytes).
Calls the selected provider.
Normalizes LLM output (strips code fences / labels if present).
Returns human-readable text plus machine-friendly structuredContent.

Related MCP server: PromptArchitect MCP

Features

Polish and refine a prompt for clarity and flow (fix_prompt).
Boost and enhance a prompt for clarity and effectiveness (boost_prompt).
Craft a reusable workflow prompt for complex tasks (crafting_prompt).
Simple structured outputs.
Retry logic with exponential backoff for transient provider failures.

Quick Start

PromptTuner runs over stdio only. The dev:http and start:http scripts are compatibility aliases (no HTTP transport yet).

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "prompttuner": {
      "command": "npx",
      "args": ["-y", "@j0hanz/prompt-tuner-mcp-server@latest"],
      "env": {
        "LLM_PROVIDER": "openai",
        "OPENAI_API_KEY": "sk-..."
      }
    }
  }
}

Replace the API key and provider with your preferred LLM. Only configure the key for the active provider.

Configuration

PromptTuner uses minimal configuration. Set the provider and API key, and you're ready to go.

Variable	Default	Description
`LLM_PROVIDER`	`openai`	`openai`, `anthropic`, or `google`.
`OPENAI_API_KEY`	-	Required for all tools when `LLM_PROVIDER=openai`.
`ANTHROPIC_API_KEY`	-	Required for all tools when `LLM_PROVIDER=anthropic`.
`GOOGLE_API_KEY`	-	Required for all tools when `LLM_PROVIDER=google`.
`LLM_MODEL`	-	Override the default model.
`DEBUG`	`false`	Enable debug logging.

All tools are LLM-backed and require an API key for the selected provider.

Default Models

Provider	Default Model
`openai`	`gpt-4o`
`anthropic`	`claude-3-5-sonnet-20241022`
`google`	`gemini-2.0-flash-exp`

CLI Options

Flag	Description
`-h, --help`	Show help text.
`-v, --version`	Print version.
`--debug / --no-debug`	Enable/disable debug logging.
`--llm-provider <provider>`	`openai`, `anthropic`, or `google`.
`--llm-model <name>`	Override the default model.

Tools

All tools accept plain text, Markdown, or XML prompts. Responses include content (human-readable) and structuredContent (machine-readable). Inputs are strict: extra fields are rejected. For fix_prompt/boost_prompt, only the prompt field is accepted.

fix_prompt

Polish and refine a prompt for clarity and flow while preserving intent and structure.

Parameter	Type	Required	Notes
`prompt`	string	Yes	Trimmed, length-checked; extra fields rejected.

Returns: ok, fixed.

boost_prompt

Refine and enhance a prompt for clarity and effectiveness.

Parameter	Type	Required	Notes
`prompt`	string	Yes	Trimmed, length-checked; extra fields rejected.

Returns: ok, boosted.

crafting_prompt

Generate a structured, reusable workflow prompt for complex tasks based on a raw request and a few settings.

Parameter	Type	Required	Notes
`request`	string	Yes	Trimmed, length-checked; strict input.
`constraints`	string	No	Hard requirements to enforce (bullet list recommended).
`mode`	string	No	`general`, `plan`, `review`, `troubleshoot`.
`approach`	string	No	`conservative`, `balanced`, `creative`.
`tone`	string	No	`direct`, `neutral`, `friendly`.
`verbosity`	string	No	`brief`, `normal`, `detailed`.

Returns: ok, prompt, settings.

Response Format

content: array of content blocks. First block is JSON for structuredContent, second is a short human message (or Error: ...).
structuredContent: machine-parseable results.
Errors return structuredContent.ok=false and an error object with code, message, optional context (sanitized, up to 200 chars), details, and recoveryHint.
Error responses also include isError: true.

Development

Prerequisites

Node.js >= 22.0.0
npm

Scripts

Command	Description
`npm run build`	Compile TypeScript and set permissions.
`npm run prepare`	Build on install (publishing helper).
`npm run dev`	Run from source in watch mode.
`npm run dev:http`	Alias of `npm run dev` (no HTTP transport yet).
`npm run watch`	TypeScript compiler in watch mode.
`npm run start`	Run the compiled server from `dist/`.
`npm run start:http`	Alias of `npm run start` (no HTTP transport yet).
`npm run test`	Run `node:test` once.
`npm run test:coverage`	Run `node:test` with experimental coverage.
`npm run test:watch`	Run `node:test` in watch mode.
`npm run lint`	Run ESLint.
`npm run format`	Run Prettier.
`npm run type-check`	TypeScript type checking.
`npm run inspector`	Run MCP Inspector against `dist/index.js`.
`npm run inspector:http`	Alias of `npm run inspector` (no HTTP transport yet).
`npm run duplication`	Run jscpd duplication report.
`npm run prepublishOnly`	Lint, type-check, and build before publish.

Project Structure

  src/
    index.ts        Entry point
    cli.ts          CLI parsing, logging bootstrap, shutdown handling
    server.ts       MCP server setup (stdio transport)
    tools.ts        Tool implementations
    schemas.ts      Zod input/output schemas
    config.ts       Configuration and constants
    types.ts        Shared types and error codes
    lib/            Shared utilities (LLM, retry, telemetry, prompt utils)

tests/            node:test suites

dist/             Compiled output (generated)

docs/             Static assets

Security

API keys are supplied only via environment variables.
Inputs are validated with Zod and additional length checks.
Error context is included in debug mode (sanitized and truncated to 200 chars).
Google safety filters are always enabled.

Contributing

Pull requests are welcome. Please include a short summary, tests run, and note any configuration changes.

License

MIT License. See LICENSE for details.

Available Tools

3 tools

boost_promptBoost PromptB

Read-only

Transform a prompt using prompt engineering best practices for maximum clarity and effectiveness.

ParametersJSON Schema

Name	Required	Description	Default
`prompt`	Yes	Prompt to transform and optimize

TDQS

B3.3/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations indicate readOnlyHint=true (safe operation), openWorldHint=true (handles diverse inputs), and idempotentHint=false (non-idempotent). The description adds value by specifying the transformation is for 'clarity and effectiveness' and involves 'prompt engineering best practices', which provides behavioral context beyond annotations. However, it doesn't detail aspects like rate limits, error handling, or output format, keeping the score moderate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core action ('Transform a prompt') and adds necessary context without waste. Every word contributes to understanding the tool's purpose, making it appropriately sized and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (transformation operation), annotations cover safety and input handling, but there's no output schema to explain return values. The description adequately states the purpose but lacks details on usage guidelines, behavioral nuances like transformation specifics, or how it differs from siblings, leaving gaps in completeness for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the 'prompt' parameter well-documented as 'Prompt to transform and optimize'. The description adds marginal meaning by implying optimization for 'clarity and effectiveness', but it doesn't provide additional syntax, examples, or constraints beyond the schema. Baseline 3 is appropriate given high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with a specific verb ('Transform') and resource ('prompt'), and it adds context about 'prompt engineering best practices' and goals like 'maximum clarity and effectiveness'. However, it doesn't explicitly differentiate from sibling tools like 'crafting_prompt' or 'fix_prompt', which might have overlapping or distinct functions, preventing a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives such as 'crafting_prompt' or 'fix_prompt'. It implies usage for optimizing prompts but lacks explicit when/when-not scenarios, prerequisites, or comparisons to siblings, leaving the agent with minimal context for selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

crafting_promptCrafting PromptB

Read-only

Generate a structured, reusable workflow prompt for complex tasks based on a raw request and a few settings.

ParametersJSON Schema

Name	Required	Description	Default
`request`	Yes	Raw user request / task description to turn into a workflow prompt
`constraints`	No	Optional: hard requirements to enforce (e.g., no breaking changes)
`mode`	No		general
`approach`	No		balanced
`tone`	No		direct
`verbosity`	No		normal

TDQS

B3.4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations indicate read-only and open-world behavior, which the description doesn't contradict, but it adds no behavioral context beyond that—no details on rate limits, authentication needs, or output characteristics. With annotations covering safety, a 3 reflects minimal added value.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose without unnecessary details, though it could be slightly more structured by explicitly listing key parameters.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity with 6 parameters, low schema coverage, no output schema, and annotations that only cover safety, the description is incomplete—it lacks details on parameter meanings, output format, and usage scenarios, making it inadequate for full understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is low at 33%, with only 'request' and 'constraints' described in the schema. The description mentions 'a few settings' but doesn't explain parameters like 'mode,' 'approach,' 'tone,' or 'verbosity,' failing to compensate for the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with a specific verb ('Generate') and resource ('structured, reusable workflow prompt for complex tasks'), distinguishing it from sibling tools like 'boost_prompt' and 'fix_prompt' by focusing on creating prompts from raw requests rather than enhancing or repairing existing ones.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage by mentioning 'based on a raw request and a few settings,' suggesting it's for turning user input into prompts, but it lacks explicit guidance on when to use this tool versus alternatives like 'boost_prompt' or 'fix_prompt,' or any context-specific exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

fix_promptFix PromptB

Read-only

Polish and refine a prompt for better clarity, readability, and flow.

ParametersJSON Schema

Name	Required	Description	Default
`prompt`	Yes	Prompt to polish and refine

TDQS

B3.3/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations indicate readOnlyHint=true (safe read operation), openWorldHint=true (broad applicability), and idempotentHint=false (non-idempotent). The description adds context by specifying the refinement goals (clarity, readability, flow), which goes beyond the annotations. However, it does not disclose other behavioral traits like potential side effects, rate limits, or detailed output expectations, keeping the score moderate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core action ('polish and refine') and purpose. It avoids redundancy and wastes no words, making it highly concise and well-structured for quick understanding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (single parameter, no output schema), the description is adequate but has gaps. It explains what the tool does but lacks details on when to use it versus siblings, output format, or error handling. With annotations covering safety and scope, it meets minimum viability but isn't fully comprehensive.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, fully documenting the single parameter 'prompt'. The description does not add any parameter-specific semantics beyond what the schema provides (e.g., it doesn't explain format or constraints). With high schema coverage, the baseline score is 3, as the description doesn't compensate but doesn't need to.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with specific verbs ('polish and refine') and the resource ('a prompt'), and it specifies the improvement goals ('better clarity, readability, and flow'). However, it does not explicitly distinguish this tool from its siblings (boost_prompt, crafting_prompt), which would be needed for a score of 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus its siblings (boost_prompt, crafting_prompt) or any alternatives. It lacks explicit instructions on context, prerequisites, or exclusions, offering only a general purpose without usage differentiation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.2/5.0

Disambiguation3/5

The three tools have overlapping purposes in prompt improvement, with 'boost_prompt' and 'fix_prompt' both focusing on clarity and effectiveness, which could cause confusion. However, 'crafting_prompt' is more distinct as it generates structured workflows, providing some differentiation.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern with clear, descriptive verbs ('boost', 'crafting', 'fix') and the same noun ('prompt'), making them predictable and easy to understand.

Tool Count2/5

With only 3 tools, the server feels thin for a domain like prompt tuning, which might involve more operations such as evaluating prompts, testing variations, or managing prompt libraries. This limited set could restrict agent capabilities.

Completeness2/5

The toolset is incomplete for prompt tuning, missing essential operations like evaluating prompt effectiveness, comparing different versions, or storing/retrieving prompts. This creates gaps that could lead to agent failures in comprehensive prompt management tasks.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

pqs-mcp-server A
io.github.OnChainAIIntel
PQS scores any prompt before the model runs. 8 dimensions. 5 frameworks. Pre-flight, not post-hoc.
AI & Machine Learning Testing & QA Tools
222
rtcf A
io.github.hengkp
Turns rough requests into sharp Role/Task/Context/Format prompts. Thai and English.
AI & Machine Learning Developer Tools
32
mcp A
org.wikiprompt
The Wikipedia of AI prompts: search 900+ curated prompts by model, style and type, in 7 languages
Search AI & Machine Learning
122
magenie33-quality-dimension-generator
ai.smithery
Generate tailored quality criteria and scoring guides from your task descriptions. Refine objectiv…
Developer Tools Testing & QA Tools Marketing
2

Related MCP Servers

MCP Prompt Cleaner
Developer Tools Text Summarization App Automation
dacebt
A
license
Not graded
quality
D
maintenance
Enhances and cleans raw prompts using AI to make them more clear, actionable, and effective. Provides quality assessment, suggestions, and supports both general and code-specific optimization modes.
Updated a year ago (2025-10-16 05:44 UTC)
1
MIT
PromptArchitect MCP
Developer Tools Autonomous Agents RAG Systems
MerabyLabs
F
license
A
quality
C
maintenance
Refines 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.
Updated 9 months ago (2025-12-19 03:10 UTC)
4
209
5
Promptheus
Developer Tools Autonomous Agents
abhichandra21
A
license
Not graded
quality
C
maintenance
Refines 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.
Updated 6 months ago (2026-03-17 19:47 UTC)
17
MIT
MCP Prompt Optimizer
Developer Tools Autonomous Agents
grandinh
A
license
B
quality
D
maintenance
Automatically analyzes and optimizes AI prompts by calculating clarity scores, detecting risks, asking clarifying questions, and adding domain-specific requirements to improve AI interaction quality.
Updated 10 months ago (2025-11-09 04:06 UTC)
1
MIT

Appeared in Searches

A guide for improving AI prompt output quality

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/j0hanz/prompt-tuner-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server