# MCPatterns
MCPatterns is a Model Context Protocol (MCP) server that enables users to save and retrieve personalized coding patterns. It helps LLMs learn how an individual codes by storing structured patterns categorized by technology, use case, and style.
## 🧠 Purpose
This server acts as a persistent memory layer for LLM agents, allowing them to reference a user's preferred coding styles, patterns, and conventions. It supports:
- Personalized code generation based on stored patterns
- Consistent refactoring following user preferences
- Style-aware suggestions using familiar patterns
- Long-term memory of coding practices across sessions
## 🧩 MCP Integration
MCPatterns follows the [Model Context Protocol](https://modelcontextprotocol.io) specification, providing tools for creating, reading, updating, and deleting coding patterns. It uses JSONL (newline-delimited JSON) storage for atomic operations and data consistency.
## 🗂 Pattern Schema
```typescript
interface Pattern {
name: string; // Unique identifier
category: string; // e.g., "Backend", "Frontend", "Database"
description: string; // What this pattern does
use_cases: string[]; // When to use this pattern
technologies: string[]; // Languages, frameworks, libraries
code_examples: { [language: string]: string }; // Code samples by language
}
```
### Example Pattern
```json
{
"name": "Error Handling Middleware",
"category": "Backend",
"description": "Express middleware for consistent error handling with structured responses",
"use_cases": ["API development", "Middleware composition", "Error standardization"],
"technologies": ["Node.js", "Express", "TypeScript"],
"code_examples": {
"JavaScript": "app.use((err, req, res, next) => {\n console.error(err.stack);\n res.status(500).json({ error: 'Something went wrong!' });\n});",
"TypeScript": "app.use((err: Error, req: Request, res: Response, next: NextFunction) => {\n console.error(err.stack);\n res.status(500).json({ error: 'Something went wrong!' });\n});"
}
}
```
## 🔧 Available Tools
MCPatterns provides the following MCP tools:
### `create_patterns`
Create multiple new coding patterns in the database.
**Input:**
```json
{
"patterns": [Pattern, ...]
}
```
### `add_code_examples`
Add new code examples to existing patterns.
**Input:**
```json
{
"additions": [
{
"patternName": "string",
"examples": { "language": "code" }
}
]
}
```
### `delete_patterns`
Delete multiple patterns by name.
**Input:**
```json
{
"patternNames": ["pattern1", "pattern2"]
}
```
### `delete_code_examples`
Remove specific code examples from patterns.
**Input:**
```json
{
"deletions": [
{
"patternName": "string",
"languages": ["JavaScript", "TypeScript"]
}
]
}
```
### `read_patterns`
Retrieve all stored patterns.
**Input:** None
### `search_patterns`
Search patterns by query across all fields.
**Input:**
```json
{
"query": "search term"
}
```
### `open_patterns`
Retrieve specific patterns by name.
**Input:**
```json
{
"names": ["pattern1", "pattern2"]
}
```
## 🗄 Storage
MCPatterns uses JSONL (newline-delimited JSON) format for data storage:
- **File location**: Configurable via `PATTERNS_FILE_PATH` environment variable
- **Default location**: `patterns.json` in the server directory
- **Format**: Each line contains a JSON object with `type: "pattern"`
- **Atomic operations**: Full file rewrite ensures data consistency
## 🚀 Getting Started
### Installation
```bash
git clone https://github.com/nicholasrubright/mcpatterns.git
cd mcpatterns
pnpm install
```
### Development
```bash
pnpm run dev
```
### Building
```bash
pnpm run build
```
### Running
```bash
pnpm start
# or
mcpatterns
```
## 🔧 Configuration
### Environment Variables
- `PATTERNS_FILE_PATH`: Custom path for the patterns database file
- Can be absolute path or relative to script directory
- Defaults to `patterns.json` in server directory
### Claude Desktop Integration
Add to your `claude_desktop_config.json`:
```json
{
"mcpServers": {
"mcpatterns": {
"command": "npx",
"args": ["-y", "@mcpatterns/server"]
}
}
}
```
### With Custom Storage Path
```json
{
"mcpServers": {
"mcpatterns": {
"command": "npx",
"args": ["-y", "@mcpatterns/server"],
"env": {
"PATTERNS_FILE_PATH": "/path/to/custom/patterns.json"
}
}
}
}
```
### VS Code Integration
Add to your VS Code settings (`settings.json`):
```json
{
"mcp": {
"servers": {
"mcpatterns": {
"command": "npx",
"args": ["-y", "@mcpatterns/server"]
}
}
}
}
```
## 💡 Usage Tips
### For LLM Agents
MCPatterns works best when integrated into your AI workflow with prompts like:
```
Before generating code, search my patterns for relevant examples using the technologies I'm working with. Use my established patterns and coding style preferences when creating new code.
```
### Pattern Organization
- Use descriptive names that clearly identify the pattern's purpose
- Group related patterns with consistent category naming
- Include comprehensive use cases to improve searchability
- Provide examples in multiple languages when applicable
### Best Practices
- **Atomic patterns**: Store focused, single-purpose patterns
- **Rich metadata**: Include detailed use cases and technology tags
- **Version examples**: Keep code examples up-to-date with current practices
- **Search-friendly**: Use descriptive language in descriptions and use cases
## 📜 License
MIT
