Mcpcontentengineering

🚀 MCP ContentEngineering - Simplified

A simplified Model Context Protocol (MCP) server that enables access to raw Markdown content. This server offers a powerful tool for accessing individual Markdown files or combining multiple files from directories, all without any processing or parsing.

🚀 Quick Start

Prerequisites

• Node.js 18+ and npm
• Markdown files or directories containing .md files
• An MCP-compatible client (such as Claude Desktop, Cursor IDE, or any other MCP client)

Installation & Configuration

Option 1: Using npx from GitHub (Recommended)

No installation is required! Simply configure your MCP client:

For Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "mcp-content-engineering": {
      "command": "npx",
      "args": ["-y", "hendrickcastro/MCPContentEngineering"],
      "env": {
        "CONTENT_SOURCE_TYPE": "file",
        "CONTENT_SOURCE_PATH": "/path/to/your/business-rules.md"
      }
    }
  }
}

For Cursor IDE:

{
  "mcpServers": {
    "mcp-content-engineering": {
      "command": "npx",
      "args": ["-y", "hendrickcastro/MCPContentEngineering"],
      "env": {
        "CONTENT_SOURCE_TYPE": "directory",
        "CONTENT_SOURCE_PATH": "/path/to/your/docs/"
      }
    }
  }
}

Option 2: Local Development Installation

1. Clone and setup:

git clone https://github.com/hendrickcastro/MCPContentEngineering.git
cd MCPContentEngineering
npm install
npm run build

2. Configure content source: Create a .env file with your content configuration:

# For single file
CONTENT_SOURCE_TYPE=file
CONTENT_SOURCE_PATH=/docs/architecture-guide.md

# For directory with multiple .md files
CONTENT_SOURCE_TYPE=directory
CONTENT_SOURCE_PATH=/docs/knowledge-base/

3. Configure MCP client with local path:

{
  "mcpServers": {
    "mcp-content-engineering": {
      "command": "node",
      "args": ["path/to/MCPContentEngineering/dist/server.js"]
    }
  }
}

✨ Features

MCPContentEngineering offers 1 specialized tool for accessing Markdown content:

🔄 Raw Content Access - content_get_raw

Retrieve raw Markdown content without any processing, parsing, or indexing. Ideal for accessing business rules, documentation, or knowledge bases in their original form.

Features:

• ✅ Single File Mode: Returns the exact content of a file
• ✅ Directory Mode: Combines ALL .md files with clear separators
• ✅ Recursive Search: Finds .md files in subdirectories
• ✅ No Processing: Content is returned exactly as written
• ✅ Metadata Included: Provides file size, modification date, and source information

📦 Installation

MCPContentEngineering supports two content source types with straightforward configuration:

📋 Environment Variables

🔧 Configuration Examples

1. 📄 Single Business Rules File

Suitable for accessing a specific rules or documentation file:

{
  "mcpServers": {
    "mcp-content-engineering": {
      "command": "npx",
      "args": ["-y", "hendrickcastro/MCPContentEngineering"],
      "env": {
        "CONTENT_SOURCE_TYPE": "file",
        "CONTENT_SOURCE_PATH": "/docs/business-rules.md"
      }
    }
  }
}

2. 📁 Knowledge Base Directory

Combines all Markdown files from a documentation directory:

{
  "mcpServers": {
    "mcp-content-engineering": {
      "command": "npx",
      "args": ["-y", "hendrickcastro/MCPContentEngineering"],
      "env": {
        "CONTENT_SOURCE_TYPE": "directory",
        "CONTENT_SOURCE_PATH": "/company/knowledge-base/"
      }
    }
  }
}

3. 🏗️ Architecture Documentation

Access comprehensive architecture documentation:

{
  "mcpServers": {
    "mcp-content-engineering": {
      "command": "npx",
      "args": ["-y", "hendrickcastro/MCPContentEngineering"],
      "env": {
        "CONTENT_SOURCE_TYPE": "directory",
        "CONTENT_SOURCE_PATH": "/docs/architecture/"
      }
    }
  }
}

4. 📐 Project Standards & Patterns

Access coding standards and design patterns:

{
  "mcpServers": {
    "mcp-content-engineering": {
      "command": "npx",
      "args": ["-y", "hendrickcastro/MCPContentEngineering"],
      "env": {
        "CONTENT_SOURCE_TYPE": "file",
        "CONTENT_SOURCE_PATH": "/standards/coding-patterns.md"
      }
    }
  }
}

5. 🔄 Local Development Configuration

For local development and testing:

{
  "mcpServers": {
    "mcp-content-engineering": {
      "command": "node",
      "args": ["./MCPContentEngineering/dist/server.js"],
      "env": {
        "CONTENT_SOURCE_TYPE": "directory",
        "CONTENT_SOURCE_PATH": "./docs"
      }
    }
  }
}

💻 Usage Examples

Single File Access

// Returns exact content of business-rules.md
const result = await content_get_raw({});

console.log(result.data.content);
// Output: Raw markdown content exactly as written
// "# Business Rules\n\n## Validation Rules\n..."

console.log(result.data.source_info);
// Output: "Single file: /docs/business-rules.md"

console.log(result.data.total_files);
// Output: 1

Directory Combination

// Combines all .md files from directory
const result = await content_get_raw({});

console.log(result.data.content);
// Output: Combined content with separators:
/*
<!-- ========== ARCHIVO: rules.md ========== -->
# Business Rules
...

<!-- ========== ARCHIVO: patterns.md ========== -->
# Design Patterns
...
*/

console.log(result.data.source_info);
// Output: "Combined 2 .md files from: /docs/"

console.log(result.data.total_files);
// Output: 2

Response Structure

interface ContentResponse {
  content: string;           // Raw markdown content
  source_info: string;       // Source description
  total_files: number;       // Number of files processed
  size_bytes: number;        // Total content size
  last_modified: string;     // ISO timestamp of latest modification
}

📚 Documentation

1. 📚 Enterprise Knowledge Base

Access company documentation, policies, and procedures:

{
  "CONTENT_SOURCE_TYPE": "directory",
  "CONTENT_SOURCE_PATH": "/company/knowledge-base/"
}

2. 🏗️ Architecture Documentation

Provide AI models with architectural guidelines and patterns:

{
  "CONTENT_SOURCE_TYPE": "file",
  "CONTENT_SOURCE_PATH": "/docs/architecture-layers-summary.md"
}

3. 📐 Coding Standards

Access development standards and best practices:

{
  "CONTENT_SOURCE_TYPE": "directory",
  "CONTENT_SOURCE_PATH": "/standards/"
}

4. 🔍 Business Rules Engine

Provide specific business rules for decision-making:

{
  "CONTENT_SOURCE_TYPE": "file",
  "CONTENT_SOURCE_PATH": "/rules/validation-rules.md"
}

5. 📖 Project Documentation

Combine all project documentation for comprehensive context:

{
  "CONTENT_SOURCE_TYPE": "directory",
  "CONTENT_SOURCE_PATH": "/project/docs/"
}

🚨 Troubleshooting Common Issues

File/Directory Not Found

• Issue: File not found or Directory not found
• Solution: Verify that the path exists and is accessible
• Check: Use absolute paths for clarity

No .md Files Found

• Issue: No .md files found in directory
• Solution: Ensure that the directory contains .md files
• Note: Searches recursively in subdirectories

Permission Errors

• Issue: Permission denied when accessing files
• Solution: Ensure that you have read permissions on the files/directories
• Check: File ownership and access rights

Configuration Issues

• Issue: CONTENT_SOURCE_PATH not configured
• Solution: Set both required environment variables
• Required: CONTENT_SOURCE_TYPE and CONTENT_SOURCE_PATH

🔧 Technical Details

Project Structure

MCPContentEngineering/
├── src/
│   ├── __tests__/              # Comprehensive test suite
│   │   ├── unit.test.ts        # Unit tests with temp files
│   │   └── real.test.ts        # Real file testing
│   ├── tools/                  # Tool implementation
│   │   ├── contentOperations.ts # Single tool: content_get_raw
│   │   ├── types.ts            # Type definitions
│   │   └── index.ts            # Tool exports
│   ├── server.ts               # MCP server setup
│   ├── tools.ts                # Tool definitions and schemas
│   └── mcp-server.ts           # Tool re-exports
├── dist/                       # Compiled JavaScript output
└── package.json               # Dependencies and scripts

Key Features

• ⚡ Zero Processing: Content is returned exactly as written
• 📁 Recursive Search: Finds .md files in all subdirectories
• 🔄 File Combination: Intelligent merging with clear separators
• 📊 Rich Metadata: Comprehensive file and content information
• 🛡️ Error Handling: Robust error handling and validation
• 🔧 Simple Configuration: Just two environment variables

📝 Important Notes

⚠️ Important Note

• File Types: Only processes .md (Markdown) files
• Content Preservation: Returns content exactly as written - no processing
• Directory Mode: Recursively finds ALL .md files in subdirectories
• File Separators: Clear HTML comment separators when combining files
• Encoding: Assumes UTF-8 encoding for all files
• Security: Read-only operations only - no file modifications

🤝 Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Make your changes and add tests
4. Ensure all tests pass (npm test)
5. Commit your changes (git commit -m 'Add amazing feature')
6. Push to the branch (git push origin feature/amazing-feature)
7. Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Built with the Model Context Protocol SDK
• Uses fs-extra for file operations
• Uses glob for file discovery
• Comprehensive testing with Jest

🏷️ Tags & Keywords

Content Management: markdown documentation knowledge-base content-access raw-content file-processing text-processing document-management

MCP & AI: model-context-protocol mcp-server mcp-tools ai-tools claude-desktop cursor-ide anthropic llm-integration ai-content intelligent-content

Technology: typescript nodejs npm-package cli-tool file-system markdown-reader content-sdk text-api file-api content-connector

Use Cases: business-rules architecture-docs coding-standards project-docs knowledge-management content-retrieval documentation-access standards-access rule-engine content-automation

🎯 MCPContentEngineering provides simple, direct access to raw Markdown content through the Model Context Protocol. Perfect for AI models that need access to business rules, documentation, or knowledge bases without any processing overhead! 🚀