MCP-Resume-AWS

vsiwach/MCP-Resume-AWS

3.2

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

The Personal Resume Agent is an AI-driven tool that processes resumes and provides intelligent responses about professional backgrounds through a Model Context Protocol (MCP) server interface.

Tools
4
Resources
0
Prompts
0

Personal Resume Agent

A personalized AI agent that reads your resume and provides intelligent responses about your professional background. Supports both local MCP (Model Context Protocol) integration with Claude Desktop and deployment to the NANDA (Network of Autonomous Decentralized Agents) for Agent-to-Agent (A2A) communication.

Features

Core Capabilities

  • Resume Processing: Automatically reads and processes resume files (PDF, DOCX, TXT, MD)
  • RAG System: Uses ChromaDB and sentence transformers for intelligent content retrieval
  • MCP Server: Exposes functionality through standardized MCP protocol for Claude Desktop
  • Skill Matching: Analyzes how well your skills match job requirements
  • Natural Language Interface: Ask questions about your experience, skills, education, etc.

NANDA Network Integration

  • A2A Communication: Connect with 484+ agents in the NANDA network
  • Agent-to-Agent Messaging: Your resume agent can communicate with other specialized agents
  • AWS Deployment: Production-ready deployment on EC2 with supervisor
  • Interactive Dashboards: CLI tools for sending tasks, viewing messages, and chatting with agents
  • Network Discovery: Registered in NANDA registry for agent discoverability

Quick Start

Local Development (MCP Server)

  1. Install Dependencies

    pip install -r requirements.txt

  2. Add Your Resume

    # Place your resume files in the data/ directory
cp your-resume.pdf data/

  3. Test the Agent

    cd src
python personal_resume_agent.py

  4. Run as MCP Server

    cd src
python mcp_resume_server.py

NANDA Network Deployment (A2A)

  1. Deploy to AWS EC2

    # Configure deployment script with your details
./deploy_aws_nest.sh

  2. Upload Resume Files

    ./upload_resume.sh

  3. Verify Deployment

    # Check agent status
ssh ubuntu@<your-ec2-ip> "sudo supervisorctl status resume-agent"

  4. Use Interactive Dashboards

    # Send tasks to your agent
python3 send_task.py

# View incoming messages
python3 view_messages.py --monitor

# Chat with other agents in NANDA network
python3 agent_chat.py

Project Structure

personal-resume-agent/
├── src/                          # Core source code
│   ├── resume_rag.py            # RAG system (ChromaDB + embeddings)
│   ├── personal_resume_agent.py # Main agent logic
│   └── mcp_resume_server.py     # MCP server for Claude Desktop
│
├── NANDA Integration
│   ├── nest_resume_agent.py     # NANDA-compatible agent wrapper
│   ├── deploy_aws_nest.sh       # AWS EC2 deployment script
│   └── upload_resume.sh         # Resume file upload script
│
├── Interactive Dashboards
│   ├── send_task.py             # Send tasks to resume agent
│   ├── view_messages.py         # View incoming A2A messages
│   └── agent_chat.py            # Chat with other NANDA agents
│
├── Documentation
│   ├── README.md                # This file
│   ├── DASHBOARD_GUIDE.md       # Dashboard usage guide
│   ├── A2A_CHAT_GUIDE.md        # Agent-to-Agent chat guide
│   ├── A2A_GUIDE.md             # A2A protocol documentation
│   └── MESSAGE_DASHBOARD.md     # Message viewing guide
│
├── data/                         # Resume files (gitignored)
├── tests/                        # Test files
└── requirements.txt              # Python dependencies

Usage Examples

Direct Agent Usage

from personal_resume_agent import PersonalResumeAgent

agent = PersonalResumeAgent()
await agent.initialize()

# Ask questions about your resume
result = await agent.process_query("What programming languages do I know?")
print(result['response'])

# Analyze skill match for a job
match = await agent.get_skill_match("Python, React, AWS, Docker")
print(f"Match: {match['match_percentage']}%")

MCP Server Tools

The MCP server exposes these tools:

  • query_resume: Ask questions about resume content
  • get_agent_info: Get agent capabilities and status
  • analyze_skill_match: Compare skills with job requirements
  • get_resume_summary: Get overview of resume knowledge base

Interactive Dashboards

1. Send Task Dashboard (send_task.py)

Interactive CLI for sending queries to your resume agent:

# Interactive mode
python3 send_task.py

# Direct query
python3 send_task.py "What are my technical skills?"

Features:

  • Color-coded interface
  • Session statistics tracking
  • Conversation history (last 10)
  • Loading animations
  • Special commands: /help, /history, /stats, /clear
2. Message Viewer (view_messages.py)

Monitor incoming A2A messages from other agents:

# View recent messages
python3 view_messages.py

# Real-time monitoring mode
python3 view_messages.py --monitor

# Show statistics
python3 view_messages.py --stats

# Filter by sender
python3 view_messages.py --filter tech-expert

Features:

  • Real-time message monitoring
  • Sender statistics with bar charts
  • Message filtering
  • Auto-refresh capability
3. A2A Network Chat (agent_chat.py)

Connect with 484+ agents in NANDA network:

python3 agent_chat.py

Commands:

  • /list - Show all available agents
  • /search <keyword> - Find agents by expertise
  • /info <agent-id> - View agent details
  • /chat <agent-id> - Start chatting with an agent
  • /history - View conversation history
  • /help - Show all commands

Example session:

📝 > /list
📝 > /chat tech-expert
💬 [tech-expert] > What are the key technical skills?
💬 [tech-expert] > back
📝 > /history

NANDA Network Deployment

Prerequisites

  • AWS account with EC2 access
  • SSH key pair for EC2 instances
  • NANDA framework installed locally

Step-by-Step Deployment

1. Configure Deployment Script

Edit deploy_aws_nest.sh with your details:

KEY_NAME="your-key-name"
KEY_FILE="/path/to/your-key.pem"
SECURITY_GROUP_ID="sg-xxxxxxxxx"
2. Deploy to AWS EC2
chmod +x deploy_aws_nest.sh
./deploy_aws_nest.sh

This script will:

  • Launch t3.small EC2 instance (20GB disk, CPU-optimized)
  • Install Python 3.11 and dependencies
  • Install PyTorch CPU-only version (saves ~2GB space)
  • Clone repository from GitHub
  • Configure supervisor for process management
  • Register agent in NANDA registry
3. Upload Resume Files
chmod +x upload_resume.sh
./upload_resume.sh
4. Verify Deployment
# Check agent status
ssh -i your-key.pem ubuntu@<ec2-ip> "sudo supervisorctl status resume-agent"

# View logs
ssh -i your-key.pem ubuntu@<ec2-ip> "sudo tail -f /var/log/resume-agent.log"

# Test agent endpoint
curl http://<ec2-ip>:6050/a2a \
  -H 'Content-Type: application/json' \
  -d '{"content": {"text": "What are my skills?", "type": "text"}, "role": "user", "conversation_id": "test-001"}'

NANDA Network Information

Once deployed, your agent will be:

Architecture: NANDA Deployment

┌─────────────────────────────────────────────────────────────┐
│                      NANDA Network                          │
│                  (484+ Connected Agents)                    │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       │ A2A Protocol
                       │
┌──────────────────────▼──────────────────────┐
│         AWS EC2 (t3.small)                  │
│    ┌────────────────────────────┐           │
│    │  Supervisor Process Mgr    │           │
│    └──────────┬─────────────────┘           │
│               │                             │
│    ┌──────────▼─────────────────┐           │
│    │  NANDA Adapter             │           │
│    │  (nest_resume_agent.py)    │           │
│    └──────────┬─────────────────┘           │
│               │                             │
│    ┌──────────▼─────────────────┐           │
│    │  Resume Agent + RAG        │           │
│    │  (ChromaDB + Embeddings)   │           │
│    └────────────────────────────┘           │
│                                             │
│    Port: 6050/a2a                           │
│    Registry: registry.chat39.com:6900       │
└─────────────────────────────────────────────┘

Environment Variables

Set these in your deployment:

AGENT_ID=resume-agent              # Your agent identifier
PORT=6050                          # HTTP server port
REGISTRY_URL=http://registry.chat39.com:6900  # NANDA registry
PUBLIC_URL=http://<ec2-ip>:6050   # Your agent's public URL
DATA_DIR=/home/resume/resume-agent/data  # Resume files directory

Configuration

Claude Desktop Integration

Add to your Claude Desktop config (claude_desktop_config.json):

{
  "mcpServers": {
    "personal-resume": {
      "command": "python",
      "args": ["/path/to/personal-resume-agent/src/mcp_resume_server.py"],
      "cwd": "/path/to/personal-resume-agent"
    }
  }
}

Supported File Formats

  • PDF: Extracted using PyPDF2
  • DOCX: Processed with python-docx
  • TXT/MD: Plain text files

Requirements

  • Python 3.8+
  • ChromaDB for vector storage
  • Sentence Transformers for embeddings
  • PyPDF2 for PDF processing
  • python-docx for Word documents

Privacy & Security

🔒 Important Privacy Notes:

  • All resume data is processed locally on your machine
  • No personal information is sent to external services
  • Vector database is stored locally in data/resume_vectordb/
  • The data/ directory is excluded from version control
  • Never commit personal resume files to public repositories

Architecture

Local MCP Mode

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Resume Files  │───▶│   RAG System    │───▶│   MCP Server    │
│   (PDF/DOCX)    │    │  (ChromaDB +    │    │  (Claude Tool)  │
│                 │    │  Transformers)  │    │                 │
└─────────────────┘    └─────────────────┘    └─────────────────┘
                                │
                                ▼
                       ┌─────────────────┐
                       │ Personal Resume │
                       │     Agent       │
                       │ (Query Engine)  │
                       └─────────────────┘
                                │
                                ▼
                       ┌─────────────────┐
                       │ Claude Desktop  │
                       └─────────────────┘

NANDA Network Mode

┌────────────────────────────────────────────────────────────┐
│                    NANDA Network (484+ Agents)             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │tech-     │  │python-   │  │financial-│  │ai-       │   │
│  │expert    │  │expert    │  │advisor   │  │researcher│   │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘   │
│       │             │              │             │         │
└───────┼─────────────┼──────────────┼─────────────┼─────────┘
        │             │              │             │
        └─────────────┴──────────────┴─────────────┘
                           │ A2A Protocol
                           ▼
              ┌────────────────────────┐
              │   NANDA Adapter        │
              │ (nest_resume_agent.py) │
              └────────────┬───────────┘
                           │
              ┌────────────▼───────────┐
              │   Resume Agent + RAG   │
              │  (ChromaDB + LLM)      │
              └────────────┬───────────┘
                           │
              ┌────────────▼───────────┐
              │    Resume Data Store   │
              │  (Vector Database)     │
              └────────────────────────┘

Accessible via:
- A2A Endpoint: http://<ec2-ip>:6050/a2a
- Registry: http://registry.chat39.com:6900
- Dashboard: https://index.projectnanda.org

Documentation

Comprehensive guides are available:

  • - Interactive dashboard usage

    • Send Task Dashboard
    • Message Viewer
    • Command reference and examples

  • - Agent-to-Agent communication

    • Connecting with 484+ agents
    • Chat commands and workflows
    • Use cases and examples

  • - A2A protocol details

    • Message format
    • Protocol specification
    • Integration patterns

  • - Message monitoring

    • Viewing incoming messages
    • Log analysis
    • Real-time monitoring

Contributing

  1. Fork the repository
  2. Create a feature branch
  3. Make your changes
  4. Add tests if applicable
  5. Submit a pull request

License

MIT License - See LICENSE file for details.