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

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 and pymupdf_rag.py)

The system extracts structured data from PDF resumes using PyMuPDF bindings. The pdf.py module orchestrates conversion to Markdown format, while pymupdf_rag.py contains the low-level extraction logic.

from pymupdf_rag import PDFExtractor

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

LLM Integration (models.py and llm_utils.py)

Interaction with large language model providers happens through abstractions defined in models.py. This file contains Pydantic schemas for data validation and the LLMProviderFactory class for instantiating different model backends.

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)

The 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.

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 and evaluator.py)

The entry point resides in score.py, which acts as the CLI orchestrator for the end-to-end evaluation pipeline. The evaluator.py module implements fairness-constrained scoring logic to ensure unbiased candidate assessments.

# 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	CLI orchestrator for the evaluation pipeline
pdf.py	PDF to Markdown conversion and section parsing
pymupdf_rag.py	Low-level PDF extraction using PyMuPDF
github.py	GitHub profile retrieval and repository classification
models.py	Pydantic schemas and LLM provider abstractions
llm_utils.py	Helper utilities for LLM interaction
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, models.py, github.py, and 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.

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