#!/usr/bin/env python3 """Generate JSONL benchmark prompts for prefix-cache evaluation. The datasets produced here are intentionally tokenizer-independent. Token counts are approximated from word counts so the generated files can be used with any LLM inference server, then re-tokenized by the benchmark client/model tokenizer. """ from __future__ import annotations import argparse import json import random from collections import Counter from pathlib import Path from statistics import mean from typing import Any, Iterable DEFAULT_NUM_REQUESTS_PER_FILE = 1000 DEFAULT_MAX_OUTPUT_TOKENS = 128 DEFAULT_SEED = 1337 WORDS_PER_TOKEN = 0.75 SCENARIO_FILES = { "shared_schema_1k": "shared_schema_1k.jsonl", "same_document_multi_query_8k": "same_document_multi_query_8k.jsonl", "multiturn_agent_branching": "multiturn_agent_branching.jsonl", "eviction_pressure_4k": "eviction_pressure_4k.jsonl", } TOPIC_VOCAB = { "legal contracts": [ "agreement", "counterparty", "indemnity", "termination", "notice", "governing", "jurisdiction", "liability", "confidential", "assignment", "warranty", "breach", "remedy", "schedule", "exhibit", "obligation", ], "medical policy": [ "member", "coverage", "authorization", "clinical", "provider", "diagnosis", "referral", "benefit", "exclusion", "claims", "appeal", "network", "therapy", "screening", "dosage", "protocol", ], "financial reports": [ "revenue", "margin", "guidance", "segment", "liquidity", "expense", "amortization", "cashflow", "forecast", "quarter", "portfolio", "currency", "impairment", "asset", "liability", "dividend", ], "software docs": [ "endpoint", "configuration", "deployment", "latency", "throughput", "serializer", "worker", "replica", "cache", "timeout", "namespace", "schema", "migration", "callback", "permission", "runtime", ], "compliance documents": [ "control", "audit", "retention", "encryption", "policy", "evidence", "review", "exception", "risk", "approval", "classification", "incident", "monitoring", "attestation", "access", "vendor", ], "research papers": [ "hypothesis", "methodology", "dataset", "baseline", "ablation", "sample", "metric", "variance", "observation", "experiment", "replication", "cohort", "analysis", "model", "appendix", "finding", ], } QUESTION_BANK = [ "Extract all obligations.", "Extract all dates and deadlines.", "Extract all entities.", "Extract all monetary amounts.", "Extract termination clauses.", "Extract jurisdiction-specific requirements.", "Extract exceptions and carve-outs.", "Extract risks that require manual review.", ] def approx_tokens(text: str) -> int: """Approximate token count using 1 word ~= 1.3 tokens.""" words = len(text.split()) return round(words / WORDS_PER_TOKEN) def target_words(target_tokens: int) -> int: return max(1, round(target_tokens * WORDS_PER_TOKEN)) def make_text(target_tokens: int, topic: str, seed: int) -> str: """Create deterministic domain-like prose close to a target token length.""" rng = random.Random(seed) vocab = TOPIC_VOCAB[topic] templates = [ "Section {section}.{clause} states that the {actor} must review {term} evidence before the {milestone} date and document the rationale in the official record.", "The {actor} may rely on {term} data when the source is validated, the exception is approved, and the responsible owner confirms operational readiness.", "If a material change affects {term}, the {actor} must notify stakeholders, update the register, and preserve supporting artifacts for audit review.", "The procedure requires a comparison of {term}, historical performance, and current constraints before the final recommendation is submitted.", "Records should identify the decision maker, affected business unit, applicable {term} threshold, and any dependency that could change the outcome.", "A reviewer should flag inconsistent {term} language, missing approvals, unusual timing, and obligations that conflict with the baseline policy.", ] actors = [ "administrator", "review committee", "service owner", "contract manager", "compliance officer", "operations lead", ] milestones = [ "renewal", "implementation", "reporting", "escalation", "submission", "certification", ] words_needed = target_words(target_tokens) sentences: list[str] = [] while len(" ".join(sentences).split()) < words_needed: sentence = rng.choice(templates).format( section=rng.randint(1, 18), clause=rng.randint(1, 9), actor=rng.choice(actors), term=rng.choice(vocab), milestone=rng.choice(milestones), ) sentences.append(sentence) words = " ".join(sentences).split() return " ".join(words[:words_needed]) + "." def write_jsonl(path: Path, rows: Iterable[dict[str, Any]]) -> None: with path.open("w", encoding="utf-8") as handle: for row in rows: validate_row(row) handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n") def validate_row(row: dict[str, Any]) -> None: required = {"id", "prompt", "max_tokens", "temperature", "metadata"} if set(row) != required: raise ValueError(f"Invalid row keys for {row.get('id', '')}: {sorted(row)}") if not isinstance(row["id"], str) or not row["id"]: raise ValueError("Row id must be a non-empty string") if not isinstance(row["prompt"], str) or not row["prompt"].strip(): raise ValueError(f"Row {row['id']} has an empty prompt") if not isinstance(row["max_tokens"], int) or row["max_tokens"] <= 0: raise ValueError(f"Row {row['id']} has invalid max_tokens") if not isinstance(row["temperature"], (int, float)): raise ValueError(f"Row {row['id']} has invalid temperature") metadata = row["metadata"] metadata_keys = { "scenario", "prefix_group", "expected_shared_prefix_tokens", "unique_suffix_tokens", "request_order", "description", } if not isinstance(metadata, dict) or set(metadata) != metadata_keys: raise ValueError(f"Row {row['id']} has invalid metadata") for key in ("scenario", "prefix_group", "description"): if not isinstance(metadata[key], str) or not metadata[key]: raise ValueError(f"Row {row['id']} metadata.{key} must be a non-empty string") for key in ("expected_shared_prefix_tokens", "unique_suffix_tokens", "request_order"): if not isinstance(metadata[key], int) or metadata[key] < 0: raise ValueError(f"Row {row['id']} metadata.{key} must be a non-negative integer") def make_row( row_id: str, prompt: str, max_tokens: int, scenario: str, prefix_group: str, expected_shared_prefix_tokens: int, unique_suffix_tokens: int, request_order: int, description: str, ) -> dict[str, Any]: return { "id": row_id, "prompt": prompt, "max_tokens": max_tokens, "temperature": 0.0, "metadata": { "scenario": scenario, "prefix_group": prefix_group, "expected_shared_prefix_tokens": expected_shared_prefix_tokens, "unique_suffix_tokens": unique_suffix_tokens, "request_order": request_order, "description": description, }, } def shared_extraction_instruction() -> str: return """You are a careful information extraction system. Return only valid JSON. Do not include markdown, commentary, or speculative fields. Preserve source wording for quoted evidence. Use null when a requested value is absent. Prefer arrays for repeated facts and include a confidence value between 0 and 1.""" def extraction_schema() -> str: return json.dumps( { "document_type": "string", "entities": [{"name": "string", "role": "string", "evidence": "string"}], "dates": [{"date": "YYYY-MM-DD or string", "meaning": "string", "evidence": "string"}], "obligations": [{"party": "string", "action": "string", "deadline": "string|null", "evidence": "string"}], "amounts": [{"value": "string", "currency": "string|null", "context": "string", "evidence": "string"}], "risks": [{"risk": "string", "severity": "low|medium|high", "evidence": "string"}], "confidence": "number", }, indent=2, ) def few_shot_examples(seed: int, target_tokens: int) -> str: base = [ "Example 1 document: Vendor must provide quarterly uptime reports within ten business days after quarter end. Customer may terminate after two uncured material breaches.", 'Example 1 output: {"document_type":"service agreement","entities":[{"name":"Vendor","role":"service provider","evidence":"Vendor must provide quarterly uptime reports"}],"dates":[{"date":"ten business days after quarter end","meaning":"report deadline","evidence":"within ten business days after quarter end"}],"obligations":[{"party":"Vendor","action":"provide quarterly uptime reports","deadline":"ten business days after quarter end","evidence":"Vendor must provide quarterly uptime reports within ten business days after quarter end"}],"amounts":[],"risks":[{"risk":"termination after repeated uncured breaches","severity":"medium","evidence":"Customer may terminate after two uncured material breaches"}],"confidence":0.92}', "Example 2 document: The policy excludes experimental therapy unless approved by the clinical review committee before treatment begins.", 'Example 2 output: {"document_type":"medical policy","entities":[{"name":"clinical review committee","role":"approver","evidence":"approved by the clinical review committee"}],"dates":[{"date":"before treatment begins","meaning":"approval timing","evidence":"unless approved by the clinical review committee before treatment begins"}],"obligations":[],"amounts":[],"risks":[{"risk":"experimental therapy excluded without prior approval","severity":"high","evidence":"policy excludes experimental therapy unless approved"}],"confidence":0.9}', ] filler_tokens = max(0, target_tokens - approx_tokens("\n".join(base))) return "\n".join(base + [make_text(filler_tokens, "compliance documents", seed)]) def build_schema_prefix(seed: int, target_tokens: int = 1000) -> str: skeleton = "\n\n".join( [ "Instruction:\n" + shared_extraction_instruction(), "JSON schema:\n" + extraction_schema(), "Few-shot examples:\n" + few_shot_examples(seed, 260), ] ) remaining = max(0, target_tokens - approx_tokens(skeleton)) if remaining: skeleton += "\n\nAdditional extraction policy:\n" + make_text(remaining, "compliance documents", seed + 1) return skeleton def build_shared_schema_rows(count: int, max_tokens: int, seed: int) -> list[dict[str, Any]]: prefix = build_schema_prefix(seed, 1000) prefix_tokens = approx_tokens(prefix) rows = [] topics = list(TOPIC_VOCAB) for idx in range(count): topic = topics[idx % len(topics)] suffix = "\n\nDocument:\n{document}\n\nTask: {question}".format( document=make_text(235, topic, seed + 1000 + idx), question=QUESTION_BANK[idx % len(QUESTION_BANK)], ) prompt = prefix + suffix rows.append( make_row( f"shared_schema_1k_{idx:05d}", prompt, max_tokens, "shared_schema_1k", "schema_prefix_001", prefix_tokens, approx_tokens(suffix), idx, "All rows share the same extraction instruction, JSON schema, and few-shot prefix; only the short document and query change.", ) ) return rows def build_same_document_rows(count: int, max_tokens: int, seed: int) -> list[dict[str, Any]]: queries_per_group = len(QUESTION_BANK) group_count = max(1, (count + queries_per_group - 1) // queries_per_group) rows = [] order = 0 topics = list(TOPIC_VOCAB) for group_idx in range(group_count): topic = topics[group_idx % len(topics)] prefix = "\n\n".join( [ "Instruction:\n" + shared_extraction_instruction(), "JSON schema:\n" + extraction_schema(), f"Long source document {group_idx + 1} ({topic}):\n" + make_text(7800, topic, seed + 2000 + group_idx), ] ) prefix_tokens = approx_tokens(prefix) prefix_group = f"doc_group_{group_idx + 1:04d}" for query_idx, question in enumerate(QUESTION_BANK): if order >= count: return rows suffix = "\n\nExtraction question:\n{question}\nReturn compact JSON using the schema above.\n\nQuestion-specific guidance:\n{guidance}".format( question=question, guidance=make_text(46, topic, seed + 2500 + order), ) prompt = prefix + suffix rows.append( make_row( f"same_document_multi_query_8k_{order:05d}", prompt, max_tokens, "same_document_multi_query_8k", prefix_group, prefix_tokens, approx_tokens(suffix), order, "Rows in this group reuse the same instruction, schema, and long document while varying only the final extraction question.", ) ) order += 1 return rows def agent_root_prefix(seed: int) -> str: tools = """Tools: - web_search(query): search public web snippets for recent context. - read_file(path): read a local project file and return relevant excerpts. - run_python(code): execute a short Python analysis script. - create_calendar_event(title, time): create a calendar event after explicit confirmation. - send_email(to, subject, body): draft an email after explicit confirmation.""" rules = """Output rules: Think through the task privately. When a tool is needed, emit exactly one tool call. When enough information is available, return a concise final answer with cited evidence. Never invent tool results. Preserve user constraints and ask for clarification only if blocked.""" system = "System: You are an agentic assistant helping enterprise users complete research, planning, and document-analysis tasks." return "\n\n".join([system, tools, rules, make_text(260, "software docs", seed)]) def build_conversation_prompt(root: str, turns: list[str], final_request: str) -> str: return root + "\n\nConversation:\n" + "\n".join(turns) + "\nUser: " + final_request + "\nAssistant:" def build_multiturn_rows(count: int, max_tokens: int, seed: int) -> list[dict[str, Any]]: root = agent_root_prefix(seed) base_turns = [ "User: We need to prepare a diligence memo for a vendor renewal.", "Assistant to=read_file: {\"path\":\"contracts/vendor_master_agreement.txt\"}", "Tool read_file result: The vendor agreement includes uptime reporting, renewal notice, data retention, audit rights, and regional hosting provisions.", ] branches = { "A": [ "User: Focus on operational obligations and deadlines.", "Assistant to=web_search: {\"query\":\"standard SaaS renewal operational diligence checklist\"}", "Tool web_search result: Common diligence checks include SLA reporting, incident response timing, audit evidence, and subcontractor controls.", ], "B": [ "User: Focus on privacy, security, and data retention.", "Assistant to=read_file: {\"path\":\"policies/data_processing_addendum.txt\"}", "Tool read_file result: The addendum requires encryption, access review, breach notification, retention limits, and subprocesser disclosure.", ], "C": [ "User: Focus on finance approvals and renewal pricing.", "Assistant to=run_python: {\"code\":\"print('renewal uplift: 7.5%')\"}", "Tool run_python result: renewal uplift: 7.5%", ], } leaves = { "A": [ "Create the operations-risk section with obligations, owners, and evidence.", "Create a deadline table for the operational obligations.", ], "B": [ "Create the privacy-risk section with controls, gaps, and evidence.", "Draft follow-up questions for the vendor security team.", ], "C": [ "Create the finance summary with pricing risks and approval steps.", "Draft an approval email to the procurement owner.", ], } rows = [] order = 0 while order < count: for branch_name, branch_turns in branches.items(): if order >= count: break branch_base = base_turns + branch_turns prefix_group = f"agent_branch_{branch_name}" for leaf_idx, request in enumerate(["Summarize current findings and identify the next tool call."] + leaves[branch_name]): if order >= count: break if leaf_idx == 0: turns = branch_base[:4] else: turns = branch_base + [ f"Assistant: Preliminary branch {branch_name} findings recorded. Additional evidence is needed before finalizing section {leaf_idx}.", ] request_with_notes = ( request + "\nUse the established branch context, preserve any tool evidence already shown, " + "and produce the next response as if this were a live agent transcript.\n" + make_text(105, "software docs", seed + 4000 + order) ) prompt = build_conversation_prompt(root, turns, request_with_notes) shared_prefix = root + "\n\nConversation:\n" + "\n".join(turns) suffix = "\nUser: " + request_with_notes + "\nAssistant:" rows.append( make_row( f"multiturn_agent_branching_{order:05d}", prompt, max_tokens, "multiturn_agent_branching", prefix_group, approx_tokens(shared_prefix), approx_tokens(suffix), order, "Agent conversation prompt with a common root and branch-specific turns; deeper leaves share longer prefixes with earlier branch requests.", ) ) order += 1 return rows def build_eviction_rows(count: int, max_tokens: int, seed: int) -> list[dict[str, Any]]: variants_per_group = 4 group_count = max(1, (count + variants_per_group - 1) // variants_per_group) topics = list(TOPIC_VOCAB) prefixes = [] for group_idx in range(group_count): topic = topics[group_idx % len(topics)] prefix = "\n\n".join( [ "Instruction:\nAnalyze the following source material and return JSON for the requested slice only.", "Response contract:\n" + json.dumps( { "summary": "string", "requested_items": [{"label": "string", "evidence": "string"}], "uncertainties": ["string"], }, indent=2, ), f"Shared source group {group_idx + 1} ({topic}):\n" + make_text(3900, topic, seed + 3000 + group_idx), ] ) prefixes.append((f"evict_group_{group_idx + 1:04d}", prefix, approx_tokens(prefix))) suffixes = [ "Find the five highest-priority obligations and cite the exact evidence.", "Find all dates, deadlines, and renewal windows that affect planning.", "Find the named parties, systems, teams, and approval bodies.", "Find exceptions, exclusions, and clauses likely to need manual review.", ] rows = [] order = 0 for variant_idx in range(variants_per_group): for group_idx, (prefix_group, prefix, prefix_tokens) in enumerate(prefixes): if order >= count: return rows topic = topics[group_idx % len(topics)] suffix = ( f"\n\nRequest variant {variant_idx + 1} for {prefix_group}:\n" f"{suffixes[variant_idx % len(suffixes)]}\nReturn only JSON.\n\n" f"Variant-specific review notes:\n{make_text(98, topic, seed + 5000 + order)}" ) prompt = prefix + suffix rows.append( make_row( f"eviction_pressure_4k_{order:05d}", prompt, max_tokens, "eviction_pressure_4k", prefix_group, prefix_tokens, approx_tokens(suffix), order, "Many distinct 4k-token prefixes are introduced before later variants repeat each prefix group, creating cache eviction pressure.", ) ) order += 1 return rows def write_readme(output_dir: Path) -> None: content = """--- pretty_name: PrefixBench language: - en task_categories: - text-generation tags: - text - synthetic - benchmark - llm-inference - prefix-caching - kv-cache - vllm - sglang - radix-attention size_categories: - 1K None: print("Generation summary:") for path in paths: rows = [] with path.open("r", encoding="utf-8") as handle: for line in handle: rows.append(json.loads(line)) scenarios = Counter(row["metadata"]["scenario"] for row in rows) avg_tokens = mean(approx_tokens(row["prompt"]) for row in rows) if rows else 0 scenario_text = ", ".join(f"{name}={count}" for name, count in sorted(scenarios.items())) print(f"- {path.name}: rows={len(rows)}, avg_prompt_tokens={avg_tokens:.1f}, scenarios={scenario_text}") def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description="Generate PrefixBench JSONL datasets.") parser.add_argument("--output-dir", type=Path, default=Path("."), help="Directory for JSONL outputs and README.md.") parser.add_argument( "--num-requests-per-file", type=int, default=DEFAULT_NUM_REQUESTS_PER_FILE, help="Number of rows to generate for each JSONL file.", ) parser.add_argument( "--max-output-tokens", type=int, default=DEFAULT_MAX_OUTPUT_TOKENS, help="Value written to each row's max_tokens field.", ) parser.add_argument("--seed", type=int, default=DEFAULT_SEED, help="Fixed random seed for deterministic data.") return parser.parse_args() def main() -> None: args = parse_args() if args.num_requests_per_file <= 0: raise SystemExit("--num-requests-per-file must be positive") if args.max_output_tokens <= 0: raise SystemExit("--max-output-tokens must be positive") random.seed(args.seed) args.output_dir.mkdir(parents=True, exist_ok=True) builders = { "shared_schema_1k": build_shared_schema_rows, "same_document_multi_query_8k": build_same_document_rows, "multiturn_agent_branching": build_multiturn_rows, "eviction_pressure_4k": build_eviction_rows, } written_paths = [] for scenario, builder in builders.items(): rows = builder(args.num_requests_per_file, args.max_output_tokens, args.seed) path = args.output_dir / SCENARIO_FILES[scenario] write_jsonl(path, rows) written_paths.append(path) write_readme(args.output_dir) print_summary(written_paths) print(f"README: {(args.output_dir / 'README.md').resolve()}") if __name__ == "__main__": main()