MCP Prompts

Overview

MCP prompts are reusable, parameterized templates that help standardize interactions with Claude. Prompts can range from simple text templates to complex, multi-step workflows that guide Claude through sophisticated tasks.

About This Section

This section is designed to be filled by forked projects with their domain-specific prompts. The base Seed server focuses on infrastructure and does not include prompts.

Why Use Prompts?

Consistency - Ensure consistent behavior across similar tasks Reusability - Write once, use many times with different parameters Composition - Combine simple prompts into complex workflows Maintenance - Update prompts in one place rather than many Discovery - Make common patterns easily discoverable

Adding Prompts to This Documentation

If you've forked Seed and are adding custom prompts, structure your documentation as follows:

Recommended Structure

wiki/prompts/
├── overview.md (this file)
├── catalog.md (list of all available prompts)
├── categories/
│   ├── analysis.md (analysis prompts)
│   ├── generation.md (content generation)
│   ├── review.md (code/document review)
│   └── workflows.md (multi-step workflows)
└── guides/
    ├── creating-prompts.md (prompt engineering guide)
    ├── composition.md (combining prompts)
    └── best-practices.md (prompt design patterns)

Prompt Documentation Template

For each prompt, include:

# Prompt Name

## Description
Brief description of what the prompt does and when to use it.

## Parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| param1 | string | Yes | Description |
| param2 | array | No | Description (default: empty) |

## Prompt Template

\`\`\`
[Show the full prompt template with {parameter} placeholders]
\`\`\`

## Example Usage

**Input:**
\`\`\`json
{
  "name": "prompt_name",
  "arguments": {
    "param1": "value",
    "param2": ["item1", "item2"]
  }
}
\`\`\`

**Rendered Prompt:**
\`\`\`
[Show how the prompt looks with example parameters filled in]
\`\`\`

**Expected Output:**
[Describe what kind of response this prompt typically generates]

## Use Cases

- Use case 1: Description
- Use case 2: Description
- Use case 3: Description

## Related Prompts

Links to related or complementary prompts.

## Tips & Considerations

- Best practices for using this prompt
- Common pitfalls to avoid
- Parameter tuning suggestions

Prompt Categories

Common Prompt Types

Analysis Prompts

• Code review and analysis
• Document summarization
• Data analysis and insights

Generation Prompts

• Code generation from specifications
• Documentation generation
• Test case generation

Review Prompts

• Pull request reviews
• Security analysis
• Quality assurance checks

Workflow Prompts

• Multi-step processes
• Decision trees
• Interactive workflows

Prompt Engineering Best Practices

1. Be Specific and Clear

# Bad
Write code for this feature

# Good
Write a TypeScript function that validates email addresses using regex,
includes JSDoc comments, handles edge cases, and includes unit tests

2. Provide Context

# Good prompt structure
You are a senior TypeScript developer working on an authentication system.

Given the following requirements:
- {requirements}

And the existing codebase structure:
- {structure}

Generate code that follows our project standards defined at /mcp-server/development/code-quality

3. Use Parameters Effectively

# Parameterized prompt
Analyze the following {language} code for {concerns}:

\`\`\`{language}
{code}
\`\`\`

Focus on:
{#each focus_areas}
- {area}
{/each}

4. Specify Output Format

Provide your analysis in the following format:

## Summary
[One paragraph overview]

## Issues Found
[Numbered list with severity and location]

## Recommendations
[Prioritized list of improvements]

## Code Examples
[Show corrected code where applicable]

5. Chain Prompts for Complex Tasks

# Step 1: Analysis
[Analyze requirements prompt]

# Step 2: Design (uses output from step 1)
[Design architecture prompt]

# Step 3: Implementation (uses output from step 2)
[Generate code prompt]

# Step 4: Testing (uses output from step 3)
[Generate tests prompt]

MCP Prompt Features

Prompt Arguments

MCP prompts support rich arguments:

• Simple values - strings, numbers, booleans
• Complex objects - nested structures
• Arrays - lists of items
• References - pointers to resources or other prompts

Prompt Composition

Compose prompts from reusable pieces:

// Base prompt
const baseReview = "Review the following code for {criteria}";

// Specialized prompts
const securityReview = baseReview + "\nFocus on security vulnerabilities";
const performanceReview = baseReview + "\nFocus on performance issues";

Dynamic Prompts

Generate prompts based on context:

function buildReviewPrompt(language: string, concerns: string[]) {
  return {
    template: `Review this ${language} code for: ${concerns.join(', ')}`,
    context: {
      standards: getStandardsFor(language),
      commonIssues: getCommonIssuesFor(language)
    }
  };
}

Development Resources

MCP Protocol

Prompts are part of the MCP specification:

• MCP Specification - Prompts
• MCP SDK Documentation

Implementation

See the MCP server architecture documentation:

• MCP Server Design
• Development Guide

Getting Started with Prompts

1. Identify Common Patterns

Look for repetitive tasks in your workflow:

• Code reviews with similar criteria
• Document generation following templates
• Analysis tasks with consistent structure

2. Extract Parameters

Identify what varies between instances:

• File names, paths
• Specific criteria or requirements
• Context or domain information

3. Create Template

Write the prompt with parameter placeholders:

Review the {file_type} file at {path} for {review_criteria}.

Consider our project standards:
{standards}

Previous feedback on similar files:
{context}

4. Test and Iterate

• Test with various parameter combinations
• Refine based on output quality
• Add constraints or examples as needed

5. Document

Use the template above to create comprehensive documentation.

Next Steps

• MCP Server Development - Learn about MCP implementation
• Tools Overview - See how tools and prompts work together
• Contributing Guide - Share your prompts

Contributing Prompts

If you've created useful prompts that others might benefit from:

1. Ensure prompts are well-tested and documented
2. Include example usage and expected outputs
3. Follow the documentation template above
4. Submit a merge request with your prompt
5. Include test cases demonstrating the prompt's effectiveness

See Contributing Guide for details.