Where Are the Main Configuration Files Located in the Hiring Agent Repository?

The main configuration files in the Interview Street Hiring Agent repository are located in the repository root and consist of config.py for global flags, .env.example for environment templates, models.py for provider settings, prompt.py for LLM mappings, and requirements.txt for dependency management.

The Interview Street Hiring Agent project centralizes all runtime configuration in top-level files to streamline development and deployment workflows. These files control everything from development mode toggles to LLM provider credentials and prompt templates. Understanding where these files are located and how they interact is essential for customizing the application to work with different AI providers like Ollama or Gemini.

Top-Level Configuration Files Overview

All configuration files reside in the repository root of interviewstreet/hiring-agent, making them immediately accessible for editing:

• config.py – Defines global Python flags such as DEVELOPMENT_MODE that control internal application behavior.
• .env.example – Provides a template for environment variables required by LLM providers and optional GitHub credentials.
• models.py – Contains provider-specific wrappers that read environment variables and abstract the implementation details of OllamaProvider and GeminiProvider.
• prompt.py – Maps the chosen LLM provider to specific model names and stores Jinja template definitions used throughout the pipeline.
• requirements.txt – Declares third-party Python dependencies that define the expected runtime environment.

Detailed Configuration File Breakdown

config.py – Global Application Flags

The config.py file houses the global application flags that determine runtime behavior. The most critical flag is DEVELOPMENT_MODE, which toggles between development and production settings.

# config.py

DEVELOPMENT_MODE = True  # Toggle for development features

When DEVELOPMENT_MODE is enabled, the application activates caching and verbose logging appropriate for debugging. In production, this flag should be set to False to minimize logging overhead.

.env.example – Environment Variable Templates

The .env.example file serves as a skeleton for all sensitive and environment-specific configuration. Developers copy this file to .env and populate it with real values for:

• LLM_PROVIDER – Specifies which provider to use (ollama or gemini)
• DEFAULT_MODEL – Sets the default model name (e.g., gemma3:4b)
• GEMINI_API_KEY – Authentication token for Google Gemini API access
• GITHUB_TOKEN – Optional credential for GitHub API integration

# .env.example

LLM_PROVIDER=ollama
DEFAULT_MODEL=gemma3:4b
GEMINI_API_KEY=your_api_key_here
GITHUB_TOKEN=your_github_token_here

models.py – Provider Configuration and Abstraction

Located in the repository root, models.py provides the provider abstraction layer that reads environment variables and instantiates the appropriate LLM client. This file defines OllamaProvider and GeminiProvider classes, along with the get_provider() factory function that resolves which implementation to use based on the LLM_PROVIDER environment variable.

from models import get_provider

provider = get_provider(
    provider_name=LLM_PROVIDER,
    model_name=DEFAULT_MODEL,
    api_key=GEMINI_API_KEY,
)

response = provider.chat(messages=[{"role": "user", "content": "Hello"}])

prompt.py – LLM Provider Mappings

The prompt.py file (along with the prompts/ directory) contains the mapping logic between the chosen LLM provider and the specific model configurations. It also stores Jinja template definitions used throughout the Hiring Agent pipeline to format prompts consistently across different providers.

requirements.txt – Runtime Dependencies

While not a traditional configuration file, requirements.txt defines the runtime environment by listing all third-party Python packages required by the application. This ensures that the code executes with the correct dependency versions across different deployment environments.

Loading Configuration in Practice

To load configuration values in your Python code, import the global flags from config.py and read environment variables using os.getenv():

import os
from config import DEVELOPMENT_MODE

# Load environment variables (make sure you have copied .env.example → .env)

LLM_PROVIDER   = os.getenv("LLM_PROVIDER", "ollama")
DEFAULT_MODEL  = os.getenv("DEFAULT_MODEL", "gemma3:4b")
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
GITHUB_TOKEN   = os.getenv("GITHUB_TOKEN")

You can conditionally execute logic based on the development mode flag:

if DEVELOPMENT_MODE:
    print("Running in development mode – caching enabled")
else:
    print("Production mode – minimal logging")

Extending the Configuration

To add a new configuration flag, such as ENABLE_METRICS, follow this two-step process:

1. Add the variable to .env.example with documentation:

# Enable detailed metrics collection (true/false)

ENABLE_METRICS=false

2. Read the value in your Python code with a sensible default:

ENABLE_METRICS = os.getenv("ENABLE_METRICS", "false").lower() == "true"

This pattern ensures backward compatibility while allowing new features to be toggled via environment variables.

Summary

• Configuration files are located in the repository root of interviewstreet/hiring-agent for easy access and editing.
• config.py controls global application behavior through flags like DEVELOPMENT_MODE.
• .env.example provides the template for LLM provider credentials and service tokens that developers copy to .env.
• models.py abstracts provider-specific implementations and reads environment variables to instantiate OllamaProvider or GeminiProvider.
• prompt.py manages the mapping between LLM providers and their respective model configurations.
• requirements.txt defines the Python dependency environment required for runtime execution.

Frequently Asked Questions

Where is the DEVELOPMENT_MODE flag defined in the Hiring Agent repository?

The DEVELOPMENT_MODE flag is defined in config.py at the repository root. This global Python variable controls whether the application runs in development mode with enhanced caching and logging, or in production mode with minimal output.

How do I configure the LLM provider in the Hiring Agent project?

To configure the LLM provider, copy .env.example to .env and set the LLM_PROVIDER variable to either ollama or gemini. The models.py file reads this variable through the get_provider() function to instantiate the appropriate provider class (OllamaProvider or GeminiProvider) along with the model name specified in DEFAULT_MODEL.

What is the purpose of the .env.example file in the Hiring Agent repository?

The .env.example file serves as a template containing all required environment variable names without sensitive values. It documents the expected variables for LLM authentication (GEMINI_API_KEY), provider selection (LLM_PROVIDER), and optional integrations (GITHUB_TOKEN), which developers copy and populate for their local environment.

How are prompt templates configured in the Hiring Agent application?

Prompt templates are configured in prompt.py and the accompanying prompts/ directory. These files contain the Jinja template definitions and the mapping logic that connects the selected LLM provider to specific model configurations, ensuring consistent prompt formatting across different AI providers like Ollama and Gemini.

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