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

Título do Artigo

MEMRES: Um Resolvedor Aumentado por Memória com Cascata de Confiança para Resolução de Dependências Python Agêntica.

1. O Problema

A gestão de dependências em código Python legado é extremamente desafiadora devido ao ecossistema massivo do PyPI (mais de 500.000 pacotes). Os principais obstáculos incluem:

• Incompatibilidades: Conflitos entre Python 2 e 3, pacotes descontinuados e nomes de importação ambíguos.
• Limitações de Sistemas Atuais: O sistema líder atual, PLLM (um pipeline de 5 estágios combinando RAG e LLM), atinge apenas 54,7% de sucesso no conjunto de dados de referência HG2.9K.
• Causas de Falha Determinísticas: A análise dos erros do PLLM revelou que a maioria das falhas (33% de SyntaxErrors por execução de código Python 2 em interpretadores 3, 30% de ImportErrors por nomes de pacotes incorretos e 20% de incompatibilidades de versão) são causadas por problemas determinísticos que não exigem inferência de LLM. Chamar um LLM para esses casos é ineficiente, gastando de 60 a 120 segundos por snippet sem benefício.

2. Metodologia

O MemRes propõe um sistema agêntico que posiciona o LLM como um "último recurso", utilizando uma Cascata de Confiança (Confidence Cascade) com seis níveis de resolução. O sistema consulta componentes determinísticos antes de recorrer à inferência do modelo.

Os quatro componentes principais são:

1. Memória Intra-Sessão:

   • Armazena soluções comprovadas durante o processamento de um lote (batch).
   • Se um novo snippet tiver alta similaridade de importação (Jaccard ≥ 0.5) com um já resolvido no mesmo lote, a solução é reaplicada diretamente via pip install, evitando reavaliação pelo LLM.

2. Cascata de Confiança (6 Níveis):

   • O sistema verifica sequencialmente:
     1. Memória da Sessão.
     2. Mapa de Compatibilidade Estático (40+ pacotes x 8 versões de Python).
     3. Modelos de Ecossistema (conjuntos de versões para ML, Web, Ciência de Dados).
     4. Mineração de Co-ocorrência (baseada em 50k arquivos requirements.txt do GitHub pré-2020).
     5. Regras Heurísticas (restrições específicas de pacotes).
     6. Seleção por LLM: Acionado apenas se todos os níveis anteriores falharem.
   • Inclui um estimador de "impossibilidade de correção" para classificar snippets que dependem de ambientes de sistema não replicáveis (ex: hardware específico) como falhas de execução, evitando inflar a taxa de sucesso.

3. Memória Autoevolutiva (Self-Evolving Memory):

   • Coleta "dicas" (guias em linguagem natural) e "atalhos" (soluções reutilizáveis) validadas por builds rápidos em Docker.
   • Atua como um mecanismo de aprendizado durante a sessão, evitando a necessidade de reavaliação pelo LLM para padrões conhecidos.

4. Base de Conhecimento de Padrões de Erro (Error Pattern KB) e Heurísticas de Build:

   • Contém mais de 200 mapeamentos de importação para pacotes (import X → pip install Y), correções de nomes e regras regex.
   • Detecção de Python 2: Identifica código Python 2 (ex: print x, raw_input) e força o uso do interpretador 2.7 com pinagem de versão adaptativa.
   • Injeção de Dependências de Sistema: Mapeia pacotes pip para dependências apt-get (ex: bibliotecas C) para resolver falhas de compilação de extensões C.

3. Principais Contribuições

1. Cascata de Confiança de 6 Níveis: Reduz as chamadas ao LLM em mais de 60% enquanto melhora a precisão.
2. Memória Intra-Sessão: Permite transferência rápida de conhecimento para bases de código similares dentro do mesmo lote de avaliação.
3. Memória Autoevolutiva: Transfere conhecimento de resolução via dicas e atalhos validados, aprendendo com o tempo sem persistir estado entre execuções independentes (evitando overfitting).
4. Base de Conhecimento e Heurísticas: Integração de mapeamentos de erros curados e detecção determinística de Python 2, resolvendo a maior categoria de falhas.
5. Avaliação Robusta: Demonstração de superioridade sobre o estado da arte no benchmark HG2.9K.

4. Resultados

A avaliação foi realizada no conjunto de dados HG2.9K (2.890 snippets válidos) utilizando o modelo Gemma-2 9B em um ambiente com 10 GB de VRAM.

• Taxa de Sucesso Geral:
  • MemRes: 86,6% (2.503 snippets resolvidos em média).
  • PLLM (Baseline): 54,7% (1.583 snippets).
  • O MemRes resolveu mais de 950 snippets adicionais onde o PLLM falhou completamente (confiança = 0).
• Eficiência:
  • 68,0% dos casos bem-sucedidos foram resolvidos sem nenhuma chamada ao LLM.
  • Redução de ~75% no uso de tokens.
  • Tempo de Resolução Mediano: Caiu de ~120-180s (PLLM) para 15,2s (MemRes).
  • Média de chamadas ao LLM por snippet: 0,34 (vs. 1-5 no PLLM).
• Análise de Falhas Remanescentes:
  • ~50% das falhas restantes devem-se a erros de build/extensões C (ferramentas C ausentes).
  • ~33% são erros de importação não resolvidos (pacotes obscuros/descontinuados).
  • ~15% são timeouts na compilação de pacotes grandes.

5. Significância e Conclusão

O trabalho do MemRes demonstra que a maioria das falhas de dependência em Python possui causas determinísticas que podem ser resolvidas através de regras, heurísticas e memória de sessão, sem a necessidade de inferência de modelos de linguagem grandes (LLMs).

• Impacto: O sistema não apenas supera significativamente o estado da arte em precisão (86,6% vs 54,7%), mas também torna o processo de resolução de dependências drasticamente mais rápido e barato (menos uso de tokens).
• Inovação: A abordagem de "LLM como último recurso" dentro de uma cascata de confiança oferece um novo paradigma para agentes de IA em tarefas de engenharia de software, priorizando a eficiência e a confiabilidade determinística antes de recorrer à geração probabilística.
• Aplicabilidade: O código e os artefatos estão disponíveis publicamente, permitindo a reprodutibilidade e o uso em pipelines de síntese de ambientes para repositórios inteiros.

Em resumo, o MemRes transforma a resolução de dependências de um problema de "tentativa e erro" baseado em LLM para um processo sistemático, rápido e altamente preciso, validado empiricamente em um benchmark rigoroso.