What can you do with this server?

The flompt server enables AI prompt engineering through three core tools: * decompose_prompt: Break a raw text prompt into structured, typed blocks (role, objective, context, constraints, etc.) using AI (Claude/OpenAI with API key) or a keyword-based heuristic fallback; returns a JSON list of blocks * compile_prompt: Take a JSON list of structured blocks and compile them into a Claude-optimized XML prompt following Anthropic's recommended ordering, with an estimated token count * list_block_types: Retrieve all 16 available block types (role, objective, context, constraints, guardrails, examples, chain of thought, output format, etc.) with descriptions and recommended canonical ordering The server requires no authentication, is stateless, and integrates with Claude Code via the Model Context Protocol (MCP) over streamable HTTP.

flompt

by Nyrok

Overview Schema Related Servers Score Discussions

TypeScript

🎥 Demo

Try it live at flompt.dev, free, no account needed.

Paste any prompt. The AI breaks it into typed blocks. Drag, reorder, compile to Claude-optimized XML.

flompt demo

Related MCP server: Refine Prompt

✨ What is flompt?

flompt is a visual prompt engineering tool.

Instead of writing one long block of text, flompt lets you:

Paste any prompt and let the AI break it into structured blocks
Drag, connect, and reorder blocks in a flowchart editor
Compile to a Claude-optimized, machine-ready XML prompt

🧩 Block Types

16 specialized blocks that map directly to Claude's prompt engineering best practices:

Block	Purpose	Claude XML
Document	External content grounding	`<documents><document>`
Role	AI persona & expertise	`<role>`
Tools	Callable functions the agent can use	`<tools>`
Audience	Who the output is written for	`<audience>`
Context	Background information	`<context>`
Environment	System context: OS, paths, date, runtime	`<environment>`
Objective	What to DO	`<objective>`
Goal	End goal & success criteria	`<goal>`
Input	Data you're providing	`<input>`
Constraints	Rules & limitations	`<constraints>`
Guardrails	Hard limits and safety refusals	`<guardrails>`
Examples	Few-shot demonstrations	`<examples><example>`
Chain of Thought	Step-by-step reasoning	`<thinking>`
Output Format	Expected output structure	`<output_format>`
Response Style	Verbosity, tone, prose, markdown (structured UI)	`<format_instructions>`
Language	Response language	`<language>`

Blocks are automatically ordered following Anthropic's recommended prompt structure.

🚀 Try It Now

flompt.dev, free and open-source, no account needed.

🧩 Browser Extension

Use flompt directly inside ChatGPT, Claude, and Gemini without leaving your tab.

Injects an Enhance button into the AI chat input
Bidirectional sync between the sidebar and the chat
Works on ChatGPT, Claude, and Gemini

🤖 Claude Code Integration (MCP)

flompt exposes its core capabilities as native tools inside Claude Code via the Model Context Protocol (MCP).

Once configured, you can call decompose_prompt, compile_prompt, and list_block_types directly from any Claude Code conversation, no browser, no copy-paste.

Installation

Option 1: CLI (recommended)

claude mcp add --transport http --scope user flompt https://flompt.dev/mcp/

The --scope user flag makes flompt available in all your Claude Code projects.

Option 2: ~/.claude.json

{
  "mcpServers": {
    "flompt": {
      "type": "http",
      "url": "https://flompt.dev/mcp/"
    }
  }
}

Available Tools

Once connected, 3 tools are available in Claude Code:

`decompose_prompt(prompt: str)`

Breaks down a raw prompt into structured blocks (role, objective, context, constraints, etc.).

Uses Claude or GPT on the server if an API key is configured
Falls back to keyword-based heuristic analysis otherwise
Returns a list of typed blocks + full JSON to pass to compile_prompt

Input:  "You are a Python expert. Write a function that parses JSON and handles errors."
Output: ✅ 3 blocks extracted:
          [ROLE] You are a Python expert.
          [OBJECTIVE] Write a function that parses JSON…
          [CONSTRAINTS] handles errors
        📋 Full blocks JSON: [{"id": "...", "type": "role", ...}, ...]

`compile_prompt(blocks_json: str)`

Compiles a list of blocks into a Claude-optimized XML prompt.

Takes the JSON from decompose_prompt (or manually crafted blocks)
Reorders blocks following Anthropic's recommended structure
Returns the final XML prompt with an estimated token count

Input:  [{"type": "role", "content": "You are a Python expert", ...}, ...]
Output: ✅ Prompt compiled (142 estimated tokens):

        <role>You are a Python expert.</role>
        <objective>Write a function that parses JSON and handles errors.</objective>

`list_block_types()`

Lists all 16 available block types with descriptions and the recommended canonical ordering. Useful when manually crafting blocks.

Typical Workflow

1. decompose_prompt("your raw prompt here")
   → get structured blocks as JSON

2. (optionally edit the JSON to add/remove/modify blocks)

3. compile_prompt("<json from step 1>")
   → get Claude-optimized XML prompt, ready to use

Technical Details

Property	Value
Transport	Streamable HTTP (POST)
Endpoint	`https://flompt.dev/mcp/`
Session	Stateless (each call is independent)
Auth	None required
DNS rebinding protection	Enabled (`flompt.dev` explicitly allowed)

🛠️ Self-Hosting (Local Dev)

Requirements

Python 3.12+
Node.js 18+
An Anthropic or OpenAI API key (optional, heuristic fallback works without one)

Setup

Backend:

cd backend
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env   # add your API key
uvicorn app.main:app --reload --port 8000

App (Frontend):

cd app
cp .env.example .env   # optional: add PostHog key
npm install
npm run dev

Blog:

cd blog
npm install
npm run dev   # available at http://localhost:3000/blog

Service	URL
App	http://localhost:5173
Backend API	http://localhost:8000
API Docs (Swagger)	http://localhost:8000/docs
MCP endpoint	http://localhost:8000/mcp/

⚙️ AI Configuration

flompt supports multiple AI providers. Copy backend/.env.example to backend/.env:

# Anthropic (recommended)
ANTHROPIC_API_KEY=sk-ant-...
AI_PROVIDER=anthropic
AI_MODEL=claude-3-5-haiku-20241022

# or OpenAI
OPENAI_API_KEY=sk-...
AI_PROVIDER=openai
AI_MODEL=gpt-4o-mini

Without an API key, flompt uses a keyword-based heuristic decomposer and still compiles structured XML.

🚢 Production Deployment

This section documents the exact production setup running at flompt.dev. Everything lives in /projects/flompt.

Architecture

Internet
   │
   ▼
Caddy (auto-TLS, reverse proxy)    ← port 443/80
   ├── /app*         → Vite SPA static files (app/dist/)
   ├── /blog*        → Next.js static export (blog/out/)
   ├── /api/*        → FastAPI backend (localhost:8000)
   ├── /mcp/*        → FastAPI MCP server (localhost:8000, no buffering)
   ├── /docs*        → Reverse proxy to GitBook
   └── /             → Static landing page (landing/)
         ↓
   FastAPI (uvicorn, port 8000)
         ↓
   Anthropic / OpenAI API

Both Caddy and the FastAPI backend are managed by supervisord, itself watched by a keepalive loop.

1. Prerequisites

# Python 3.12+ with pip
python --version

# Node.js 18+
node --version

# Caddy binary placed at /projects/flompt/caddy
# (not committed to git, download from https://caddyserver.com/download)
curl -o caddy "https://caddyserver.com/api/download?os=linux&arch=amd64"
chmod +x caddy

# supervisor installed in a Python virtualenv
pip install supervisor

2. Environment Variables

Backend (backend/.env):

ANTHROPIC_API_KEY=sk-ant-...       # or OPENAI_API_KEY
AI_PROVIDER=anthropic              # or: openai
AI_MODEL=claude-3-5-haiku-20241022 # model to use for decompose/compile

App frontend (app/.env):

VITE_POSTHOG_KEY=phc_...           # optional analytics
VITE_POSTHOG_HOST=https://eu.i.posthog.com

Blog (blog/.env.local):

NEXT_PUBLIC_POSTHOG_KEY=phc_...
NEXT_PUBLIC_POSTHOG_HOST=https://eu.i.posthog.com

3. Build

All assets must be built before starting services. Use the deploy script or manually:

Full deploy (build + restart + health check):

cd /projects/flompt
./deploy.sh

Build only (no service restart):

./deploy.sh --build-only

Restart only (no rebuild):

./deploy.sh --restart-only

Manual build steps:

# 1. Vite SPA → app/dist/
cd /projects/flompt/app
npm run build
# Output: app/dist/ (pre-compressed with gzip, served by Caddy)

# 2. Next.js blog → blog/out/
cd /projects/flompt/blog
rm -rf .next out   # clear cache to avoid stale builds
npm run build
# Output: blog/out/ (full static export, no Node server needed)

4. Process Management

Production processes are managed by supervisord (supervisord.conf):

Program	Command	Port	Log
`flompt-backend`	`uvicorn app.main:app --host 0.0.0.0 --port 8000`	8000	`/tmp/flompt-backend.log`
`flompt-caddy`	`caddy run --config /projects/flompt/Caddyfile`	443/80	`/tmp/flompt-caddy.log`

Both programs have autorestart=true and startretries=5, they automatically restart on crash.

Start supervisord (first boot or after a full restart):

supervisord -c /projects/flompt/supervisord.conf

Common supervisorctl commands:

# Check status of all programs
supervisorctl -c /projects/flompt/supervisord.conf status

# Restart backend only (e.g. after a code change)
supervisorctl -c /projects/flompt/supervisord.conf restart flompt-backend

# Restart Caddy only (e.g. after a Caddyfile change)
supervisorctl -c /projects/flompt/supervisord.conf restart flompt-caddy

# Restart everything
supervisorctl -c /projects/flompt/supervisord.conf restart all

# Stop everything
supervisorctl -c /projects/flompt/supervisord.conf stop all

# Read real-time logs
tail -f /tmp/flompt-backend.log
tail -f /tmp/flompt-caddy.log
tail -f /tmp/flompt-supervisord.log

5. Keepalive Watchdog

keepalive.sh is an infinite bash loop (running as a background process) that:

Checks every 30 seconds whether supervisord is alive
If supervisord is down, kills any zombie process occupying port 8000 (via inode lookup in /proc/net/tcp)
Restarts supervisord
Logs all events to /tmp/flompt-keepalive.log

Start keepalive (should be running at all times):

nohup /projects/flompt/keepalive.sh >> /tmp/flompt-keepalive.log 2>&1 &
echo $!   # note the PID

Check if keepalive is running:

ps aux | grep keepalive.sh
tail -f /tmp/flompt-keepalive.log

Note: keepalive.sh uses the same Python virtualenv path as supervisord. If you reinstall supervisor in a different venv, update SUPERVISORD and SUPERVISORCTL paths at the top of keepalive.sh.

6. Caddy Configuration

Caddyfile handles all routing for flompt.dev. Key rules (in priority order):

/blog*      → Static Next.js export at blog/out/
/api/*      → FastAPI backend at localhost:8000
/health     → FastAPI health check
/mcp/*      → FastAPI MCP server (flush_interval -1 for streaming)
/mcp        → 308 redirect to /mcp/ (avoids upstream 307 issues)
/docs*      → Reverse proxy to GitBook (external)
/app*       → Vite SPA at app/dist/ (gzip precompressed)
/           → Static landing page at landing/

Reload Caddy after a Caddyfile change:

supervisorctl -c /projects/flompt/supervisord.conf restart flompt-caddy
# or directly:
/projects/flompt/caddy reload --config /projects/flompt/Caddyfile

Caddy auto-manages TLS certificates via Let's Encrypt, no manual SSL setup needed.

7. Health Checks

The deploy script runs these checks automatically. You can run them manually:

# Backend API
curl -s https://flompt.dev/health
# → {"status":"ok","service":"flompt-api"}

# Landing page
curl -s -o /dev/null -w "%{http_code}" https://flompt.dev/
# → 200

# Vite SPA
curl -s -o /dev/null -w "%{http_code}" https://flompt.dev/app
# → 200

# Blog
curl -s -o /dev/null -w "%{http_code}" https://flompt.dev/blog/en
# → 200

# MCP endpoint (requires Accept header)
curl -s -o /dev/null -w "%{http_code}" \
  -X POST https://flompt.dev/mcp/ \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","method":"tools/list","id":1}'
# → 200

8. Updating the App

After a backend code change:

cd /projects/flompt
git pull
supervisorctl -c supervisord.conf restart flompt-backend

After a frontend change:

cd /projects/flompt
git pull
cd app && npm run build
# No service restart needed, Caddy serves static files directly

After a blog change:

cd /projects/flompt
git pull
cd blog && rm -rf .next out && npm run build
# No service restart needed

After a Caddyfile change:

supervisorctl -c /projects/flompt/supervisord.conf restart flompt-caddy

Full redeploy from scratch:

cd /projects/flompt && ./deploy.sh

9. Log Files Reference

File	Content
`/tmp/flompt-backend.log`	FastAPI/uvicorn stdout + stderr
`/tmp/flompt-caddy.log`	Caddy access + error logs
`/tmp/flompt-supervisord.log`	supervisord daemon logs
`/tmp/flompt-keepalive.log`	keepalive watchdog events

🏗️ Tech Stack

Layer	Technology
Frontend	React 18, TypeScript, React Flow v11, Zustand, Vite
Backend	FastAPI, Python 3.12, Uvicorn
MCP Server	FastMCP (streamable HTTP transport)
AI	Anthropic Claude / OpenAI GPT (pluggable)
Reverse Proxy	Caddy (auto-TLS via Let's Encrypt)
Process Manager	Supervisord + keepalive watchdog
Blog	Next.js 15 (static export), Tailwind CSS
Extension	Chrome & Firefox MV3 (content script + sidebar)
i18n	10 languages: EN FR ES DE PT JA TR ZH AR RU

🌍 Features

🎨 Visual flowchart editor with drag-and-drop blocks (React Flow)
📋 Dual-view editor: toggle between canvas and card list at any time
👁️ Hide/show any block; hidden blocks are excluded from the assembled prompt
📑 Duplicate any block in one click from the List View
🤖 AI-powered decomposition: paste a prompt, get structured blocks
🔄 Async job queue for non-blocking decomposition with live progress
🦾 XML output structured following Anthropic best practices
🧩 Browser extension for ChatGPT, Claude, and Gemini (Chrome + Firefox)
🔌 Claude Code MCP: native tool integration via Model Context Protocol
📱 Responsive with full touch support
🌙 Dark theme
🌐 10 languages: EN, FR, ES, DE, PT, JA, TR, ZH, AR, RU, each with a dedicated indexed page for SEO
💾 Auto-save via local Zustand persistence
⌨️ Keyboard shortcuts
📋 Export as TXT or JSON
🔓 MIT licensed, self-hostable

🤝 Contributing

Contributions are welcome: bug reports, features, translations, and docs!

Read CONTRIBUTING.md to get started. The full changelog is in CHANGELOG.md.

📄 License

MIT, built by Nyrok

Available Tools

3 tools

compile_promptA

Compile a list of blocks into a Claude-optimized structured XML prompt.

Takes the JSON returned by decompose_prompt (or manually crafted blocks)
and produces a ready-to-use XML prompt with a token estimate.

Args:
    blocks_json: JSON-stringified list of blocks.
                 Each block: {"type": "role|objective|...", "content": "...",
                              "label": "...", "description": "...", "summary": ""}

Returns:
    The compiled XML prompt with token estimate.

ParametersJSON Schema

Name	Required	Description	Default
`blocks_json`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.3/5.0

Behavior3/5

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

With no annotations, the description should disclose behavioral traits; it mentions the output (XML prompt with token estimate) but does not cover side effects, permissions, or error behavior, leaving some gaps.

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 concise (5 sentences plus structured Args/Returns), with the core purpose in the first sentence, and no unnecessary information.

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

Completeness4/5

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

Given the tool's simplicity (1 parameter, no enums) and presence of an output schema, the description covers the input format and output summary adequately, though 'Claude-optimized' could be elaborated.

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

Parameters5/5

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

The input schema only provides a title and type, but the description thoroughly explains the parameter's format (JSON-stringified list of blocks) with field details, fully compensating for the 0% schema coverage.

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 explicitly states it compiles blocks into a Claude-optimized XML prompt, and references decompose_prompt to differentiate from siblings like list_block_types.

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

Usage Guidelines4/5

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

It indicates the tool is used after decompose_prompt or with manually crafted blocks, providing clear context for when to invoke it, but does not explicitly exclude other scenarios.

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

decompose_promptA

Decompose a raw prompt into structured blocks (role, objective, context, constraints, etc.).

Uses AI (Claude/OpenAI) if an API key is configured on the server, otherwise
falls back to keyword-based heuristic analysis.
Returns a JSON list of blocks ready to edit or pass to compile_prompt.

Args:
    prompt: The raw prompt string to decompose.

Returns:
    A summary of extracted blocks + the full JSON to pass to compile_prompt.

ParametersJSON Schema

Name	Required	Description	Default
`prompt`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.9/5.0

Behavior3/5

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

With no annotations, the description carries full burden. It discloses the AI vs heuristic behavior and that the return value includes both a summary and full JSON. However, it does not mention limitations like prompt size, rate limits, or error conditions, leaving some gaps.

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 concise and front-loaded with the main action. It uses a clear two-paragraph structure. The 'Args' and 'Returns' sections add minor redundancy but overall the text is efficient and focused.

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

Completeness4/5

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

Given the tool's simplicity (one param, output schema exists), the description covers the key points: how it works (AI vs heuristic), what it produces (structured blocks), and how to use the result (edit or pass to compile_prompt). It does not list block types but references a sibling tool, which is acceptable.

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?

Schema coverage is 0%, so description must compensate. It adds 'The raw prompt string to decompose', which clarifies the parameter's role. However, this is minimal—no examples, length constraints, or formatting hints. For a single simple parameter, this is adequate but not exemplary.

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: 'Decompose a raw prompt into structured blocks'. It specifies the action (decompose) and resource (raw prompt), and hints at the output format. This distinguishes it from siblings like compile_prompt, which does the reverse.

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

Usage Guidelines4/5

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

The description mentions when to use AI vs heuristic fallback based on configuration, and suggests the output is 'ready to edit or pass to compile_prompt'. It does not explicitly state when not to use, but the sibling context and the decomposition vs compilation contrast provide adequate guidance.

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

list_block_typesA

List all available block types in flompt with their descriptions.

Useful to know which types to use when manually crafting blocks
to pass to compile_prompt.

Returns:
    Description of each block type and the recommended canonical ordering.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.5/5.0

Behavior4/5

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

With no annotations, description carries full burden. Discloses that it returns descriptions and recommended canonical ordering, and that it is a list operation, which implies no side effects.

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?

Three concise, front-loaded sentences with no waste. Every sentence adds value.

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

Completeness5/5

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

Given low complexity and existence of output schema, description sufficiently covers purpose and return structure. No gaps.

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

Parameters4/5

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

No parameters, so baseline 4. Description does not need to add parameter info.

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?

Clearly states 'List all available block types' with specific verb and resource. Distinguishes from sibling tools compile_prompt and decompose_prompt by indicating its use case for manual block crafting.

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

Usage Guidelines4/5

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

Explicitly states when to use: 'when manually crafting blocks to pass to compile_prompt.' Provides clear context, though does not mention when not to use.

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. Dates show when Glama detected each change.

3 tool updatesv1.0.0Mar 11, 2026
- First observedcompile_prompt
- First observeddecompose_prompt
- First observedlist_block_types

Install Server

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

TDQS

A4.4/5.0

Disambiguation5/5

Each tool has a unique, clearly defined role: decompose breaks down prompts, compile assembles them, and list_block_types provides reference. No ambiguity.

Naming Consistency5/5

All tools follow a consistent verb_noun pattern with snake_case (compile_prompt, decompose_prompt, list_block_types), making the purpose obvious.

Tool Count5/5

With only 3 tools, the server is tightly scoped to a focused prompt engineering workflow—no bloat, each tool earns its place.

Completeness5/5

The set covers the full pipeline: decompose an existing prompt, list available block types for manual editing, and compile into XML. No obvious gaps for the intended domain.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

Server4AgentOAuth
com.server4agent
Give any MCP-compatible AI assistant a builder for live, hosted web tools and workflows.
App Automation Developer Tools Browser Automation
2
PromptOTOAuth
com.promptot
Manage, version, and publish LLM prompts with blocks, variables, and evaluations.
Developer Tools AI & Machine Learning RAG Systems
2
Sleepwalker AOAuth
ai.sleepwalker
AI Visibility and Content Intelligence tools for Claude and MCP-compatible agents.
Agent Orchestration Developer Tools Marketing
222
ПромтЛаб — библиотека AI-промптов
ru.promtlabs
Self-hosted AI prompt library: prompts, collections, tags, teams, chains. 29 MCP tools for agents.
AI & Machine Learning Knowledge & Memory Developer Tools
2

Related MCP Servers

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
-
Refine Prompt
Developer Tools Autonomous Agents
FelippeFarias
A
license
A
quality
D
maintenance
An MCP server that uses Claude 3.5 Sonnet to transform ordinary prompts into structured, professionally engineered instructions for any LLM. It enhances AI interactions by adding context, requirements, and structural clarity to raw user inputs.
Updated a year ago (2025-04-03 00:31 UTC)
1
3
MIT
Clarifyprompt-MCP
Developer Tools App Automation
LumabyteCo
A
license
A
quality
A
maintenance
An MCP server that transforms vague prompts into platform-optimized prompts for 58 AI platforms across 7 categories. Send a raw prompt. Get back a version specifically optimized for Midjourney, DALL-E, Sora, Runway, ElevenLabs, Claude, ChatGPT, or any of the 58 supported platforms — with the right syntax, parameters, and structure each platform expects.
Updated 2 months ago (2026-07-14 17:07 UTC)
23
160
12
Apache 2.0
ctxrayofficial
Developer Tools AI & Machine Learning
ctxray
A
license
Not graded
quality
C
maintenance
Context intelligence for AI coding sessions. 7 MCP tools to score, compare, compress, build, and scan prompts across 9 AI tools. Rule-based, <5ms/prompt, all analysis runs locally.
Updated 2 months ago (2026-06-24 02:33 UTC)
46
MIT

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/Nyrok/flompt'

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

🎥 Demo

✨ What is flompt?

🧩 Block Types

🚀 Try It Now

🧩 Browser Extension

🤖 Claude Code Integration (MCP)

Installation

Available Tools

decompose_prompt(prompt: str)

compile_prompt(blocks_json: str)

list_block_types()

Typical Workflow

Technical Details

🛠️ Self-Hosting (Local Dev)

Requirements

Setup

⚙️ AI Configuration

🚢 Production Deployment

Architecture

1. Prerequisites

2. Environment Variables

3. Build

4. Process Management

5. Keepalive Watchdog

6. Caddy Configuration

7. Health Checks

8. Updating the App

9. Log Files Reference

🏗️ Tech Stack

🌍 Features

🤝 Contributing

📄 License

Available Tools

Output Schema

TDQS

Output Schema

TDQS

Output Schema

TDQS

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

PromptArchitect MCP

Refine Prompt

Clarifyprompt-MCP

ctxrayofficial

Latest Blog Posts

MCP directory API

`decompose_prompt(prompt: str)`

`compile_prompt(blocks_json: str)`

`list_block_types()`