Is InterviewStreet Hiring-Agent Open Source? Complete Guide to the MIT-Licensed Resume Pipeline

Yes, InterviewStreet Hiring-Agent is fully open-source under the MIT license, hosted publicly on GitHub at interviewstreet/hiring-agent where developers can freely clone, inspect, modify, and redistribute the code according to the terms specified in the repository's LICENSE file.

The InterviewStreet Hiring-Agent is an open-source Resume-to-Score pipeline that converts PDF résumés into structured evaluations using LLM-driven analysis and GitHub enrichment. Released under the permissive MIT license, this repository allows engineering teams to self-host, customize, and extend the hiring workflow without proprietary restrictions. Whether you're verifying the open-source status for compliance or planning to integrate the scoring engine into your recruitment stack, the complete source code is available for immediate access and modification.

License and Open Source Status

The repository is explicitly released under the MIT License, confirming its open-source status. The full legal text resides in the LICENSE file at the repository root, granting users the rights to use, copy, modify, merge, publish, distribute, sublicense, and sell copies of the software. This permissive licensing means organizations can embed the hiring pipeline into commercial recruitment tools without copyleft obligations or usage fees.

According to the source code analysis, the open-source nature extends to all components of the pipeline, including the LLM provider abstractions, scoring algorithms, and prompt templates. There are no proprietary closed-source dependencies required for core functionality.

Architecture of the Open-Source Hiring Pipeline

The InterviewStreet Hiring-Agent implements a five-stage Resume-to-Score pipeline that processes candidate documents through distinct transformation layers. The data flows sequentially through specific Python modules:

1. pymupdf_rag.py → 2. pdf.py → 3. github.py → 4. evaluator.py → 5. score.py

Each stage is implemented as a separate module with clear responsibilities, making the codebase modular and extensible.

Stage 1: PDF Extraction with PyMuPDF

The pipeline begins with pymupdf_rag.py, which handles PDF extraction by converting each page of the résumé into a Markdown-like representation. This module utilizes PyMuPDF (also known as fitz) to read binary PDF data and provides the to_markdown logic that transforms visual document structures into parseable text.

Stage 2: LLM-Powered Section Parsing

Next, pdf.py orchestrates the section parsing stage. It sends each résumé section—Basics, Work, Education, Skills, Projects, and Awards—to an LLM using Jinja2 templates stored in prompts/templates/*.jinja. This process builds a structured JSON-Resume object that normalizes candidate data regardless of original PDF formatting.

Stage 3: GitHub Profile Enrichment

The github.py module handles GitHub enrichment by detecting GitHub usernames within the parsed résumé. It fetches profile metadata and repository information via the GitHub API, classifies each project by relevance and quality, and selects the top seven contributions for evaluation. This stage adds external validation signals to the candidate profile.

Stage 4: Fairness-Aware Evaluation

Scoring logic resides in evaluator.py, which applies fairness-aware evaluation rules. The module evaluates categories including open-source contributions, self-initiated projects, production experience, and technical skills, computing bonuses and deductions based on configurable templates that encode evaluation criteria. This ensures consistent, explainable scoring across candidates.

Stage 5: Output Generation and CSV Export

Finally, score.py serves as the CLI entry point that ties the pipeline together. It prints human-readable evaluation reports to stdout and, when DEVELOPMENT_MODE=True, appends structured data rows to resume_evaluations.csv for later analysis or audit trails.

Provider-Agnostic LLM Implementation

The open-source codebase is deliberately provider-agnostic, allowing deployment with either local or cloud-based language models. The architectural abstraction is defined in models.py, which contains Pydantic schemas for data validation and the LLMProvider protocol that standardizes interface contracts.

Two concrete implementations are available:

• OllamaProvider (models.OllamaProvider) for local inference using the ollama runtime
• GeminiProvider (models.GeminiProvider) for Google's Gemini API access

The provider selection logic in prompt.py reads the LLM_PROVIDER environment variable to instantiate the appropriate class. Both providers expose a common chat method, enabling the rest of the pipeline in pdf.py, github.py, and evaluator.py to remain unchanged regardless of backend selection.

Installation and Usage Examples

Because InterviewStreet Hiring-Agent is open source, you can install it directly from the GitHub repository and run it locally or integrate it into existing Python applications.

Installing from Source

Clone the repository and install dependencies using standard Python tooling:

git clone https://github.com/interviewstreet/hiring-agent
cd hiring-agent
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt

Copy the example environment configuration and set your preferred LLM provider:

cp .env.example .env
export LLM_PROVIDER=ollama        # or gemini

export DEFAULT_MODEL=gemma3:4b    # example Ollama model

# For Gemini, also set GEMINI_API_KEY in .env

Running the CLI Scoring Pipeline

Execute the full evaluation pipeline from the command line using score.py:

python score.py path/to/resume.pdf

This command processes the PDF through all five stages, prints a formatted evaluation to the terminal, and appends results to resume_evaluations.csv when running in development mode.

Programmatic Integration

Import the pipeline components directly into Python applications for customized workflows:

from pdf import PDFHandler
from github import GitHubEnricher
from evaluator import Evaluator
from score import run_pipeline

# Process a single resume

result = run_pipeline(resume_path="candidate_resume.pdf")
print(result.scores)          # CategoryScore objects

print(result.key_strengths)   # Top strengths identified by LLM

The run_pipeline function returns an EvaluationData instance defined in models.py, containing structured scores and qualitative assessments.

Configuring Different LLM Providers

Switch between LLM backends by modifying environment variables before importing the pipeline:

import os
os.environ["LLM_PROVIDER"] = "gemini"
os.environ["DEFAULT_MODEL"] = "gemini-2.5-pro"
os.environ["GEMINI_API_KEY"] = "YOUR_API_KEY"

# Subsequent imports will use Gemini instead of Ollama

from score import run_pipeline

This flexibility allows organizations to use local models for privacy-sensitive candidate data or cloud APIs for enhanced reasoning capabilities without modifying the core scoring logic.

Summary

• InterviewStreet Hiring-Agent is confirmed open-source under the MIT license, with full source code available at interviewstreet/hiring-agent.
• The resume evaluation pipeline consists of five modular stages: PDF extraction (pymupdf_rag.py), section parsing (pdf.py), GitHub enrichment (github.py), fairness-aware evaluation (evaluator.py), and output generation (score.py).
• Provider-agnostic architecture supports both local Ollama instances and Google Gemini APIs through the LLMProvider protocol defined in models.py.
• The codebase includes Jinja2 evaluation templates, Pydantic data models, and CSV export functionality for comprehensive hiring workflow integration.
• All components—from prompt templates to scoring algorithms—are included in the open-source release with no proprietary dependencies.

Frequently Asked Questions

Is InterviewStreet Hiring-Agent free for commercial use?

Yes. The MIT license explicitly permits commercial use, allowing companies to integrate the resume scoring pipeline into proprietary recruitment systems, modify the evaluation criteria, and redistribute the software without paying licensing fees or disclosing source code modifications.

Where can I find the source code for the resume scoring algorithm?

The core scoring algorithm resides in evaluator.py, which applies fairness-aware rules to the structured candidate data. The specific evaluation criteria templates are stored in the prompts/templates/ directory as Jinja2 files, making the scoring logic transparent and customizable by editing these open-source template files.

Can I run Hiring-Agent without internet connectivity?

Yes. By setting LLM_PROVIDER=ollama and running a local Ollama instance, the entire pipeline operates offline. The models.py file contains the OllamaProvider implementation that communicates with localhost endpoints, requiring no external API calls for PDF processing, section parsing, or evaluation stages.

What license file confirms the open-source status?

The LICENSE file in the repository root contains the complete MIT license text. This file legally confirms that InterviewStreet Hiring-Agent is open source, granting globally recognized rights to use, modify, and distribute the software according to the permissive terms outlined in that document.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}