Pith. sign in

REVIEW 4 major objections 6 minor 37 references

MRCoder: An Efficient Context Selecting Approach for Repository-Level Code Generation

T0 review · 4 major / 6 minor · reviewed 2026-07-30 · grok-4.5

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

Pith's one-line read MRCoder filters retrieved repository context with draft-guided API and logic signals, improving code generation accuracy while cutting tokens 30–50% and inference time by up to 52%.

desk verdict Solid systems paper: draft-guided API+BM25 context filtering plus speculative decode gives real Pass@1 and latency wins on repo code gen; novelty is compositional, not foundational. read the letter →

arxiv 2607.26805 v1 pith:R7B65DWN submitted 2026-07-29 cs.SE

Peiding Wang , Li Zhang , Fang Liu This is my paper
classification cs.SE
keywords LargeLanguageModelsContextSelectionRepository-LevelCodeGenerationEfficientInferenceRetrieval-AugmentedDraft-GuidedParallelDecoding
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

Repository-level code generation needs project-specific context, but retrieving more snippets often adds noise that hurts correctness and slows inference. This paper argues that the fix is not better retrieval alone, but a post-retrieval Map–Reduce selection step: a small model drafts code on short partitions of the retrieved set, then keeps only contexts that match the draft’s API calls or logical shape; a larger model then generates from the thinned context and verifies draft tokens in parallel. On two standard benchmarks with two code LLM families, that design raises Pass@1 over strong RAG and compression baselines while using far fewer tokens and less wall-clock time. A sympathetic reader cares because the same noisy Top-K problem shows up whenever LLMs must ground generation in a large codebase, and the paper claims a practical way to keep the useful bits without paying the full context cost.

What carries the argument

Structure-Aware Draft-Guided Selection (SADGS): after a small draft model generates code on each fixed-size partition of Top-K contexts, keep a context if it shares API calls with the draft’s external calls or ranks in the Top-L BM25 similarity to the draft; merge those sets, then generate with the target LLM under parallel draft-token verification.

What would settle it

On the same CoderEval/DevEval splits, replace SADGS with random retention of the same token budget (or force-drop contexts that share the draft’s external APIs) and check whether Pass@1 and the reported time/token gains over RAG and LongCodeZip disappear.

Watch

Extended reading notes

Core claim

The authors claim that Structure-Aware Draft-Guided Selection (SADGS) inside a Map–Reduce pipeline yields both higher functional correctness and lower cost than standard RAG, RL-tuned retrieval, selective-retrieval control tokens, or perplexity-based line compression. Drafts from a lightweight model on fixed sequential partitions supply reliable signals—API-call overlap and BM25 logical similarity—so the Reduce-phase target model sees concise, multi-perspective context and can accept draft tokens in parallel, producing up to about 53% relative Pass@1 gains and roughly 30–50% fewer tokens with inference time cuts up to about 52% on CoderEval and DevEval.

Load-bearing premise

Drafts from a much smaller model on simple sequential partitions of retrieved blocks are trustworthy enough proxies of what the large model needs that API overlap and draft–context similarity will keep the truly useful snippets and drop the rest.

Editorial extensions

If this is right

  • Raising Top-K for recall need not force a quality–latency tradeoff if draft-guided filtering follows retrieval.
  • API-call consistency plus logical similarity can replace multi-pass perplexity scoring as a cheaper selection signal.
  • Map-phase drafts can double as speculative tokens for Reduce-phase parallel verification, offsetting draft cost.
  • Sequential ranking-preserving partitions are enough; clustering or random grouping is not required for the gains.
  • The pipeline is retrieval-agnostic, so the same selection step can sit on BM25 or other retrievers.

Reading between the lines

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

  • If small-model drafts systematically miss rare project APIs, hybrid signals (static call graphs plus drafts) may be needed before scaling to multilingual or multi-million-line repos.
  • The same Map–draft–filter pattern could transfer to other long-context grounded tasks where structure (calls, schemas, citations) is cheaper to check than full perplexity sweeps.
  • Acceptance rates of draft tokens under the target model would be a useful diagnostic of when First-Draft selection helps most.
Share X Bluesky LinkedIn Reddit HN

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. MRCoder proposes a post-retrieval Map–Reduce context selection framework for repository-level code generation. In the Map phase, Top-K retrieved contexts are partitioned into fixed groups; a lightweight draft LLM generates per-group drafts; Structure-Aware Draft-Guided Selection (SADGS) retains contexts via (i) overlap between draft external API calls and context internal/external APIs (Eq. 5) and (ii) Top-L BM25 similarity between draft and contexts (Eqs. 6–7), merged in Eq. 8. In the Reduce phase, selected contexts feed a larger target LLM, and Map drafts are reused for parallel/speculative verification (Algorithm 1) to cut decoding latency. On CoderEval and DevEval with Qwen2.5-Coder and DeepSeek-Coder pairs, the paper reports higher Pass@1 than RAG and several selection/compression baselines in most settings, with ~30–50% fewer context tokens and up to ~52% lower wall-clock time, plus ablations of API, similarity, and parallel decoding components.

Significance. Repository-level RAG noise and context bloat are genuine, practical bottlenecks; a method that jointly improves Pass@1 and reduces tokens/latency is valuable to the SE and code-LLM communities. Strengths include a clear pipeline, structure-aware selection signals (API calls via tree-sitter plus draft-conditioned BM25), efficiency decomposed into Proc.T/Gen.T/All.T and tokens, ablations (Tables 3–4, Fig. 4), partition/draft-selection discussions (§6.2–6.3), a concrete case study (§6.1), and released code. The contribution is primarily empirical/systems rather than theoretical; if the draft-as-proxy assumption holds more broadly, the Map–Reduce + SADGS pattern is a reusable design point for repo-level generation.

major comments (4)
  1. [§3.3.2, §5.3 Table 3, §4.4] The central quality claim depends on small-model drafts being faithful selectors of contexts the target needs (§3.3.1–3.3.2, Eqs. 5–8). All reported runs use same-family draft/target pairs (Qwen 1.5B→7B, DeepSeek 1.3B→6.7B; §4.4). Table 3 shows that removing API or Sim sometimes does not hurt and occasionally slightly improves Pass@1 (e.g., DeepSeek CoderEval K=3/5 w/o_API). Without cross-family or weaker-draft controls, or analysis of when drafts omit needed APIs vs. latch onto lexical similarity, it remains unclear how much of the Pass@1 gain is robust to draft fidelity rather than favorable pairing and BM25 ranking. A targeted experiment or failure analysis would substantially strengthen the load-bearing proxy assumption.
  2. [§4.4, §3.3.1–3.3.2, §6.2] Hyperparameters that define SADGS—group size M=4 and logic Top-L=1—are stated as chosen from “preliminary experiments” (§4.4) without a reported sensitivity sweep in the main results. §6.2 compares partition strategies on Pass@1 but does not systematically vary M or L against both quality and token/time trade-offs. Because Eqs. 5–8 and the sequential first-group draft choice (§3.4.2) are the mechanism behind the headline 30–50% token cut and stable-vs-K behavior, the paper should show that gains are not brittle to these free parameters (or report the preliminary grid).
  3. [Table 1, §5.1, Abstract] Table 1’s strongest relative claim (e.g., +52.7% Pass@1 vs RAG for DeepSeek on CoderEval at K=10) coincides with a sharp RAG collapse (23.9). On DevEval with DeepSeek, MRCoder is tied or behind RL-Coder and/or LongCodeZip at several K (e.g., K=3,5,7,10). The narrative of consistent superiority and “more stable” K-behavior is only partly supported. Please qualify the abstract/§5 claims to match the full grid (best-K and average-K, and when compression baselines win), and avoid leading with the most favorable relative delta without that context.
  4. [§3.4.1–3.4.2, Algorithm 1, Fig. 4] Algorithm 1 extends standard speculative decoding with rejection fallback plus span re-alignment into the remaining draft suffix. The text asserts that parallel verification preserves the target model’s distribution when the same decode/sampling strategy is used (§3.4.1). Span matching and resuming from an interior draft position can change the accepted prefix path relative to pure autoregressive or vanilla speculative decoding. Please either prove/argue invariance of the final token distribution under temperature 0 (as used), or empirically verify Pass@1 with vs. without PD on the same refined context G* (quality is claimed unaffected; only w/o_PD time is ablated in Fig. 4).
minor comments (6)
  1. [Fig. 1] Figure 1 caption and axis labels are useful; ensure the main text states the exact retrieval and model setup in the figure itself for standalone reading.
  2. [§3.1, §3.4.2] Typos/wording: “Phrase Pipline” → “Phase Pipeline” (§3.4.2); “Map Phrase” / “Reduce Phrase” appear in places instead of Phase; “are are effective” (§3.1); “pipline” in §3.4.2.
  3. [Front matter] ACM reference date shows 2018 and placeholder conference/DOI (XXXXXXX). Update metadata before camera-ready.
  4. [§4.1] DevEval filtering to 1,462/1,825 runnable instances (§4.1) is reasonable; briefly state whether failures are environment vs. test flakiness and whether the filtered subset biases difficulty.
  5. [§7] Threats (§7) correctly note Python-only and BM25-centric evaluation. A single dense-retriever or cross-language spot check would help the “retrieval-agnostic” claim, even if left as limitation if resources are tight.
  6. [§4.4, §5.1] Report whether Pass@1 differences are averaged over one deterministic run (T=0) only; if so, note variance across seeds is N/A but sensitivity to retrieval ties/order may still matter.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: empirical systems paper; quality and efficiency claims are judged on external benchmarks, not redefined by the selection rules.

full rationale

MRCoder’s chain is engineering, not a first-principles derivation. Top-K retrieval, fixed sequential partitions, small-model drafts, SADGS (API-call intersection plus BM25(draft, context)), and Reduce-phase parallel verification are design choices whose success is measured by Pass@1 on CoderEval/DevEval and by token/wall-time costs—metrics external to the selection objective. Drafts guide which contexts are kept, but final correctness is not scored by re-optimizing the same API/BM25 criteria used to select them; ablations and baselines are reported against those external metrics. Hyperparameters (M=4, L=1, first-draft choice) are stated as preliminary-experiment settings, not fitted “predictions.” Self-citations (e.g., authors’ other code-generation tools) are background and not load-bearing uniqueness or ansatz imports. Speculative/parallel verification is standard decoding acceleration, not a tautological rename of the quality claim. No step reduces Eq. X to Eq. Y by construction or renames a fit as a prediction.

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

Load-bearing content is methodological and empirical. The claim rests on standard code-LLM/RAG practice, static-analysis definitions of APIs, BM25 as logic proxy, speculative-decoding acceptance semantics, and a few hand-chosen hyperparameters—not on new physical entities. Free parameters are the operational knobs (group size, Top-L, K grid, similarity leak threshold) that shape reported curves.

free parameters (4)
  • Map group size M = 4
    Fixed partition width for draft prompts; set to 4 from preliminary experiments (§4.4). Changes draft quality, parallelism, and what SADGS sees per group.
  • Logic similarity Top-L = 1
    How many BM25-ranked contexts per group are kept from the logic perspective (§3.3.2); set to 1 in prelim experiments (§4.4).
  • Retrieval Top-K grid = {0,3,5,7,10}
    Evaluated K∈{0,3,5,7,10} chosen because prelim runs showed Pass@1 rise-then-fall (§4.4); frames all main tables.
  • Near-duplicate Jaccard filter threshold = 0.9
    Contexts with Jaccard similarity >0.9 to the gold answer are removed to mitigate leakage (§3.3.1).
assumptions (5)
  • domain assumption Repository context can be adequately represented as tree-sitter-extracted function/class units ranked by a retriever (default BM25) for generation.
    Task definition and pipeline start (§3.1–3.3.1); retrieval-agnostic claim still assumes chunking+Top-K is the right interface.
  • ad hoc to paper Overlap between draft external API calls and context internal/external APIs marks contexts useful for final generation.
    Core of SADGS API perspective (Eq. 5, §3.3.2); motivated but not independently proven outside this design.
  • domain assumption BM25(draft, context) is a sufficient proxy for ‘logical similarity’ of implementation patterns.
    Logic perspective (§3.3.2 Eqs. 6–7); standard IR tool reused as semantic/structure stand-in.
  • standard math Parallel verification that accepts draft tokens only when they match target decode(p_i) preserves the target model’s output distribution under the same decoding policy.
    Speculative/parallel decoding preliminaries (§3.4.1) following established speculative decoding arguments.
  • ad hoc to paper The first Map draft (highest-ranked context group) is the best single draft for verification efficiency and quality.
    Reduce-phase choice (§3.4.2); supported by small comparison to random draft (Table 6) but still a design axiom.
invented entities (2)
  • SADGS (Structure-Aware Draft-Guided Selection)
    purpose: Name the dual-signal filter that keeps contexts by API-call intersection with drafts and Top-L BM25 similarity to drafts.
    Central named mechanism (§3.3.2); algorithmic construct, not a physical entity. Independent evidence is only via ablations/benchmarks in this paper.
  • MRCoder Map–Reduce pipeline for post-retrieval context selection
    purpose: Organize partitioned drafting, selection, aggregation, and draft-accelerated final decode for repo-level code gen.
    System framing (§3.2); composition of known parts. Falsifiable only through external re-runs of the reported metrics.

how reviews work

0 comments
Cite this review

Pith. "Pith review of MRCoder: An Efficient Context Selecting Approach for Repository-Level Code Generation." pith.science (2026). https://pith.science/paper/R7B65DWN

@misc{pith2026260726805,
  author       = {Pith},
  title        = {Pith review of: MRCoder: An Efficient Context Selecting Approach for Repository-Level Code Generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/R7B65DWN}},
  note         = {Machine review of arXiv:2607.26805}
}
read the original abstract

Large language models (LLMs) have demonstrated strong capabilities in code generation. However, repository-level code generation remains challenging, as it requires effectively identifying and utilizing repository-specific context. While retrieval-augmented generation (RAG) incorporates relevant code snippets, it often introduces redundant context that interferes with the LLM's ability to utilize relevant information, leading to degraded generation quality and increased computational cost. Moreover, existing context selection and compression methods struggle to balance efficiency and quality, either introducing additional computational overhead or failing to effectively select valid context. In this paper, we propose MRCoder, an efficient context selection framework that improves both the effectiveness and efficiency of repository-level code generation. MRCoder adopts a Map-Reduce paradigm: in the Map Phase, a lightweight draft model generates drafts over partitioned contexts, and Structure-Aware Draft-Guided Selection (SADGS) selects informative contexts based on drafts through API consistency and logical similarity; in the Reduce Phase, the refined contexts are aggregated for final generation, with a parallel verification strategy further accelerating decoding. We evaluate MRCoder on two widely used repository-level code generation benchmarks, CoderEval and DevEval, using Qwen2.5-Coder and DeepSeek-Coder as backbone LLMs. Experimental results show that MRCoder improves code generation accuracy over strong baselines while reducing token consumption by 30 to 50% and inference time by up to 52%. These results demonstrate that our proposed structured and draft-guided context selection strategy is crucial for improving both the quality and efficiency of repository-level code generation

Figures

Figures reproduced from arXiv: 2607.26805 by the authors.

Figure 1
Figure 1. Motivation Example. Results from Qwen2.5-Coder-7B-Instruct on CoderEval with BM25 retrieval. As Top-𝐾 increases, recall improves, but redundant and noisy context degrades generation quality after an initial gain. Meanwhile, longer contexts increase both token consumption and generation time, leading to reduced efficiency. The emergence of powerful code-centric LLMs, such as Qwen-Coder [11] and DeepSeek-Coder [36], h… view at source ↗
Figure 2
Figure 2. The overall pipeline of MRCoder. descending order according to their similarity to the query 𝑄. We then divide the ranked list into 𝑛 consecutive groups with a fixed stride of 𝑀: {𝐶1, . . . ,𝐶𝐾 } = Ä𝑛 𝑖=1 𝐺𝑖 , |𝐺𝑖 | = 𝑀 (𝑖 < 𝑛), |𝐺𝑛 | ≤ 𝑀 (3) where 𝑛 =  𝐾 𝑀  , and each group 𝐺𝑖 contains a contiguous segment of contexts from the ranked list. We also explored dynamic partitioning strategies based on clustering metho… view at source ↗
Figure 3
Figure 3. Inference time comparison of MRCoder and baseline methods. The green percentage boxes indicate the percentage reduction in time for MRCoder compared to the RAG baseline. 52.7% over standard RAG at 𝐾 = 10 and 31.2% over best baseline LongCodeZip. On DevEval, MRCoder consistently outperforms the RAG baseline across all settings. Although it is slightly inferior to RL-Coder (𝐾 = 3, 5) and LongCodeZip (𝐾 = 7, 10) at spe… view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Efficiency ablation analysis for MRCoder on CoderEval and DevEval. The red percentages boxes in w/o_PD denote the percentage reduction in time compared to MRCoder. can be observed in both w/o_API and w/o_Sim variants in some cases. However, the overall performance tren…
Figure 5
Figure 5. Figure 5: An example from the DevEval benchmark, illustrating the code generation results and corresponding retrieved contexts for [PITH_FULL_IMAGE:figures/full_fig_p017_5.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

37 extracted references · 2 canonical work pages

  1. [1]

    Mohiuddin Ahmed, Raihan Seraj, and Syed Mohammed Shamsul Islam. 2020. The k-means algorithm: A comprehensive survey and performance evaluation. Electronics 9, 8 (2020), 1295

    2020

  2. [2]

    Anysphere. 2023. Cursor. https://www.cursor.com/

    2023

  3. [3]

    Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, and Charles Sutton. 2021. Program Synthesis with Large Language Models. arXiv:2108.07732 [cs.PL] https://arxiv.org/abs/2108.07732

    arXiv 2021

  4. [4]

    Zhangqian Bi, Yao Wan, Zheng Wang, Hongyu Zhang, Batu Guan, Fangxin Lu, Zili Zhang, Yulei Sui, Hai Jin, and Xuanhua Shi. 2024. Iterative Refinement of Project-Level Code Context for Precise Code Generation with Compiler Feedback. In Findings of the Association for Computational Linguistics: ACL 2024, Lun-Wei Ku, Andre Martins, and Vivek Srikumar (Eds.). A...

    work page doi:10.18653/v1/2024.findings-acl.138 2024

  5. [5]

    Aichen Cai, Anmeng Zhang, Anyu Li, Bo Zhang, Bohua Cai, Chang Li, Changjian Jiang, Changkai Lu, Chao Xue, Chaocai Liang, Cheng Zhang, Dongkai Liu, Fei Wang, Guoqiang Huang, Haijian Ke, Han Lin, Hao Wang, Ji Miao, Jiacheng Zhang, Jialong Shi, Jifeng Zhu, Jingjing Qian, Junhui Luo, Junwu Xiong, Lam So, Liang Huang, Ming Ke, Mingyang Li, Panfeng Shi, Peng Ha...

    arXiv 2026

  6. [6]

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavarian...

    arXiv 2021

  7. [7]

    Florin Cuconasu, Giovanni Trappolini, Federico Siciliano, Simone Filice, Cesare Campagnano, Yoelle Maarek, Nicola Tonellotto, and Fabrizio Silvestri

  8. [8]

    Yangruibo Ding, Zijian Wang, Wasi Uddin Ahmad, Hantian Ding, Ming Tan, Nihal Jain, Murali Krishna Ramanathan, Ramesh Nallapati, Parminder Bhatia, Dan Roth, and Bing Xiang. 2023. CrossCodeEval: A Diverse and Multilingual Benchmark for Cross-File Code Completion. In Thirty-seventh Conference on Neural Information Processing Systems Datasets and Benchmarks T...

    2023

Show all 37 references
  1. [9]

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020. CodeBERT: A Pre-Trained Model for Programming and Natural Languages. arXiv:2002.08155 [cs.CL] https://arxiv.org/abs/2002.08155

    2020 arXiv

  2. [10]

    Nam Le Hai, Dung Manh Nguyen, and Nghi D. Q. Bui. 2025. On the Impacts of Contexts on Repository-Level Code Generation. In Findings of the Association for Computational Linguistics: NAACL 2025, Luis Chiruzzo, Alan Ritter, and Lu Wang (Eds.). Association for Computational Lingu...

    2025 doi

  3. [11]

    Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Keming Lu, Kai Dang, Yang Fan, Yichang Zhang, An Yang, Rui Men, Fei Huang, Bo Zheng, Yibo Miao, Shanghaoran Quan, Yunlong Feng, Xingzhang Ren, Xuancheng Ren, Jingren Zhou...

    2024 arXiv

  4. [12]

    Mintong Kang, Nezihe Merve Gürel, Ning Yu, Dawn Song, and Bo Li. 2024. C-RAG: Certified Generation Risks for Retrieval-Augmented Language Models. arXiv:2402.03181 [cs.AI] https://arxiv.org/abs/2402.03181

    2024 arXiv

  5. [13]

    Karunanayaka

    Indrajith P. Karunanayaka. 2026. SplitGuard: A Resource Efficient Framework for Auditing Train and Eval Overlap and Near Duplicate Contamination in NLP Datasets. TechRxiv 2026, 0225 (2026). arXiv:https://www.techrxiv.org/doi/pdf/10.36227/techrxiv.177205027.77074976/v1 doi:10.3...

    2026

  6. [14]

    Yaniv Leviathan, Matan Kalman, and Yossi Matias. 2023. Fast Inference from Transformers via Speculative Decoding. arXiv:2211.17192 [cs.LG] https://arxiv.org/abs/2211.17192

    2023 arXiv

  7. [15]

    Jia Li, Ge Li, Yunfei Zhao, Yongmin Li, Huanyu Liu, Hao Zhu, Lecheng Wang, Kaibo Liu, Zheng Fang, Lanshen Wang, Jiazheng Ding, Xuanming Zhang, Yuqi Zhu, Yihong Dong, Zhi Jin, Binhua Li, Fei Huang, Yongbin Li, Bin Gu, and Mengfei Yang. 2024. DevEval: A Manually-Annotated Code G...

    2024

  8. [16]

    Yanzhou Li, Shangqing Liu, Kangjie Chen, Tianwei Zhang, and Yang Liu. 2025. Impact-driven Context Filtering For Cross-file Code Completion. arXiv:2508.05970 [cs.SE] https://arxiv.org/abs/2508.05970

    2025 arXiv

  9. [17]

    Dianshu Liao, Shidong Pan, Xiaoyu Sun, Xiaoxue Ren, Qing Huang, Zhenchang Xing, Huan Jin, and Qinying Li. 2024. A3A3-CodGen: A Repository- Level Code Generation Framework for Code Reuse With Local-Aware, Global-Aware, and Third-Party-Library-Aware. IEEE Transactions on Softwar...

    2024

  10. [18]

    Wei Liu, Ailun Yu, Daoguang Zan, Bo Shen, Wei Zhang, Haiyan Zhao, Zhi Jin, and Qianxiang Wang. 2024. GraphCoder: Enhancing Repository-Level Code Completion via Code Context Graph-based Retrieval and Language Model. arXiv:2406.07003 [cs.SE] https://arxiv.org/abs/2406.07003

    2024 arXiv

  11. [19]

    Yang Liu, Li Zhang, Fang Liu, Zhuohang Wang, Donglin Wei, Zhishuo Yang, Kechi Zhang, Jia Li, and Lin Shi. 2025. RepoScope: Leveraging Call Chain-Aware Multi-View Context for Repository-Level Code Generation. arXiv preprint arXiv:2507.14791 (2025)

    2025

  12. [20]

    Stephen Robertson and Hugo Zaragoza. 2009. The Probabilistic Relevance Framework: BM25 and Beyond. Found. Trends Inf. Retr. 3, 4 (April 2009), 333–389. doi:10.1561/1500000019

    2009 doi

  13. [21]

    Baptiste Rozière, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, Jérémy Rapin, Artyom Kozhevnikov, Ivan Evtimov, Joanna Bitton, Manish Bhatt, Cristian Canton Ferrer, Aaron Grattafiori, Wenhan Xiong...

    2024 arXiv

  14. [22]

    Yuling Shi, Yichun Qian, Hongyu Zhang, Beijun Shen, and Xiaodong Gu. 2025. LongCodeZip: Compress Long Context for Code Language Models. arXiv:2510.00446 [cs.CL] https://arxiv.org/abs/2510.00446

    2025

  15. [23]

    Gonzalo Travieso, Alexandre Benatti, and Luciano da F. Costa. 2024. An Analytical Approach to the Jaccard Similarity Index. arXiv:2410.16436 [physics.data-an] https://arxiv.org/abs/2410.16436

    2024 arXiv

  16. [24]

    Gomez, Lukasz Kaiser, and Illia Polosukhin

    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. 2023. Attention Is All You Need. arXiv:1706.03762 [cs.CL] https://arxiv.org/abs/1706.03762

    2023 arXiv

  17. [25]

    Peiding Wang, Li Zhang, Fang Liu, Lin Shi, Minxiao Li, Bo Shen, and An Fu. 2025. CodeIF-Bench: Evaluating Instruction-Following Capabilities of Large Language Models in Interactive Code Generation. arXiv:2503.22688 [cs.SE] https://arxiv.org/abs/2503.22688

    2025

  18. [26]

    Peiding Wang, Li Zhang, Fang Liu, Yinghao Zhu, Wang Xu, Lin Shi, Xiaoli Lian, Minxiao Li, Bo Shen, and An Fu. 2025. EfficientEdit: Accelerating Code Editing via Edit-Oriented Speculative Decoding. arXiv:2506.02780 [cs.SE] https://arxiv.org/abs/2506.02780

    2025

  19. [27]

    Yan Wang, Xiaoning Li, Tien Nguyen, Shaohua Wang, Chao Ni, and Ling Ding. 2024. Natural Is The Best: Model-Agnostic Code Simplification for Pre-trained Large Language Models. arXiv:2405.11196 [cs.SE] https://arxiv.org/abs/2405.11196

    2024 arXiv

  20. [28]

    Yanlin Wang, Yanli Wang, Daya Guo, Jiachi Chen, Ruikai Zhang, Yuchi Ma, and Zibin Zheng. 2025. RLCoder: Reinforcement Learning for Repository-Level Code Completion. IEEE Press, 1140–1152. https://doi.org/10.1109/ICSE55347.2025.00014

    2025

  21. [29]

    Di Wu, Wasi Uddin Ahmad, Dejiao Zhang, Murali Krishna Ramanathan, and Xiaofei Ma. 2024. REPOFORMER: selective retrieval for repository-level code completion. In Proceedings of the 41st International Conference on Machine Learning (Vienna, Austria) (ICML’24). JMLR.org, Article ...

    2024

  22. [30]

    Zezhou Yang, Sirong Chen, Cuiyun Gao, Zhenhao Li, Xing Hu, Kui Liu, and Xin Xia. 2025. An Empirical Study of Retrieval-Augmented Code Generation: Challenges and Opportunities. ACM Trans. Softw. Eng. Methodol. 34, 7, Article 188 (Aug. 2025), 28 pages. doi:10.1145/3717061

    2025 doi

  23. [31]

    Hao Yu, Bo Shen, Dezhi Ran, Jiaxin Zhang, Qi Zhang, Yuchi Ma, Guangtai Liang, Ying Li, Qianxiang Wang, and Tao Xie. 2024. CoderEval: A Benchmark of Pragmatic Code Generation with Generative Pre-trained Models. In Proceedings of the IEEE/ACM 46th International Conference on Sof...

    2024

  24. [32]

    Fengji Zhang, Bei Chen, Yue Zhang, Jacky Keung, Jin Liu, Daoguang Zan, Yi Mao, Jian-Guang Lou, and Weizhu Chen. 2023. RepoCoder: Repository- Level Code Completion Through Iterative Retrieval and Generation. In Proceedings of the 2023 Conference on Empirical Methods in Natural ...

    2023

  25. [33]

    Kechi Zhang, Jia Li, Ge Li, Xianjie Shi, and Zhi Jin. 2024. CodeAgent: Enhancing Code Generation with Tool-Integrated Agent Systems for Real-World Repo-level Coding Challenges. arXiv:2401.07339 [cs.SE] https://arxiv.org/abs/2401.07339 Manuscript submitted to ACM MRCoder: An Ef...

    2024 arXiv

  26. [34]

    Zhaowei Zhang, Hongyu Zhang, Beijun Shen, and Xiaodong Gu. 2022. Diet code is healthy: simplifying programs for pre-trained models of code. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (E...

    2022

  27. [35]

    Qianhui Zhao, Li Zhang, Fang Liu, Xiaoli Lian, Qiaoyuanhe Meng, Ziqian Jiao, Zetong Zhou, Jia Li, and Lin Shi. 2025. FastCoder: Accelerating Repository-level Code Generation via Efficient Retrieval and Verification. arXiv:2502.17139 [cs.AI] https://arxiv.org/abs/2502.17139

    2025

  28. [36]

    Qihao Zhu, Daya Guo, Zhihong Shao, Dejian Yang, Peiyi Wang, Runxin Xu, Y Wu, Yukun Li, Huazuo Gao, Shirong Ma, et al. 2024. DeepSeek-Coder-V2: Breaking the Barrier of Closed-Source Models in Code Intelligence. arXiv preprint arXiv:2406.11931 (2024). Manuscript submitted to ACM

    2024 arXiv

  29. [2024]

    In Proceedings of the 47th International ACM SIGIR Conference on Research and Development in Information Retrieval (SIGIR 2024)

    The Power of Noise: Redefining Retrieval for RAG Systems. In Proceedings of the 47th International ACM SIGIR Conference on Research and Development in Information Retrieval (SIGIR 2024). ACM, 719–729. doi:10.1145/3626772.3657834

    2024

Pith tools

Reviewed July 30, 2026 · model on record in the stance chip above.