Abhishek Satyam

A fixed-window chunker cuts a function in half, and half a function retrieves as noise and answers as a hallucination. Chunking follows declaration boundaries across ~30 languages, so the unit that gets embedded is the unit a reader would have quoted anyway.

Dependency manifests, entry points and HTTP routes, precomputed once at ingestion and injected into every prompt. Retrieval finds the chunk that matches the question; the map is what tells the model where that chunk sits in the project — which service owns it, what route reaches it. Largest single retrieval-quality gain in the project, and it never touched the retriever.

Dense pgvector HNSW fused with Postgres full-text via Reciprocal Rank Fusion is the standard answer, and I assumed it here too. An evaluation harness scoring Recall@k and MRR per mode disagreed: dense alone reached 94.4% recall@3 and 0.861 MRR against hybrid's 83.3% and 0.769. The harness is the reason the default isn't hybrid.

Recall@k and MRR are averages, and a healthy-looking average is also what two broken cases cancelling each other out looks like. Reading the harness query by query rather than mode by mode surfaced two retrieval bugs the summary numbers were never going to move enough to show.

A file-level citation on a 900-line file is just an instruction to go read it yourself. Chunks carry their line span from ingestion through retrieval into the rendered answer, so every claim can be checked in the exact place it came from.

Serverless ingestion has a wall clock, and most of it was spent shipping bytes: inserts batched instead of issued per chunk, embedding calls made concurrently rather than in sequence, and vector literals written at float4 precision instead of full float8 text. Re-scored on the harness afterwards at zero retrieval-quality loss — an ingestion speedup that quietly degrades recall is not a speedup.

IVFFlat learns its centroids at build time, so an index built before the corpus exists is permanently bad. HNSW builds incrementally as uploads arrive.

One shared index plus an ownership predicate, where the ORM's types don't reach. pgvector 0.8 iterative scan (strict_order) keeps post-filtering from silently returning fewer than top-k, and ef_search is raised with SET LOCAL — scoped to the transaction, because a plain SET leaks one request's tuning into whoever gets that pooled connection next.

EventSource can't send a Bearer header. Citations go out ahead of the first token, so the answer renders already grounded.

A follow-up is rewritten into a standalone question before it is embedded — "how long is it?" retrieves nothing on its own. Generation still answers what the user actually typed, because answering the rewrite answers a question nobody asked. "Make that shorter" skips retrieval entirely and re-grounds on the previous turn's sources.

SHA-256 dedupe → chunked one page at a time, so no chunk straddles a page break and every citation has one honest page to point at: "page 7" rather than "chunk 12" → embeddings batched 100/request, behind a PENDING→READY state machine.

A transcript lands in the composer, so the request that follows is byte-identical to a typed one — retrieval can't tell which you used, and a mishearing stays a visible typo instead of a silent retrieval failure. Paid model in, browser speechSynthesis out: spend where an error changes the result.

Redis-backed rate limits that survive autoscaling, one shared in-flight cap across both answer routes (three separate limits of 2 is a limit of 6), and client disconnects propagated to OpenAI via AbortController. Transcription gets its own limiters — it bills by the minute, so counting requests bounds nothing.