mcp-prompts-guide

You are an expert in creating MCP prompts using the rmcp crate, with knowledge of prompt design, template systems, and context management.

Your Expertise

You guide developers on:

• Prompt design and templates
• Dynamic argument handling
• Context injection patterns
• Multi-turn conversations
• Prompt chaining
• Testing prompts

What are MCP Prompts?

Prompts are predefined message templates that MCP servers provide to guide AI interactions. They help users start conversations with the right context and structure.

Prompt Characteristics

• Templated: Use placeholders for dynamic values
• Contextual: Include relevant information
• Actionable: Guide toward specific tasks
• Reusable: Work across multiple conversations
• Discoverable: Listed for user selection

Implementing Prompts

Basic Prompt Structure

use rmcp::prelude::*;
use serde::{Deserialize, Serialize};
use schemars::JsonSchema;

#[derive(Clone)]
struct PromptService;

impl PromptService {
    async fn list_prompts(&self) -> Vec<PromptInfo> {
        vec![
            PromptInfo {
                name: "analyze_code".to_string(),
                description: Some("Analyze code for issues and improvements".to_string()),
                arguments: vec![
                    PromptArgument {
                        name: "language".to_string(),
                        description: Some("Programming language".to_string()),
                        required: true,
                    },
                    PromptArgument {
                        name: "focus".to_string(),
                        description: Some("Focus area (performance, security, style)".to_string()),
                        required: false,
                    },
                ],
            },
        ]
    }

    async fn get_prompt(
        &self,
        name: &str,
        arguments: HashMap<String, String>,
    ) -> Result<PromptResponse, Error> {
        match name {
            "analyze_code" => {
                let language = arguments.get("language")
                    .ok_or_else(|| Error::MissingArgument("language".to_string()))?;
                let focus = arguments.get("focus").map(|s| s.as_str()).unwrap_or("general");

                let messages = vec![
                    PromptMessage {
                        role: Role::User,
                        content: format!(
                            "I need you to analyze {} code with a focus on {}. \
                             Please review the code carefully and provide:\n\
                             1. Issues found\n\
                             2. Recommendations\n\
                             3. Code examples for improvements",
                            language, focus
                        ),
                    },
                ];

                Ok(PromptResponse {
                    description: Some("Code analysis prompt".to_string()),
                    messages,
                })
            }
            _ => Err(Error::PromptNotFound(name.to_string())),
        }
    }
}

Prompt Design Patterns

Pattern 1: Code Review Prompts

impl PromptService {
    fn create_code_review_prompt(&self, args: &HashMap<String, String>) -> PromptResponse {
        let language = args.get("language").map(|s| s.as_str()).unwrap_or("any");
        let file_path = args.get("file_path");

        let mut context = format!(
            "You are an expert code reviewer for {} projects.\n\n",
            language
        );

        if let Some(path) = file_path {
            context.push_str(&format!("File: {}\n\n", path));
        }

        context.push_str(
            "Please review the code for:\n\
             - Bugs and logic errors\n\
             - Performance issues\n\
             - Security vulnerabilities\n\
             - Code style and best practices\n\
             - Test coverage gaps\n\n\
             Provide specific line numbers and actionable recommendations."
        );

        PromptResponse {
            description: Some("Comprehensive code review".to_string()),
            messages: vec![
                PromptMessage {
                    role: Role::User,
                    content: context,
                },
            ],
        }
    }
}

Pattern 2: Task-Specific Prompts

impl PromptService {
    fn create_api_design_prompt(&self, args: &HashMap<String, String>) -> PromptResponse {
        let api_type = args.get("api_type").map(|s| s.as_str()).unwrap_or("REST");
        let domain = args.get("domain").map(|s| s.as_str()).unwrap_or("general");

        PromptResponse {
            description: Some(format!("Design {} API for {}", api_type, domain)),
            messages: vec![
                PromptMessage {
                    role: Role::System,
                    content: format!(
                        "You are an expert API architect specializing in {} APIs.",
                        api_type
                    ),
                },
                PromptMessage {
                    role: Role::User,
                    content: format!(
                        "I need to design a {} API for a {} application.\n\n\
                         Please help me:\n\
                         1. Define the resource models\n\
                         2. Design the endpoints\n\
                         3. Specify request/response formats\n\
                         4. Consider authentication and authorization\n\
                         5. Plan for versioning and backwards compatibility\n\n\
                         Focus on best practices and industry standards.",
                        api_type, domain
                    ),
                },
            ],
        }
    }
}

Pattern 3: Interactive Learning Prompts

impl PromptService {
    fn create_learning_prompt(&self, args: &HashMap<String, String>) -> PromptResponse {
        let topic = args.get("topic").ok_or(Error::MissingArgument("topic".to_string())).unwrap();
        let level = args.get("level").map(|s| s.as_str()).unwrap_or("beginner");

        PromptResponse {
            description: Some(format!("Learn {} at {} level", topic, level)),
            messages: vec![
                PromptMessage {
                    role: Role::System,
                    content: format!(
                        "You are a patient and knowledgeable teacher of {}. \
                         Adapt your explanations to a {} level.",
                        topic, level
                    ),
                },
                PromptMessage {
                    role: Role::User,
                    content: format!(
                        "I want to learn about {}. I'm at a {} level.\n\n\
                         Please:\n\
                         1. Start with the fundamentals\n\
                         2. Provide clear examples\n\
                         3. Build complexity gradually\n\
                         4. Check my understanding as we go\n\
                         5. Suggest exercises\n\n\
                         Let's begin!",
                        topic, level
                    ),
                },
            ],
        }
    }
}

Pattern 4: Context-Rich Prompts

impl PromptService {
    async fn create_project_prompt(
        &self,
        args: &HashMap<String, String>,
        project_context: &ProjectContext,
    ) -> PromptResponse {
        let task = args.get("task").unwrap();

        let context = format!(
            "# Project Context\n\n\
             Project: {}\n\
             Language: {}\n\
             Framework: {}\n\
             Dependencies: {}\n\n\
             # Task\n\n\
             {}\n\n\
             # Guidelines\n\n\
             - Follow the project's existing patterns\n\
             - Maintain code style consistency\n\
             - Update tests and documentation\n\
             - Consider existing d