# What Programming Languages Are Used in the Hiring Agent? A Complete Technical Breakdown

> Discover the programming languages powering the InterviewStreet Hiring Agent. Explore its Python 3.11+ core, Jinja2 templates, PyMuPDF, and Pydantic integration for efficient resume processing.

- Repository: [HackerRank/hiring-agent](https://github.com/interviewstreet/hiring-agent)
- Tags: technical-breakdown
- Published: 2026-07-24

---

**The InterviewStreet Hiring Agent is implemented exclusively in Python 3.11+, utilizing Jinja2 templates for prompt generation and leveraging libraries such as PyMuPDF and Pydantic for resume processing.**

The `interviewstreet/hiring-agent` repository serves as an AI-powered candidate evaluation tool, and understanding what programming languages power this hiring agent reveals a streamlined Python-centric architecture. This analysis examines the source code to confirm that Python is the sole development language driving the entire pipeline, from PDF extraction to LLM orchestration.

## Core Programming Language: Python 3.11+

The repository maintains a **Python-only** codebase with no secondary languages present. According to the README badge and source tree analysis, the project requires **Python 3.11 or higher** to operate.

Every module in the repository uses the `.py` extension, confirming zero dependencies on compiled languages like Rust, Go, or alternative runtimes like Node.js. The codebase avoids polyglot patterns, instead centralizing all logic—from document parsing to machine learning inference—within Python's ecosystem.

## Key Python Modules and Architecture

The hiring agent organizes functionality into discrete Python modules, each handling specific stages of the candidate evaluation workflow.

### Resume Processing ([`pdf.py`](https://github.com/interviewstreet/hiring-agent/blob/main/pdf.py) and [`pymupdf_rag.py`](https://github.com/interviewstreet/hiring-agent/blob/main/pymupdf_rag.py))

The system extracts structured data from PDF resumes using PyMuPDF bindings. The [`pdf.py`](https://github.com/interviewstreet/hiring-agent/blob/main/pdf.py) module orchestrates conversion to Markdown format, while [`pymupdf_rag.py`](https://github.com/interviewstreet/hiring-agent/blob/main/pymupdf_rag.py) contains the low-level extraction logic.

```python
from pymupdf_rag import PDFExtractor

extractor = PDFExtractor()
markdown = extractor.to_markdown("/path/to/resume.pdf")
print(markdown)

```

### LLM Integration ([`models.py`](https://github.com/interviewstreet/hiring-agent/blob/main/models.py) and [`llm_utils.py`](https://github.com/interviewstreet/hiring-agent/blob/main/llm_utils.py))

Interaction with large language model providers happens through abstractions defined in [`models.py`](https://github.com/interviewstreet/hiring-agent/blob/main/models.py). This file contains **Pydantic schemas** for data validation and the `LLMProviderFactory` class for instantiating different model backends.

```python
from models import LLMProviderFactory

provider = LLMProviderFactory.create(provider_name="ollama", model="gemma3:4b")
response = provider.chat(messages=[{"role": "user", "content": "Summarize this resume"}])
print(response)

```

### GitHub Data Enrichment ([`github.py`](https://github.com/interviewstreet/hiring-agent/blob/main/github.py))

The [`github.py`](https://github.com/interviewstreet/hiring-agent/blob/main/github.py) module retrieves candidate repository data and classifies projects using the GitHub API. It handles authentication via personal access tokens and structures profile information for downstream scoring.

```python
from github import GitHubEnricher

enricher = GitHubEnricher(token="YOUR_TOKEN")
profile = enricher.fetch_user_profile("octocat")
repos = enricher.fetch_user_repos("octocat")
print(profile, repos)

```

### Scoring Pipeline ([`score.py`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py) and [`evaluator.py`](https://github.com/interviewstreet/hiring-agent/blob/main/evaluator.py))

The entry point resides in [`score.py`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py), which acts as the CLI orchestrator for the end-to-end evaluation pipeline. The [`evaluator.py`](https://github.com/interviewstreet/hiring-agent/blob/main/evaluator.py) module implements fairness-constrained scoring logic to ensure unbiased candidate assessments.

```python

# score.py – entry point

from score import main

if __name__ == "__main__":
    # Provide a path to a resume PDF

    main("/path/to/resume.pdf")

```

## Template Engine: Jinja2

While the repository contains `.jinja` files within `prompts/templates/`, these represent **data templates** rather than separate programming languages. The Jinja2 syntax within these files is interpreted by Python's Jinja2 library at runtime to generate dynamic LLM prompts. No compilation or separate runtime environment processes these templates—they remain dependent on the Python execution context.

## Project File Structure

The following table maps key files to their responsibilities within the Python architecture:

| File | Purpose |
|------|---------|
| [`score.py`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py) | CLI orchestrator for the evaluation pipeline |
| [`pdf.py`](https://github.com/interviewstreet/hiring-agent/blob/main/pdf.py) | PDF to Markdown conversion and section parsing |
| [`pymupdf_rag.py`](https://github.com/interviewstreet/hiring-agent/blob/main/pymupdf_rag.py) | Low-level PDF extraction using PyMuPDF |
| [`github.py`](https://github.com/interviewstreet/hiring-agent/blob/main/github.py) | GitHub profile retrieval and repository classification |
| [`models.py`](https://github.com/interviewstreet/hiring-agent/blob/main/models.py) | Pydantic schemas and LLM provider abstractions |
| [`llm_utils.py`](https://github.com/interviewstreet/hiring-agent/blob/main/llm_utils.py) | Helper utilities for LLM interaction |
| [`evaluator.py`](https://github.com/interviewstreet/hiring-agent/blob/main/evaluator.py) | Fairness-constrained scoring algorithms |
| `prompts/templates/*.jinja` | Jinja2 prompt templates interpreted by Python |

## Summary

- The InterviewStreet Hiring Agent uses **Python 3.11+** as its sole programming language.
- **No JavaScript, TypeScript, Go, or Rust** code exists in the repository.
- Key functionality spans modules including [`score.py`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py), [`models.py`](https://github.com/interviewstreet/hiring-agent/blob/main/models.py), [`github.py`](https://github.com/interviewstreet/hiring-agent/blob/main/github.py), and [`evaluator.py`](https://github.com/interviewstreet/hiring-agent/blob/main/evaluator.py).
- **Jinja2 templates** in `prompts/templates/` are data files processed by Python, not standalone languages.
- The architecture relies on popular Python libraries including PyMuPDF for PDF handling and Pydantic for data validation.

## Frequently Asked Questions

### Is the Hiring Agent built with JavaScript or TypeScript?

No. The repository contains no JavaScript or TypeScript files. According to the source tree analysis, every module uses the `.py` extension, confirming that Python handles all logic including the CLI interface and API interactions.

### What Python version is required to run the Hiring Agent?

The project requires **Python 3.11 or higher**. This requirement is explicitly advertised in the README badge and supported by modern Python features used throughout the codebase, such as advanced type hints and Pydantic v2 integration.

### Does the project use any compiled languages like Rust or Go?

No. There are no Rust, Go, C++, or other compiled language files in the repository. The entire hiring agent implementation remains within Python's interpreted ecosystem, leveraging C-extensions through Python packages (like PyMuPDF) where performance is critical.

### Are the Jinja template files considered a separate programming language?

No. While the repository includes `.jinja` files in `prompts/templates/`, these are **template data files** interpreted by Python's Jinja2 library. They contain markup for dynamic prompt generation but lack standalone execution capability and require the Python runtime to process and render final outputs.