MEMRES: A Memory-Augmented Resolver with Confidence Cascade for Agentic Python Dependency Resolution

Probleemstelling

Het Python-ecosysteem omvat meer dan 500.000 pakketten op PyPI, wat het beheer van afhankelijkheden voor legacy-code aanzienlijk bemoeilijkt. Het bepalen van de juiste pakketten, versies en Python-interpreter voor een codefragment is complex vanwege:

• Incompatibiliteiten tussen Python 2 en 3.
• Verouderde (deprecated) pakketten.
• Ambigue importnamen (bijv. cv2 vs. opencv-python).

Bestaande systemen zoals PLLM (een RAG+LLM-pijplijn) bereiken slechts een succespercentage van 54,7% op de HG2.9K-benchmark. Analyse toont aan dat veel fouten deterministische oorzaken hebben (zoals syntaxisfouten door Python 2-code die onder Python 3 wordt uitgevoerd, of bekende naam-mismatches) waarvoor het gebruik van een Large Language Model (LLM) onnodig is, duur (60-120 seconden per snippet) en inefficiënt.

Methodologie: MemRes

MemRes is een agentisch systeem dat de LLM alleen als "laatste redmiddel" inzet. Het systeem gebruikt een multi-level confidence cascade (vertrouwenscascade) waarbij eerst deterministische regels en kennisbronnen worden geraadpleegd voordat er een LLM-inferentie wordt uitgevoerd.

De architectuur bestaat uit vier hoofdcomponenten die in een specifieke volgorde worden doorlopen:

1. Intra-Session Memory (Inter-sessiegeheugen):

   • Bouwt een cache op tijdens het verwerken van een batch codefragmenten.
   • Als een nieuw fragment een hoge gelijkenis heeft met een eerder succesvol opgelost fragment (bijv. identieke GitHub-forks), wordt de bekende oplossing direct hergebruikt via pip install.
   • Dit versnelt de verwerking van bijna-identieke datasets zonder herhaalde LLM-inferentie.

2. Confidence Cascade (Vertrouwenscascade):

   • Een 6-staps proces voor het selecteren van pakketversies. De cascade stopt zodra een niveau een geldige versie teruggeeft:
     1. Sessiegeheugen: Eerder bewezen versies binnen de batch.
     2. Statische Compatibiliteitskaart: Handmatig samengestelde "good pins" voor 40+ pakketten over 8 Python-versies.
     3. Ecosysteem-sjablonen: Bewezen versiecombinaties voor veelvoorkomende groepen (ML, web, data science).
     4. Co-voorkomendheid Mining: Gewogen scores gebaseerd op 50.000 open-source requirements.txt-bestanden (gefilterd op pre-2020 repositories).
     5. Heuristische Regels: 45+ pakket-specifieke beperkingen.
     6. LLM-selectie: Alleen als alle bovenstaande deterministische niveaus falen.

3. Self-Evolving Memory (Zelfevoluerend geheugen):

   • Verzamelt "tips" (natuurtaalgidsen) en "shortcuts" (herbruikbare oplossingen) gebaseerd op Jaccard-gelijkheid van importsets.
   • Shortcuts worden gevalideerd via een snelle Docker-build om fouten te voorkomen.
   • Het geheugen wordt volledig gereset tussen onafhankelijke evaluaties om overfitting te voorkomen.

4. Error Pattern Knowledge Base (KB) & Build Heuristieken:

   • Bevat 200+ mappings van importnamen naar pakketten, 35 naamcorrecties en regex-gebaseerde foutpatronen.
   • Semantische Importanalyse: Analyseert hoe imports worden gebruikt (bijv. import Image met Image.open() duidt op Pillow, niet op de standaard bibliotheek).
   • Python 2 Detectie: Detecteert Python 2-code (bijv. print x, raw_input) en forceert de uitvoering in een Python 2.7-omgeving via Docker-out-of-Docker (DooD).
   • Systeemafhankelijkheidsinjectie: Injecteert apt-get-afhankelijkheden voor C-extension pakketten en behandelt system-only pakketten (zoals GTK, RPi.GPIO) als "runtime passes" (succesvolle afhankelijkheden, maar falende omgeving).

Belangrijkste Bijdragen

1. Vertrouwenscascade: Een 6-niveau systeem dat LLM-aanroepen met meer dan 60% reduceert terwijl de nauwkeurigheid stijgt.
2. Intra-Session Memory: Mogelijk maakt het snelle kennisoverdracht voor vergelijkbare codebases binnen dezelfde batch.
3. Zelfevoluerend Geheugen: Transfereert oplossingskennis via tips en shortcuts zonder herhaalde LLM-inferentie.
4. Error Pattern KB & Heuristieken: Een database met 200+ mappings en runtime zelflering, gecombineerd met systeemafhankelijkheidsinjectie voor C-extensies.
5. Evaluatie: Een uitgebreide evaluatie op de HG2.9K-benchmark die een significant verbeterde resolutie toont.

Resultaten

De evaluatie is uitgevoerd op de HG2.9K-benchmark (2890 geldige codefragmenten) met een Gemma-2 9B-model (10 GB VRAM).

• Resolutiepercentage: MemRes lost 86,6% van de fragmenten op (gemiddeld over 10 runs), vergeleken met 54,7% voor PLLM.
• Aantal opgeloste fragmenten: 2503 van de 2890 fragmenten (PLLM faalde volledig bij 1308 fragmenten; MemRes lost er meer dan 950 van deze op).
• Efficiëntie:
  • 68,0% van de succesvolle gevallen wordt opgelost zonder enige LLM-aanroep.
  • Het verbruik van tokens wordt met ongeveer 75% gereduceerd.
  • De mediaan oplostijd voor succesvolle gevallen is 15,2 seconden (PLLM: 120-180 seconden).
• Ablatie-studie: Het uitschakelen van het Intra-Session Memory (Level 1) verlaagt het succespercentage met 5,0% (van 86,6% naar 81,6%), wat aantoont dat het geheugen cruciaal is voor het hanteren van bijna-identieke patronen.

Betekenis en Conclusie

MemRes demonstreert dat de meeste afhankelijkheidsfouten deterministische oorzaken hebben die zonder modelinferentie kunnen worden opgelost. Door de LLM te positioneren als laatste redmiddel binnen een gestructureerde cascade, bereikt het systeem:

• Een aanzienlijke verbetering in succespercentage (+31,9%).
• Een drastische reductie in kosten en tijd (minder tokens, snellere uitvoering).
• Een robuuste aanpak voor legacy-code, inclusief Python 2-detectie en systeemafhankelijkheden.

De kerninzicht is dat kennisgebaseerde heuristieken en deterministische regels de zoekruimte voor versies drastisch kunnen verkleinen voordat er überhaupt een dure LLM-query nodig is. Dit biedt een schaalbaar pad voor agentic systemen in softwareconfiguratie en versiebeheer.