MyResumo is an AI-powered resume customization platform that tailors your professional profile to match specific job descriptions. By leveraging advanced natural language processing, it analyzes job requirements and adapts your resume to highlight relevant skills and experiences, significantly improving your chances of passing through Applicant Tracking Systems (ATS) and catching recruiters' attention.

• AI-Powered Resume Customization: Automatically tailors your resume content to match job requirements
• ATS Optimization: Enhances keyword matching for better visibility in applicant tracking systems
• Skills Gap Analysis: Identifies missing skills based on job descriptions
• Resume Generation: Creates formatted, professional resumes in multiple formats
• Version Management: Track different versions of your resume for various applications

Below are screenshots showcasing the main features of MyResumo:

Landing Page

The landing page introduces users to the AI-powered resume optimization service, highlighting the key benefits of using MyResumo to tailor resumes for specific job applications.

Dashboard

The user dashboard provides an overview of all your resumes, including ATS scores, last update dates, and quick access to actions like viewing, editing, downloading, or deleting each resume.

Resume Optimization

The resume optimization page analyzes your resume against job descriptions, providing detailed feedback on missing keywords, skills, and suggestions for improvement.

Resume Creation

The intuitive resume creation interface allows you to build professional resumes with AI assistance, ensuring they're optimized for both ATS systems and human reviewers.

Resume View

The resume view page displays the generated resume in a clean, professional format, ready for download.

• Backend: FastAPI, Python 3.8+
• Database: MongoDB
• Frontend: Jinja2 templates, Alpine.js, HTML/CSS
• AI Integration: Deepseek API
• Deployment: Docker
• Package Management: uv

• Python 3.8+
• Docker (for containerized deployment)
• MongoDB instance (local or remote)
• Deepseek API key

uv is a fast Python package installer and resolver:

# Install uv using pip
pip install uv

# Or using the recommended installer script
curl -LsSf https://astral.sh/uv/install.sh | sh

Options for MongoDB setup:

1. Using Docker (recommended for development):

docker run -d --name mongodb -p 27017:27017 mongo:latest

2. Local Installation:

   • MongoDB Installation Guide

3. MongoDB Atlas (Cloud Hosted):

   • Sign up for MongoDB Atlas
   • Create a free tier cluster
   • Get your connection string from the dashboard

1. Sign up at Deepseek Platform
2. Navigate to API section and generate a new key
3. Save your API key securely for the next step

Create a .env file in the project root with the following variables:

# API Configuration
API_KEY=your_api_key_here
API_BASE=https://api.deepseek.com/v1
MODEL_NAME=deepseek-chat

# Database Configuration
MONGODB_URL=mongodb://username:password@host:port/myresumo

# Build Configuration (for Docker)
CACHE_BUST=1
NO_CACHE=false
APP_VERSION=2.0.0

For more details on the project structure and configuration, see the PROJECT_LAYOUT.MD file.

The fastest way to get started is to use our official Docker image:

docker pull ghcr.io/analyticace/myresumo:latest

Run the container with your environment variables:

docker run -d --name myresumo \
  -p 8080:8080 \
  -e API_KEY=your_api_key_here \
  -e API_BASE=https://api.deepseek.com/v1 \
  -e MODEL_NAME=deepseek-chat \
  -e MONGODB_URL=mongodb://username:password@host:port/ \
  ghcr.io/analyticace/myresumo:latest

For a more complete development environment with MongoDB included, use Docker Compose:

1. Clone the repository:

git clone https://github.com/AnalyticAce/MyResumo.git
cd MyResumo

2. Create a .env file with your configuration:

API_KEY=your_api_key_here
API_BASE=https://api.deepseek.com/v1
MODEL_NAME=deepseek-chat
MONGODB_URL=mongodb://mongodb:27017/myresumo
# Build configuration
CACHE_BUST=1
NO_CACHE=false
# Application version
APP_VERSION=2.0.0

3. Start the application with Docker Compose:

docker-compose up -d

This will start both the MyResumo application and a MongoDB instance. The application will be available at http://localhost:8080.

MyResumo supports multiple AI backends to power its resume customization features:

You can easily switch between different AI providers by configuring these environment variables:

# For Deepseek (default)
API_KEY=your_deepseek_api_key
API_BASE=https://api.deepseek.com/v1
MODEL_NAME=deepseek-chat

# For OpenAI
API_KEY=your_openai_api_key
API_BASE=https://api.openai.com/v1
MODEL_NAME=gpt-4

# For other providers, configure accordingly

When running the Docker container, simply pass these environment variables:

docker run -d --name myresumo \
   -p 8080:8080 \
   -e API_KEY=your_api_key_here \
   -e API_BASE=your_provider_base_url \
   -e MODEL_NAME=your_preferred_model \
   -e MONGODB_URL=mongodb://username:password@host:port/ \
   ghcr.io/analyticace/myresumo:latest

Access the application at http://localhost:8080

1. Clone the repository:

git clone https://github.com/AnalyticAce/MyResumo.git
cd MyResumo

2. Create and activate a virtual environment:

uv venv
source .venv/bin/activate  # On macOS/Linux
.venv\Scripts\activate     # On Windows

3. Install dependencies:

uv pip install -r requirements.txt

4. Run development server:

uvicorn app.main:app --reload --host 0.0.0.0 --port 8080

5. Access the application at http://localhost:8080

Once the application is running, access the API documentation at:

• Interactive API docs: http://localhost:8080/docs
• OpenAPI specification: http://localhost:8080/openapi.json

Run the test suite with:

pytest tests/

1. Upload Your Resume: Submit your existing resume in PDF or DOCX format
2. Add Job Description: Paste the job description or upload it as a text file
3. Generate Tailored Resume: Let AI analyze and customize your resume
4. Review and Edit: Make any final adjustments to the generated content
5. Export: Download your optimized resume in your preferred format

This project uses Ruff for code linting and formatting. Ruff is a fast Python linter written in Rust that helps maintain consistent code quality across the project.

Our GitHub Actions workflow automatically runs Ruff on all Python files whenever code is pushed or a pull request is created. The workflow:

• Checks code against our style rules
• Verifies code formatting
• Reports any issues directly in the PR or commit

To run the linter locally:

1. Install Ruff:

   pip install ruff

2. Run the linter:

   ruff check .

3. Check formatting:

   ruff format --check .

4. Auto-format code:

   ruff format .

Our configuration (in pyproject.toml) enforces:

• Google-style docstrings
• Import sorting
• Standard Python code style conventions

Contributions are welcome! Please check the contribution guidelines for more details.

1. Fork the repository
2. Create a feature branch: git checkout -b feature/amazing-feature
3. Commit your changes: git commit -m 'feat: add amazing feature'
4. Push to the branch: git push origin feature/amazing-feature
5. Open a pull request

• Multi-language support
• Resume analytics dashboard
• Get personalized resume advice through conversational AI
• Interview preparation suggestions
• Cover letter generation
• Integration with job search platforms
• Enhanced PDF parsing and extraction

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

DOSSEH Shalom - LinkedIn - GitHub

Project Link: https://github.com/AnalyticAce/MyResumo