Inspiration

With the advancement of AI, the pace of contributions to the repository is increasing. Size of Readme.md file is increasing, making new contributors intimidating to make their first contribution. Consider repositories like spark, cassandra, its so huge, you can only make a meaningful contribution if you know the struncture of the repository from first principles.

When we join a company, understanding huge repository, setting up locally experiencing it may take weeks of time, developer might not get proper information that he/ she is looking for if there is not proper documentation and doesn't understand the code.

What it does

RepoLab helps reducing the time taken for the first meaning commit to a repository. Creates an enviroment where you can discuss with the repo, understand the repo, get the exact code lines that is reposible for what you have asked. Help more contributers involve in development. More contributors, means more ideas , more ideas means the better is the quality of product.

How we built it

RepoLab is four parts that work together. Here's how it's built and how it runs.

The four parts

Part Tech Job
web/ Next.js, TypeScript, Tailwind, xterm.js The browser UI: import a repo, watch progress, playground, Ask RepoLab, approve experiments, terminal
api/ Python 3.11, FastAPI Creates jobs, serves results, streams live progress, hosts the terminal WebSocket
worker/ RQ + Redis Does the slow work: cloning, investigation, builds, runs, experiments, lessons
repolab/ Shared Python package The logic: agents, the model router, ingestion, classification, sandbox, experiments, evidence

Postgres holds everything durable: jobs, events, manifests, experiments and measurements. Redis holds only the queues and worker heartbeats.

How one request flows

  1. You submit a GitHub URL. The web app calls POST /jobs on the API.
  2. The API queues it. It never does slow work itself. The job goes onto Redis.
  3. A worker picks it up:
    • It clones the repo with a hardened git command.
    • Agents investigate the code. They ask for tools (read file, search code…) and deterministic code runs them.
    • The result is a RepoManifest: languages, entry points, and interaction surfaces such as data playground, CLI, web or API.
  4. The worker emits events as it goes. They're stored in Postgres, and the API streams them to the browser over SSE. That's why the screens fill in progressively, and why a browser refresh replays the history.
  5. The worker builds and runs the software in Docker containers. For example: Spark jobs, Cassandra nodes, live web apps.
  6. "Why?" questions become experiments:
    • Nemotron Ultra designs a plan, and nothing runs until you approve it.
    • The worker runs the variants for real and measures.
    • Deterministic Python computes the statistics.
    • Nemotron explains the measured results, with evidence attached.

The AI side

All model calls go through one router in repolab/llm/, using Nebius Token Factory's OpenAI-compatible API.

Model tier Used for
Nano Cheap, quick tasks
Super Investigation, architecture, lessons
Ultra Experiment design and interpretation

Model IDs come from environment variables, and outputs are validated against Pydantic schemas.

Building it locally

make install                  # uv sync (Python) + npm install (web)
make up && make db-upgrade    # Postgres + Redis in Docker, then migrations
make dev                      # api :8000, two workers, web :3000

Challenges we ran into

Analyzing large repositories took time, and waiting for model responses made the website feel unresponsive. We addressed this by delivering an initial response that felt complete on its own, allowing users to start exploring while the remaining analysis continued in the background.

Accomplishments that we're proud of

We built an agent-powered learning experience that helps users explore repositories and understand how the code fits together. With Tavily, we connected relevant code to clear explanations, making unfamiliar concepts easier to understand in context.

What we learned

There is no one-size-fits-all approach to explaining a repository. Each codebase has its own architecture, patterns, and complexity. Generating an effective learning website requires adapting both the content and its structure to the repository.

What's next for RepoLab

  • Build a community where developers can learn and explore code at the same time.
  • Scale the app to support more users and larger repositories.
  • Improve the learning experience and navigation.
  • Personalize explanations to each user’s knowledge level, including foundational concepts for beginners.
  • Add a Slack connector to bring repository insights into team conversations.

Built With

Share this project:

Updates

Submission history