Context windows in 2025-26: how do you use 128k-1M tokens without drowning?

// Long context without drowning: (1) cost of stuffing vs retrieving at volume,
// (2) placing the best chunks at the edges, (3) a needle-at-depth test harness.
// Prices are ILLUSTRATIVE round numbers, not any vendor list.
const WINDOW = 1_000_000;
const PRICE = 3.0;           // $ per 1M input tokens up to the long-context threshold
const LONG_THRESHOLD = 200_000, LONG_MULT = 2; // whole request billed at 2x above it
const CACHE_READ = 0.1;      // cached prefix tokens billed at 10% of the input price
const QUERIES_PER_MONTH = 300_000;
const OVERHEAD = 1_500;      // instructions + question per request

function perRequest(tokens, cachedTokens = 0) {
  const rate = tokens > LONG_THRESHOLD ? PRICE * LONG_MULT : PRICE;
  return ((tokens - cachedTokens) * rate + cachedTokens * rate * CACHE_READ) / 1e6;
}
function money(x, d = 2) {
  const [int, frac] = x.toFixed(d).split(".");
  return "$" + int.replace(/\B(?=(\d{3})+(?!\d))/g, ",") + "." + frac;
}

const CORPORA = [["one contract", 90_000], ["mid codebase", 600_000], ["company wiki", 40_000_000]];
console.log("corpus         tokens      strategy          tok/request  $/request  $/month");
for (const [name, size] of CORPORA) {
  const rows = [];
  if (size + OVERHEAD <= WINDOW) {
    rows.push(["stuff all", size + OVERHEAD, perRequest(size + OVERHEAD)]);
    rows.push(["stuff all+cache", size + OVERHEAD, perRequest(size + OVERHEAD, size)]);
  } else rows.push(["stuff all", size + OVERHEAD, null]);
  const rag = 8 * 800 + OVERHEAD; // top-8 chunks of 800 tokens
  rows.push(["retrieve top-8", rag, perRequest(rag)]);
  for (const [s, tok, cost] of rows) {
    const c = cost === null ? "does not fit" : `${money(cost, 4).padStart(9)}  ${money(cost * QUERIES_PER_MONTH)}`;
    console.log(`${name.padEnd(14)} ${String(size).padStart(10)}  ${s.padEnd(16)} ${String(tok).padStart(11)}  ${c}`);
  }
}

// (2) Edge ordering: rank 1 is most relevant. Alternate front/back so the
// weakest chunks end up in the middle (the idea behind LangChain LongContextReorder).
function edgeOrder(ranked) {
  const front = [], back = [];
  ranked.forEach((x, i) => (i % 2 === 0 ? front.push(x) : back.unshift(x)));
  return [...front, ...back];
}
const ranked = [1, 2, 3, 4, 5, 6, 7, 8];
console.log("\nretrieval order:", ranked.join(" "));
console.log("edge order:     ", edgeOrder(ranked).join(" "), "(best at both ends, weakest in the middle)");

// (3) Needle-at-depth harness. Filler sentences, one fact inserted at a depth.
const FILLER = "The quarterly report lists routine facility updates and staffing notes.";
const NEEDLE = "The vault access code for project Heron is 4417.";
const QUESTION = "What is the vault access code for project Heron?";
function buildHaystack(nSentences, depth) {
  const s = Array(nSentences).fill(FILLER);
  const at = Math.round((nSentences - 1) * depth);
  s.splice(at, 0, NEEDLE);
  const text = s.join(" ");
  return { text, needleTokenPos: Math.ceil(text.indexOf(NEEDLE) / 4), totalTok: Math.ceil(text.length / 4) };
}
// Canned answers stand in for a model; the harness scores them.
const CANNED = { 0: "4417", 0.25: "The code is 4417.", 0.5: "I could not find a code.", 0.75: "4471", 1: "Code: 4417" };
const grade = (answer) => /\b4417\b/.test(answer);
console.log("\nneedle test, 2000 filler sentences:");
console.log("depth  needle at tok  of total  canned answer               pass");
let pass = 0;
for (const depth of [0, 0.25, 0.5, 0.75, 1]) {
  const h = buildHaystack(2000, depth);
  const ok = grade(CANNED[depth]);
  pass += ok;
  console.log(`${(depth * 100).toFixed(0).padStart(4)}%  ${String(h.needleTokenPos).padStart(13)}  ${String(h.totalTok).padStart(8)}  ${CANNED[depth].padEnd(26)}  ${ok ? "yes" : "NO"}`);
}
console.log(`recall ${pass}/5 for question: ${QUESTION}`);