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

Resumen Técnico: MEMRES

1. El Problema

La gestión de dependencias en Python es extremadamente compleja debido a su vasto ecosistema (más de 500,000 paquetes en PyPI). Los desafíos principales incluyen:

• Incompatibilidades: Diferencias críticas entre Python 2 y 3, paquetes obsoletos y nombres de importación ambiguos.
• Fallas en la Resolución Actual: El sistema líder actual, PLLM (basado en LLMs y RAG), logra una tasa de éxito de solo el 54.7% en el conjunto de datos de referencia HG2.9K.
• Causas Deterministas Ignoradas: El análisis de las fallas de PLLM revela que el 83% de los errores son causales deterministas que no requieren inferencia de un LLM:
  • 33%: SyntaxError por ejecutar código Python 2 bajo un intérprete Python 3.
  • 30%: ImportError por desajustes de nombres conocidos (ej. cv2 debe ser opencv-python).
  • 20%: Incompatibilidades de versiones resolubles mediante mapas curados.
• Ineficiencia: Llamar a un LLM para estos casos desperdicia entre 60 y 120 segundos por fragmento de código sin aportar valor.

2. Metodología: MEMRES

MEMRES es un sistema agéntico que introduce una Cascada de Confianza (Confidence Cascade) de múltiples niveles. La premisa central es que el LLM debe ser el último recurso, utilizándose solo cuando todas las reglas deterministas fallan.

El sistema se compone de cuatro pilares principales que se consultan en orden:

1. Memoria Intra-Sesión (Intra-Session Memory):

   • Almacena soluciones probadas exitosamente dentro del mismo lote de procesamiento.
   • Si un nuevo fragmento de código tiene una alta similitud de importaciones con uno ya resuelto, reutiliza la solución (ej. pip install) sin consultar al LLM.
   • Permite una transferencia rápida de conocimiento dentro del mismo batch de evaluación.

2. Cascada de Confianza (6 Niveles):
   Un flujo de decisión adaptativo que selecciona versiones de paquetes y Python:

   • Nivel 1: Memoria de Sesión (soluciones previas).
   • Nivel 2: Mapa de Compatibilidad Estático (40+ paquetes x 8 versiones de Python, curados manualmente).
   • Nivel 3: Plantillas del Ecosistema (23 conjuntos de versiones probados para grupos comunes como ML o Web).
   • Nivel 4: Minería de Co-ocurrencia (basada en 50k archivos requirements.txt de GitHub pre-2020).
   • Nivel 5: Reglas Heurísticas (45+ restricciones específicas por paquete).
   • Nivel 6: Selección por LLM (Solo si fallan los niveles 1-5).
   • Estimador de Irreparabilidad: Clasifica fragmentos que dependen de hardware o sistemas externos (ej. gtk, RPi.GPIO) como "pases de tiempo de ejecución" (falsos negativos intencionales para no inflar la métrica).

3. Memoria Auto-Evolucionante (Self-Evolving Memory):

   • Recopila "consejos" (guías en lenguaje natural) y "atajos" (soluciones reutilizables validadas por similitud Jaccard).
   • Las nuevas soluciones se validan en contenedores Docker aislados antes de guardarse, evitando la propagación de errores.
   • El estado se reinicia entre ejecuciones independientes para evitar overfitting.

4. Base de Conocimiento de Patrones de Error y Heurísticas de Construcción:

   • Error Pattern KB: Contiene más de 200 mapeos de importación a paquetes, correcciones de nombres y reglas de expresiones regulares. Aprende en tiempo real durante la ejecución.
   • Análisis Semántico de Importaciones: No solo mapea import X a pip install X, sino que analiza el uso del código (ej. import Image con Image.open() se resuelve como Pillow).
   • Detección de Python 2: Identifica determinísticamente código Python 2 (usando indicadores como print x, urllib2) y fuerza la ejecución en un contenedor Python 2.7 mediante la técnica Docker-out-of-Docker (DooD).
   • Inyección de Dependencias del Sistema: Mapea paquetes pip a dependencias apt-get necesarias para compilaciones de extensiones C, resolviendo fallos comunes de compilación.

3. Contribuciones Clave

1. Cascada de Confianza: Reduce las llamadas al LLM en más del 60% mientras mejora la precisión, priorizando reglas deterministas.
2. Memoria Intra-Sesión: Habilita la transferencia de resolución rápida para bases de código similares sin inferencia repetida.
3. Memoria Auto-Evolucionante: Transfiere conocimiento mediante consejos y atajos validados, aprendiendo de los éxitos y fracasos dentro de la sesión.
4. Base de Conocimiento y Heurísticas: Un KB con 200+ mapeos y técnicas de inyección de dependencias del sistema para manejar paquetes C y detección robusta de Python 2.
5. Evaluación Superior: Demuestra una tasa de resolución global del 86.6%, superando significativamente al estado del arte.

4. Resultados Experimentales

Evaluado en el conjunto de datos HG2.9K (2890 fragmentos de código) utilizando el modelo Gemma-2 9B (10 GB VRAM):

• Tasa de Éxito Global:
  • MemRes: 86.6% (2503 fragmentos resueltos).
  • PLLM (Baseline): 54.7% (1583 fragmentos).
  • Mejora: MemRes resuelve más de 950 fragmentos adicionales que PLLM no pudo resolver (donde la confianza era 0).
• Eficiencia:
  • 68.0% de los casos exitosos se resolvieron sin ninguna llamada al LLM.
  • Reducción del uso de tokens en ~75%.
  • Tiempo de Resolución Mediano: 15.2 segundos (vs. 120-180s de PLLM).
  • Promedio de llamadas al LLM por fragmento: 0.34 (vs. 1-5 en PLLM).
• Análisis de Fallos:
  • Las fallas restantes (13.4%) se deben principalmente a errores de compilación de extensiones C (50%), importaciones no resolubles de paquetes obsoletos (~33%) y tiempos de espera.

5. Significado e Impacto

El trabajo de MemRes demuestra que la mayoría de los problemas de resolución de dependencias en Python tienen causas raíz deterministas que pueden abordarse mediante reglas heurísticas, bases de conocimiento curadas y análisis semántico, sin necesidad de la costosa inferencia de modelos de lenguaje grandes (LLM).

• Paradigma Agéntico: Propone un cambio de enfoque donde el LLM actúa como un "último recurso" en lugar del motor principal, optimizando costos y latencia.
• Viabilidad Práctica: Al reducir el tiempo de resolución a ~15 segundos y eliminar la dependencia del LLM para la mayoría de los casos, hace viable la integración de sistemas de resolución automática en flujos de trabajo de desarrollo continuo (CI/CD) y herramientas de mantenimiento de código heredado.
• Reproducibilidad: El sistema aborda directamente la brecha entre el código generado y los conjuntos de dependencias reproducibles, un problema crítico en la ingeniería de software actual.

En conclusión, MemRes establece un nuevo estándar para la resolución de dependencias en Python, combinando la velocidad de las reglas deterministas con la flexibilidad de los agentes de IA, logrando una precisión superior y una eficiencia operativa drásticamente mejorada.