Resume Processing Pipeline

Resume Management System with Model Context Protocol (MCP) Integration
Open Systems Lab - info@opensystemslab.com

🚀 Overview

Pipeline that transforms Markdown resumes into multiple formats using AI processing, containerized workflows, and DevOps practices.

Project Motivation

This project addresses the need to reformat Markdown resumes with custom LaTeX styles and fonts, while generating text-based formats for easy copy-paste integration with LinkedIn profiles. The implementation applies DevOps practices through:

• CI/CD Pipeline: Automated workflow for consistent resume processing

• Model Context Protocol (MCP): Integration for agentic applications with AI platforms

• Testing Infrastructure: Validation using the ACT tool for GitHub Actions workflows

This capstone project demonstrates the application of DevOps methodology and MCP extensions to personal document management, combining traditional document processing with modern AI integration and automated testing practices.

Features

• AI Processing: MCP server with Claude integration for resume analysis

• Multi-Format Output: PDF (LaTeX), LinkedIn templates, clean text formats

• Automated CI/CD: GitHub Actions pipeline with Docker containerization

• Local Testing: Test suite with ACT integration

• Production Ready

Related MCP server: resume-onepage-autofit-mcp

📚 Documentation

🏗️ Architecture

• Architecture Overview - System design and component relationships

• MCP Implementation - Model Context Protocol server details

🔗 Integration

• Claude Integration Guide - Setting up Claude AI with MCP

• Cursor IDE Integration - Development environment setup

• MCP Server Setup - MCP server configuration

📖 Guides

• Quick Start Guide - Get started in 5 minutes

• Workflow Diagrams - Visual process flows

• Documentation Index - Documentation reference

🧪 Testing

• Testing Overview - Test scripts and usage

• ACT Testing Guide - Local GitHub Actions testing

📝 Samples

• Sample Resume - Template and examples

🚀 Quick Start

Prerequisites

• Docker

• Go (for MCP server)

• Git

Option 1: MCP Server Mode (Recommended)

# Build MCP server
make build

# Run tests
make test-all

# Start MCP server
make run

# Test MCP functionality  
make test-mcp

Option 2: Docker Pipeline

# Build container
docker build -t resume-processor .

# Process resume
docker run --rm \
  -v "$(pwd)/input:/workspace/input:ro" \
  -v "$(pwd)/output:/workspace/output" \
  resume-processor

Option 3: Direct Script Processing

# Process resume with local script
make process-resume

🛠️ Development

Available Make Targets

Building:

make build              # Build MCP server binary
make build-all          # Build for all platforms
make docker-build       # Build Docker image

Testing:

make test               # Run unit tests
make test-all           # Run all tests (unit + integration)
make test-mcp           # Test MCP server functionality
make test-act           # Test GitHub Actions locally
make test-integration   # Run integration test suite

Running:

make run                # Start MCP server (HTTP mode)
make run-stdio          # Start MCP server (stdio mode)
make process-resume     # Run resume processing script

Setup:

make pipeline-setup     # Install dependencies
make integration-setup  # Verify scripts setup
make mcp-setup          # Configure MCP for Claude

🏗️ Project Structure

resume/
├── README.md                     # This file
├── Makefile                      # Build and test automation
├── Dockerfile                    # Container definition
├── go.mod, go.sum               # Go dependencies
├── cmd/server/                   # MCP server entry point
├── pkg/                         # Go packages
│   ├── mcp/                     # MCP protocol implementation
│   ├── processor/               # Resume processing logic
│   └── server/                  # HTTP server implementation
├── scripts/                     # Processing scripts
│   ├── process_resume.sh        # Main processing script
│   ├── linkedin_template_generator.py
│   ├── requirements.txt
│   └── testing/                 # Test scripts
│       ├── README.md            # Testing documentation
│       ├── run-tests.sh         # Main test runner
│       ├── test-mcp.sh          # MCP server tests
│       └── test-act.sh          # ACT pipeline tests
├── docs/                        # Documentation
│   ├── architecture/            # System architecture docs
│   ├── integration/             # Integration guides
│   ├── guides/                  # User guides
│   ├── testing/                 # Testing documentation
│   └── samples/                 # Example files
├── local/                       # Local resume files
├── .github/workflows/           # CI/CD pipeline
└── .vscode/                     # VS Code configuration

🎯 Output Formats

PDF Resume

• LaTeX formatting via Pandoc

• Multi-page support with pagination

• Typography optimized for ATS systems

LinkedIn Templates

• Headline: 220 character summary

• About Section: 2600 character summary

• Experience Entries: Formatted job descriptions

• Skills Categories: Organized technical competencies

• Clean text format (no emojis/special characters)

AI Analysis

• Resume content extraction and analysis

• Skills categorization and gap analysis

• ATS optimization recommendations

• Industry-specific customizations

🔧 Configuration

First-Time Setup

The repository includes template files for local configuration:

1. Claude Desktop Configuration:

cp claude-desktop-config.json.template claude-desktop-config.json
# Edit paths to match your system

2. ACT Configuration (for local GitHub Actions testing):

cp .actrc.template .actrc
# Customize as needed

3. Secrets (for testing with tokens):

cp .secrets.template .secrets
# Add your GitHub token

MCP Server Configuration

After copying the template, update claude-desktop-config.json with your actual paths:

{
  "mcpServers": {
    "resume-processor": {
      "command": "/your/actual/path/to/resume-processor-mcp",
      "args": ["stdio", "--work-dir", "/your/actual/path/to/resume/directory"],
      "env": {
        "WORK_DIR": "/your/actual/path/to/resume/directory"
      }
    }
  }
}

Environment Variables

• WORK_DIR: Working directory for resume processing

• LOG_LEVEL: Logging level (debug, info, warn, error)

• PORT: HTTP server port (default: 8080)

Note: Configuration files are in .gitignore to keep personal paths private.

🚀 CI/CD Integration

GitHub Actions Workflow

• Triggers: Push to resume files, manual dispatch

• Processing: Automated PDF and LinkedIn template generation

• Artifacts: 90-day retention with downloadable outputs

• Branches: main, master, develop

Local Testing with ACT

# Install ACT
brew install act

# Test workflows locally
make test-act

# Full workflow test with Docker
make test-act-full

📞 Support & Contact

Open Systems Lab
📧 Email: info@opensystemslab.com
🌐 Resume processing solutions

Getting Help

1. Check the documentation for your specific use case

2. Review testing guides for troubleshooting

3. Run make help for available commands

4. Contact us for enterprise support

📝 License

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

Tooling by Open Systems Lab.

Resume processing with AI integration 🎯

🔄 Recent Updates

• ✅ MCP Integration: Added Claude AI integration via Model Context Protocol

• ✅ Testing Framework: Test suite with ACT support

• ✅ Documentation: Organized docs structure with guides

• ✅ Project Cleanup: Streamlined structure with proper script organization

• ✅ Makefile Enhancement: Added build and test targets