MCP-Prompts

A comprehensive collection of Model Context Protocol (MCP) prompt templates and tools for various AI-powered workflows and integrations.

Overview

MCP-Prompts is a repository designed to provide ready-to-use prompt templates and tools for working with the Model Context Protocol. This project includes various prompt templates, integration examples, and utilities to help developers quickly implement MCP-based solutions in their applications.

Features

📝 Curated Prompt Templates: Pre-built prompts for common use cases
🔧 MCP Tools Integration: Ready-to-use tool configurations
🚀 AWS Integration: Complete AWS deployment examples
📚 Comprehensive Documentation: Detailed guides and examples
🐳 Docker Support: Containerized deployments for various MCP servers

Available MCP Tools

This repository includes configurations and examples for the following MCP tools:

Core MCP Servers

File System Server (Dockerfile.file): Access and manage local file systems
Memory Server (Dockerfile.memory): Persistent memory and state management
AWS Integration Server (Dockerfile.aws): AWS services integration
Generic MCP Server (Dockerfile.mcp): Base MCP server configuration

Tool Categories

File Operations: Read, write, search, and manage files
Memory Management: Store and retrieve conversation context
Cloud Integration: AWS services (S3, Lambda, DynamoDB, etc.)
Development Tools: Code analysis, testing, and deployment utilities

Existing Templates

The repository includes several prompt template categories:

1. Development & Coding

Code review and analysis prompts
Debugging assistance templates
Documentation generation guides
Testing strategy prompts

2. AWS Integration

Infrastructure as Code (CDK) templates
Serverless deployment prompts
AWS service configuration guides
Monitoring and logging setups

3. Data Processing

Data transformation prompts
Analysis and reporting templates
ETL pipeline configurations

4. System Administration

Docker containerization guides
CI/CD pipeline templates
Environment configuration prompts

How to Use

Quick Start

Clone the repository:

git clone https://github.com/sparesparrow/mcp-prompts.git
cd mcp-prompts

Explore available templates:
```
ls -la examples/
ls -la data/
```
Choose your integration method:
- Use Docker containers for quick deployment
- Configure MCP tools directly in your application
- Adapt templates to your specific needs

Using Docker Containers

Each MCP server type has a dedicated Dockerfile:

# Build the file system MCP server
docker build -f Dockerfile.file -t mcp-file-server .

# Build the memory MCP server
docker build -f Dockerfile.memory -t mcp-memory-server .

# Build the AWS integration MCP server
docker build -f Dockerfile.aws -t mcp-aws-server .

Configuring MCP Tools

Create a configuration file (.env based on .env.example):
```
cp .env.example .env
```

Edit configuration with your specific settings:

MCP_SERVER_PORT=3000
AWS_REGION=us-east-1
# Add other required environment variables

Run the MCP server:

docker run -p 3000:3000 --env-file .env mcp-aws-server

Integrating with Claude Desktop or Other MCP Clients

Add the MCP server configuration to your client's config file:

{
  "mcpServers": {
    "mcp-prompts": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "mcp-aws-server"],
      "env": {
        "AWS_REGION": "us-east-1"
      }
    }
  }
}

Examples

Example 1: File System Operations

// Using the file system MCP server
const response = await mcpClient.callTool({
  name: "read_file",
  arguments: {
    path: "./data/sample.json"
  }
});

Example 2: AWS S3 Integration

// Upload a file to S3 using AWS MCP server
const response = await mcpClient.callTool({
  name: "s3_upload",
  arguments: {
    bucket: "my-bucket",
    key: "data/file.json",
    content: fileContent
  }
});

Example 3: Memory Management

// Store context in memory server
await mcpClient.callTool({
  name: "store_memory",
  arguments: {
    key: "conversation_context",
    value: conversationData
  }
});

// Retrieve stored context
const context = await mcpClient.callTool({
  name: "retrieve_memory",
  arguments: {
    key: "conversation_context"
  }
});

Example 4: Using Prompt Templates

Browse the examples/ directory for complete prompt templates:

Code Review: examples/code-review-prompt.md
AWS Deployment: examples/aws-deployment-guide.md
Data Analysis: examples/data-analysis-template.md

AWS Integration Details

For comprehensive AWS integration documentation, see:

DEPLOYMENT_GUIDE.md - Complete deployment instructions
DOCKER_AWS_TEST_REPORT.md - AWS Docker testing results
cdk/ - AWS CDK infrastructure as code
Dockerfile.aws - AWS-specific MCP server container

AWS Services Supported

S3: Object storage operations
Lambda: Serverless function management
DynamoDB: NoSQL database operations
CloudWatch: Logging and monitoring
IAM: Identity and access management
ECR: Container registry integration

Project Structure

mcp-prompts/
├── apps/              # Application code
├── cdk/               # AWS CDK infrastructure
├── data/              # Sample data and datasets
├── docs/              # Documentation
├── examples/          # Example prompts and usage
├── layers/            # Lambda layers
├── packages/          # Reusable packages
├── scripts/           # Utility scripts
├── src/               # Source code
├── web/               # Web interface
├── Dockerfile.*       # Various MCP server containers
└── README.md          # This file

Development

Prerequisites

Node.js 18+ or compatible runtime
Docker (for containerized deployments)
AWS CLI (for AWS integrations)
Git

Setup Development Environment

Install dependencies:
```
npm install
```

Set up environment variables:

cp .env.example .env
# Edit .env with your configuration

Run tests:
```
npm test
```

Using DevContainers

This project includes DevContainer configurations in .devcontainer/ for VS Code and GitHub Codespaces:

# Open in VS Code with Dev Containers extension
code .
# Then: Cmd/Ctrl + Shift + P -> "Reopen in Container"

Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

How to Contribute

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Please read our CODE_OF_CONDUCT.md before contributing.

Troubleshooting

Common Issues

Issue: MCP server not starting

Check that all required environment variables are set
Verify Docker is running (for containerized deployments)
Check logs: docker logs <container-id>

Issue: AWS credentials not working

Ensure AWS CLI is configured: aws configure
Verify IAM permissions for required services
Check environment variables: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY

Issue: Port already in use

Change the port in your configuration
Stop conflicting services: docker ps and docker stop <container-id>

License

MIT License - see LICENSE file for details.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Support

For questions and support:

Open an issue
Join our discussions
Check the wiki for additional documentation