Every time I wanted to give an LLM context from a codebase, I ended up doing this:

- Set up a vector DB - Write chunking logic - Run an indexer - Keep it in sync with git on any change

For just answer this question about this repo, it felt a bit too much. So I built a small API instead: you send a repo + question, it sends back the files an LLM actually needs (not sure how novel this is at all?).

What it does:

You call an HTTP endpoint with a GitHub repo URL + natural language question (better if specific, but this will also work: How does auth work? What validates webhook signatures? etc).

The API returns JSON with 1–10 ranked files: - `path`, `language`, `size`, full `content` - plus a small `stats` object (token estimate, rough cost savings)

You plug those files into your own LLM / agent / tool. There's no embeddings, no vector DB, no background indexing job. It works on the very first request.

Why I built this?

I just wanted to ask this repo a question without:

- Standing up Pinecone/Weaviate/Chroma - Picking chunk sizes and overlap - Running an indexer for every repo - Dealing with sync jobs when code changes

This API skips all of that. It's meant for:

- One-off questions on random repos - Agents / tools that hop across many repos - Internal tools where you don't want more infra

Does it work at all?

On a small internal eval (177 questions across 14 repos, mix of Python, TS, monorepos + private ones):

- A cross-model LLM judge rated answers roughly on par with a standard embeddings + vector DB setup - Latency is about 2–4 seconds on the first request per repo (shallow cloning + scanning), then faster from cache - No indexing step: new repos work immediately

Numbers are from our own eval, so treat them as directional, not a paper. Happy to share the setup if anyone wants to dig in.

How it works:

1. On first request, it shallow clones the repo and builds a lightweight index: file paths, sizes, languages, and top-level symbols where possible.

2. It gives an LLM the file tree + question and asks it to pick the most relevant files.

3. It ranks, dedupes, and returns a pack of files that fits in a reasonable context window.

Basically: let an LLM read the file tree and pick files, instead of cosine-searching over chunks.

*imitations:

- Eval is relatively small (177 questions / 14 repos), all hand-written – directional, not research-grade - Works best on repos with sane structure and filenames - First request per repo pays the clone cost (cached after)

Try it:

- Live demo: https://contextpacker.com - DM me for an API key – keeping it free while I validate the idea.

If you're building code agents, "explain this repo" tools, or internal AI helpers over your company's repos – I'd love to hear how you'd want to integrate something like this (or where you think it will fall over). Very open to feedback and harsh benchmarks.

Camera traps snap 3X more images of endangered Sumatran tigers than before

A Template-Driven Approach to Resource Management for AI Compute

Rnj-1: Building Instruments of Intelligence

Risks to British Business

The Hays Code

Agents need good developer experience too

One Last Trip: Traveling with my brother's remains (2022)

Notes on Distributed Systems for Young Bloods (2013)

Ferrari's Formula 1 Handovers: Handovers from Surgery to Intensive Care 2008;pdf

The Influence of Self

Show HN: LLMs Play Mafia

Germany votes to bring in voluntary military service programme for 18-year-olds

Tell HN: iOS 18.7.2 in Lockdown Mode is unable to load many websites

ChatGPT Competed in an Economist's Prediction Game

Law of Reflection

OMSCS Open Courseware

Swift-HuggingFace: The Complete Swift Client for Hugging Face

Show HN: ContextPacker code context API for your agent without vector databases

Scientists are turning Earth into a giant detector for hidden forces

What Is a Pedersen Commitment?

Show HN: Pure – An interactive satire on the absurdity of 'Terms of Service'

Show HN: RocketGift: Find the perfect gift in 30 seconds using AI

Flow Control: a programmer's text editor

Fixed Points and Strike Mandates (2012)

Indiana had most losses in college football. Now it's a championship contender

The Binding Problem

Running Claude Code in a loop to mirror human development practices

What happened in Moq library: A Blog on Controversies (2003)

Why Programming Was Never About Code (Opinion)

Meta II: a syntax-oriented compiler writing language. (1964)

Show HN: UISora – AI-Powered Mobile App UI Designer