# Where Are Cached GitHub Data Results Stored in the Hiring Agent Repository?

> Find out where cached GitHub data results are stored in the interviewstreet/hiring-agent repository. Learn about the cache directory and filename conventions to access these valuable results.

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

---

**Cached GitHub API responses in the Hiring Agent repository are stored as JSON files in a top-level `cache/` directory, with filenames prefixed by `gh_githubcache_` and constructed by the `_create_cache_filename` helper in [`github.py`](https://github.com/interviewstreet/hiring-agent/blob/main/github.py).**

The [interviewstreet/hiring-agent](https://github.com/interviewstreet/hiring-agent) project caches GitHub API results to speed up development and reduce rate-limit hits. Understanding exactly where these cached GitHub data results are stored helps you debug stale data, clear outdated responses, or manually seed specific API outputs for testing.

## Cache Directory Location and Naming Convention

All cached GitHub data lives under the **`cache/`** directory at the repository root. Files follow a strict naming pattern:

```

cache/gh_githubcache_<url_parts>[_<param_str>].json

```

The components break down as follows:

- **`<url_parts>`** – A sanitized version of the API endpoint path (e.g., `users_octocat` for the `/users/octocat` endpoint).
- **`<param_str>`** – An optional, URL-encoded query string appended only when `params` are supplied to the request.

For example, a request to `https://api.github.com/users/octocat` creates [`cache/gh_githubcache_users_octocat.json`](https://github.com/interviewstreet/hiring-agent/blob/main/cache/gh_githubcache_users_octocat.json), while parameterized requests include the encoded query in the filename.

## How Cache Filenames Are Generated

The helper function **`_create_cache_filename`** (defined in [[`github.py`](https://github.com/interviewstreet/hiring-agent/blob/main/github.py)](https://github.com/interviewstreet/hiring-agent/blob/main/github.py) lines 18–35) builds these paths dynamically. It sanitizes the endpoint URL and appends encoded parameters to ensure unique cache keys per distinct API call.

During runtime, this function returns an absolute or relative path string pointing to the specific JSON file inside `cache/`. If the directory does not exist, it is created on demand during the write phase.

## Cache Read and Write Mechanics

### Loading Cached Data

The main GitHub-fetch routine (lines 35–44 of [[`github.py`](https://github.com/interviewstreet/hiring-agent/blob/main/github.py)](https://github.com/interviewstreet/hiring-agent/blob/main/github.py)) checks for cached results before making a network request:

```python
if DEVELOPMENT_MODE and os.path.exists(cache_filename):
    print(f"Loading cached GitHub data from {cache_filename}")
    cached_data = json.loads(Path(cache_filename).read_text(encoding="utf-8"))
    return 200, cached_data

```

When the file exists and `DEVELOPMENT_MODE` is **True**, the function returns the stored JSON payload immediately, bypassing the live API.

### Writing Cache Files

When fetching fresh data, the response is persisted to disk (lines 106–111 of [[`github.py`](https://github.com/interviewstreet/hiring-agent/blob/main/github.py)](https://github.com/interviewstreet/hiring-agent/blob/main/github.py)):

```python
os.makedirs("cache", exist_ok=True)
Path(cache_filename).write_text(json.dumps(resp_json, ensure_ascii=False))

```

This ensures the `cache/` directory exists and writes the normalized JSON response for future requests.

## Practical Cache Management

### Manually Clearing the GitHub Cache

To remove stale GitHub data and force fresh API calls, delete files matching the `gh_githubcache_` prefix:

```python
import os

cache_dir = "cache"
if os.path.isdir(cache_dir):
    for filename in os.listdir(cache_dir):
        if filename.startswith("gh_githubcache_"):
            os.remove(os.path.join(cache_dir, filename))

```

### Inspecting Cache Contents

You can read and debug cached responses directly:

```python
import json
from pathlib import Path

cache_file = Path("cache/gh_githubcache_repo_issues.json")
if cache_file.is_file():
    cached_json = json.loads(cache_file.read_text())
    print(json.dumps(cached_json, indent=2))

```

### Disabling Caching for One-Off Runs

Set `DEVELOPMENT_MODE` to **False** before invoking fetch functions to bypass the cache entirely:

```python
from config import DEVELOPMENT_MODE
DEVELOPMENT_MODE = False

# This call will always hit the live GitHub API

status, data = fetch_github_data(api_url, params)

```

## Related Caching Patterns

The same repository uses analogous caching elsewhere. For example, resume-scoring logic in [[`score.py`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py)](https://github.com/interviewstreet/hiring-agent/blob/main/score.py) (lines 215–220) writes to `cache/resumecache_*.json`. While this uses a different prefix, the underlying mechanism—timestamped JSON files in the `cache/` directory—remains consistent.

## Summary

- **Location:** All cached GitHub data results are stored in the `cache/` directory at the repository root.
- **Filename Pattern:** Files use the format `cache/gh_githubcache_<url_parts>[_<param_str>].json`, generated by `_create_cache_filename` in [`github.py`](https://github.com/interviewstreet/hiring-agent/blob/main/github.py).
- **Activation:** Caching only operates when `DEVELOPMENT_MODE` is enabled; production runs bypass the cache.
- **Persistence:** Cache files are plain JSON and can be edited, deleted, or version-controlled for testing scenarios.

## Frequently Asked Questions

### Where exactly are cached GitHub results stored in the Hiring Agent project?

Cached GitHub results are stored as individual JSON files inside a `cache/` folder at the repository root. Each file is named `gh_githubcache_<sanitized_endpoint>[_<params>].json` according to the specific API call that generated it.

### How do I clear the GitHub cache to fetch fresh data?

Delete files starting with `gh_githubcache_` from the `cache/` directory. You can do this manually or programmatically by iterating over the directory contents and removing matching filenames. The next API call will then fetch fresh data from GitHub and repopulate the cache.

### Why is my Hiring Agent not loading cached GitHub data?

The cache is only checked when `DEVELOPMENT_MODE` is set to `True`. If this flag is disabled, the application ignores existing cache files and always makes live API requests. Verify your configuration settings and ensure the cache files actually exist in the `cache/` directory.

### Can I disable caching entirely for production deployments?

Yes. Caching is gated by the `DEVELOPMENT_MODE` environment variable or configuration flag. Setting this to `False` disables all cache reads and writes, forcing every request to hit the live GitHub API. This is the recommended configuration for production environments to avoid serving stale data.