mcp-as-a-resume

BradWebb101/mcp-as-a-resume

3.1

If you are the rightful owner of mcp-as-a-resume and would like to certify it and/or have it hosted online, please leave a comment on the right or send an email to dayong@mcphub.com.

MCP as a Resume transforms a static resume into a dynamic, queryable API using the Model Context Protocol, making professional profiles interactive and always up-to-date.

Tools
5
Resources
0
Prompts
0

MCP as a Resume (MaaR)

Transforming a static resume into a living, queryable API using the Model Context Protocol

Live Endpoint: https://www.bradwebb101.com/about-me/mcp

What is This?

MCP as a Resume reimagines professional profiles for an AI-native world. Instead of maintaining a static PDF that needs manual updates, this project exposes your professional information through the Model Context Protocol (MCP) - making it queryable, always current, and interactive.

When AI agents or applications want to know about your skills, articles, or projects, they simply call a function and get structured data. No parsing, no guessing, no ambiguity.

Architecture

Built entirely on AWS serverless architecture:

  • AWS Lambda (Docker/ARM64) - Hosts the MCP server with Python 3.13
  • CloudFront - Global distribution and HTTPS termination
  • DynamoDB - Stores contact info and skillset data
  • Amazon SES - Handles email communication
  • Route53 - DNS management
  • AWS CDK - Infrastructure as Code (TypeScript)

The Lambda function intelligently routes requests:

  • GET requests → Beautiful landing page for humans
  • POST requests → MCP JSON-RPC for machines

Features

Read Operations (4 tools)

getContactInfo()

  • Retrieves contact details, social profiles, and professional links
  • Sourced from DynamoDB for instant updates

getArticles()

  • Fetches latest Medium articles via RSS feed
  • Real-time sync with published content

getSkillset()

  • Returns technical skills, certifications, and specializations
  • Structured for easy AI parsing

getGithubRepos()

  • Pulls 5 most recent GitHub repositories with metadata
  • Live data directly from GitHub API

Write Operation (1 tool)

sendEmailToBrad()

  • Enables direct communication through the MCP interface
  • Uses AWS SES with reply-to support
  • Demonstrates MCP's action capabilities beyond data retrieval

Tech Stack

Languages:

  • TypeScript (Infrastructure)
  • Python 3.13 (Lambda runtime)

AWS Services:

  • Lambda, CloudFront, DynamoDB, SES, Route53
  • All defined with AWS CDK

Dependencies:

  • awslabs-mcp-lambda-handler - MCP protocol implementation
  • boto3 - AWS SDK for Python
  • requests - HTTP client for external APIs

Prerequisites

  • AWS Account with credentials configured
  • Node.js & npm (for CDK)
  • Docker (for Lambda container builds)
  • AWS CDK CLI: npm install -g aws-cdk

Setup

1. Clone and Install

git clone <repository>
cd resume_mcp
npm install

2. Configure Environment

Create a .env file in the project root:

DOMAIN_NAME=yourdomain.com
HOSTED_ZONE_ID=Z1234567890ABC
GITHUB_USERNAME=yourusername
MEDIUM_USERNAME=yourusername
RECIPIENT_EMAIL=your@email.com
VERIFIED_SENDER_EMAIL=your@email.com

3. Verify SES Email

aws ses verify-email-identity \
  --email-address your@email.com \
  --region eu-west-1

Check your email and click the verification link.

4. Deploy

npx cdk deploy

The CDK will:

  • Build and publish the Docker container to ECR
  • Create the Lambda function
  • Set up DynamoDB table
  • Configure IAM roles and permissions
  • Deploy the Lambda Function URL

Add Data to DynamoDB

Contact Information

Go to AWS Console → DynamoDB → McpResumeTable → Create Item:

{
  "category": {"S": "contact"},
  "name": {"S": "Your Name"},
  "email": {"S": "your@email.com"},
  "github_url": {"S": "https://github.com/username"},
  "linkedin_url": {"S": "https://linkedin.com/in/username"},
  "medium_url": {"S": "https://medium.com/@username"}
}

Skillset

{
  "category": {"S": "skillset"},
  "programming_languages": {"L": [
    {"S": "Python"},
    {"S": "TypeScript"}
  ]},
  "cloud_platforms": {"L": [
    {"S": "AWS CDK"},
    {"S": "Lambda"}
  ]},
  "certifications": {"L": [
    {"S": "AWS Solutions Architect"}
  ]}
}

Usage

Access in Browser

Visit https://www.bradwebb101.com/about-me/mcp to see the landing page.

Query from MCP Client

Add to your MCP client configuration:

{
  "mcpServers": {
    "brads-resume": {
      "url": "https://www.bradwebb101.com/about-me/mcp",
      "transport": {
        "type": "streamable-http"
      }
    }
  }
}

Test with cURL

List all tools:

curl -X POST https://www.bradwebb101.com/about-me/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tools/list","params":{},"id":1}'

Get contact info:

curl -X POST https://www.bradwebb101.com/about-me/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"getContactInfo","arguments":{}},"id":1}'

Send an email:

curl -X POST https://www.bradwebb101.com/about-me/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"sendEmailToBrad","arguments":{"sender_name":"John Doe","sender_email":"john@example.com","message":"Great MCP server!","subject":"Hello"}},"id":1}'

Project Structure

resume_mcp/
├── bin/
│   └── resume-mcp.ts          # CDK app entry point
├── lib/
│   └── resume-mcp-stack.ts    # Infrastructure definition
├── lambda/
│   ├── main.py                # MCP server implementation
│   ├── Dockerfile             # Container configuration
│   └── requirements.txt       # Python dependencies
├── cdk.json                   # CDK configuration
├── package.json               # Node dependencies
└── .env                       # Environment variables (not committed)

CDK Commands

  • npm run build - Compile TypeScript to JavaScript
  • npm run watch - Watch for changes and compile
  • npm run test - Run Jest unit tests
  • npx cdk deploy - Deploy stack to AWS
  • npx cdk diff - Compare deployed vs current state
  • npx cdk synth - Generate CloudFormation template
  • npx cdk destroy - Remove all resources

Cost Optimization

This serverless architecture is extremely cost-efficient:

  • Lambda: Pay per invocation (~$0.20/million requests)
  • DynamoDB: Provisioned at minimum (1 RCU/WCU)
  • CloudFront: 1TB free tier monthly
  • SES: 62,000 free emails/month

Expected monthly cost for personal use: < $1

Security

  • Lambda Function URL uses NONE auth for public accessibility
  • CloudFront provides DDoS protection and rate limiting
  • SES sandbox mode requires email verification
  • All IAM permissions follow least privilege principle
  • No credentials stored in code (uses environment variables)

Why MCP as a Resume?

Traditional resumes are:

  • ❌ Static documents requiring manual updates
  • ❌ Difficult for machines to parse accurately
  • ❌ One-way information broadcast (read-only)
  • ❌ Version controlled across multiple platforms

MCP as a Resume is:

  • ✅ Always up-to-date (pulls from live sources)
  • ✅ Machine-native structured data
  • ✅ Interactive (supports write operations)
  • ✅ Single source of truth

Future Enhancements

  • Add more data sources (Twitter, YouTube, etc.)
  • Implement caching for external API calls
  • Add analytics to track tool usage
  • Create resources in addition to tools
  • Support multiple resume versions (technical vs general)
  • Add OpenAPI/Swagger documentation endpoint

Contributing

This is a personal project, but feel free to fork and adapt for your own MCP resume!

License

MIT License - Feel free to use this as inspiration for your own MCP projects

Author

Brad Webb

Current Role: Serverless AWS Developer - AI Center of Excellence at PostNL

Built with ❤️ using AWS CDK, Lambda, and the Model Context Protocol