MCP's prompt management functionality allows predefined and reusable prompt templates, improving development efficiency and consistency. Here are detailed implementation methods:
Prompt Definition
MCP prompts include name, description, and parameterized templates:
{ "name": "prompt_name", "description": "Prompt description", "arguments": [ { "name": "param1", "description": "Description of parameter 1", "required": true } ] }
1. Prompt Registration
from mcp.server import Server server = Server("my-mcp-server") @server.prompt( name="code_review", description="Code review prompt template" ) async def code_review_prompt( code: str, language: str = "python" ) -> str: """Generate code review prompt""" return f""" Please review the following {language} code and provide improvement suggestions: Code: {code} Please focus on: 1. Code quality and readability 2. Performance optimization suggestions 3. Security issues 4. Best practices 5. Potential bugs """ @server.prompt( name="data_analysis", description="Data analysis prompt template" ) async def data_analysis_prompt( data: str, analysis_type: str = "summary" ) -> str: """Generate data analysis prompt""" return f""" Please perform {analysis_type} analysis on the following data: Data: {data} Please provide: 1. Data summary 2. Key insights 3. Trend analysis 4. Visualization suggestions """
2. Prompt Template Engine
from string import Template import json from typing import Dict, Any class PromptTemplateEngine: def __init__(self): self.templates = {} def register_template(self, name: str, template: str, parameters: list): """Register prompt template""" self.templates[name] = { "template": template, "parameters": parameters } def render(self, name: str, **kwargs) -> str: """Render prompt template""" if name not in self.templates: raise ValueError(f"Template '{name}' does not exist") template_info = self.templates[name] template = template_info["template"] # Validate required parameters required_params = [ p["name"] for p in template_info["parameters"] if p.get("required", False) ] missing_params = [ param for param in required_params if param not in kwargs ] if missing_params: raise ValueError( f"Missing required parameters: {', '.join(missing_params)}" ) # Render using Template t = Template(template) return t.substitute(**kwargs) def list_templates(self) -> list: """List all templates""" return [ { "name": name, "description": info.get("description", ""), "parameters": info["parameters"] } for name, info in self.templates.items() ]
3. Prompt Version Management
from datetime import datetime from typing import Optional class PromptVersionManager: def __init__(self): self.versions = {} self.current_versions = {} def save_version( self, prompt_name: str, version: str, template: str, metadata: dict = None ): """Save prompt version""" if prompt_name not in self.versions: self.versions[prompt_name] = {} self.versions[prompt_name][version] = { "template": template, "metadata": metadata or {}, "created_at": datetime.now().isoformat() } def set_current_version(self, prompt_name: str, version: str): """Set current version""" if prompt_name not in self.versions or \ version not in self.versions[prompt_name]: raise ValueError(f"Version '{version}' does not exist") self.current_versions[prompt_name] = version def get_current_version(self, prompt_name: str) -> Optional[str]: """Get current version""" return self.current_versions.get(prompt_name) def get_version( self, prompt_name: str, version: str ) -> Optional[dict]: """Get specified version""" if prompt_name not in self.versions: return None return self.versions[prompt_name].get(version) def list_versions(self, prompt_name: str) -> list: """List all versions""" if prompt_name not in self.versions: return [] return list(self.versions[prompt_name].keys())
4. Prompt Caching
from functools import lru_cache import hashlib class PromptCache: def __init__(self, max_size: int = 1000): self.cache = {} self.max_size = max_size def _generate_key( self, prompt_name: str, params: dict ) -> str: """Generate cache key""" param_str = json.dumps(params, sort_keys=True) combined = f"{prompt_name}:{param_str}" return hashlib.md5(combined.encode()).hexdigest() def get(self, prompt_name: str, params: dict) -> Optional[str]: """Get cached prompt""" key = self._generate_key(prompt_name, params) return self.cache.get(key) def set(self, prompt_name: str, params: dict, prompt: str): """Set cache""" # If cache is full, remove oldest entry if len(self.cache) >= self.max_size: oldest_key = next(iter(self.cache)) del self.cache[oldest_key] key = self._generate_key(prompt_name, params) self.cache[key] = prompt def clear(self): """Clear cache""" self.cache.clear() def invalidate(self, prompt_name: str): """Invalidate cache for specific prompt""" keys_to_remove = [ key for key in self.cache if key.startswith(hashlib.md5(prompt_name.encode()).hexdigest()[:16]) ] for key in keys_to_remove: del self.cache[key]
5. Prompt Testing and Validation
class PromptTester: def __init__(self, template_engine: PromptTemplateEngine): self.engine = template_engine def test_template( self, template_name: str, test_cases: list ) -> dict: """Test prompt template""" results = { "template": template_name, "total_tests": len(test_cases), "passed": 0, "failed": 0, "errors": [] } for i, test_case in enumerate(test_cases): try: # Render prompt prompt = self.engine.render( template_name, **test_case["params"] ) # Validate output if "expected_contains" in test_case: for expected in test_case["expected_contains"]: if expected not in prompt: results["errors"].append({ "test": i, "error": f"Expected to contain '{expected}' but not found" }) results["failed"] += 1 break else: results["passed"] += 1 else: results["passed"] += 1 except Exception as e: results["errors"].append({ "test": i, "error": str(e) }) results["failed"] += 1 return results def validate_parameters( self, template_name: str, params: dict ) -> tuple[bool, str]: """Validate parameters""" try: # Try to render prompt self.engine.render(template_name, **params) return True, "" except Exception as e: return False, str(e)
6. Prompt Analysis and Optimization
import re from collections import Counter class PromptAnalyzer: def analyze(self, prompt: str) -> dict: """Analyze prompt""" return { "length": len(prompt), "word_count": len(prompt.split()), "sentence_count": len(re.split(r'[.!?]+', prompt)), "token_estimate": self._estimate_tokens(prompt), "complexity": self._calculate_complexity(prompt), "variables": self._extract_variables(prompt) } def _estimate_tokens(self, text: str) -> int: """Estimate token count""" # Rough estimate: English ~4 chars/token, Chinese ~1.5 chars/token chinese_chars = len(re.findall(r'[\u4e00-\u9fff]', text)) english_chars = len(re.findall(r'[a-zA-Z]', text)) return int(chinese_chars / 1.5 + english_chars / 4) def _calculate_complexity(self, prompt: str) -> float: """Calculate complexity""" words = prompt.split() unique_words = set(words) # Vocabulary diversity diversity = len(unique_words) / len(words) if words else 0 # Average sentence length sentences = re.split(r'[.!?]+', prompt) avg_sentence_length = sum(len(s.split()) for s in sentences) / len(sentences) if sentences else 0 return (diversity + min(avg_sentence_length / 20, 1)) / 2 def _extract_variables(self, prompt: str) -> list: """Extract variables""" return re.findall(r'\{(\w+)\}', prompt)
Best Practices:
- Parameterized Design: Use parameterized templates to improve reusability
- Version Control: Implement version management for important prompts
- Caching Strategy: Cache rendered results to improve performance
- Test Coverage: Write test cases to ensure prompt quality
- Performance Monitoring: Monitor token usage and performance of prompts
- Complete Documentation: Provide clear documentation for each prompt
Through comprehensive prompt management mechanisms, you can improve the development efficiency and consistency of MCP systems.