JustHireMe V0.1.31 is out. Github: https://github.com/vasu-devs/JustHireMe… Download: https://justhireme.ai The first post hit 390K impressions, 3.2K likes, 6K+ bookmarks, 1.2k+ GitHub stars and 400+ downloads . Genuinely didn’t expect that. I’ve been shipping updates since and this release is a big one. Full video walkthrough attached but here’s what’s new: Command Center — proper dashboard now — active leads, scores, agent status, top roles — all in one screen — no more clicking around to figure out where things stand Customize One Job — paste any job URL — agent captures the JD, scores your fit, shows keyword gaps — generates a tailored resume + cover letter as PDFs — one page, one flow Outreach Generator — every lead now comes with ready-to-copy messages — 3-line founder DM — LinkedIn connection note — cold email — all written from your real profile, not templates Knowledge Graph (rebuilt from scratch) — Relation Atlas - weighted ribbons showing how projects prove skills — Gravity Graph - force-directed career layout — 3D Orbit - rotate through your profile in 3D — Curated mode - strongest evidence paths only — this is what the matching engine actually uses to rank you Job Pipeline — stages: Hot → New → Rated → Ready → Applied → Discarded — Fit score + Quality score on every lead — search, filter, re-eval, bulk clean, export — feels like a real job search CRM now Live Activity Stream — “what is the agent thinking?” — real-time logs of every query, eval, and decision — full transparency, nothing hidden Built-in AI Assistant — ask the app how to configure sources, understand a lead, generate packages — right inside the dashboard Modular Agent Config — Scout, Evaluator, Generator, Ingestor — each one independently configurable — pick your own models and thresholds Still local-first. Still privacy-first. Still open source. Still free. Your data never leaves your machine. If you starred the repo last time — pull the new release. If you bookmarked and forgot — now’s a good time. Feedback, issues, PRs, or just a — all welcome. https://github.com/vasu-devs/JustHireMe… https://justhireme.ai #OpenSource #AgenticAI #AIAgents #GraphRAG #Python #FastAPI #ReactJS #TypeScript #Tauri #JobSearch #CareerTech #PrivacyFirst

vasu-devs/JustHireMe

Source: https://github.com/vasu-devs/JustHireMe

JustHireMe

Local-first AI job intelligence for scraping better roles, ranking fit, and generating tailored application materials.

What It Does · Workflow · Architecture · Quick Start · Agent Skill + MCP · Contributing · Roadmap

Star History

The Short Version

JustHireMe is an AGPL-licensed, local-first desktop workbench for people who are tired of noisy job boards and black-box AI apply tools.

Maintainer

JustHireMe is built and maintained by Vasudev Siddh - full-stack AI engineer, open-source builder, and the person who got tired of bad job boards and built something better.

Sponsor the project - Sponsorship keeps JustHireMe actively maintained, funds source adapter coverage, and supports the local-first architecture that makes this different from every cloud-first alternative.

Current Status

JustHireMe is in alpha. The repository is public, hackable, and ready for source-adapter, ranking, docs, and Windows packaging contributions, but it is not a polished one-click consumer product yet.

If you are new here, start with the frontend preview first. If you want to contribute backend behavior, source adapters, or packaging, use the full desktop setup below.

It helps you:

Browser automation and auto-apply code exists in the repository, but it is experimental and unsupported. The supported open-source core is scraper, ranker, vector matching, and customizer.

Visual Workflow

flowchart LR
    A["Import Resume / Profile"] --> B["Profile Graph<br/>Kuzu"]
    A --> C["Skill + Project Vectors<br/>LanceDB"]
    D["Scraper Sources"] --> E["Normalized Leads"]
    E --> F["Lead Quality Gate"]
    F --> G["Ranker + Evaluator"]
    B --> G
    C --> G
    G --> H["Lead Pipeline"]
    H --> I["Customizer"]
    I --> J["Resume PDF"]
    I --> K["Cover Letter PDF"]
    I --> L["Outreach Drafts"]

flowchart TD
    S["Source Adapter"] --> N["Normalize Lead"]
    N --> Q{"Quality Gate"}
    Q -- "Reject" --> R["Filtered with reason"]
    Q -- "Accept" --> C["Local CRM"]
    C --> E["Fit Evaluation"]
    E --> U["User Review"]

    Q:::gate
    R:::reject
    C:::store
    E:::score

    classDef gate fill:#e0f2fe,stroke:#0284c7,color:#0f172a
    classDef reject fill:#fee2e2,stroke:#dc2626,color:#0f172a
    classDef store fill:#dcfce7,stroke:#16a34a,color:#0f172a
    classDef score fill:#fef3c7,stroke:#d97706,color:#0f172a

What It Does

Why This Exists

Most job search tools make one of two mistakes:

JustHireMe takes a different path:

More signal.
More explanation.
More local control.
More contributor-friendly source adapters.
Less blind automation.

Product Principles

Architecture

flowchart TB
    subgraph Desktop["Tauri Desktop Shell"]
        UI["React + TypeScript UI"]
        Bridge["Tauri Commands<br/>Port + API Token"]
    end

    subgraph Backend["Python Backend Sidecar"]
        API["FastAPI + WebSockets"]
        Scrapers["Scraper Agents"]
        Gate["Lead Quality Gate"]
        Ranker["Ranker / Evaluator"]
        Customizer["Document + Outreach Generator"]
    end

    subgraph LocalData["Local Data Layer"]
        SQLite["SQLite CRM"]
        Kuzu["Kuzu Profile Graph"]
        LanceDB["LanceDB Vectors"]
        Files["Generated PDFs"]
    end

    UI --> Bridge --> API
    API --> Scrapers --> Gate --> SQLite
    API --> Ranker
    Ranker --> Kuzu
    Ranker --> LanceDB
    API --> Customizer --> Files
    API --> SQLite

More detail: docs/ARCHITECTURE.md

Repository Map

JustHireMe/
|-- src/                         React frontend
|   |-- components/              Shared UI components
|   |-- hooks/                   Data and websocket hooks
|   |-- settings/                Settings panels
|   `-- views/                   Main screens
|-- backend/                     Python API and agents
|   |-- agents/                  Scrapers, rankers, evaluator, generator
|   |-- db/                      SQLite, Kuzu, LanceDB helpers
|   |-- graph/                   Evaluation graph flow
|   `-- tests/                   Backend tests
|-- src-tauri/                   Tauri Rust shell
|-- docs/                        Architecture, source adapter, release docs
|-- scripts/                     Build scripts
`-- .github/                    CI, issue templates, PR template

Quick Start

Install On Windows

Use this path if you are not a developer and just want to run JustHireMe.

1. Open the latest GitHub Release.
2. Download the JustHireMe_*_x64-setup.exe installer.
3. Run the installer.
4. If Windows SmartScreen appears, click More info, then Run anyway.
5. Launch JustHireMe from the Start Menu and follow the setup wizard.

Release notes include SHA256 checksums for the installer assets. The Windows installer is built by GitHub Actions from the release tag so the published binary matches the repository source.

Requirements

Optional:

• Ollama for local model experiments
• Playwright browser dependencies only for experimental automation work

Fast Frontend Preview

Use this path if you just want to inspect the UI, design direction, or frontend code.

git clone https://github.com/vasu-devs/JustHireMe.git
cd JustHireMe
npm install
npm run dev

This starts the Vite frontend only. Backend-backed workflows may show empty, mocked, or unavailable states depending on the screen.

Full Desktop Setup

Use this path if you want the Tauri shell and Python backend sidecar.

git clone https://github.com/vasu-devs/JustHireMe.git
cd JustHireMe
npm install
cd backend
uv sync --dev
cd ..

Then run:

npm run tauri dev

The Tauri shell starts the frontend and launches the Python backend sidecar/dev process.

Before Opening An Issue

• Check whether the bug is in supported core behavior or experimental automation.
• Remove API keys, cookies, resumes, local databases, and generated private documents from logs or screenshots.
• For source requests, include a public example URL and expected normalized fields.
• For ranking bugs, include the expected score behavior and sanitized job/profile snippets.

Development Commands

Agent Skill And MCP

JustHireMe includes two reusable agent surfaces:

• An agent-neutral skill at skills/justhireme/SKILL.md
• A lightweight stdio MCP server at backend/mcp_server.py

The skill is plain Markdown with YAML frontmatter. It is written to be useful in any AI coding assistant that can load local instructions, including Claude, Codex, IDE agents, and custom agent runners. It tells an agent how to work safely inside this repository: preserve local-first behavior, keep ranking explainable, treat browser automation as experimental, and use the existing backend/frontend patterns.

Use The Skill

Point your agent or assistant at:

skills/justhireme/SKILL.md

If your agent expects skills in a separate directory, copy or symlink the skills/justhireme folder into that tool’s skill/instruction location. The skill has no runtime dependency on Codex-specific APIs.

Use The MCP Server

Install backend dependencies first:

cd backend
uv sync --dev
cd ..

Start the MCP server from the repository root on Windows:

backend\.venv\Scripts\python.exe backend\mcp_server.py

Start it on macOS/Linux:

backend/.venv/bin/python backend/mcp_server.py

The MCP server exposes:

Example MCP client configuration:

{
  "mcpServers": {
    "justhireme": {
      "command": "/absolute/path/to/JustHireMe/backend/.venv/bin/python",
      "args": ["/absolute/path/to/JustHireMe/backend/mcp_server.py"],
      "cwd": "/absolute/path/to/JustHireMe"
    }
  }
}

On Windows, use the venv interpreter at backend\\.venv\\Scripts\\python.exe. More detail: docs/MCP.md

Core Concepts

Source Adapters

Source adapters turn external job sources into normalized lead dictionaries.

flowchart LR
    A["Raw Source"] --> B["Adapter"]
    B --> C["Normalized Lead"]
    C --> D["Quality Gate"]
    D --> E["Local CRM"]

Read: docs/source-adapters.md

Quality Gate

The gate lives in backend/agents/quality_gate.py.

It checks:

Ranking

Ranking combines:

• source signal
• lead quality score
• deterministic fit rubric
• seniority caps
• project and stack evidence
• optional LLM-assisted evaluation
• semantic fit when vectors are available
• feedback learning

Vector Matching

flowchart LR
    Resume["Resume / Profile"] --> Graph["Kuzu Graph"]
    Resume --> Embed["Embeddings"]
    Embed --> Vectors["LanceDB"]
    Job["Job Description"] --> Query["Semantic Query"]
    Query --> Vectors
    Vectors --> Fit["Semantic Fit Signal"]
    Graph --> Fit

Customizer

For a strong lead, the customizer produces:

Configuration And Privacy

Settings are configured inside the desktop app. For v1, API keys are stored in local app settings.

Local data may include:

Do not share screenshots, logs, local app data, issue attachments, or database files that contain API keys, cookies, private resumes, or personal data.

Planned improvement:

• OS keychain-backed API key storage

Windows Release Build

The first public packaging target is Windows. Public installers are built and published by GitHub Actions when a v* tag is pushed.

npm run release:windows

For local smoke tests without installer bundling, use npm run release:smoke.

Release smoke test and packaging details: docs/windows-release.md

Contributing

The best first contribution path is scraper/source quality.

Start here:

Please do not open public issues with API keys, resumes, cookies, bearer tokens, or database files.

Experimental Automation

The repository contains browser automation and auto-apply code for experimentation and future plugin work.

Roadmap

timeline
    title JustHireMe Open-Source Roadmap
    v0.1 : Open-source readiness
         : Quality gate
         : Source adapter docs
    v0.2 : More ATS adapters
         : Parser fixtures
         : Better source quality dashboards
    v0.3 : Ranking evaluation dataset
         : Semantic matching visibility
         : Feedback learning improvements
    Future : OS keychain support
           : Cross-platform installers
           : Optional automation plugin

Near-term priorities:

• more high-quality ATS/company source adapters
• stronger quality gate tests
• clearer vector matching state in the UI
• Windows installer polish
• contributor-friendly source plugin boundaries
• OS keychain support for API keys

License

JustHireMe is open source under the GNU Affero General Public License v3.0 only.

You may self-host, modify, and use JustHireMe, including with your own API keys, under the terms of the AGPL-3.0 license. If you modify JustHireMe and make it available over a network, the AGPL requires you to provide the corresponding source code for that modified version to users of the network service.

Commercial licenses are available for organizations that want to use JustHireMe outside the AGPL terms, including private forks, proprietary modifications, embedding, white-labeling, or managed deployments. See COMMERCIAL_LICENSE.md for the commercial path.

Maintainer Note

This project is being built in the open because one person cannot cover every job source, every market, every ranking edge case, and every packaging path alone.

The goal is a useful local tool and a welcoming codebase where contributors can add sources, improve ranking, and help job seekers get better signal with less noise.