This document provides visual diagrams showing the architecture and data flow of the Resume Processor MCP integration with Claude Desktop.
C4Context
title System Context Diagram - Resume Processor MCP Integration
Person(user, "User", "Creates and processes resumes using natural language")
System_Boundary(claude_system, "Claude Desktop Environment") {
System(claude_app, "Claude Desktop", "AI assistant application with MCP support")
}
System_Boundary(mcp_system, "Resume Processor MCP System") {
System(mcp_server, "MCP Server", "Go-based server implementing MCP protocol")
System(processing_pipeline, "Processing Pipeline", "Resume conversion and analysis tools")
}
System_Boundary(external_tools, "External Dependencies") {
System_Ext(pandoc, "Pandoc", "Document converter")
System_Ext(pdflatex, "PDFLaTeX", "PDF generator")
System_Ext(python, "Python", "LinkedIn template generator")
}
System_Boundary(output_system, "Output System") {
SystemDb(file_storage, "File Storage", "Generated PDFs, LaTeX, LinkedIn templates")
}
Rel(user, claude_app, "Requests resume processing")
Rel(claude_app, mcp_server, "MCP protocol (stdio)")
Rel(mcp_server, processing_pipeline, "Tool invocation")
Rel(processing_pipeline, pandoc, "Markdown → LaTeX")
Rel(processing_pipeline, pdflatex, "LaTeX → PDF")
Rel(processing_pipeline, python, "LinkedIn generation")
Rel(processing_pipeline, file_storage, "Stores generated files")
Rel(mcp_server, claude_app, "Processing results")
Rel(claude_app, user, "Formatted response with file info")
C4Container
title Container Diagram - MCP Server Internal Architecture
Person(user, "User")
System_Ext(claude, "Claude Desktop")
Container_Boundary(mcp_container, "Resume Processor MCP Server") {
Container(cli_interface, "CLI Interface", "Cobra", "Command-line interface and argument parsing")
Container(mcp_handler, "MCP Protocol Handler", "Go/JSON-RPC", "Handles MCP protocol communication")
Container(tool_router, "Tool Router", "Go", "Routes tool calls to appropriate handlers")
Container(processor_service, "Processor Service", "Go", "Manages resume processing workflow")
Container(docker_manager, "Docker Manager", "Go", "Handles containerized processing")
Container(local_manager, "Local Manager", "Go", "Handles local script execution")
}
Container_Boundary(pipeline_container, "Processing Pipeline") {
Container(pipeline_scripts, "Pipeline Scripts", "Bash/Python", "Core processing logic")
Container(pandoc_wrapper, "Pandoc Wrapper", "Bash", "Markdown to LaTeX conversion")
Container(latex_processor, "LaTeX Processor", "Bash/PDFLaTeX", "LaTeX to PDF conversion")
Container(linkedin_generator, "LinkedIn Generator", "Python", "LinkedIn template creation")
}
ContainerDb(temp_storage, "Temporary Storage", "File System", "Processing workspace")
ContainerDb(output_storage, "Output Storage", "File System", "Generated files")
ContainerDb(log_storage, "Log Storage", "File System", "Processing logs")
Rel(user, claude, "Natural language requests")
Rel(claude, cli_interface, "stdio MCP communication")
Rel(cli_interface, mcp_handler, "Parse commands")
Rel(mcp_handler, tool_router, "Route tool calls")
Rel(tool_router, processor_service, "Execute processing")
Rel(processor_service, docker_manager, "Use Docker", "if available")
Rel(processor_service, local_manager, "Use local", "fallback")
Rel(docker_manager, pipeline_scripts, "Container execution")
Rel(local_manager, pipeline_scripts, "Direct execution")
Rel(pipeline_scripts, pandoc_wrapper, "MD → LaTeX")
Rel(pipeline_scripts, latex_processor, "LaTeX → PDF")
Rel(pipeline_scripts, linkedin_generator, "LinkedIn templates")
Rel(processor_service, temp_storage, "Working files")
Rel(pipeline_scripts, output_storage, "Generated files")
Rel(mcp_handler, log_storage, "Activity logs")
graph TD
subgraph "User Interface Layer"
A[User Input] --> B[Claude Desktop]
end
subgraph "Communication Layer"
B --> C[MCP Protocol]
C --> D[JSON-RPC Messages]
end
subgraph "MCP Server Core"
D --> E[Message Router]
E --> F{Message Type}
F -->|initialize| G[Initialize Handler]
F -->|tools/list| H[Tools Handler]
F -->|tools/call| I[Tool Execution]
F -->|resources/list| J[Resources Handler]
F -->|prompts/get| K[Prompts Handler]
end
subgraph "Processing Engine"
I --> L[Processor Service]
L --> M{Processing Mode}
M -->|Docker Available| N[Docker Execution]
M -->|Local Only| O[Local Execution]
N --> P[Container Runtime]
O --> P
end
subgraph "Pipeline Execution"
P --> Q[process_resume.sh]
Q --> R[Pandoc: MD→LaTeX]
Q --> S[PDFLaTeX: LaTeX→PDF]
Q --> T[Python: LinkedIn Templates]
end
subgraph "Output Management"
R --> U[File Collection]
S --> U
T --> U
U --> V[Manifest Generation]
V --> W[Result Packaging]
end
subgraph "Response Chain"
W --> X[MCP Response]
X --> Y[Claude Processing]
Y --> Z[User Display]
end
style A fill:#e1f5fe
style Z fill:#e8f5e8
style P fill:#f3e5f5
style U fill:#fff3e0
flowchart TB
subgraph "Input Stage"
I1[User Resume Content]
I2[Processing Parameters]
I3[Output Format Preferences]
end
subgraph "Validation & Setup"
V1[Content Validation]
V2[Parameter Parsing]
V3[Environment Setup]
V4[Temp Directory Creation]
end
subgraph "Processing Core"
P1[Markdown Processing]
P2[LaTeX Generation]
P3[PDF Compilation]
P4[LinkedIn Template Creation]
end
subgraph "Quality Control"
Q1[File Validation]
Q2[Content Verification]
Q3[Error Detection]
end
subgraph "Output Generation"
O1[PDF Files]
O2[LaTeX Source]
O3[LinkedIn Templates]
O4[Processing Manifest]
O5[Log Files]
end
subgraph "Response Formatting"
R1[Result Aggregation]
R2[Metadata Generation]
R3[User-Friendly Summary]
end
I1 --> V1
I2 --> V2
I3 --> V2
V1 --> V3
V2 --> V3
V3 --> V4
V4 --> P1
P1 --> P2
P2 --> P3
P1 --> P4
P2 --> Q1
P3 --> Q1
P4 --> Q2
Q1 --> Q3
Q2 --> Q3
Q3 --> O1
Q3 --> O2
Q3 --> O3
Q3 --> O4
Q3 --> O5
O1 --> R1
O2 --> R1
O3 --> R1
O4 --> R2
O5 --> R2
R1 --> R3
R2 --> R3
style I1 fill:#e3f2fd
style R3 fill:#e8f5e8
style P1 fill:#f3e5f5
style P2 fill:#f3e5f5
style P3 fill:#f3e5f5
style P4 fill:#f3e5f5
classDiagram
class MCPServer {
-logger Logger
-processor ProcessorService
-initialized bool
-clientInfo ClientInfo
+Start(address string) error
+StartStdio() error
+handleMessage(msg Message) Message
+initialize() InitializeResult
+listTools() ToolsListResult
+callTool(name string, args object) ToolResult
}
class ProcessorService {
-workDir string
-scriptsDir string
+ProcessResume(req ProcessRequest) ProcessResult
+AnalyzeResume(content string) ResumeAnalysis
+GetProcessingStatus(id string) ProcessResult
+ListTemplates() []string
}
class Message {
+jsonrpc string
+id any
+method string
+params object
+result object
+error RPCError
}
class InitializeResult {
+protocolVersion string
+capabilities ServerCapabilities
+serverInfo ServerInfo
}
class ServerCapabilities {
+logging object
+tools ToolsCapability
+resources ResourcesCapability
+prompts PromptsCapability
}
class ToolsCapability {
+listChanged bool
}
class Tool {
+name string
+description string
+inputSchema JSONSchema
}
class ToolsListResult {
+tools Tool[]
}
class ToolResult {
+content Content[]
+isError bool
}
class ProcessRequest {
+resumeContent string
+resumeFilename string
+outputFormats string[]
+options object
}
class ProcessResult {
+status string
+processedAt string
+processingID string
+files ProcessedFile[]
+logs string[]
+error string
}
class ProcessedFile {
+name string
+path string
+size number
+type string
}
class ResumeAnalysis {
+wordCount number
+sections string[]
+skills string[]
+summary string
}
class RPCError {
+code number
+message string
+data object
}
class Content {
+type string
+text string
}
%% Core Relationships
MCPServer --> ProcessorService
MCPServer --> Message
MCPServer --> Tool
MCPServer --> InitializeResult
%% Service Dependencies
ProcessorService --> ProcessRequest
ProcessorService --> ProcessResult
ProcessorService --> ResumeAnalysis
%% MCP Protocol Structure
InitializeResult --> ServerCapabilities
ServerCapabilities --> ToolsCapability
ToolsListResult --> Tool
ToolResult --> Content
Message --> RPCError
ProcessResult --> ProcessedFile
graph TB
subgraph "Project Root Directory"
PR[/path/to/your/resume/]
subgraph "Core Files"
CF1[resume-processor-mcp - Binary]
CF2[go.mod - Dependencies]
CF3[Makefile - Build System]
end
subgraph "Source Code"
SC1[cmd/server/main.go]
SC2[pkg/mcp/types.go]
SC3[pkg/processor/service.go]
SC4[pkg/server/server.go]
end
subgraph "Pipeline Scripts"
PS1[process_resume.sh]
PS2[scripts/linkedin_template_generator.py]
PS3[requirements.txt]
PS4[scripts/ - Directory]
end
subgraph "Configuration"
C1[~/.claude/config.json]
C2[mcp-config.json]
C3[claude-desktop-config.json]
end
subgraph "Documentation"
D1[README-MCP.md]
D2[CLAUDE-INTEGRATION-GUIDE.md]
D3[CLAUDE-WORKFLOW-DIAGRAMS.md]
D4[ARCHITECTURE-OVERVIEW.md]
end
subgraph "Runtime Files"
RF1[tmp/proc_*/input/]
RF2[tmp/proc_*/output/]
RF3[claude-mcp.log]
RF4[processing_manifest.json]
end
PR --> CF1
PR --> CF2
PR --> CF3
PR --> SC1
PR --> SC2
PR --> SC3
PR --> SC4
PR --> PS1
PR --> PS2
PR --> PS3
PR --> PS4
PR --> D1
PR --> D2
PR --> D3
PR --> D4
C1 -.-> CF1
RF1 -.-> PS1
RF2 -.-> PS1
RF3 -.-> CF1
end
style PR fill:#f9f9f9
style CF1 fill:#e8f5e8
style C1 fill:#fff3e0
style RF3 fill:#ffebee
graph TB
subgraph "Input Validation Layer"
IV1[Content Sanitization]
IV2[Parameter Validation]
IV3[File Path Checking]
IV4[Size Limits]
end
subgraph "Process Isolation"
PI1[Temporary Directories]
PI2[Process Sandboxing]
PI3[Resource Limits]
PI4[Cleanup Procedures]
end
subgraph "File System Security"
FS1[Path Traversal Prevention]
FS2[Permission Controls]
FS3[Secure Temp Files]
FS4[Log File Protection]
end
subgraph "Communication Security"
CS1[MCP Protocol Validation]
CS2[JSON Schema Validation]
CS3[Error Information Filtering]
CS4[Log Sanitization]
end
subgraph "Runtime Security"
RS1[Non-Root Execution]
RS2[Docker Isolation]
RS3[Environment Variable Controls]
RS4[Signal Handling]
end
IV1 --> PI1
IV2 --> PI2
IV3 --> FS1
IV4 --> PI3
PI1 --> FS3
PI2 --> RS1
PI3 --> RS2
PI4 --> FS3
FS1 --> CS1
FS2 --> CS2
FS4 --> CS4
CS1 --> RS3
CS2 --> RS4
CS3 --> RS4
style IV1 fill:#ffebee
style PI2 fill:#e8f5e8
style FS1 fill:#fff3e0
style CS1 fill:#e1f5fe
style RS1 fill:#f3e5f5
graph LR
subgraph "Performance Monitoring"
PM1[Request Timing]
PM2[Memory Usage]
PM3[CPU Utilization]
PM4[Disk I/O Metrics]
end
subgraph "Optimization Strategies"
OS1[Concurrent Processing]
OS2[Resource Pooling]
OS3[Caching Mechanisms]
OS4[Cleanup Automation]
end
subgraph "Scalability Features"
SF1[Stateless Design]
SF2[Process Isolation]
SF3[Horizontal Scaling]
SF4[Load Distribution]
end
subgraph "Resource Management"
RM1[Memory Limits]
RM2[Timeout Controls]
RM3[Cleanup Procedures]
RM4[Error Recovery]
end
PM1 --> OS1
PM2 --> OS2
PM3 --> OS3
PM4 --> OS4
OS1 --> SF1
OS2 --> SF2
OS3 --> SF3
OS4 --> SF4
SF1 --> RM1
SF2 --> RM2
SF3 --> RM3
SF4 --> RM4
style PM1 fill:#e3f2fd
style OS1 fill:#e8f5e8
style SF1 fill:#fff3e0
style RM1 fill:#f3e5f5
graph TB
subgraph "Developer Machine"
DM1[Claude Desktop App]
DM2[MCP Server Binary]
DM3[Local Dependencies]
DM4[Processing Scripts]
DM1 --> DM2
DM2 --> DM3
DM2 --> DM4
end
style DM1 fill:#e1f5fe
style DM2 fill:#e8f5e8
graph TB
subgraph "Host System"
HS1[Claude Desktop App]
subgraph "Docker Container"
DC1[MCP Server]
DC2[Pipeline Tools]
DC3[Dependencies]
DC1 --> DC2
DC1 --> DC3
end
HS1 --> DC1
end
style HS1 fill:#e1f5fe
style DC1 fill:#e8f5e8
graph TB
subgraph "Client Machine"
CM1[Claude Desktop App]
end
subgraph "Remote Server"
RS1[MCP Server]
RS2[Processing Pipeline]
RS3[File Storage]
RS1 --> RS2
RS1 --> RS3
end
CM1 -.->|WebSocket| RS1
style CM1 fill:#e1f5fe
style RS1 fill:#e8f5e8
sequenceDiagram
User->>Claude: Resume request
Claude->>MCP: Direct tool call
MCP->>Pipeline: Process resume
Pipeline->>MCP: Results
MCP->>Claude: Formatted response
Claude->>User: Final output
sequenceDiagram
User->>Claude: Resume request
Claude->>MCP: Start processing
MCP->>Pipeline: Background process
MCP->>Claude: Processing ID
Claude->>User: "Processing started..."
Note over Pipeline: Processing continues
User->>Claude: Check status
Claude->>MCP: Status request
MCP->>Claude: Current status
Claude->>User: Status update
sequenceDiagram
User->>Claude: Multiple resumes
Claude->>MCP: Batch request
loop For each resume
MCP->>Pipeline: Process resume
Pipeline->>MCP: Individual result
end
MCP->>Claude: Batch results
Claude->>User: Summary + files
flowchart TD
subgraph "Error Detection"
ED1[Input Validation Errors]
ED2[Processing Errors]
ED3[System Errors]
ED4[Communication Errors]
end
subgraph "Error Classification"
EC1{Error Type}
EC1 -->|User Error| EC2[Validation Failed]
EC1 -->|System Error| EC3[Internal Error]
EC1 -->|External Error| EC4[Dependency Failed]
end
subgraph "Error Handling"
EH1[Log Error Details]
EH2[Cleanup Resources]
EH3[Format User Message]
EH4[Return Error Response]
end
subgraph "Recovery Actions"
RA1[Retry Logic]
RA2[Fallback Methods]
RA3[Graceful Degradation]
RA4[User Notification]
end
ED1 --> EC1
ED2 --> EC1
ED3 --> EC1
ED4 --> EC1
EC2 --> EH1
EC3 --> EH1
EC4 --> EH1
EH1 --> EH2
EH2 --> EH3
EH3 --> EH4
EH4 --> RA1
EH4 --> RA2
EH4 --> RA3
EH4 --> RA4
style ED1 fill:#ffebee
style EH1 fill:#fff3e0
style RA1 fill:#e8f5e8
This architecture overview provides visual documentation of the Resume Processor MCP system, covering:
- System Architecture: High-level component relationships
- Data Flow: How information moves through the system
- Security Design: Protection mechanisms and validation
- Performance Characteristics: Optimization and scalability
- Deployment Options: Various installation patterns
- Error Handling: Error management
These diagrams serve as both implementation guides and troubleshooting references, making the system easier to understand, maintain, and extend.
📧 Support: info@opensystemslab.com 📚 Related Documentation:
CLAUDE-WORKFLOW-DIAGRAMS.md- Detailed sequence diagramsREADME-MCP.md- Implementation guideCLAUDE-INTEGRATION-GUIDE.md- Setup instructions