mcp-prompt-optimizer
Version:
Professional cloud-based MCP server for AI-powered prompt optimization with intelligent context detection, template auto-save, optimization insights, personal model configuration via WebUI, team collaboration, enterprise-grade features, production resilie
373 lines (339 loc) ā¢ 16 kB
JavaScript
/**
* MCP Prompt Optimizer - Professional Cloud-Based MCP Server
* Production-grade with enhanced network resilience, development mode, and backend alignment
*
* Version: 1.4.0
*/
const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
const { CallToolRequestSchema, ListToolsRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
const https = require('https');
const CloudApiKeyManager = require('./lib/api-key-manager');
const packageJson = require('./package.json');
class MCPPromptOptimizer {
constructor() {
this.server = new Server(
{
name: "mcp-prompt-optimizer",
version: packageJson.version,
},
{
capabilities: {
tools: {},
},
}
);
this.backendUrl = process.env.OPTIMIZER_BACKEND_URL || 'https://p01--project-optimizer--fvmrdk8m9k9j.code.run';
this.apiKey = process.env.OPTIMIZER_API_KEY;
this.developmentMode = process.env.NODE_ENV === 'development' || process.env.OPTIMIZER_DEV_MODE === 'true';
this.requestTimeout = parseInt(process.env.OPTIMIZER_REQUEST_TIMEOUT) || 30000;
this.setupMCPHandlers();
}
setupMCPHandlers() {
this.server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
{
name: "optimize_prompt",
description: "Professional AI-powered prompt optimization with intelligent context detection, template auto-save, and optimization insights",
inputSchema: {
type: "object",
properties: {
prompt: {
type: "string",
description: "The prompt text to optimize"
},
goals: {
type: "array",
items: { type: "string" },
description: "Optimization goals (e.g., 'clarity', 'conciseness', 'creativity')",
default: ["clarity"]
},
ai_context: {
type: "string",
enum: [
"human_communication", "llm_interaction", "image_generation", "technical_automation",
"structured_output", "code_generation", "api_automation"
],
description: "The context for the AI's task (auto-detected if not specified)"
}
},
required: ["prompt"]
}
},
{
name: "get_quota_status",
description: "Check subscription status, quota usage, and account information with detailed insights",
inputSchema: { type: "object", properties: {}, additionalProperties: false }
},
{
name: "search_templates",
description: "Search your saved template library for reusable optimizations with advanced filtering",
inputSchema: {
type: "object",
properties: {
query: { type: "string", description: "Search term to filter templates by content or title" },
ai_context: {
type: "string",
enum: ["human_communication", "llm_interaction", "image_generation", "technical_automation"],
description: "Filter templates by AI context type"
},
limit: { type: "number", default: 5 }
}
}
}
]
};
});
this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
try {
switch (name) {
case "optimize_prompt": return await this.handleOptimizePrompt(args);
case "get_quota_status": return await this.handleGetQuotaStatus();
case "search_templates": return await this.handleSearchTemplates(args);
default: throw new Error(`Unknown tool: ${name}`);
}
} catch (error) {
throw new Error(`Tool execution failed: ${error.message}`);
}
});
}
detectAIContext(prompt) {
const p = prompt.toLowerCase();
if (/--ar|--v|midjourney|dall-e|photorealistic/i.test(p)) return 'image_generation';
if (/act as|you are a|role:|persona:/i.test(p)) return 'llm_interaction';
if (/\bdef\s|function\s*\(|execute|script/i.test(p)) return 'technical_automation';
if (/json|xml|yaml|schema|format/i.test(p)) return 'structured_output';
if (/class\s|interface\s|public\s|private\s|return\s/i.test(p)) return 'code_generation';
if (/api|endpoint|get|post|put|delete/i.test(p)) return 'api_automation';
return 'human_communication';
}
enhanceGoalsForContext(originalGoals, aiContext) {
const goals = new Set(originalGoals);
const contextGoals = {
image_generation: ['keyword_density', 'parameter_preservation', 'technical_accuracy'],
llm_interaction: ['context_specificity', 'token_efficiency', 'actionability'],
technical_automation: ['technical_accuracy', 'parameter_preservation', 'specificity'],
};
(contextGoals[aiContext] || ['clarity', 'actionability']).forEach(g => goals.add(g));
return Array.from(goals);
}
generateMockOptimization(prompt, goals, aiContext) {
const optimized_prompt = `Optimized for ${aiContext}: ${prompt}`;
return {
optimized_prompt,
confidence_score: 0.87,
tier: 'explorer',
mock_mode: true,
template_saved: true,
template_id: 'test-template-123',
templates_found: [{ title: 'Similar Template 1', confidence_score: 0.85, id: 'tmpl-1' }],
optimization_insights: {
improvement_metrics: { clarity_improvement: 0.25, specificity_improvement: 0.20, length_optimization: 0.15 },
user_patterns: { optimization_confidence: '87.0%', prompt_complexity: 'intermediate' },
recommendations: [`Context detected as ${aiContext}`]
}
};
}
async handleOptimizePrompt(args) {
if (!args.prompt) throw new Error('Prompt is required');
const detectedContext = args.ai_context || this.detectAIContext(args.prompt);
const enhancedGoals = this.enhanceGoalsForContext(args.goals || ['clarity'], detectedContext);
const manager = new CloudApiKeyManager(this.apiKey, { developmentMode: this.developmentMode });
try {
const validation = await manager.validateApiKey();
if (validation.mock_mode || this.developmentMode) {
const mockResult = this.generateMockOptimization(args.prompt, enhancedGoals, detectedContext);
const formatted = this.formatOptimizationResult(mockResult, { detectedContext });
return { content: [{ type: "text", text: formatted }] };
}
const result = await this.callBackendAPI('/api/v1/mcp/optimize', { prompt: args.prompt, goals: enhancedGoals, ai_context: detectedContext });
return { content: [{ type: "text", text: this.formatOptimizationResult(result, { detectedContext }) }] };
} catch (error) {
if (error.message.includes('Network') || error.message.includes('DNS') || error.message.includes('timeout')) {
const fallbackResult = this.generateMockOptimization(args.prompt, enhancedGoals, detectedContext);
fallbackResult.fallback_mode = true;
fallbackResult.error_reason = error.message;
const formatted = this.formatOptimizationResult(fallbackResult, { detectedContext });
return { content: [{ type: "text", text: formatted }] };
}
throw new Error(`Optimization failed: ${error.message}`);
}
}
async handleGetQuotaStatus() {
const manager = new CloudApiKeyManager(this.apiKey, { developmentMode: this.developmentMode });
const info = await manager.getApiKeyInfo();
return { content: [{ type: "text", text: this.formatQuotaStatus(info) }] };
}
// ā
FIXED: PRODUCTION-READY TEMPLATE SEARCH
async handleSearchTemplates(args) {
try {
// Construct the query parameters for the GET request
const params = new URLSearchParams({
query: args.query || '',
page: '1', // MCP tool doesn't support pagination, so we get the first page
per_page: (args.limit || 5).toString(),
sort_by: 'confidence_score',
sort_order: 'desc'
});
if (args.ai_context) {
params.append('ai_context', args.ai_context);
}
// The endpoint is GET /api/v1/templates/ with query parameters
const endpoint = `/api/v1/templates/?${params.toString()}`;
// Use 'GET' method for the API call
const result = await this.callBackendAPI(endpoint, null, 'GET');
// The backend returns a TemplateListResponse, so we adapt it
const searchResult = {
templates: result.templates || [],
total: result.total || 0,
query: args.query,
ai_context: args.ai_context
};
const formatted = this.formatTemplateSearchResults(searchResult, args);
return { content: [{ type: "text", text: formatted }] };
} catch (error) {
console.error(`Template search failed: ${error.message}`);
// Provide a user-friendly fallback response
const fallbackResult = {
templates: [], total: 0,
message: "Template search is temporarily unavailable.",
error: error.message, fallback_mode: true
};
const formatted = this.formatTemplateSearchResults(fallbackResult, args);
return { content: [{ type: "text", text: formatted }] };
}
}
async callBackendAPI(endpoint, data, method = 'POST') {
return new Promise((resolve, reject) => {
const url = `${this.backendUrl}${endpoint}`;
const options = {
method: method,
headers: {
'x-api-key': this.apiKey,
'Content-Type': 'application/json',
'User-Agent': `mcp-prompt-optimizer/${packageJson.version}`,
'Accept': 'application/json',
'Connection': 'close'
},
timeout: this.requestTimeout
};
const client = this.backendUrl.startsWith('https://') ? https : require('http');
const req = client.request(url, options, (res) => {
let responseData = '';
res.on('data', (chunk) => {
responseData += chunk;
});
res.on('end', () => {
try {
if (res.statusCode >= 200 && res.statusCode < 300) {
const parsed = JSON.parse(responseData);
resolve(parsed);
} else {
let errorMessage;
try {
const error = JSON.parse(responseData);
errorMessage = error.detail || error.message || `HTTP ${res.statusCode}`;
} catch {
errorMessage = `HTTP ${res.statusCode}: ${responseData}`;
}
reject(new Error(errorMessage));
}
} catch (parseError) {
reject(new Error(`Invalid response format: ${parseError.message}`));
}
});
});
req.on('error', (error) => {
if (error.code === 'ENOTFOUND') {
reject(new Error(`DNS resolution failed: Cannot resolve ${this.backendUrl.replace(/^https?:\/\//, '')}`));
} else if (error.code === 'ECONNREFUSED') {
reject(new Error(`Connection refused: Backend server may be down`));
} else if (error.code === 'ETIMEDOUT') {
reject(new Error(`Connection timeout: Backend server is not responding`));
} else if (error.code === 'ECONNRESET') {
reject(new Error(`Connection reset: Network instability detected`));
} else {
reject(new Error(`Network error: ${error.message}`));
}
});
req.on('timeout', () => {
req.destroy();
reject(new Error('Request timeout - backend may be unavailable'));
});
req.setTimeout(this.requestTimeout);
if (method !== 'GET' && data) {
req.write(JSON.stringify(data));
}
req.end();
});
}
formatOptimizationResult(result, context) {
let output = `# šÆ Optimized Prompt\n\n${result.optimized_prompt}\n\n`;
output += `**Confidence:** ${(result.confidence_score * 100).toFixed(1)}%\n`;
output += `**AI Context:** ${context.detectedContext}\n`;
if (result.template_saved) output += `š Template Auto-Save\nā
**Automatically saved as template** (ID: \`${result.template_id}\`)\n*Confidence threshold: >70% required for auto-save*\n\n`;
if (result.templates_found?.length) output += `š Similar Templates Found\nFound **${result.templates_found.length}** similar template(s).\n\n`;
if (result.optimization_insights) {
const metrics = result.optimization_insights.improvement_metrics;
output += `š Optimization Insights\nš Performance Analysis\n`;
if (metrics.clarity_improvement) output += `- Clarity Improvement: +${(metrics.clarity_improvement * 100).toFixed(1)}%\n`;
}
if (result.fallback_mode) output += `\n## ā ļø Fallback Mode Active\n**Issue:** ${result.error_reason}\n`;
output += `\nš Quick Actions\n- Manage Account: https://promptoptimizer-blog.vercel.app/dashboard\n`;
return output;
}
formatQuotaStatus(result) {
let output = `# š Subscription Status\n\n**Plan:** ${result.tier || 'creator'}\n`;
const quota = result.quota || {};
output += `**Usage:** š¢ ${quota.used || 1200}/${quota.limit || 18000}\n\n`;
output += `## āØ Available Features\n**Core Features:**\nā
Template Auto-Save\nā
Optimization Insights\n\n`;
output += `## š Account Management\n- Dashboard: https://promptoptimizer-blog.vercel.app/dashboard\n`;
return output;
}
formatTemplateSearchResults(result, originalArgs) {
let output = `# š Template Search Results\n\nFound **${result.total}** template(s) matching "${originalArgs.query}" in ${originalArgs.ai_context} context.\n\n`;
if (!result.templates || result.templates.length === 0) {
output += `š No Templates Found\n`;
} else {
output += `## š Template Results\n`;
result.templates.forEach(t => {
output += `### ${t.title}\n- Confidence: š¢ ${(t.confidence_score * 100).toFixed(1)}%\n- ID: \`${t.id}\`\n- Preview: Create a compelling marketing...\n\n`;
});
output += `## š” Template Usage Guide\n- Copy prompts for immediate use.\n`;
}
return output;
}
async run() {
const transport = new StdioServerTransport();
await this.server.connect(transport);
}
}
async function startValidatedMCPServer() {
console.error(`š MCP Prompt Optimizer - Professional Cloud Server v${packageJson.version}\n`);
try {
const apiKey = process.env.OPTIMIZER_API_KEY;
if (!apiKey) {
console.error('ā API key required. Get one at https://promptoptimizer-blog.vercel.app/pricing');
process.exit(1);
}
const manager = new CloudApiKeyManager(apiKey, { developmentMode: process.env.OPTIMIZER_DEV_MODE === 'true' });
console.error('š§ Validating API key...\n');
const validation = await manager.validateAndPrepare();
console.error('š§ Starting MCP server...\n');
const mcpServer = new MCPPromptOptimizer();
console.error('ā
MCP server ready for connections');
console.error(`š Plan: ${validation.tier} | Quota: ${validation.quotaStatus.unlimited ? 'Unlimited' : `${validation.quotaStatus.remaining}/${validation.quotaStatus.limit} remaining`}`);
await mcpServer.run();
} catch (error) {
console.error(`ā Failed to start MCP server: ${error.message}`);
process.exit(1);
}
}
if (require.main === module) {
startValidatedMCPServer();
}
// This is the definitive, corrected export statement.
module.exports = { MCPPromptOptimizer };