Pith. sign in

REVIEW 4 major objections 6 minor 89 references

Harmonia: End-to-End RAG Serving Optimization

T0 review · 4 major / 6 minor · reviewed 2026-08-16 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper claims the first end-to-end serving system for RAG pipelines, reporting a 1.48x throughput gain over the best commercial alternative and about 24% fewer SLO violations across four applications.

desk verdict A useful RAG-serving system with a novel graph-capture idea and real gains, but the optimizer has a unit error and the abstract overclaims results. read the letter →

arxiv 2505.07833 v2 pith:YIVXF3SS submitted 2025-05-01 cs.DC cs.AIcs.MAcs.OS

Saurabh Agarwal , Bodun Hu , Luis Pabon , Myungjin Lee , Jayanth Srinivasa , Aditya Akella This is my paper · ORCID
classification cs.DCcs.AIcs.MAcs.OS
keywords retrieval-augmentedgenerationRAGservingresourceallocationbatchingservice-levelobjectivesdistributedinferencethroughputoptimizationpipelinescheduling
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper claims that serving retrieval-augmented generation (RAG) pipelines can be optimized end to end instead of tuning each component in isolation. It presents a system that lets developers write a RAG pipeline in ordinary Python, then automatically captures the compute graph, profiles how each component's latency scales with batch size, and solves a throughput-maximizing resource-allocation problem to decide batch sizes and CPU/GPU splits per component. At runtime, the system tracks each request's progress and prioritizes or autoscales to keep requests inside their latency deadlines. The reported payoff is a 1.48x throughput gain over the best commercial serving system tested and about 24% fewer SLO violations across four RAG applications, with much larger gains over unoptimized reference implementations. This matters because RAG serving mixes GPU-bound generation with CPU-bound retrieval, so the component that bottlenecks the pipeline can shift with workload, component choice, and configuration.

What carries the argument

The carrier of the argument is the maximizing-concurrent-flow formulation: each RAG component is a node that can simultaneously send and receive batches, and the scheduler maximizes the minimum per-component throughput subject to resource limits, batch-flow conservation from predecessors, and per-node memory bounds on batch size. Because real component runtimes are not known in closed form, the system profiles each component and fits a piecewise-linear curve $T_i(b_{i,k}, a_{i,k})$, which turns the optimization into a mixed-integer linear program solvable in seconds even for hundreds of nodes. The second mechanism is the runtime controller: a running-average estimator of remaining completion time, paired with out-of-order prioritization, temporary admission pause, and autoscaling, all coordinated by a scheduler whose per-request latency stays near two milliseconds in the reported measurements. Together these two mechanisms let the system adapt as the bottleneck moves from the retriever to the generator when components or workloads change.

What would settle it

Run the four reported RAG applications on the same cluster with the same Poisson arrivals and compare end-to-end throughput and SLO violations against the best commercial engine: if the throughput gain does not reach roughly 1.48x or the SLO reduction falls short of about 24%, the central claim fails. A sharper check is to profile one component whose latency is not piecewise-linear in batch size—such as a network-bound retriever—and verify whether the optimizer's recommended batch size still maximizes measured throughput.

Watch

Extended reading notes

Core claim

The central claim is that a developer-specified RAG pipeline can be deployed as a distributed inference system in which every component gets its own batch size and resource share, chosen by solving a max-concurrent-flow problem over the compute graph rather than by per-component heuristics. The objective is to maximize the minimum throughput across components, written as $\max \min_i \sum_k b_{i,k}/T_i(b_{i,k}, a_{i,k})$ where $b_{i,k}$ is the batch size for component $i$ on node type $k$, $a_{i,k}$ the resources allocated, and $T_i$ the profiled per-query processing time. Profiling is made scalable by modeling $T_i$ as a piecewise-linear function of batch size, which keeps the optimization a mixed-integer linear program. At runtime a lightweight estimator flags requests likely to miss their latency deadlines, and the scheduler responds by prioritizing those requests, pausing new admissions, and autoscaling the bottleneck component. The paper reports that this combination achieves a 1.48x throughput gain over the best commercial engine tested and up to 24% fewer SLO violations, with component-level batching as the largest single source of gain.

Load-bearing premise

The whole optimization assumes that each pipeline component can concurrently send and receive batches and that its per-query runtime is accurately captured by piecewise-linear profiling, so if real components behave differently under queueing, network, or straggler effects, the chosen batch sizes and resource splits will not be the throughput-maximizing ones.

Editorial extensions

If this is right

  • A developer can write a RAG pipeline as ordinary single-node Python and deploy it across heterogeneous CPUs and GPUs without writing communication or orchestration code.
  • Because batch sizes and resource splits are recomputed during autoscaling, the system can re-balance the pipeline when the bottleneck component shifts under load.
  • Component-level batching delivers the largest share of the throughput gain (about 9.6x in one ablation), with pipelining and resource allocation contributing further multiplicative gains.
  • Enabling SLO mitigation reduces deadline misses by up to 24% but can cost up to 16% end-to-end throughput, a tradeoff the paper measures explicitly.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The body of the manuscript reports 1.48x throughput gain and ~24% SLO reduction against one commercial engine, while the abstract's larger 2.04x and 78.4% figures do not correspond to the evaluation described in the body; a careful reader should treat the body's numbers as the measured claim.
  • The same concurrent-flow optimization could plausibly extend to other compound AI pipelines beyond RAG—tool-calling agents, multi-model chains, or database-backed LLM applications—wherever components scale differently with batch size and resources.
  • The SLO controller's simplicity (a running average rivals a trained tree model) suggests that deadline-miss prediction is not the main bottleneck; richer per-stage features or online learning could tighten admission control further and reduce the measured 16% throughput cost of mitigation.
  • A direct test of transferability would be to apply the piecewise-linear profiling to components with strongly superlinear or network-bound scaling, where the fitted $T_i$ may deviate enough that the chosen batch sizes cease to be throughput-optimal.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 6 minor

Summary. The paper, titled 'Patchwork: A Unified Framework for RAG Serving' in the body but announced as 'Harmonia' in the abstract, proposes an end-to-end serving framework for Retrieval-Augmented Generation pipelines. The system has three main components: a lightweight Python interface that captures user-defined RAG pipelines via PEP 523 frame evaluation; an offline scheduler that formulates component-level resource allocation and batch-size selection as a mixed-integer linear program with piecewise-linear profiling of component runtimes; and an online scheduler that predicts SLO violations and mitigates them through prioritization, admission control, and autoscaling. The evaluation covers four RAG applications (CRAG, MemoRAG, IRCoT, HippoRAG) and reports throughput improvements and SLO-violation reductions relative to a LangGraph baseline and author-provided single-node baselines. The abstract claims a 2.04x throughput improvement and up to 78.4% SLO-violation reduction, while the body reports 1.48x and about 24%.

Significance. If the central claims hold, the paper would be a useful contribution to systems support for compound AI workloads: it addresses a real problem (heterogeneous, unpredictable RAG pipelines), introduces a plausible end-to-end design, and provides an ablation separating batching, pipelining, and resource-allocation effects. The paper's strengths include a concrete implementation, measurements of scheduler and optimizer scalability, a stated one-time profiling cost, and an explicit discussion of the throughput cost of SLO mitigation. However, the significance is currently limited by three issues: the core optimization objective in Section 3.3 does not, as written, quantify the effect of replica count on throughput; the abstract and body report conflicting headline numbers and even conflicting system names; and the SLO metric is defined relative to the system's own low-load latency, making the reported violation reduction difficult to interpret. These are load-bearing for the paper's main performance claims rather than cosmetic concerns.

major comments (4)
  1. [Section 3.3, Eq. (1)] The SLO definition in Section 4.3 is self-referential: the threshold is set to 2x the average request latency of Patchwork under low load. Violation rates are therefore measured against a target derived from the system being evaluated, not from an application requirement. When comparing Patchwork with a baseline, the same numeric threshold is applied, but the baseline may have a very different low-load latency, so the comparison is not apples-to-apples. The authors should either fix a single SLO value independently of any system's measured latency, or report the low-load latencies of both systems and show that the chosen threshold is meaningful for each.
  2. [Abstract and Section 4.2] The paper's headline results are internally inconsistent. The abstract states that 'Harmonia' achieves throughput gains of 'more than 2.04x' and SLO-violation reductions of 'up to 78.4 percent,' while the body and conclusion report that 'Patchwork' achieves a 1.48x speedup and about 24% SLO-violation reduction. Section 4.2 further reports speedups of 15x, 14x, and 22x for MemoRAG, HippoRAG, and IRCoT relative to the respective author-provided baselines. The central claim of the paper cannot be assessed until the authors state which numbers are the definitive ones, reconcile the naming inconsistency, and make the abstract match the experimental evidence in the body.
  3. [Section 4.2 and Table 1] Three of the four baselines (MemoRAG, HippoRAG, IRCoT) are author-provided single-node implementations that lack component-level batching, pipelining, and resource allocation. The large speedups of 14-22x are thus improvements over unoptimized reference implementations, not over commercial serving systems. Only CRAG is compared with LangGraph, and there the reported gain is 1.48x at high load. The paper should make this distinction precise in the abstract and conclusion, and the evaluation should include stronger baselines, such as an optimized pipeline with per-component batching and pipelining but without Patchwork's resource-allocation and SLO mechanisms, so that the incremental contribution of each component is clear. Without this, the claim of being the first end-to-end RAG serving system with the stated benefits is overstated.
  4. [Section 4.2, Figure 11 and Figure 13] All throughput and SLO-violation plots lack error bars, confidence intervals, or multiple-run statistics, even though the system involves Poisson arrivals, gRPC networking, and variable LLM latencies. The reported differences, particularly the 1.48x LangGraph comparison and the roughly 24% SLO-violation reduction, are not established to be statistically distinguishable from noise. The authors should report means and variances over repeated runs, or at least state the number of runs and the observed variability.
minor comments (6)
  1. [Throughout] The system is called 'Harmonia' in the abstract and in the caption of Figure 8, but 'Patchwork' in the body, headings, tables, and conclusion. The manuscript must use a single name consistently.
  2. [Section 3.3, constraints (4)-(5)] Constraint (5) uses the symbol r_{i,k}, which was not defined; the resource allocation variable is a_{i,k} elsewhere. The notation should be unified.
  3. [Section 3.3, estimating T_i] The phrase 'profiling improvement threshold' is introduced as a fixed threshold in the binary-search profiling procedure, but the threshold value is never specified or varied in the sensitivity analysis. The authors should state the value and, ideally, test its sensitivity.
  4. [Section 4.3, Figure 10] The comparison between the running-average estimator and XGBoost is shown for a single workload (HippoRAG) without error bars or confidence intervals, so the claim that the two are 'largely similar' is not strongly supported.
  5. [Section 4.4, Figure 15] The auto-scaling experiment appears to be a single trace, and the text does not state how many violations were detected or how often autoscaling triggered. Reporting aggregate statistics would strengthen the claim that autoscaling works with zero downtime.
  6. [Section 3.3] The problem is described as a 'max-flow' formulation, but the constraints as written do not model flow on edges, capacity per edge, or routing; they only conserve batch sizes across adjacent components. The term is misleading and should either be justified or replaced with a more standard throughput-maximization description.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity; the paper's claims are validated by end-to-end measurements against external baselines rather than by a derivation that reduces to its own inputs.

full rationale

Harmonia (presented as Patchwork in the body) is a systems paper whose performance claims rest on direct measurement against external baselines, including LangGraph and author-provided single-node implementations. The offline scheduler of Section 3.3 is a formulated optimization built from profiled component runtimes, and the paper then measures the resulting system's throughput and SLO behavior in Figures 11-16; there is no fitted parameter later renamed as a prediction. The batch sizes in Table 3 are optimizer outputs, not fits to the measured end-to-end throughput, and the running-average SLO predictor is explicitly compared with XGBoost (Figure 10) before selection. The SLO threshold is defined as 2x Patchwork's own low-load latency, which makes the SLO metric a chosen evaluation convention rather than an independent target; this raises a measurement-validity question, but it does not make the reported throughput or relative violation reductions equal to the paper's inputs by construction. No load-bearing self-citation chain is present. The Eq. (1) formulation omits a multiplicative resource-count factor in the throughput expression; that is a correctness risk in the optimizer's objective rather than a circularity, because the paper does not define the claimed throughput to be true by construction.

Assumptions & free parameters 2 free parameters · 4 assumptions · 0 invented entities

The paper does not introduce new physical entities, but it relies on several modeling simplifications and a self-referential SLO definition. The two free parameters above are the only numbers the authors choose by hand that directly affect the reported metrics.

free parameters (2)
  • SLO threshold multiplier = 2
    The SLO is defined as twice the average latency of Patchwork under low load (Section 4.3), a value chosen by the authors rather than derived from an external contract. It directly determines the measured violation rate and is self-referential.
  • Profiling improvement threshold = not disclosed
    Section 3.3: 'If a profiled point yields a throughput improvement below a fixed threshold, we continue the binary search in the lower half.' The threshold value is never specified, so the profiling procedure is underdetermined and affects the fitted T_i curves.
assumptions (4)
  • domain assumption Each RAG component node can concurrently send and receive batches, so the pipeline can be modeled as a concurrent flow graph.
    Section 3.3 states this explicitly. It ignores queueing, network, and straggler effects that are present in the gRPC-based implementation.
  • domain assumption Per-component execution time is a stable function of batch size and allocated resources, captured by piecewise-linear profiling.
    The MILP in Section 3.3 uses T_i(b,a) profiles. The paper acknowledges variability from query content and conditional execution, so this assumption is only approximate.
  • domain assumption A running-average estimator of remaining runtime is sufficient for SLO-violation prediction.
    Section 3.4 selects the running average over XGBoost after showing similar SLO violation rates (Figure 10). This is an empirical choice rather than a proven bound, and it assumes historical runtimes represent future ones.
  • ad hoc to paper Users' component choices and static configurations should not be changed by the serving system.
    Requirement 2 in Section 2.3 rules out configuration adaptation (as in RAGServe [60]) and shapes the design toward resource allocation only. It is a design axiom, not a mathematical necessity.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Harmonia: End-to-End RAG Serving Optimization." pith.science (2026). https://pith.science/paper/YIVXF3SS

@misc{pith2026250507833,
  author       = {Pith},
  title        = {Pith review of: Harmonia: End-to-End RAG Serving Optimization},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YIVXF3SS}},
  note         = {Machine review of arXiv:2505.07833}
}
read the original abstract

Retrieval-Augmented Generation (RAG) improves the reliability of large language models by integrating external knowledge, but serving RAG pipelines efficiently is challenging because requests traverse heterogeneous components spanning LLM inference, databases, and CPU-side processing. We present Harmonia, an end-to-end RAG serving framework that addresses these bottlenecks through (i) a flexible pipeline specification interface for composing custom workflows, (ii) heterogeneity-aware deployment that provisions and configures components as a distributed inference system, and (iii) a closed-loop runtime controller that monitors load and execution progress and reduces SLO violations through request prioritization and auto-scaling. Across four RAG applications, Harmonia outperforms commercial alternatives, improving throughput by more than 2.04x while reducing SLO violations by up to 78.4 percent.

Figures

Figures reproduced from arXiv: 2505.07833 by the authors.

Figure 1
Figure 1. Overview of RAG Pipeline: The above figure shows a schematic of RAG pipeline with details in Section 2. RAG logic can vary dramatically from simple concatenation operation to a com￾plicated execution logic with conditional and recursive operations. framework. Users simply specify the RAG pipeline. Patch￾work then automatically orchestrates the entire pipeline, conducting holistic performance-driven component-level r… view at source ↗
Figure 2
Figure 2. Components of a RAG pipeline: The above provides a schematic of RAG execution pipeline. The box with solid colors represent the mandatory components, while the the box with hatch pattern represents the optional pattern. The text below the boxes represent a subset of parameters on which the scalability depends. 5000 10000 20000 40000 80000 Number of documents 0.00000 0.00002 0.00004 0.00006 0.00008 0.00010 0.00012 0.… view at source ↗
Figure 3
Figure 3. Scaling with documents: In the above figure, we show the time to find five nearest neighbors using L2 distance metrics scale with number of documents for two popular vector databases￾Qdrant and ChromaDB. We observe that the time taken per query by Qdrant scales faster than ChromaDB, highlighting different scalability patterns. 5 10 100 200 Number of nearest neighbors 0.00 0.01 0.02 0.03 0.04 0.05 0.06 Per-query late… view at source ↗
Figures from the paper (11 more)
Figure 4
Figure 4. Figure 4: Scaling with candidates: In the above figure, we show how the time for ChromaDB and Qdrant scales with different num￾bers of nearest neighbors. We observe that these two databases behave differently: ChromaDB remains largely constant as the num￾ber of nearest neighbors…
Figure 5
Figure 5. Figure 5: Scaling behavior of Qdrant and ChromaDB with batch size, using cosine sim￾ilarity as the distance metric. 1 2 4 8 16 Batch size 0 200 400 600 800 1000 1200 Tokens per second Ollama Llama.cpp vLLM [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 8
Figure 8. Figure 8: Patchwork overview: Patchwork consists of Patch￾work’s client library and Patchwork scheduler. The user’s RAG pipeline is written in Patchwork’s client library. Resource allocation problems at the intersection of the above requirements – brought to the fore by RAGs - h…
Figure 9
Figure 9. Figure 9: Patchwork flow: The code above shows an example of how to leverage abstraction to efficiently construct a RAG pipeline within Patchwork. logic of the RAG pipeline within a single-node environment, where Patchwork captures the computational graph. Fi￾nally, Patchwork se…
Figure 10
Figure 10. Figure 10: Scaling with request rate:The figure above shows the percentage of requests that result in SLO violations at various request rates when running on HippoRAG, with SLO enforcement enabled. We observe that performance is largely similar between XGBoost and the running av…
Figure 11
Figure 11. Figure 11: Comparing Patchwork: We compare Patchwork with baseline implementation for four different RAG systems. For LangGraph we observe speedups of atmost 1.48×. For other baselines we see speedups between 15× to 22×. 4.2 Comparing Patchwork’s Throughput We begin by evaluatin…
Figure 12
Figure 12. Figure 12: Understanding Reason for Patchwork’s perfor￾mance gains. component-level batching, pipelining, and resource alloca￾tion. To understand how Patchwork’s optimizations en￾hance performance, we conduct an ablation study. As shown in Figure 12b, we begin with a version of …
Figure 13
Figure 13. Figure 13: SLO violation minimization: We evaluate Patchwork’s impact on SLO violations and observe that it can reduce violations by up to 24%. However, under high load, Patchwork is unable to perform SLO mitigation due to limited resources, which leads to all requests violating…
Figure 14
Figure 14. Figure 14: Evaluating loss in throughput due to SLO mitigation: We evaluate the throughput loss caused by SLO mitigation strategies at different batch sizes. 0 10 20 30 40 50 60 Time (s) 60 80 100 120 140 Tokens/s SLO violation detected New machine available [PITH_FULL_IMAGE:fi…
Figure 17
Figure 17. Figure 17: Scheduler Processing Latency: We observe that processing latency per request remains constant for Patchwork’s scheduler as the load increases. This indicates that the scheduler is unlikely to become a bottleneck. 16 32 64 128 256 512 Maximum Nodes 0.0 0.5 1.0 1.5 2.0 …
Figure 18
Figure 18. Figure 18: Scalability of Optimization Problem: Optimizer latency versus number of nodes for a RAG application with 16 components. performance and find that, even on a cluster with 512 hetero￾geneous nodes, the optimization completes in around three seconds — demonstrating its e…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

89 extracted references · 32 canonical work pages

  1. [1]

    https://grpc.io/, 2025

    grpc–an rpc library and framework. https://grpc.io/, 2025. Accessed: 2025-04-17

    2025

  2. [2]

    Infercept: efficient intercept support for augmented large language model inference

    Reyna Abhyankar, Zijian He, Vikranth Srivatsa, Hao Zhang, and Yiying Zhang. Infercept: efficient intercept support for augmented large language model inference. In Proceedings of the 41st International Conference on Machine Learning , ICML’24. JMLR.org, 2024

    2024

  3. [3]

    What’s new in gurobi 9.0

    Tobias Achterberg. What’s new in gurobi 9.0. Webinar Talk url: https://www. gurobi. com/wp-content/uploads/2019/12/Gurobi-90- Overview-Webinar-Slides-1. pdf, 5(9):97–113, 2019

    2019

  4. [4]

    Sarathi: Efficient llm inference by piggybacking decodes with chunked prefills

    Amey Agrawal, Ashish Panwar, Jayashree Mohan, Nipun Kwatra, Bhargav S Gulavani, and Ramachandran Ramjee. Sarathi: Efficient llm inference by piggybacking decodes with chunked prefills. arXiv preprint arXiv:2308.16369, 2023

    arXiv 2023

  5. [5]

    Programming with legion

    Alex Aiken and Michael Bauer. Programming with legion. 2022

    2022

  6. [6]

    Improving lan- guage models by retrieving from trillions of tokens

    Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Millican, George Bm Van Den Driessche, Jean- Baptiste Lespiau, Bogdan Damoc, Aidan Clark, et al. Improving lan- guage models by retrieving from trillions of tokens. In International conference on machine learning , pages 2206–2240. PMLR, 2022

    2022

  7. [7]

    Rq-rag: Learning to refine queries for retrieval augmented generation

    Chi-Min Chan, Chunpu Xu, Ruibin Yuan, Hongyin Luo, Wei Xue, Yike Guo, and Jie Fu. Rq-rag: Learning to refine queries for retrieval augmented generation. arXiv preprint arXiv:2404.00610, 2024

    arXiv 2024

  8. [8]

    Lire: Efficient query rewriting for re- trieval augmented generation systems

    Chengfeng Chen, Xiaodong Huang, Yangzhen Xu, Runfeng Lin, Gan- gliang Li, and Shouqiang Liu. Lire: Efficient query rewriting for re- trieval augmented generation systems. In 2024 4th International Con- ference on Computer Science, Electronic Information Engineering and Intelligent Control Technology (CEI), pages 27–31. IEEE, 2024

    2024

Show all 89 references
  1. [9]

    Siyuan Chen, Zhipeng Jia, Samira Khan, Arvind Krishnamurthy, and Phillip B. Gibbons. Slos-serve: Optimized serving of multi-slo llms. 2025

    2025

  2. [10]

    Xgboost: A scalable tree boosting system

    Tianqi Chen and Carlos Guestrin. Xgboost: A scalable tree boosting system. In Proceedings of the 22nd ACM SIGKDD International Confer- ence on Knowledge Discovery and Data Mining , KDD ’16, page 785–794. ACM, August 2016

    2016

  3. [11]

    Hiqa: A hierarchical contextual augmentation rag for multi-documents qa

    Xinyue Chen, Pengyu Gao, Jiangjiang Song, and Xiaoyang Tan. Hiqa: A hierarchical contextual augmentation rag for multi-documents qa. arXiv preprint arXiv:2402.01767, 2024

    2024 arXiv

  4. [12]

    Llm-inference-bench: Inference benchmarking of large language models on ai accelerators

    Krishna Teja Chitty-Venkata, Siddhisanket Raskar, Bharat Kale, Farah Ferdaus, Aditya Tanikanti, Ken Raffenetti, Valerie Taylor, Murali Emani, and Venkatram Vishwanath. Llm-inference-bench: Inference benchmarking of large language models on ai accelerators. In SC24- W: Workshop...

    2024

  5. [13]

    Lazybatching: An sla-aware batching system for cloud machine learning inference, 2020

    Yujeong Choi, Yunseong Kim, and Minsoo Rhu. Lazybatching: An sla-aware batching system for cloud machine learning inference, 2020

    2020

  6. [14]

    https://github.com/ chroma-core/chroma

    Chroma - the open-source embedding database. https://github.com/ chroma-core/chroma

  7. [15]

    Clipper: A{Low-Latency} online prediction serving system

    Daniel Crankshaw, Xin Wang, Guilio Zhou, Michael J Franklin, Joseph E Gonzalez, and Ion Stoica. Clipper: A{Low-Latency} online prediction serving system. In 14th USENIX Symposium on Networked Systems Design and Implementation (NSDI 17) , pages 613–627, 2017

    2017

  8. [16]

    Mapreduce: simplified data pro- cessing on large clusters

    Jeffrey Dean and Sanjay Ghemawat. Mapreduce: simplified data pro- cessing on large clusters. Communications of the ACM, 51(1):107–113, 2008

    2008

  9. [17]

    From local to global: A graph rag approach to query-focused summarization

    Darren Edge, Ha Trinh, Newman Cheng, Joshua Bradley, Alex Chao, Apurva Mody, Steven Truitt, Dasha Metropolitansky, Robert Osazuwa Ness, and Jonathan Larson. From local to global: A graph rag approach to query-focused summarization. arXiv preprint arXiv:2404.16130, 2024

    2024 arXiv

  10. [18]

    Kirag: Knowledge- driven iterative retriever for enhancing retrieval-augmented genera- tion

    Jinyuan Fang, Zaiqiao Meng, and Craig Macdonald. Kirag: Knowledge- driven iterative retriever for enhancing retrieval-augmented genera- tion. arXiv preprint arXiv:2502.18397, 2025

    2025 arXiv

  11. [19]

    T-rag: lessons from the llm trenches

    Masoomali Fatehkia, Ji Kim Lucas, and Sanjay Chawla. T-rag: lessons from the llm trenches. arXiv preprint arXiv:2402.07483, 2024

    2024 arXiv

  12. [20]

    Chainpoll: A high efficacy method for llm hallucination detection

    Robert Friel and Atindriyo Sanyal. Chainpoll: A high efficacy method for llm hallucination detection. arXiv preprint arXiv:2310.18344, 2023

    2023 arXiv

  13. [21]

    Dominant resource fairness: Fair allocation of multiple resource types

    Ali Ghodsi, Matei Zaharia, Benjamin Hindman, Andy Konwinski, Scott Shenker, and Ion Stoica. Dominant resource fairness: Fair allocation of multiple resource types. In 8th USENIX symposium on networked systems design and implementation (NSDI 11) , 2011

    2011

  14. [22]

    Serving {DNNs} like clockwork: Performance predictability from the bottom up

    Arpan Gujarati, Reza Karimi, Safya Alzayat, Wei Hao, Antoine Kauf- mann, Ymir Vigfusson, and Jonathan Mace. Serving {DNNs} like clockwork: Performance predictability from the bottom up. In 14th USENIX Symposium on Operating Systems Design and Implementation (OSDI 20), pages 44...

    2020

  15. [23]

    Accelerating large-scale inference with anisotropic vector quantization

    Ruiqi Guo, Philip Sun, Erik Lindgren, Quan Geng, David Simcha, Felix Chern, and Sanjiv Kumar. Accelerating large-scale inference with anisotropic vector quantization. InInternational Conference on Machine Learning, pages 3887–3896. PMLR, 2020

    2020

  16. [24]

    Hipporag: Neurobiologically inspired long-term memory for large language models

    Bernal Jiménez Gutiérrez, Yiheng Shu, Yu Gu, Michihiro Yasunaga, and Yu Su. Hipporag: Neurobiologically inspired long-term memory for large language models. In The Thirty-eighth Annual Conference on Neural Information Processing Systems , 2024

    2024

  17. [25]

    Hipporag: Neurobiologically inspired long-term memory for large language models, 2025

    Bernal Jiménez Gutiérrez, Yiheng Shu, Yu Gu, Michihiro Yasunaga, and Yu Su. Hipporag: Neurobiologically inspired long-term memory for large language models, 2025

    2025

  18. [26]

    Retrieval-augmented generation with graphs (graphrag)

    Haoyu Han, Yu Wang, Harry Shomer, Kai Guo, Jiayuan Ding, Yongjia Lei, Mahantesh Halappanavar, Ryan A Rossi, Subhabrata Mukherjee, Xianfeng Tang, et al. Retrieval-augmented generation with graphs (graphrag). arXiv preprint arXiv:2501.00309, 2024

    2024 arXiv

  19. [27]

    Which economic tasks are performed with ai? evidence from millions of claude conversations

    Kunal Handa, Alex Tamkin, Miles McCain, Saffron Huang, Esin Dur- mus, Sarah Heck, Jared Mueller, Jerry Hong, Stuart Ritchie, Tim Be- lonax, et al. Which economic tasks are performed with ai? evidence from millions of claude conversations. arXiv preprint arXiv:2503.04761, 2025

    2025 arXiv

  20. [28]

    MOSEL: Inference serving using dynamic modality selec- tion

    Bodun Hu, Le Xu, Jeongyoon Moon, Neeraja J Yadwadkar, and Aditya Akella. MOSEL: Inference serving using dynamic modality selec- tion. In Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen, editors, Proceedings of the 2024 Conference on Empirical Methods in Natural Language Proc...

    2024

  21. [29]

    Rago: Systematic performance op- timization for retrieval-augmented generation serving

    Wenqi Jiang, Suvinay Subramanian, Cat Graves, Gustavo Alonso, Amir Yazdanbakhsh, and Vidushi Dadu. Rago: Systematic performance op- timization for retrieval-augmented generation serving. arXiv preprint arXiv:2503.14649, 2025

    2025 arXiv

  22. [30]

    Chameleon: a heterogeneous and disaggregated acceler- ator system for retrieval-augmented language models

    Wenqi Jiang, Marco Zeller, Roger Waleffe, Torsten Hoefler, and Gus- tavo Alonso. Chameleon: a heterogeneous and disaggregated acceler- ator system for retrieval-augmented language models. arXiv preprint arXiv:2310.09949, 2023

    arXiv

  23. [31]

    Piperag: Fast retrieval-augmented generation via algorithm- system co-design

    Wenqi Jiang, Shuai Zhang, Boran Han, Jie Wang, Bernie Wang, and Tim Kraska. Piperag: Fast retrieval-augmented generation via algorithm- system co-design. arXiv preprint arXiv:2403.05676, 2024

    2024 arXiv

  24. [32]

    Active retrieval augmented generation

    Zhengbao Jiang, Frank F Xu, Luyu Gao, Zhiqing Sun, Qian Liu, Jane Dwivedi-Yu, Yiming Yang, Jamie Callan, and Graham Neubig. Active retrieval augmented generation. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 7969–7992, 2023

    2023

  25. [33]

    Flashrag: A modular toolkit for efficient retrieval-augmented generation research

    Jiajie Jin, Yutao Zhu, Guanting Dong, Yuyao Zhang, Xinyu Yang, Chenghao Zhang, Tong Zhao, Zhao Yang, Zhicheng Dou, and Ji-Rong Wen. Flashrag: A modular toolkit for efficient retrieval-augmented generation research. arXiv preprint arXiv:2405.13576, 2024

    2024 arXiv

  26. [34]

    Efficient memory management for large language model serving with pagedattention

    Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph Gonzalez, Hao Zhang, and Ion Stoica. Efficient memory management for large language model serving with pagedattention. In Proceedings of the 29th Symposium on Operating Systems Principles, p...

    2023

  27. [35]

    https: //www.langchain.com/langgraph

    Langgraph platform: Design and deploy your agents at scale. https: //www.langchain.com/langgraph

  28. [36]

    Pre-training via paraphrasing

    Mike Lewis, Marjan Ghazvininejad, Gargi Ghosh, Armen Aghajanyan, Sida Wang, and Luke Zettlemoyer. Pre-training via paraphrasing. Advances in Neural Information Processing Systems , 33:18470–18481, 2020

    2020

  29. [37]

    Retrieval-augmented generation for knowledge- intensive nlp tasks

    Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, et al. Retrieval-augmented generation for knowledge- intensive nlp tasks. Advances in neural information processing system...

    2020

  30. [38]

    Dmqr-rag: Diverse multi-query rewriting for rag

    Zhicong Li, Jiahao Wang, Zhishu Jiang, Hangyu Mao, Zhongxia Chen, Jiazhen Du, Yuanxing Zhang, Fuzheng Zhang, Di Zhang, and Yong Liu. Dmqr-rag: Diverse multi-query rewriting for rag. arXiv preprint arXiv:2411.13154, 2024

    2024 arXiv

  31. [39]

    Cft-rag: An entity tree based retrieval augmented generation algorithm with cuckoo filter

    Zihang Li, Yangdong Ruan, Wenjun Liu, Zhengyang Wang, and Tong Yang. Cft-rag: An entity tree based retrieval augmented generation algorithm with cuckoo filter. arXiv preprint arXiv:2501.15098, 2025

    2025

  32. [40]

    Lyra: A benchmark for turducken-style code generation

    Qingyuan Liang, Zeyu Sun, Qihao Zhu, Wenjie Zhang, Lian Yu, Yingfei Xiong, and Lu Zhang. Lyra: A benchmark for turducken-style code generation. arXiv preprint arXiv:2108.12144, 2021

    2021 arXiv

  33. [41]

    Saferag: Benchmarking security in retrieval-augmented genera- tion of large language model

    Xun Liang, Simin Niu, Zhiyu Li, Sensen Zhang, Hanyu Wang, Feiyu Xiong, Jason Zhaoxin Fan, Bo Tang, Shichao Song, Mengwei Wang, et al. Saferag: Benchmarking security in retrieval-augmented genera- tion of large language model. arXiv preprint arXiv:2501.18636, 2025

    2025 arXiv

  34. [42]

    Telerag: Efficient retrieval-augmented generation inference with lookahead retrieval

    Chien-Yu Lin, Keisuke Kamahori, Yiyu Liu, Xiaoxiang Shi, Madhav Kashyap, Yile Gu, Rulin Shao, Zihao Ye, Kan Zhu, Stephanie Wang, et al. Telerag: Efficient retrieval-augmented generation inference with lookahead retrieval. arXiv preprint arXiv:2502.20969, 2025

    2025 arXiv

  35. [43]

    Hoprag: Multi-hop reasoning for logic-aware retrieval-augmented generation

    Hao Liu, Zhengren Wang, Xi Chen, Zhiyu Li, Feiyu Xiong, Qinhan Yu, and Wentao Zhang. Hoprag: Multi-hop reasoning for logic-aware retrieval-augmented generation. arXiv preprint arXiv:2502.12442, 2025

    2025 arXiv

  36. [44]

    https://github.com/ggml-org/llama.cpp

    Llama cpp. https://github.com/ggml-org/llama.cpp

  37. [45]

    Query rewriting in retrieval-augmented large language models

    Xinbei Ma, Yeyun Gong, Pengcheng He, Hai Zhao, and Nan Duan. Query rewriting in retrieval-augmented large language models. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 5303–5315, 2023

    2023

  38. [46]

    Luminirag: Vision-enhanced graph rag for complex multi-modal document understanding

    Lionel Martis. Luminirag: Vision-enhanced graph rag for complex multi-modal document understanding. Authorea Preprints, 2024

    2024

  39. [47]

    Helix: Serving large language models over heterogeneous gpus and network via max-flow

    Yixuan Mei, Yonghao Zhuang, Xupeng Miao, Juncheng Yang, Zhi- hao Jia, and Rashmi Vinayak. Helix: Serving large language models over heterogeneous gpus and network via max-flow. arXiv preprint arXiv:2406.01566, 2024

    2024 arXiv

  40. [48]

    Mllib: Machine learning in apache spark

    Xiangrui Meng, Joseph Bradley, Burak Yavuz, Evan Sparks, Shivaram Venkataraman, Davies Liu, Jeremy Freeman, DB Tsai, Manish Amde, Sean Owen, et al. Mllib: Machine learning in apache spark. Journal of Machine Learning Research, 17(34):1–7, 2016

    2016

  41. [49]

    Sosecure: Safer code generation with rag and stackoverflow discussions

    Manisha Mukherjee and Vincent J Hellendoorn. Sosecure: Safer code generation with rag and stackoverflow discussions. arXiv preprint arXiv:2503.13654, 2025

    2025

  42. [50]

    {Heterogeneity-Aware} cluster scheduling policies for deep learning workloads

    Deepak Narayanan, Keshav Santhanam, Fiodar Kazhamiaka, Amar Phanishayee, and Matei Zaharia. {Heterogeneity-Aware} cluster scheduling policies for deep learning workloads. In 14th USENIX Symposium on Operating Systems Design and Implementation (OSDI 20), pages 481–498, 2020

    2020

  43. [51]

    W-rag: Weakly supervised dense retrieval in rag for open-domain question answering

    Jinming Nian, Zhiyuan Peng, Qifan Wang, and Yi Fang. W-rag: Weakly supervised dense retrieval in rag for open-domain question answering. arXiv preprint arXiv:2408.08444, 2024

    2024 arXiv

  44. [52]

    Aladdin: Joint placement and scaling for slo-aware llm serving

    Chengyi Nie, Rodrigo Fonseca, and Zhenhua Liu. Aladdin: Joint placement and scaling for slo-aware llm serving. arXiv preprint arXiv:2405.06856, 2024

    2024 arXiv

  45. [53]

    Fastertransformer

    NVIDIA. Fastertransformer. https://github.com/NVIDIA/ FasterTransformer, 2023. GitHub repository, accessed on April 18, 2025

    2023

  46. [54]

    https://github.com/digithree/ollama-rag

    Ollama llm-rag. https://github.com/digithree/ollama-rag

  47. [55]

    Automatic differentiation in pytorch

    Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017

    2017

  48. [56]

    https://peps

    Pep 523 – adding a frame evaluation api to cpython. https://peps. python.org/pep-0523/

  49. [57]

    Legalbench-rag: A bench- mark for retrieval-augmented generation in the legal domain

    Nicholas Pipitone and Ghita Houir Alami. Legalbench-rag: A bench- mark for retrieval-augmented generation in the legal domain. arXiv preprint arXiv:2408.10343, 2024

    2024 arXiv

  50. [58]

    Memorag: Moving towards next-gen rag via memory-inspired knowledge discovery

    Hongjin Qian, Peitian Zhang, Zheng Liu, Kelong Mao, and Zhicheng Dou. Memorag: Moving towards next-gen rag via memory-inspired knowledge discovery. arXiv preprint arXiv:2409.05591, 2024

    2024 arXiv

  51. [59]

    Squad: 100,000+ questions for machine comprehension of text

    Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: 100,000+ questions for machine comprehension of text. arXiv preprint arXiv:1606.05250, 2016

    2016 arXiv

  52. [60]

    Ragserve: Fast quality- aware rag systems with configuration adaptation

    Siddhant Ray, Rui Pan, Zhuohan Gu, Kuntai Du, Ganesh Anantha- narayanan, Ravi Netravali, and Junchen Jiang. Ragserve: Fast quality- aware rag systems with configuration adaptation. arXiv preprint arXiv:2412.10543, 2024

    2024

  53. [61]

    {INFaaS}: Automated model-less inference serving

    Francisco Romero, Qian Li, Neeraja J Yadwadkar, and Christos Kozyrakis. {INFaaS}: Automated model-less inference serving. In 2021 USENIX Annual Technical Conference (USENIX ATC 21) , pages 397–411, 2021

    2021

  54. [62]

    Scaling retrieval-based language models with a trillion-token datastore

    Rulin Shao, Jacqueline He, Akari Asai, Weijia Shi, Tim Dettmers, Sewon Min, Luke Zettlemoyer, and Pang Wei W Koh. Scaling retrieval-based language models with a trillion-token datastore. Advances in Neural Information Processing Systems, 37:91260–91299, 2024

    2024

  55. [63]

    Nexus: A gpu cluster engine for accelerating dnn-based video analysis

    Haichen Shen, Lequn Chen, Yuchen Jin, Liangyu Zhao, Bingyu Kong, Matthai Philipose, Arvind Krishnamurthy, and Ravi Sundaram. Nexus: A gpu cluster engine for accelerating dnn-based video analysis. In Pro- ceedings of the 27th ACM Symposium on Operating Systems Principles , page...

    2019

  56. [64]

    Flexgen: high-throughput generative inference of large language mod- els with a single gpu

    Ying Sheng, Lianmin Zheng, Binhang Yuan, Zhuohan Li, Max Ryabinin, Beidi Chen, Percy Liang, Christopher Ré, Ion Stoica, and Ce Zhang. Flexgen: high-throughput generative inference of large language mod- els with a single gpu. InProceedings of the 40th International Conference ...

    2023

  57. [65]

    Enhancing retrieval and managing retrieval: A four-module synergy for improved quality and efficiency in rag systems

    Yunxiao Shi, Xing Zi, Zijing Shi, Haimin Zhang, Qiang Wu, and Min Xu. Enhancing retrieval and managing retrieval: A four-module synergy for improved quality and efficiency in rag systems. arXiv preprint arXiv:2407.10670, 2024

    2024 arXiv

  58. [66]

    Chunkrag: Novel llm-chunk filtering method for rag systems

    Ishneet Sukhvinder Singh, Ritvik Aggarwal, Ibrahim Allahverdiyev, Muhammad Taha, Aslihan Akalin, Kevin Zhu, and Sean O’Brien. Chunkrag: Novel llm-chunk filtering method for rag systems. arXiv preprint arXiv:2410.19572, 2024

    2024 arXiv

  59. [67]

    The hippocampal memory indexing theory

    Timothy J Teyler and Pascal DiScenna. The hippocampal memory indexing theory. Behavioral neuroscience, 100(2):147, 1986

    1986

  60. [68]

    Interleaving retrieval with chain-of-thought reason- ing for knowledge-intensive multi-step questions

    Harsh Trivedi, Niranjan Balasubramanian, Tushar Khot, and Ashish Sabharwal. Interleaving retrieval with chain-of-thought reason- ing for knowledge-intensive multi-step questions. arXiv preprint arXiv:2212.10509, 2022

    2022 arXiv

  61. [69]

    Interleaving retrieval with chain-of-thought reasoning for knowledge-intensive multi-step questions, 2023

    Harsh Trivedi, Niranjan Balasubramanian, Tushar Khot, and Ashish Sabharwal. Interleaving retrieval with chain-of-thought reasoning for knowledge-intensive multi-step questions, 2023

    2023

  62. [70]

    Interleaving retrieval with chain-of-thought reasoning for knowledge-intensive multi-step questions

    Harsh Trivedi, Niranjan Balasubramanian, Tushar Khot, and Ashish Sabharwal. Interleaving retrieval with chain-of-thought reasoning for knowledge-intensive multi-step questions. In Anna Rogers, Jor- dan Boyd-Graber, and Naoaki Okazaki, editors, Proceedings of the 61st Annual Me...

    2023

  63. [71]

    Instructretro: Instruction tuning post retrieval-augmented pretraining

    Boxin Wang, Wei Ping, Lawrence McAfee, Peng Xu, Bo Li, Mohammad Shoeybi, and Bryan Catanzaro. Instructretro: Instruction tuning post retrieval-augmented pretraining. arXiv preprint arXiv:2310.07713, 2023. 15

    2023 arXiv

  64. [72]

    Richrag: Crafting rich responses for multi- faceted queries in retrieval-augmented generation

    Shuting Wang, Xin Yu, Mang Wang, Weipeng Chen, Yutao Zhu, and Zhicheng Dou. Richrag: Crafting rich responses for multi- faceted queries in retrieval-augmented generation. arXiv preprint arXiv:2406.12566, 2024

    2024 arXiv

  65. [73]

    Speculative rag: Enhancing retrieval augmented generation through drafting

    Zilong Wang, Zifeng Wang, Long Le, Huaixiu Steven Zheng, Swaroop Mishra, Vincent Perot, Yuwei Zhang, Anush Mattapalli, Ankur Taly, Jingbo Shang, et al. Speculative rag: Enhancing retrieval augmented generation through drafting. arXiv preprint arXiv:2407.08223, 2024

    2024 arXiv

  66. [74]

    Chain-of-thought prompt- ing elicits reasoning in large language models

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of-thought prompt- ing elicits reasoning in large language models. Advances in neural information processing systems, 35:24824–24837, 2022

    2022

  67. [75]

    https://www.octomind.dev/blog/why-we-no-longer-use-langchain- for-building-our-ai-agents

    why we no longer use langchain for building our ai agents. https://www.octomind.dev/blog/why-we-no-longer-use-langchain- for-building-our-ai-agents

  68. [76]

    Medical graph rag: Towards safe medical large language model via graph retrieval-augmented generation.arXiv preprint arXiv:2408.04187, 2024

    Junde Wu, Jiayuan Zhu, Yunli Qi, Jingkun Chen, Min Xu, Filippo Meno- lascina, and Vicente Grau. Medical graph rag: Towards safe medical large language model via graph retrieval-augmented generation.arXiv preprint arXiv:2408.04187, 2024

    2024 arXiv

  69. [77]

    Irina: Accelerating dnn inference with efficient online scheduling

    Xiaorui Wu, Hong Xu, and Yi Wang. Irina: Accelerating dnn inference with efficient online scheduling. In Proceedings of the 4th Asia-Pacific Workshop on Networking, APNet ’20, page 36–43, New York, NY, USA,

  70. [78]

    Tkg-rag: A retrieval-augmented generation framework with text-chunk knowl- edge graph

    Wei Xiao, Yu Liu, XiangLong Li, Feng Gao, and JinGuang Gu. Tkg-rag: A retrieval-augmented generation framework with text-chunk knowl- edge graph. In 2024 25th International Arab Conference on Information Technology (ACIT), pages 1–9. IEEE, 2024

    2024

  71. [79]

    Corrective retrieval augmented generation

    Shi-Qi Yan, Jia-Chen Gu, Yun Zhu, and Zhen-Hua Ling. Corrective retrieval augmented generation. 2024

    2024

  72. [80]

    Wikiqa: A challenge dataset for open-domain question answering

    Yi Yang, Wen-tau Yih, and Christopher Meek. Wikiqa: A challenge dataset for open-domain question answering. In Proceedings of the 2015 conference on empirical methods in natural language processing , pages 2013–2018, 2015

    2015

  73. [81]

    Orca: A distributed serving system for {Transformer-Based} generative models

    Gyeong-In Yu, Joo Seong Jeong, Geon-Woo Kim, Soojeong Kim, and Byung-Gon Chun. Orca: A distributed serving system for {Transformer-Based} generative models. In 16th USENIX Sympo- sium on Operating Systems Design and Implementation (OSDI 22) , pages 521–538, 2022

    2022

  74. [82]

    Spark: Cluster computing with working sets

    Matei Zaharia, Mosharaf Chowdhury, Michael J Franklin, Scott Shenker, and Ion Stoica. Spark: Cluster computing with working sets. In 2nd USENIX workshop on hot topics in cloud computing (HotCloud 10), 2010

    2010

  75. [83]

    SHEP- HERD: Serving DNNs in the wild

    Hong Zhang, Yupeng Tang, Anurag Khandelwal, and Ion Stoica. SHEP- HERD: Serving DNNs in the wild. In 20th USENIX Symposium on Net- worked Systems Design and Implementation (NSDI 23) , pages 787–808, Boston, MA, April 2023. USENIX Association

    2023

  76. [84]

    Raft: Adapting language model to domain specific rag

    Tianjun Zhang, Shishir G Patil, Naman Jain, Sheng Shen, Matei Zaharia, Ion Stoica, and Joseph E Gonzalez. Raft: Adapting language model to domain specific rag. In First Conference on Language Modeling , 2024

    2024

  77. [85]

    Accelerating retrieval-augmented language model serving with speculation

    Zhihao Zhang, Alan Zhu, Lijie Yang, Yihua Xu, Lanting Li, Phitchaya Mangpo Phothilimthana, and Zhihao Jia. Accelerating retrieval-augmented language model serving with speculation. arXiv preprint arXiv:2401.14021, 2024

    2024 arXiv

  78. [86]

    P Xing, Joseph E

    Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Tianle Li, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zhuohan Li, Zi Lin, Eric. P Xing, Joseph E. Gonzalez, Ion Stoica, and Hao Zhang. Lmsys-chat-1m: A large-scale real-world llm conversation dataset, 2023

    2023

  79. [87]

    Seq2sql: Generating structured queries from natural language using reinforcement learning

    Victor Zhong, Caiming Xiong, and Richard Socher. Seq2sql: Generating structured queries from natural language using reinforcement learning. arXiv preprint arXiv:1709.00103, 2017. 16

    2017 arXiv

  80. [2020]

    Association for Computing Machinery

  81. [2024]

    Association for Computational Linguistics

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.