Commit 35ad549

@@ -0,0 +1,294 @@
+# Fetch MCP Server
+
+A Model Context Protocol (MCP) server that provides web content fetching capabilities with advanced HTML processing and conversion.
+
+## Overview
+
+The Fetch MCP server enables AI assistants to retrieve and process web content through a standardized protocol. It features professional HTML parsing, automatic content cleaning, and conversion to clean markdown format for better AI consumption.
+
+## Installation
+
+### From Source
+```bash
+# Build the binary
+make fetch
+
+# Install system-wide (requires sudo)
+sudo make install
+```
+
+### Direct Build
+```bash
+go build -o mcp-fetch ./cmd/fetch
+```
+
+## Usage
+
+### Command Line Arguments
+
+```bash
+mcp-fetch
+```
+
+**No arguments required** - The server is ready to accept fetch requests for any publicly accessible URL.
+
+### Examples
+
+#### Basic Testing
+```bash
+# Test server initialization
+echo '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0.0"}}}' | timeout 5s mcp-fetch
+
+# List available tools
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}' | timeout 5s mcp-fetch
+
+# Fetch a webpage
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://example.com"}}}' | timeout 10s mcp-fetch
+```
+
+#### Web Content Fetching
+```bash
+# Fetch news article
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://news.ycombinator.com"}}}' | timeout 10s mcp-fetch
+
+# Fetch documentation
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://golang.org/doc/"}}}' | timeout 10s mcp-fetch
+
+# Fetch with custom reason
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://api.github.com", "reason": "Check GitHub API status"}}}' | timeout 10s mcp-fetch
+```
+
+## Available Tools
+
+### Web Fetching
+- **`fetch`**: Retrieve and process web content
+  - **Parameters:**
+    - `url` (required): The URL to fetch
+    - `reason` (optional): Human-readable reason for the fetch (for logging/context)
+  - **Returns:** Clean markdown representation of the web content
+
+## Prompts
+
+### Interactive URL Fetching
+- **`fetch`**: Interactive prompt for URL entry with context
+  - Guides users through URL entry
+  - Requests optional reasoning for the fetch
+  - Validates URLs before processing
+
+## Advanced Features
+
+### HTML Processing
+- **Professional Parsing**: Uses `goquery` for robust HTML parsing
+- **Content Extraction**: Intelligent content area detection
+- **Noise Removal**: Automatic filtering of ads, navigation, scripts, and styles
+- **Clean Conversion**: HTML-to-markdown conversion with proper formatting
+
+### Content Optimization
+- **Markdown Output**: Clean, AI-friendly markdown format
+- **Structure Preservation**: Maintains headings, lists, and formatting
+- **Link Processing**: Converts HTML links to markdown format
+- **Image Handling**: Processes image references and alt text
+
+### Performance & Reliability
+- **Timeout Handling**: Configurable request timeouts
+- **Error Recovery**: Graceful handling of network errors
+- **User Agent**: Professional user agent for better site compatibility
+- **Rate Limiting**: Built-in protection against excessive requests
+
+## Configuration Examples
+
+### Claude Desktop Integration
+```json
+{
+  "mcpServers": {
+    "fetch": {
+      "command": "/usr/local/bin/mcp-fetch"
+    }
+  }
+}
+```
+
+### Multiple Fetch Services
+```json
+{
+  "mcpServers": {
+    "web-fetch": {
+      "command": "/usr/local/bin/mcp-fetch"
+    },
+    "backup-fetch": {
+      "command": "/usr/local/bin/mcp-fetch"
+    }
+  }
+}
+```
+
+## Example Workflows
+
+### Research and Documentation
+```bash
+# Fetch technical documentation
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://docs.python.org/3/library/requests.html", "reason": "Learning about Python requests library"}}}' | mcp-fetch
+
+# Fetch latest news
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://techcrunch.com", "reason": "Checking latest tech news"}}}' | mcp-fetch
+```
+
+### API Documentation Access
+```bash
+# Fetch REST API docs
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://docs.github.com/en/rest", "reason": "GitHub API reference"}}}' | mcp-fetch
+
+# Fetch OpenAPI specs
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://petstore.swagger.io/", "reason": "Example API specification"}}}' | mcp-fetch
+```
+
+### Content Analysis
+```bash
+# Fetch blog posts for analysis
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://blog.golang.org/go1.21", "reason": "Analyzing Go 1.21 features"}}}' | mcp-fetch
+
+# Fetch competitor content
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://competitor.com/features", "reason": "Competitive analysis"}}}' | mcp-fetch
+```
+
+### Interactive Fetching with Prompts
+```bash
+# Use the interactive prompt
+echo '{"jsonrpc": "2.0", "id": 1, "method": "prompts/get", "params": {"name": "fetch", "arguments": {}}}' | mcp-fetch
+
+# The prompt will guide you through:
+# 1. URL entry with validation
+# 2. Optional reason/context entry
+# 3. Automatic fetching and processing
+```
+
+## Supported Content Types
+
+### Web Pages
+- **HTML Documents**: Full HTML parsing and conversion
+- **Blog Posts**: Article extraction with clean formatting
+- **Documentation Sites**: Technical documentation processing
+- **News Articles**: News content with metadata extraction
+
+### API Responses
+- **JSON APIs**: Raw JSON content preservation
+- **XML Responses**: Basic XML structure maintenance
+- **Plain Text**: Direct text content handling
+
+### Social Media
+- **Limited Support**: Basic content extraction where possible
+- **Rate Limiting**: Respects site rate limits and robots.txt
+
+## Security Considerations
+
+### URL Validation
+- **Protocol Restrictions**: Only HTTP/HTTPS supported
+- **Malicious URL Detection**: Basic URL validation
+- **Request Limits**: Built-in timeout and size limits
+
+### Content Safety
+- **No JavaScript Execution**: Static content only
+- **Content Filtering**: Automatic removal of potentially harmful content
+- **Privacy Protection**: No cookies or session management
+
+### Network Security
+- **Timeout Protection**: Prevents hanging requests
+- **Size Limits**: Prevents excessive content download
+- **Error Handling**: Safe error reporting without sensitive data exposure
+
+## Performance
+
+- **Startup Time**: ~1.5ms
+- **Memory Usage**: <10MB during operation
+- **Request Timeout**: 30 seconds default
+- **Content Limits**: Reasonable size limits for AI processing
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"Failed to fetch URL"**
+   ```bash
+   # Check URL accessibility
+   curl -I https://example.com
+   
+   # Verify network connectivity
+   ping google.com
+   ```
+
+2. **"Timeout errors"**
+   ```bash
+   # Check if site is slow
+   time curl https://slow-site.com
+   
+   # Try with different URL
+   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://httpbin.org/delay/1"}}}' | mcp-fetch
+   ```
+
+3. **"Content parsing errors"**
+   ```bash
+   # Test with simple HTML page
+   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://example.com"}}}' | mcp-fetch
+   ```
+
+4. **"Network blocked"**
+   ```bash
+   # Check if behind firewall/proxy
+   curl --proxy http://proxy:8080 https://example.com
+   
+   # Verify DNS resolution
+   nslookup example.com
+   ```
+
+### Testing Connectivity
+```bash
+# Test basic fetch functionality
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://httpbin.org/json"}}}' | mcp-fetch
+
+# Test HTML processing
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://httpbin.org/html"}}}' | mcp-fetch
+
+# Test error handling
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://httpbin.org/status/404"}}}' | mcp-fetch
+```
+
+## Best Practices
+
+1. **Provide Context**: Always include a reason for fetching to aid in logging and debugging
+2. **Test URLs First**: Verify URLs are accessible before using in production
+3. **Handle Errors**: Expect network errors and have fallback strategies
+4. **Respect Rate Limits**: Don't make excessive requests to the same domain
+5. **Check Content**: Verify the fetched content meets your expectations
+
+## Limitations
+
+### Technical Limitations
+- **Static Content Only**: No JavaScript execution or dynamic content
+- **Size Limits**: Large files may be truncated
+- **Format Limitations**: Best results with standard HTML content
+
+### Network Limitations
+- **Public URLs Only**: Cannot access internal/private networks
+- **No Authentication**: Cannot handle login-required content
+- **Rate Limiting**: May be limited by target sites
+
+### Content Limitations
+- **Dynamic Content**: Cannot fetch dynamically generated content
+- **Interactive Elements**: Forms, buttons, etc. are not preserved
+- **Multimedia**: Limited support for video/audio content
+
+## Use Cases
+
+- **Research**: Gathering information from web sources
+- **Documentation**: Accessing technical documentation
+- **Content Analysis**: Analyzing competitor or industry content
+- **News Monitoring**: Tracking news and updates
+- **API Exploration**: Examining API documentation and responses
+
+## Contributing
+
+See the main project README for contribution guidelines.
+
+## License
+
+This project is licensed under the same terms as the parent MCP project.
\ No newline at end of file

@@ -0,0 +1,273 @@
+# Filesystem MCP Server
+
+A Model Context Protocol (MCP) server that provides secure filesystem access with configurable directory restrictions.
+
+## Overview
+
+The Filesystem MCP server enables AI assistants to safely interact with the local filesystem through a standardized protocol. It provides tools for file operations (read, write, edit, search) and directory management while maintaining strict security boundaries.
+
+## Installation
+
+### From Source
+```bash
+# Build the binary
+make filesystem
+
+# Install system-wide (requires sudo)
+sudo make install
+```
+
+### Direct Build
+```bash
+go build -o mcp-filesystem ./cmd/filesystem
+```
+
+## Usage
+
+### Command Line Arguments
+
+```bash
+mcp-filesystem --allowed-directory <path1> [--allowed-directory <path2> ...]
+```
+
+**Required Arguments:**
+- `--allowed-directory <path>`: Directory path to allow access to (can be repeated for multiple directories)
+
+### Examples
+
+#### Basic Testing
+```bash
+# Test server initialization
+echo '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0.0"}}}' | timeout 5s mcp-filesystem --allowed-directory /tmp
+
+# List available tools
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}' | timeout 5s mcp-filesystem --allowed-directory /tmp
+
+# List filesystem resources
+echo '{"jsonrpc": "2.0", "id": 3, "method": "resources/list", "params": {}}' | timeout 5s mcp-filesystem --allowed-directory /tmp
+
+# List directory contents
+echo '{"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "list_directory", "arguments": {"path": "/tmp"}}}' | timeout 5s mcp-filesystem --allowed-directory /tmp
+```
+
+#### Multiple Directories
+```bash
+# Allow access to multiple directories
+mcp-filesystem --allowed-directory /home/user/projects --allowed-directory /tmp --allowed-directory /var/log
+```
+
+#### File Operations Testing
+```bash
+# Create a test file
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "write_file", "arguments": {"path": "/tmp/test.txt", "content": "Hello, World!"}}}' | timeout 5s mcp-filesystem --allowed-directory /tmp
+
+# Read the file back
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "read_file", "arguments": {"path": "/tmp/test.txt"}}}' | timeout 5s mcp-filesystem --allowed-directory /tmp
+
+# Get file information
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "get_file_info", "arguments": {"path": "/tmp/test.txt"}}}' | timeout 5s mcp-filesystem --allowed-directory /tmp
+```
+
+## Available Tools
+
+### File Operations
+- **`read_file`**: Read contents of a text file
+- **`read_multiple_files`**: Read multiple files in a single operation
+- **`write_file`**: Write content to a file (creates or overwrites)
+- **`edit_file`**: Apply targeted edits to a file using search/replace
+- **`get_file_info`**: Get detailed file metadata (size, permissions, timestamps)
+
+### Directory Operations
+- **`list_directory`**: List files and directories with basic info
+- **`list_directory_with_sizes`**: List directory contents with detailed size information
+- **`directory_tree`**: Generate a tree view of directory structure
+- **`create_directory`**: Create new directories (with parent creation)
+
+### File Management
+- **`move_file`**: Move or rename files and directories
+- **`search_files`**: Search for files by name pattern or content
+
+### Utility Operations
+- **`list_allowed_directories`**: Show which directories the server can access
+
+## Resources
+
+The server provides `file://` resources for:
+
+### Directory Resources
+- **URI Format**: `file://<directory_path>`
+- **Example**: `file:///home/user/projects`
+- **Description**: Represents allowed directories and their contents
+
+## Prompts
+
+### Interactive File Editing
+- **`edit-file`**: Interactive prompt for guided file editing
+  - Provides context-aware editing suggestions
+  - Validates changes before applying
+  - Supports complex multi-step edits
+
+## Security Features
+
+### Access Control
+- **Directory Restrictions**: Only allowed directories are accessible
+- **Path Validation**: All paths are validated and normalized
+- **No Directory Traversal**: `../` attempts are blocked
+- **Hidden File Protection**: Hidden files (starting with `.`) require explicit access
+
+### File Size Limits
+- **Read Operations**: Large files are truncated for safety
+- **Write Operations**: Size limits prevent disk exhaustion
+- **Binary Detection**: Automatic detection and handling of binary files
+
+## Configuration Examples
+
+### Claude Desktop Integration
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "/usr/local/bin/mcp-filesystem",
+      "args": ["--allowed-directory", "/home/user/projects", "--allowed-directory", "/tmp"]
+    }
+  }
+}
+```
+
+### Development Environment
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "/usr/local/bin/mcp-filesystem",
+      "args": [
+        "--allowed-directory", "/home/user/code",
+        "--allowed-directory", "/home/user/documents",
+        "--allowed-directory", "/tmp"
+      ]
+    }
+  }
+}
+```
+
+### Restricted Environment
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "/usr/local/bin/mcp-filesystem",
+      "args": ["--allowed-directory", "/home/user/safe-workspace"]
+    }
+  }
+}
+```
+
+## Example Workflows
+
+### File Content Analysis
+```bash
+# Read a configuration file
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "read_file", "arguments": {"path": "/home/user/config.json"}}}' | mcp-filesystem --allowed-directory /home/user
+
+# Search for specific patterns
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "search_files", "arguments": {"path": "/home/user", "pattern": "*.json", "search_content": "database"}}}' | mcp-filesystem --allowed-directory /home/user
+```
+
+### Project Management
+```bash
+# Create project structure
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "create_directory", "arguments": {"path": "/tmp/my-project/src"}}}' | mcp-filesystem --allowed-directory /tmp
+
+# Generate directory tree
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "directory_tree", "arguments": {"path": "/tmp/my-project", "max_depth": 3}}}' | mcp-filesystem --allowed-directory /tmp
+
+# Create initial files
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "write_file", "arguments": {"path": "/tmp/my-project/README.md", "content": "# My Project\\n\\nProject description here."}}}' | mcp-filesystem --allowed-directory /tmp
+```
+
+### Batch File Operations
+```bash
+# Read multiple configuration files
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "read_multiple_files", "arguments": {"paths": ["/tmp/config1.json", "/tmp/config2.json", "/tmp/settings.yaml"]}}}' | mcp-filesystem --allowed-directory /tmp
+```
+
+### File Editing
+```bash
+# Make targeted edits to a file
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "edit_file", "arguments": {"path": "/tmp/config.txt", "edits": [{"old_text": "debug=false", "new_text": "debug=true"}]}}}' | mcp-filesystem --allowed-directory /tmp
+```
+
+## Advanced Features
+
+### Search Capabilities
+- **File Name Search**: Find files by glob patterns
+- **Content Search**: Search within file contents
+- **Combined Filters**: Search by name and content simultaneously
+- **Case Sensitivity**: Configurable case-sensitive/insensitive search
+
+### File Type Support
+- **Text Files**: Full read/write support for text content
+- **Binary Files**: Detection and basic metadata support
+- **Large Files**: Automatic truncation with size warnings
+- **Encoding**: UTF-8 text encoding support
+
+## Performance
+
+- **Startup Time**: ~1ms for typical configurations
+- **Memory Usage**: <5MB base usage
+- **File Limits**: 10MB default limit for individual file operations
+- **Concurrent Operations**: Thread-safe for multiple requests
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"Access denied" errors**
+   ```bash
+   # Ensure the directory is in allowed-directory list
+   mcp-filesystem --allowed-directory /correct/path
+   ```
+
+2. **"File not found"**
+   ```bash
+   # Check if path exists and is accessible
+   ls -la /path/to/file
+   ```
+
+3. **"Permission denied"**
+   ```bash
+   # Check file system permissions
+   ls -la /path/to/directory
+   # Ensure the user has appropriate read/write permissions
+   ```
+
+4. **Large file warnings**
+   ```bash
+   # Files over 10MB are truncated
+   # Use file splitting for large files if needed
+   ```
+
+### Path Troubleshooting
+```bash
+# Test allowed directories
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "list_allowed_directories", "arguments": {}}}' | mcp-filesystem --allowed-directory /test/path
+
+# Verify directory access
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "list_directory", "arguments": {"path": "/test/path"}}}' | mcp-filesystem --allowed-directory /test/path
+```
+
+## Best Practices
+
+1. **Use Absolute Paths**: Always specify full paths to avoid ambiguity
+2. **Limit Directory Scope**: Only include necessary directories in allowed list
+3. **Regular Backups**: Important files should be backed up before modification
+4. **Test in Safe Environment**: Try operations in `/tmp` before production use
+5. **Monitor File Sizes**: Be aware of file size limits for read/write operations
+
+## Contributing
+
+See the main project README for contribution guidelines.
+
+## License
+
+This project is licensed under the same terms as the parent MCP project.
\ No newline at end of file

@@ -0,0 +1,215 @@
+# Git MCP Server
+
+A Model Context Protocol (MCP) server that provides comprehensive Git repository operations and browsing capabilities.
+
+## Overview
+
+The Git MCP server enables AI assistants to interact with Git repositories through a standardized protocol. It provides tools for Git operations (status, diff, commit, branch management) and resources for browsing repository contents.
+
+## Installation
+
+### From Source
+```bash
+# Build the binary
+make git
+
+# Install system-wide (requires sudo)
+sudo make install
+```
+
+### Direct Build
+```bash
+go build -o mcp-git ./cmd/git
+```
+
+## Usage
+
+### Command Line Arguments
+
+```bash
+mcp-git --repository <path>
+```
+
+**Required Arguments:**
+- `--repository <path>`: Path to the Git repository to manage
+
+### Examples
+
+#### Basic Testing
+```bash
+# Test server initialization
+echo '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0.0"}}}' | timeout 5s mcp-git --repository .
+
+# List available tools
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}' | timeout 5s mcp-git --repository .
+
+# List repository resources
+echo '{"jsonrpc": "2.0", "id": 3, "method": "resources/list", "params": {}}' | timeout 5s mcp-git --repository .
+
+# Check Git status
+echo '{"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "git_status", "arguments": {}}}' | timeout 5s mcp-git --repository .
+```
+
+#### Interactive Session
+```bash
+# Start the server (in another terminal or script)
+mcp-git --repository /path/to/your/repo
+
+# Then send JSON-RPC requests via stdin
+```
+
+## Available Tools
+
+### Repository Status & Information
+- **`git_status`**: Get current repository status
+- **`git_log`**: View commit history with filtering options
+- **`git_show`**: Show details of a specific commit
+
+### Diff Operations
+- **`git_diff`**: Show differences between commits/branches
+- **`git_diff_staged`**: Show staged changes
+- **`git_diff_unstaged`**: Show unstaged changes
+
+### Branch Management
+- **`git_create_branch`**: Create a new branch
+- **`git_checkout`**: Switch branches or checkout commits
+- **`git_list_branches`**: List all local and remote branches
+
+### File Operations
+- **`git_add`**: Stage files for commit
+- **`git_commit`**: Create commits with messages
+- **`git_reset`**: Reset changes (soft, mixed, hard)
+
+### Repository Initialization
+- **`git_init`**: Initialize a new Git repository
+
+## Resources
+
+The server provides `git://` resources for:
+
+### File Resources
+- **URI Format**: `git://<repo_path>/<branch>/<file_path>`
+- **Example**: `git:///home/user/project/main/src/main.go`
+- **Description**: Access to tracked files in the repository
+
+### Branch Resources  
+- **URI Format**: `git://<repo_path>/branches/<branch_name>`
+- **Example**: `git:///home/user/project/branches/feature-branch`
+- **Description**: Information about repository branches
+
+### Commit Resources
+- **URI Format**: `git://<repo_path>/commits/<commit_hash>`
+- **Example**: `git:///home/user/project/commits/abc123def456`
+- **Description**: Detailed commit information
+
+## Configuration Examples
+
+### Claude Desktop Integration
+Add to your `~/.claude.json`:
+
+```json
+{
+  "mcpServers": {
+    "git": {
+      "command": "/usr/local/bin/mcp-git",
+      "args": ["--repository", "/path/to/your/repository"]
+    }
+  }
+}
+```
+
+### Multiple Repositories
+```json
+{
+  "mcpServers": {
+    "git-project1": {
+      "command": "/usr/local/bin/mcp-git",
+      "args": ["--repository", "/home/user/project1"]
+    },
+    "git-project2": {
+      "command": "/usr/local/bin/mcp-git",
+      "args": ["--repository", "/home/user/project2"]
+    }
+  }
+}
+```
+
+## Example Workflows
+
+### Check Repository Status
+```bash
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "git_status", "arguments": {}}}' | mcp-git --repository .
+```
+
+### Create and Switch to New Branch
+```bash
+# Create branch
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "git_create_branch", "arguments": {"branch_name": "feature-new"}}}' | mcp-git --repository .
+
+# Switch to branch
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "git_checkout", "arguments": {"target": "feature-new"}}}' | mcp-git --repository .
+```
+
+### View Recent Commits
+```bash
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "git_log", "arguments": {"max_count": 5}}}' | mcp-git --repository .
+```
+
+### Stage and Commit Changes
+```bash
+# Stage files
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "git_add", "arguments": {"files": ["src/main.go", "README.md"]}}}' | mcp-git --repository .
+
+# Commit changes
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "git_commit", "arguments": {"message": "Add new feature implementation"}}}' | mcp-git --repository .
+```
+
+## Security Considerations
+
+- The server only operates within the specified repository directory
+- No access to files outside the repository
+- Git operations respect repository permissions
+- No network operations (clone, push, pull) for security
+
+## Performance
+
+- **Startup Time**: ~2-3ms for typical repositories
+- **Resource Limit**: Maximum 500 files loaded for resource discovery
+- **Memory Usage**: <10MB for most repositories
+- **Lazy Loading**: Resources discovered on-demand
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"Repository not found"**
+   ```bash
+   # Ensure the path exists and is a Git repository
+   git status  # Test if directory is a valid Git repo
+   ```
+
+2. **"Permission denied"**
+   ```bash
+   # Check file permissions
+   ls -la /path/to/repository
+   ```
+
+3. **"Invalid repository path"**
+   ```bash
+   # Use absolute paths for reliability
+   mcp-git --repository "$(pwd)"
+   ```
+
+### Debug Mode
+```bash
+# Enable verbose logging (if implemented)
+RUST_LOG=debug mcp-git --repository .
+```
+
+## Contributing
+
+See the main project README for contribution guidelines.
+
+## License
+
+This project is licensed under the same terms as the parent MCP project.
\ No newline at end of file

@@ -0,0 +1,398 @@
+# Maildir MCP Server
+
+A Model Context Protocol (MCP) server that provides secure email management through the Maildir format with comprehensive email analysis capabilities.
+
+## Overview
+
+The Maildir MCP server enables AI assistants to interact with email data stored in Maildir format through a standardized protocol. It provides tools for scanning folders, reading messages, searching emails, analyzing contacts, and generating statistics while maintaining privacy and security.
+
+## Installation
+
+### From Source
+```bash
+# Build the binary
+make maildir
+
+# Install system-wide (requires sudo)
+sudo make install
+```
+
+### Direct Build
+```bash
+go build -o mcp-maildir ./cmd/maildir
+```
+
+## Usage
+
+### Command Line Arguments
+
+```bash
+mcp-maildir --maildir-path <path1> [--maildir-path <path2> ...]
+```
+
+**Required Arguments:**
+- `--maildir-path <path>`: Path to Maildir directory (can be repeated for multiple mailboxes)
+
+### Examples
+
+#### Basic Testing
+```bash
+# Test server initialization
+echo '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0.0"}}}' | timeout 5s mcp-maildir --maildir-path ~/.local/share/mail
+
+# List available tools
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}' | timeout 5s mcp-maildir --maildir-path ~/.local/share/mail
+
+# List maildir resources
+echo '{"jsonrpc": "2.0", "id": 3, "method": "resources/list", "params": {}}' | timeout 5s mcp-maildir --maildir-path ~/.local/share/mail
+
+# Scan folders
+echo '{"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "maildir_scan_folders", "arguments": {"maildir_path": "~/.local/share/mail"}}}' | timeout 5s mcp-maildir --maildir-path ~/.local/share/mail
+```
+
+#### Multiple Mailboxes
+```bash
+# Handle multiple email accounts
+mcp-maildir --maildir-path ~/.local/share/mail/personal --maildir-path ~/.local/share/mail/work
+```
+
+#### Email Operations Testing
+```bash
+# List messages in INBOX
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "maildir_list_messages", "arguments": {"maildir_path": "~/.local/share/mail", "folder": "INBOX", "limit": 10}}}' | timeout 5s mcp-maildir --maildir-path ~/.local/share/mail
+
+# Search for emails
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "maildir_search_messages", "arguments": {"maildir_path": "~/.local/share/mail", "query": "important meeting"}}}' | timeout 5s mcp-maildir --maildir-path ~/.local/share/mail
+
+# Get statistics
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "maildir_get_statistics", "arguments": {"maildir_path": "~/.local/share/mail"}}}' | timeout 5s mcp-maildir --maildir-path ~/.local/share/mail
+```
+
+## Available Tools
+
+### Folder Management
+- **`maildir_scan_folders`**: Scan and list all Maildir folders
+  - **Parameters:**
+    - `maildir_path` (required): Path to the Maildir directory
+    - `include_counts` (optional): Include message and unread counts (default: true)
+  - **Returns:** List of folders with metadata
+
+### Message Operations
+- **`maildir_list_messages`**: List messages in a specific folder
+  - **Parameters:**
+    - `maildir_path` (required): Path to the Maildir directory
+    - `folder` (optional): Folder name (default: "INBOX")
+    - `limit` (optional): Maximum messages to return (max: 200, default: 50)
+    - `offset` (optional): Number of messages to skip (default: 0)
+    - `date_from` (optional): Filter messages from date (YYYY-MM-DD format)
+    - `date_to` (optional): Filter messages to date (YYYY-MM-DD format)
+    - `sender` (optional): Filter by sender email/name
+    - `subject_contains` (optional): Filter by subject content
+    - `unread_only` (optional): Show only unread messages (default: false)
+  - **Returns:** Paginated list of message metadata
+
+- **`maildir_read_message`**: Read full message content
+  - **Parameters:**
+    - `maildir_path` (required): Path to the Maildir directory
+    - `message_id` (required): Message ID (filename)
+    - `include_html` (optional): Include HTML body if available (default: false)
+    - `include_headers` (optional): Include email headers (default: true)
+    - `sanitize_content` (optional): Apply privacy sanitization (default: true)
+  - **Returns:** Complete message with headers and body
+
+### Search and Analysis
+- **`maildir_search_messages`**: Search messages by content
+  - **Parameters:**
+    - `maildir_path` (required): Path to the Maildir directory
+    - `query` (required): Search query string
+    - `limit` (optional): Maximum results to return (max: 200, default: 50)
+    - `search_headers` (optional): Include headers in search (default: true)
+    - `search_body` (optional): Include body in search (default: true)
+  - **Returns:** Search results with message metadata
+
+- **`maildir_get_thread`**: Get email thread for a message
+  - **Parameters:**
+    - `maildir_path` (required): Path to the Maildir directory
+    - `message_id` (required): Starting message ID
+    - `max_depth` (optional): Maximum thread depth (default: 50)
+  - **Returns:** Thread of related messages
+
+### Contact and Statistics
+- **`maildir_analyze_contacts`**: Analyze contact interactions
+  - **Parameters:**
+    - `maildir_path` (required): Path to the Maildir directory
+    - `min_messages` (optional): Minimum message count for inclusion (default: 1)
+    - `date_range` (optional): Analyze contacts within date range
+  - **Returns:** Contact analysis with interaction statistics
+
+- **`maildir_get_statistics`**: Generate mailbox statistics
+  - **Parameters:**
+    - `maildir_path` (required): Path to the Maildir directory
+    - `include_folders` (optional): Include per-folder statistics (default: true)
+    - `include_time_analysis` (optional): Include time-based analysis (default: false)
+  - **Returns:** Comprehensive mailbox statistics
+
+## Resources
+
+The server provides `maildir://` resources for:
+
+### Maildir Resources
+- **URI Format**: `maildir://<maildir_path>`
+- **Example**: `maildir:///home/user/.local/share/mail/personal`
+- **Description:** Access to Maildir folders and their metadata
+
+## Maildir Format Support
+
+### Standard Structure
+```
+maildir/
+├── cur/           # Current messages (read)
+├── new/           # New messages (unread)
+├── tmp/           # Temporary files
+└── .folder/       # Subfolders
+    ├── cur/
+    ├── new/
+    └── tmp/
+```
+
+### Message Flags
+- **S**: Seen (read)
+- **R**: Replied
+- **F**: Flagged (important)
+- **T**: Trashed (deleted)
+- **D**: Draft
+- **P**: Passed (forwarded)
+
+### Folder Detection
+Automatically detects standard Maildir folders:
+- **INBOX**: Main inbox folder
+- **Sent**: Sent messages
+- **Drafts**: Draft messages
+- **Trash**: Deleted messages
+- **Custom folders**: User-created folders
+
+## Privacy and Security Features
+
+### Content Sanitization
+- **PII Masking**: Automatic detection and masking of sensitive information
+- **Phone Number Masking**: XXX-XXX-XXXX pattern replacement
+- **SSN Masking**: XXX-XX-XXXX pattern replacement
+- **Custom Patterns**: Configurable sanitization rules
+
+### Access Control
+- **Path Restrictions**: Only allowed Maildir paths are accessible
+- **No Modification**: Read-only access to email data
+- **Safe Parsing**: Robust email parsing with error handling
+- **Size Limits**: Prevents processing of extremely large emails
+
+## Configuration Examples
+
+### Claude Desktop Integration
+```json
+{
+  "mcpServers": {
+    "maildir": {
+      "command": "/usr/local/bin/mcp-maildir",
+      "args": ["--maildir-path", "/home/user/.local/share/mail"]
+    }
+  }
+}
+```
+
+### Multiple Email Accounts
+```json
+{
+  "mcpServers": {
+    "email-personal": {
+      "command": "/usr/local/bin/mcp-maildir",
+      "args": ["--maildir-path", "/home/user/.local/share/mail/personal"]
+    },
+    "email-work": {
+      "command": "/usr/local/bin/mcp-maildir",
+      "args": ["--maildir-path", "/home/user/.local/share/mail/work"]
+    }
+  }
+}
+```
+
+### Combined Mailboxes
+```json
+{
+  "mcpServers": {
+    "all-email": {
+      "command": "/usr/local/bin/mcp-maildir",
+      "args": [
+        "--maildir-path", "/home/user/.local/share/mail/personal",
+        "--maildir-path", "/home/user/.local/share/mail/work",
+        "--maildir-path", "/home/user/.local/share/mail/lists"
+      ]
+    }
+  }
+}
+```
+
+## Example Workflows
+
+### Email Management
+```bash
+# Get overview of mailbox
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "maildir_scan_folders", "arguments": {"maildir_path": "~/.local/share/mail", "include_counts": true}}}' | mcp-maildir --maildir-path ~/.local/share/mail
+
+# Check unread messages
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "maildir_list_messages", "arguments": {"maildir_path": "~/.local/share/mail", "folder": "INBOX", "unread_only": true, "limit": 20}}}' | mcp-maildir --maildir-path ~/.local/share/mail
+
+# Read specific message
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "maildir_read_message", "arguments": {"maildir_path": "~/.local/share/mail", "message_id": "1701439800.12345_1.hostname", "include_headers": true}}}' | mcp-maildir --maildir-path ~/.local/share/mail
+```
+
+### Email Search and Analysis
+```bash
+# Search for project-related emails
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "maildir_search_messages", "arguments": {"maildir_path": "~/.local/share/mail", "query": "project alpha", "limit": 50}}}' | mcp-maildir --maildir-path ~/.local/share/mail
+
+# Find emails from specific date range
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "maildir_list_messages", "arguments": {"maildir_path": "~/.local/share/mail", "date_from": "2023-12-01", "date_to": "2023-12-31", "limit": 100}}}' | mcp-maildir --maildir-path ~/.local/share/mail
+
+# Analyze most frequent contacts
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "maildir_analyze_contacts", "arguments": {"maildir_path": "~/.local/share/mail", "min_messages": 5}}}' | mcp-maildir --maildir-path ~/.local/share/mail
+```
+
+### Thread and Conversation Analysis
+```bash
+# Get email thread
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "maildir_get_thread", "arguments": {"maildir_path": "~/.local/share/mail", "message_id": "1701439800.12345_1.hostname", "max_depth": 20}}}' | mcp-maildir --maildir-path ~/.local/share/mail
+
+# Search conversation history
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "maildir_search_messages", "arguments": {"maildir_path": "~/.local/share/mail", "query": "from:john@example.com"}}}' | mcp-maildir --maildir-path ~/.local/share/mail
+```
+
+### Statistics and Reporting
+```bash
+# Get mailbox statistics
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "maildir_get_statistics", "arguments": {"maildir_path": "~/.local/share/mail", "include_folders": true}}}' | mcp-maildir --maildir-path ~/.local/share/mail
+
+# Analyze email patterns
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "maildir_analyze_contacts", "arguments": {"maildir_path": "~/.local/share/mail"}}}' | mcp-maildir --maildir-path ~/.local/share/mail
+```
+
+## Advanced Features
+
+### Email Parsing
+- **MIME Support**: Full MIME multipart message support
+- **Encoding Handling**: Proper handling of various text encodings
+- **HTML Processing**: Conversion of HTML emails to plain text
+- **Attachment Detection**: Identification of email attachments (metadata only)
+
+### Search Capabilities
+- **Full-Text Search**: Search across headers, subject, and body
+- **Field-Specific Search**: Search within specific email fields
+- **Date Range Filtering**: Filter messages by date ranges
+- **Sender/Recipient Filtering**: Filter by email participants
+- **Case-Insensitive**: Flexible search matching
+
+### Performance Optimization
+- **Lazy Loading**: Folders and messages loaded on demand
+- **Pagination**: Efficient handling of large mailboxes
+- **Caching**: Smart caching of folder metadata
+- **Resource Limits**: Configurable limits to prevent resource exhaustion
+
+## Common Email Clients
+
+### Compatible Email Clients
+- **Mutt**: Terminal-based email client
+- **Thunderbird**: Cross-platform email client (with Maildir support)
+- **Evolution**: GNOME email client
+- **Claws Mail**: Lightweight email client
+- **OfflineIMAP**: IMAP to Maildir synchronization
+- **mbsync/isync**: Mailbox synchronization utility
+
+### Setting up Maildir
+```bash
+# Create Maildir structure
+mkdir -p ~/.local/share/mail/{cur,new,tmp}
+
+# Use with OfflineIMAP
+offlineimap -c ~/.offlineimaprc
+
+# Use with mbsync
+mbsync -a
+```
+
+## Performance
+
+- **Startup Time**: ~1ms (lazy loading)
+- **Memory Usage**: <10MB for typical mailboxes
+- **Search Performance**: Fast full-text search with indexing
+- **Scalability**: Handles mailboxes with 100K+ messages
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"Maildir not found" errors**
+   ```bash
+   # Check if path exists and has proper structure
+   ls -la ~/.local/share/mail
+   ls -la ~/.local/share/mail/{cur,new,tmp}
+   ```
+
+2. **"Permission denied" errors**
+   ```bash
+   # Check file permissions
+   ls -la ~/.local/share/mail
+   chmod -R 755 ~/.local/share/mail
+   ```
+
+3. **"No messages found"**
+   ```bash
+   # Verify Maildir contains messages
+   ls ~/.local/share/mail/cur/
+   ls ~/.local/share/mail/new/
+   ```
+
+4. **"Invalid message format"**
+   ```bash
+   # Check message file format
+   head -20 ~/.local/share/mail/cur/some_message_file
+   ```
+
+### Debugging
+```bash
+# Test basic folder scanning
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "maildir_scan_folders", "arguments": {"maildir_path": "/path/to/maildir"}}}' | mcp-maildir --maildir-path /path/to/maildir
+
+# Test message listing
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "maildir_list_messages", "arguments": {"maildir_path": "/path/to/maildir", "limit": 1}}}' | mcp-maildir --maildir-path /path/to/maildir
+```
+
+## Best Practices
+
+1. **Backup First**: Always backup email data before processing
+2. **Use Absolute Paths**: Specify full paths to avoid ambiguity
+3. **Monitor Resources**: Be aware of memory usage with large mailboxes
+4. **Regular Cleanup**: Clean up old messages to maintain performance
+5. **Privacy Awareness**: Enable content sanitization for sensitive data
+
+## Security Considerations
+
+- **Read-Only Access**: Server provides read-only access to email data
+- **Path Validation**: All paths are validated to prevent directory traversal
+- **Content Sanitization**: Optional PII masking for privacy protection
+- **No Network Access**: Server does not make external network connections
+- **Safe Parsing**: Robust email parsing prevents malformed message exploits
+
+## Use Cases
+
+- **Email Analysis**: Analyze email patterns and communication trends
+- **Contact Management**: Identify and analyze email contacts
+- **Information Retrieval**: Search and extract information from emails
+- **Productivity Analysis**: Understand email usage patterns
+- **Archive Management**: Organize and manage email archives
+
+## Contributing
+
+See the main project README for contribution guidelines.
+
+## License
+
+This project is licensed under the same terms as the parent MCP project.
\ No newline at end of file

@@ -0,0 +1,365 @@
+# Memory MCP Server
+
+A Model Context Protocol (MCP) server that provides persistent knowledge graph management with entities, relations, and observations.
+
+## Overview
+
+The Memory MCP server enables AI assistants to maintain persistent knowledge through a graph-based memory system. It supports creating entities, establishing relationships, adding observations, and querying the knowledge graph for intelligent context retention across conversations.
+
+## Installation
+
+### From Source
+```bash
+# Build the binary
+make memory
+
+# Install system-wide (requires sudo)
+sudo make install
+```
+
+### Direct Build
+```bash
+go build -o mcp-memory ./cmd/memory
+```
+
+## Usage
+
+### Command Line Arguments
+
+```bash
+mcp-memory [--memory-file <path>]
+```
+
+**Optional Arguments:**
+- `--memory-file <path>`: Path to JSON file for persistent storage (default: `~/.mcp-memory.json`)
+
+### Examples
+
+#### Basic Testing
+```bash
+# Test server initialization
+echo '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0.0"}}}' | timeout 5s mcp-memory
+
+# List available tools
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}' | timeout 5s mcp-memory
+
+# List memory resources
+echo '{"jsonrpc": "2.0", "id": 3, "method": "resources/list", "params": {}}' | timeout 5s mcp-memory
+
+# Read the knowledge graph
+echo '{"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "read_graph", "arguments": {}}}' | timeout 5s mcp-memory
+```
+
+#### Custom Memory File
+```bash
+# Use a specific file for storage
+mcp-memory --memory-file /home/user/my-knowledge.json
+```
+
+#### Knowledge Management Testing
+```bash
+# Create entities
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "create_entities", "arguments": {"entities": [{"name": "Alice", "entityType": "person", "observations": ["Works as a software engineer", "Lives in San Francisco"]}]}}}' | timeout 5s mcp-memory
+
+# Create relationships
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "create_relations", "arguments": {"relations": [{"from": "Alice", "to": "Python", "relationType": "uses"}]}}}' | timeout 5s mcp-memory
+
+# Search for entities
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "search_nodes", "arguments": {"query": "software engineer"}}}' | timeout 5s mcp-memory
+```
+
+## Available Tools
+
+### Entity Management
+- **`create_entities`**: Create new entities with observations
+- **`add_observations`**: Add observations to existing entities
+- **`delete_entities`**: Remove entities from the knowledge graph
+- **`open_nodes`**: Retrieve detailed information about specific entities
+
+### Relationship Management
+- **`create_relations`**: Establish relationships between entities
+- **`delete_relations`**: Remove relationships from the knowledge graph
+
+### Knowledge Exploration
+- **`read_graph`**: Get overview of the entire knowledge graph
+- **`search_nodes`**: Search entities by name, type, or observations
+
+### Observation Management
+- **`delete_observations`**: Remove specific observations from entities
+
+## Resources
+
+The server provides `memory://` resources for:
+
+### Knowledge Graph Resource
+- **URI Format**: `memory://graph`
+- **Description**: Access to the complete knowledge graph with entities and relations
+- **Content**: JSON representation of all entities, relations, and observations
+
+## Prompts
+
+### Knowledge Query Interface
+- **`knowledge-query`**: Interactive prompt for exploring the knowledge graph
+  - Natural language queries about stored information
+  - Context-aware search across entities and observations
+  - Relationship discovery and exploration
+
+## Data Model
+
+### Entities
+```json
+{
+  "name": "entity_name",
+  "entityType": "type",
+  "observations": ["observation1", "observation2"]
+}
+```
+
+### Relations
+```json
+{
+  "from": "source_entity",
+  "to": "target_entity", 
+  "relationType": "relationship_type"
+}
+```
+
+### Knowledge Graph Structure
+```json
+{
+  "entities": {
+    "entity_name": {
+      "name": "entity_name",
+      "entityType": "type",
+      "observations": ["list", "of", "observations"]
+    }
+  },
+  "relations": {
+    "relation_id": {
+      "from": "source",
+      "to": "target",
+      "relationType": "type"
+    }
+  }
+}
+```
+
+## Configuration Examples
+
+### Claude Desktop Integration
+```json
+{
+  "mcpServers": {
+    "memory": {
+      "command": "/usr/local/bin/mcp-memory"
+    }
+  }
+}
+```
+
+### Custom Memory File
+```json
+{
+  "mcpServers": {
+    "memory": {
+      "command": "/usr/local/bin/mcp-memory",
+      "args": ["--memory-file", "/home/user/ai-memory.json"]
+    }
+  }
+}
+```
+
+### Project-Specific Memory
+```json
+{
+  "mcpServers": {
+    "project-memory": {
+      "command": "/usr/local/bin/mcp-memory",
+      "args": ["--memory-file", "/home/user/projects/myapp/knowledge.json"]
+    }
+  }
+}
+```
+
+## Example Workflows
+
+### Building a Knowledge Base
+```bash
+# Create people entities
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "create_entities", "arguments": {"entities": [{"name": "Alice", "entityType": "person", "observations": ["Software engineer", "Loves Python", "Works remotely"]}, {"name": "Bob", "entityType": "person", "observations": ["Product manager", "Lives in NYC", "Enjoys hiking"]}]}}}' | mcp-memory
+
+# Create project entities
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "create_entities", "arguments": {"entities": [{"name": "ProjectX", "entityType": "project", "observations": ["Web application", "Uses React and Node.js", "Due in Q2"]}]}}}' | mcp-memory
+
+# Establish relationships
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "create_relations", "arguments": {"relations": [{"from": "Alice", "to": "ProjectX", "relationType": "works_on"}, {"from": "Bob", "to": "ProjectX", "relationType": "manages"}]}}}' | mcp-memory
+```
+
+### Knowledge Exploration
+```bash
+# Search for people
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "search_nodes", "arguments": {"query": "engineer"}}}' | mcp-memory
+
+# Get detailed information about Alice
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "open_nodes", "arguments": {"names": ["Alice"]}}}' | mcp-memory
+
+# View the entire knowledge graph
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "read_graph", "arguments": {}}}' | mcp-memory
+```
+
+### Updating Knowledge
+```bash
+# Add new observations to Alice
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "add_observations", "arguments": {"entityName": "Alice", "observations": ["Completed Python certification", "Mentoring junior developers"]}}}' | mcp-memory
+
+# Create new relationships
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "create_relations", "arguments": {"relations": [{"from": "Alice", "to": "Python", "relationType": "expert_in"}]}}}' | mcp-memory
+```
+
+### Knowledge Cleanup
+```bash
+# Remove specific observations
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "delete_observations", "arguments": {"entityName": "Alice", "observations": ["Old outdated info"]}}}' | mcp-memory
+
+# Remove relationships
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "delete_relations", "arguments": {"relations": [{"from": "Alice", "to": "OldProject", "relationType": "worked_on"}]}}}' | mcp-memory
+
+# Remove entire entities
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "delete_entities", "arguments": {"entityNames": ["ObsoleteEntity"]}}}' | mcp-memory
+```
+
+## Advanced Features
+
+### Search Capabilities
+- **Entity Name Search**: Find entities by partial name matching
+- **Type-based Search**: Filter entities by their type
+- **Observation Search**: Search within observation text
+- **Relationship Discovery**: Find connected entities
+
+### Persistence
+- **Automatic Saving**: Changes are automatically persisted to disk
+- **JSON Format**: Human-readable storage format
+- **Backup Support**: File-based storage enables easy backups
+- **Version Control**: JSON files can be version controlled
+
+### Memory Efficiency
+- **Lazy Loading**: Knowledge graph loaded only when needed
+- **Selective Loading**: Load only requested parts of the graph
+- **Memory Limits**: Configurable limits for large knowledge bases
+
+## Data Storage
+
+### Default Location
+```bash
+~/.mcp-memory.json
+```
+
+### Custom Locations
+```bash
+# Project-specific memory
+mcp-memory --memory-file ./project-knowledge.json
+
+# Shared memory location
+mcp-memory --memory-file /shared/team-knowledge.json
+
+# Backup location
+mcp-memory --memory-file /backup/ai-memory-$(date +%Y%m%d).json
+```
+
+### File Format
+The memory file is stored as JSON with the following structure:
+```json
+{
+  "entities": {
+    "Alice": {
+      "name": "Alice",
+      "entityType": "person",
+      "observations": ["Software engineer", "Loves Python"]
+    }
+  },
+  "relations": {
+    "rel_1": {
+      "from": "Alice",
+      "to": "Python",
+      "relationType": "uses"
+    }
+  }
+}
+```
+
+## Performance
+
+- **Startup Time**: ~1ms (lazy loading)
+- **Memory Usage**: <5MB for typical knowledge graphs
+- **Storage Efficiency**: JSON compression for large graphs
+- **Query Performance**: In-memory search for fast responses
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Memory file not found**
+   ```bash
+   # Check if file exists and is readable
+   ls -la ~/.mcp-memory.json
+   
+   # Create with proper permissions if needed
+   touch ~/.mcp-memory.json
+   chmod 644 ~/.mcp-memory.json
+   ```
+
+2. **JSON parsing errors**
+   ```bash
+   # Validate JSON format
+   jq . ~/.mcp-memory.json
+   
+   # Backup and reset if corrupted
+   cp ~/.mcp-memory.json ~/.mcp-memory.json.backup
+   echo '{"entities":{},"relations":{}}' > ~/.mcp-memory.json
+   ```
+
+3. **Permission errors**
+   ```bash
+   # Check file permissions
+   ls -la ~/.mcp-memory.json
+   
+   # Fix permissions
+   chmod 644 ~/.mcp-memory.json
+   ```
+
+### Backup and Recovery
+```bash
+# Create backup
+cp ~/.mcp-memory.json ~/.mcp-memory-backup-$(date +%Y%m%d).json
+
+# Restore from backup
+cp ~/.mcp-memory-backup-20231201.json ~/.mcp-memory.json
+
+# Reset memory (caution: destroys all data)
+echo '{"entities":{},"relations":{}}' > ~/.mcp-memory.json
+```
+
+## Best Practices
+
+1. **Regular Backups**: Backup memory files before major changes
+2. **Meaningful Names**: Use descriptive entity names and types
+3. **Structured Observations**: Keep observations concise and factual
+4. **Relationship Types**: Use consistent relationship type naming
+5. **Cleanup**: Regularly remove outdated entities and observations
+6. **Version Control**: Store memory files in version control for shared projects
+
+## Use Cases
+
+- **Personal Knowledge Management**: Track people, projects, and ideas
+- **Research Notes**: Organize research findings and connections
+- **Project Documentation**: Maintain project context and relationships
+- **Learning Journals**: Record learning progress and connections
+- **Team Knowledge**: Share institutional knowledge across team members
+
+## Contributing
+
+See the main project README for contribution guidelines.
+
+## License
+
+This project is licensed under the same terms as the parent MCP project.
\ No newline at end of file

@@ -0,0 +1,273 @@
+# Sequential Thinking MCP Server
+
+A Model Context Protocol (MCP) server that provides structured thinking workflows for AI assistants to break down complex problems step-by-step.
+
+## Overview
+
+The Sequential Thinking MCP server enables AI assistants to engage in structured, step-by-step reasoning through a standardized protocol. It provides tools for organizing thoughts, breaking down complex problems, and maintaining logical flow in problem-solving processes.
+
+## Installation
+
+### From Source
+```bash
+# Build the binary
+make sequential-thinking
+
+# Install system-wide (requires sudo)
+sudo make install
+```
+
+### Direct Build
+```bash
+go build -o mcp-sequential-thinking ./cmd/sequential-thinking
+```
+
+## Usage
+
+### Command Line Arguments
+
+```bash
+mcp-sequential-thinking
+```
+
+**No arguments required** - The server provides thinking workflow utilities without any configuration.
+
+### Examples
+
+#### Basic Testing
+```bash
+# Test server initialization
+echo '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0.0"}}}' | timeout 5s mcp-sequential-thinking
+
+# List available tools
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}' | timeout 5s mcp-sequential-thinking
+
+# Start a thinking process
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "How to design a scalable web application?"}}}' | timeout 5s mcp-sequential-thinking
+```
+
+#### Structured Problem Solving
+```bash
+# Break down a complex programming problem
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Design a distributed caching system", "steps": ["Identify requirements", "Choose architecture", "Design data model", "Plan implementation", "Consider scalability"]}}}' | timeout 5s mcp-sequential-thinking
+
+# Analyze a business decision
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Should we migrate to microservices?", "context": "Current monolith serves 10M users, team of 50 developers"}}}' | timeout 5s mcp-sequential-thinking
+```
+
+## Available Tools
+
+### Structured Thinking
+- **`sequentialthinking`**: Engage in step-by-step problem analysis
+  - **Parameters:**
+    - `problem` (required): The problem or question to analyze
+    - `context` (optional): Additional context or background information
+    - `steps` (optional): Predefined steps to follow in the analysis
+    - `depth` (optional): Level of analysis depth (1-5, default: 3)
+    - `focus` (optional): Specific aspect to focus on ("technical", "business", "creative", "analytical")
+  - **Returns:** Structured thinking process with step-by-step analysis
+
+## Thinking Frameworks
+
+### Problem Types
+- **Technical Problems**: Software design, architecture decisions, debugging
+- **Business Problems**: Strategic decisions, process optimization, market analysis
+- **Creative Problems**: Brainstorming, innovation, design thinking
+- **Analytical Problems**: Data analysis, research, hypothesis testing
+
+### Depth Levels
+1. **Surface (1)**: Basic overview and immediate considerations
+2. **Standard (2)**: Common approach with key factors identified
+3. **Detailed (3)**: Comprehensive analysis with multiple perspectives (default)
+4. **Deep (4)**: Thorough examination with edge cases and implications
+5. **Exhaustive (5)**: Complete analysis with all possible angles and contingencies
+
+### Focus Areas
+- **Technical**: Implementation details, architecture, performance, scalability
+- **Business**: ROI, market impact, stakeholder concerns, strategic alignment
+- **Creative**: Innovation, user experience, design alternatives, brainstorming
+- **Analytical**: Data-driven insights, metrics, testing, validation
+
+## Configuration Examples
+
+### Claude Desktop Integration
+```json
+{
+  "mcpServers": {
+    "thinking": {
+      "command": "/usr/local/bin/mcp-sequential-thinking"
+    }
+  }
+}
+```
+
+### Multiple Thinking Services
+```json
+{
+  "mcpServers": {
+    "structured-thinking": {
+      "command": "/usr/local/bin/mcp-sequential-thinking"
+    }
+  }
+}
+```
+
+## Example Workflows
+
+### Software Architecture Design
+```bash
+# Analyze microservices migration
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Should we break our monolith into microservices?", "context": "E-commerce platform, 50 developers, 1M daily users", "focus": "technical", "depth": 4}}}' | mcp-sequential-thinking
+
+# Database selection process
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Choose between PostgreSQL, MongoDB, and DynamoDB for our new project", "context": "Real-time analytics dashboard, 100K concurrent users", "steps": ["Define requirements", "Compare capabilities", "Evaluate performance", "Consider costs", "Assess team expertise"]}}}' | mcp-sequential-thinking
+```
+
+### Business Decision Making
+```bash
+# Product feature prioritization
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Which features should we build next quarter?", "context": "SaaS product, limited engineering resources, competitive pressure", "focus": "business", "depth": 3}}}' | mcp-sequential-thinking
+
+# Market expansion strategy
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Should we expand to European markets?", "context": "US-based startup, $2M ARR, 20 employees", "focus": "business"}}}' | mcp-sequential-thinking
+```
+
+### Creative Problem Solving
+```bash
+# User experience improvement
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "How can we improve user onboarding experience?", "context": "Complex B2B software, high drop-off rates", "focus": "creative", "depth": 3}}}' | mcp-sequential-thinking
+
+# Innovation brainstorming
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "What new AI features could differentiate our product?", "context": "Project management tool, growing AI competition", "focus": "creative"}}}' | mcp-sequential-thinking
+```
+
+### Research and Analysis
+```bash
+# Technology evaluation
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Evaluate the impact of implementing GraphQL", "context": "REST API currently serves mobile and web clients", "focus": "analytical", "depth": 4}}}' | mcp-sequential-thinking
+
+# Performance optimization
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Why is our application slow and how can we fix it?", "context": "Web app with 2-second load times, user complaints increasing", "steps": ["Identify bottlenecks", "Measure current performance", "Analyze root causes", "Propose solutions", "Plan implementation"]}}}' | mcp-sequential-thinking
+```
+
+## Advanced Features
+
+### Structured Output
+- **Step-by-Step Breakdown**: Clear progression through thinking process
+- **Logical Flow**: Each step builds on previous conclusions
+- **Alternative Perspectives**: Consideration of multiple viewpoints
+- **Risk Assessment**: Identification of potential issues and mitigation strategies
+
+### Contextual Adaptation
+- **Domain Awareness**: Adapts reasoning style to problem domain
+- **Complexity Scaling**: Adjusts depth based on problem complexity
+- **Stakeholder Consideration**: Includes relevant stakeholder perspectives
+- **Implementation Focus**: Balances theoretical analysis with practical considerations
+
+### Thinking Patterns
+- **Analytical**: Systematic breakdown and evaluation
+- **Creative**: Divergent thinking and innovation
+- **Critical**: Questioning assumptions and finding flaws
+- **Systems**: Understanding interconnections and dependencies
+
+## Use Cases
+
+### Software Development
+- Architecture design decisions
+- Technology stack selection
+- Performance optimization strategies
+- Code review and refactoring plans
+- Testing strategy development
+
+### Product Management
+- Feature prioritization
+- User story analysis
+- Competitive analysis
+- Go-to-market strategy
+- Product roadmap planning
+
+### Business Strategy
+- Market entry decisions
+- Investment evaluations
+- Risk assessment
+- Process optimization
+- Team structure planning
+
+### Research and Development
+- Hypothesis formation
+- Experimental design
+- Literature review structure
+- Data analysis approaches
+- Innovation opportunities
+
+## Performance
+
+- **Startup Time**: ~1ms
+- **Memory Usage**: <5MB
+- **Response Time**: Varies by problem complexity (typically 1-10 seconds)
+- **Scalability**: Handles complex multi-step problems efficiently
+
+## Best Practices
+
+### Problem Definition
+1. **Be Specific**: Clearly define the problem or question
+2. **Provide Context**: Include relevant background information
+3. **Set Boundaries**: Define scope and constraints
+4. **Specify Outcomes**: Clarify desired results or decisions
+
+### Using Parameters Effectively
+1. **Context is Key**: Always provide relevant context for better analysis
+2. **Choose Appropriate Depth**: Match depth to problem complexity
+3. **Select Right Focus**: Align focus area with problem type
+4. **Guide with Steps**: Use predefined steps for structured domains
+
+### Interpreting Results
+1. **Follow the Logic**: Understand the reasoning chain
+2. **Question Assumptions**: Validate underlying assumptions
+3. **Consider Alternatives**: Look for alternative approaches mentioned
+4. **Plan Next Steps**: Use conclusions to guide action plans
+
+## Example Output Structure
+
+A typical sequential thinking response includes:
+
+1. **Problem Understanding**: Restated problem with key aspects identified
+2. **Context Analysis**: Relevant factors and constraints
+3. **Step-by-Step Reasoning**: Logical progression through the problem
+4. **Alternative Considerations**: Different perspectives and approaches
+5. **Risk Assessment**: Potential issues and mitigation strategies
+6. **Recommendations**: Actionable conclusions and next steps
+7. **Implementation Considerations**: Practical aspects of executing solutions
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Vague problem statements**
+   ```bash
+   # Instead of: "What should I do?"
+   # Use: "Should I implement caching to improve API response times?"
+   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Should I implement Redis caching for our user profile API?", "context": "Currently serves 10K requests/min, 500ms average response time"}}}' | mcp-sequential-thinking
+   ```
+
+2. **Missing context**
+   ```bash
+   # Provide relevant background information
+   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Choose between React and Vue", "context": "Team of 5 developers, all experienced with JavaScript, building customer portal, 6-month timeline"}}}' | mcp-sequential-thinking
+   ```
+
+3. **Wrong depth level**
+   ```bash
+   # Adjust depth based on problem complexity
+   # Simple decisions: depth 1-2
+   # Complex strategic decisions: depth 4-5
+   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Company acquisition strategy", "depth": 5}}}' | mcp-sequential-thinking
+   ```
+
+## Contributing
+
+See the main project README for contribution guidelines.
+
+## License
+
+This project is licensed under the same terms as the parent MCP project.
\ No newline at end of file

@@ -0,0 +1,309 @@
+# Time MCP Server
+
+A Model Context Protocol (MCP) server that provides comprehensive time and date utilities for AI assistants.
+
+## Overview
+
+The Time MCP server enables AI assistants to work with time-related operations through a standardized protocol. It provides tools for getting current time, converting between time zones, parsing dates, and performing time calculations.
+
+## Installation
+
+### From Source
+```bash
+# Build the binary
+make time
+
+# Install system-wide (requires sudo)
+sudo make install
+```
+
+### Direct Build
+```bash
+go build -o mcp-time ./cmd/time
+```
+
+## Usage
+
+### Command Line Arguments
+
+```bash
+mcp-time
+```
+
+**No arguments required** - The server provides time utilities without any configuration.
+
+### Examples
+
+#### Basic Testing
+```bash
+# Test server initialization
+echo '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0.0"}}}' | timeout 5s mcp-time
+
+# List available tools
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}' | timeout 5s mcp-time
+
+# Get current time
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {}}}' | timeout 5s mcp-time
+```
+
+#### Time Operations Testing
+```bash
+# Get current time in specific timezone
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"timezone": "America/New_York"}}}' | timeout 5s mcp-time
+
+# Convert time between timezones
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "2023-12-01T15:30:00Z", "from_timezone": "UTC", "to_timezone": "America/Los_Angeles"}}}' | timeout 5s mcp-time
+
+# Get current time in multiple formats
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"format": "RFC3339"}}}' | timeout 5s mcp-time
+```
+
+## Available Tools
+
+### Current Time
+- **`get_current_time`**: Get current date and time
+  - **Parameters:**
+    - `timezone` (optional): Target timezone (e.g., "America/New_York", "Europe/London")
+    - `format` (optional): Output format ("RFC3339", "Unix", "ISO8601", "Human")
+  - **Returns:** Current time in specified timezone and format
+
+### Time Conversion
+- **`convert_time`**: Convert time between different timezones and formats
+  - **Parameters:**
+    - `time` (required): Input time string or Unix timestamp
+    - `from_timezone` (optional): Source timezone (defaults to UTC)
+    - `to_timezone` (required): Target timezone
+    - `format` (optional): Output format
+  - **Returns:** Converted time in target timezone and format
+
+## Supported Timezones
+
+### Major Timezones
+- **UTC**: Coordinated Universal Time
+- **America/New_York**: Eastern Time (US & Canada)
+- **America/Chicago**: Central Time (US & Canada)
+- **America/Denver**: Mountain Time (US & Canada)
+- **America/Los_Angeles**: Pacific Time (US & Canada)
+- **Europe/London**: Greenwich Mean Time / British Summer Time
+- **Europe/Paris**: Central European Time
+- **Europe/Berlin**: Central European Time
+- **Asia/Tokyo**: Japan Standard Time
+- **Asia/Shanghai**: China Standard Time
+- **Asia/Kolkata**: India Standard Time
+- **Australia/Sydney**: Australian Eastern Time
+
+### Full IANA Support
+The server supports all IANA timezone identifiers. Common patterns:
+- **Continent/City**: `America/New_York`, `Europe/London`, `Asia/Tokyo`
+- **Regional**: `US/Eastern`, `US/Pacific`, `GMT`, `UTC`
+
+## Supported Formats
+
+### Input Formats
+- **RFC3339**: `2023-12-01T15:30:00Z`
+- **ISO8601**: `2023-12-01T15:30:00+00:00`
+- **Unix Timestamp**: `1701439800` (seconds since epoch)
+- **Human Readable**: `December 1, 2023 3:30 PM`
+
+### Output Formats
+- **RFC3339**: `2023-12-01T15:30:00Z`
+- **ISO8601**: `2023-12-01T15:30:00-08:00`
+- **Unix**: `1701439800`
+- **Human**: `Friday, December 1, 2023 at 3:30 PM PST`
+
+## Configuration Examples
+
+### Claude Desktop Integration
+```json
+{
+  "mcpServers": {
+    "time": {
+      "command": "/usr/local/bin/mcp-time"
+    }
+  }
+}
+```
+
+### Multiple Time Services
+```json
+{
+  "mcpServers": {
+    "time-utils": {
+      "command": "/usr/local/bin/mcp-time"
+    }
+  }
+}
+```
+
+## Example Workflows
+
+### Current Time Operations
+```bash
+# Get current UTC time
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {}}}' | mcp-time
+
+# Get current time in New York
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"timezone": "America/New_York"}}}' | mcp-time
+
+# Get current time in multiple formats
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"timezone": "Europe/London", "format": "Human"}}}' | mcp-time
+
+# Get Unix timestamp
+echo '{"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"format": "Unix"}}}' | mcp-time
+```
+
+### Time Zone Conversions
+```bash
+# Convert UTC to Eastern Time
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "2023-12-01T20:30:00Z", "from_timezone": "UTC", "to_timezone": "America/New_York"}}}' | mcp-time
+
+# Convert Eastern to Pacific Time
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "2023-12-01T15:30:00", "from_timezone": "America/New_York", "to_timezone": "America/Los_Angeles"}}}' | mcp-time
+
+# Convert to multiple timezones
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "2023-12-01T12:00:00Z", "to_timezone": "Asia/Tokyo", "format": "Human"}}}' | mcp-time
+```
+
+### Business Hours Calculations
+```bash
+# Check if it's business hours in New York
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"timezone": "America/New_York", "format": "Human"}}}' | mcp-time
+
+# Get meeting time across timezones
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "2023-12-01T14:00:00", "from_timezone": "America/New_York", "to_timezone": "Europe/London"}}}' | mcp-time
+
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "2023-12-01T14:00:00", "from_timezone": "America/New_York", "to_timezone": "Asia/Tokyo"}}}' | mcp-time
+```
+
+### Unix Timestamp Operations
+```bash
+# Convert Unix timestamp to human readable
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "1701439800", "to_timezone": "America/Los_Angeles", "format": "Human"}}}' | mcp-time
+
+# Get current Unix timestamp
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"format": "Unix"}}}' | mcp-time
+```
+
+## Advanced Features
+
+### Automatic Format Detection
+- **Smart Parsing**: Automatically detects input time format
+- **Flexible Input**: Accepts various common time formats
+- **Error Handling**: Clear error messages for invalid formats
+
+### Daylight Saving Time
+- **Automatic DST**: Handles daylight saving time transitions
+- **Historical Accuracy**: Correct DST rules for historical dates
+- **Future Dates**: Accurate predictions for future DST changes
+
+### High Precision
+- **Nanosecond Precision**: Full Go time precision support
+- **Leap Seconds**: Proper handling of leap seconds
+- **Time Zones**: Complete IANA timezone database support
+
+## Use Cases
+
+### Scheduling and Coordination
+```bash
+# Plan international meeting
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "2023-12-05T09:00:00", "from_timezone": "America/New_York", "to_timezone": "Europe/London"}}}' | mcp-time
+
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "2023-12-05T09:00:00", "from_timezone": "America/New_York", "to_timezone": "Asia/Tokyo"}}}' | mcp-time
+```
+
+### Log Analysis
+```bash
+# Convert log timestamps
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "1701439800", "to_timezone": "America/Denver", "format": "Human"}}}' | mcp-time
+```
+
+### Business Operations
+```bash
+# Check current time in office locations
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"timezone": "America/New_York", "format": "Human"}}}' | mcp-time
+
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"timezone": "Europe/London", "format": "Human"}}}' | mcp-time
+
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"timezone": "Asia/Singapore", "format": "Human"}}}' | mcp-time
+```
+
+## Performance
+
+- **Startup Time**: ~1ms
+- **Memory Usage**: <5MB
+- **Response Time**: <1ms for time operations
+- **Timezone Data**: Built-in IANA timezone database
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"Invalid timezone" errors**
+   ```bash
+   # Check valid timezone format
+   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"timezone": "UTC"}}}' | mcp-time
+   
+   # Use IANA format: Continent/City
+   echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"timezone": "America/New_York"}}}' | mcp-time
+   ```
+
+2. **"Invalid time format" errors**
+   ```bash
+   # Use RFC3339 format for reliability
+   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "2023-12-01T15:30:00Z", "to_timezone": "UTC"}}}' | mcp-time
+   
+   # Or Unix timestamp
+   echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "1701439800", "to_timezone": "UTC"}}}' | mcp-time
+   ```
+
+### Testing Time Operations
+```bash
+# Test basic functionality
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {}}}' | mcp-time
+
+# Test timezone conversion
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "convert_time", "arguments": {"time": "2023-01-01T00:00:00Z", "to_timezone": "America/New_York"}}}' | mcp-time
+
+# Test format conversion
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "get_current_time", "arguments": {"format": "Unix"}}}' | mcp-time
+```
+
+## Best Practices
+
+1. **Use IANA Timezones**: Always use standard IANA timezone identifiers
+2. **Specify Formats**: Explicitly specify input/output formats when possible
+3. **Handle DST**: Be aware of daylight saving time transitions
+4. **UTC for Storage**: Store times in UTC and convert for display
+5. **Validate Inputs**: Check timezone and format validity before processing
+
+## Timezone Reference
+
+### Common US Timezones
+- `America/New_York` (EST/EDT)
+- `America/Chicago` (CST/CDT)
+- `America/Denver` (MST/MDT)
+- `America/Los_Angeles` (PST/PDT)
+- `America/Anchorage` (AKST/AKDT)
+- `Pacific/Honolulu` (HST)
+
+### Common European Timezones
+- `Europe/London` (GMT/BST)
+- `Europe/Paris` (CET/CEST)
+- `Europe/Berlin` (CET/CEST)
+- `Europe/Rome` (CET/CEST)
+- `Europe/Madrid` (CET/CEST)
+
+### Common Asian Timezones
+- `Asia/Tokyo` (JST)
+- `Asia/Shanghai` (CST)
+- `Asia/Kolkata` (IST)
+- `Asia/Dubai` (GST)
+- `Asia/Singapore` (SGT)
+
+## Contributing
+
+See the main project README for contribution guidelines.
+
+## License
+
+This project is licensed under the same terms as the parent MCP project.
\ No newline at end of file