Sistema de múltiples agentes para la detección de errores de código automático

¿Puede la IA detectar y corregir errores de codificación simplemente analizando una captura de pantalla? Con un sistema de múltiples agentes para la detección de errores de código automático, la respuesta es sí. Este enfoque innovador utiliza inteligencia artificial y razonamiento para identificar errores de codificación de imágenes, proponer soluciones precisas y explicar la lógica detrás de ellas. En el núcleo hay un sistema descentralizado de múltiples agentes, donde los agentes autónomos, como modelos, herramientas o servicios de IA, trabajan en colaboración. Cada agente reúne datos, toma decisiones localizadas y contribuye a resolver tareas de depuración complejas. Al automatizar este proceso, los desarrolladores pueden ahorrar tiempo, mejorar la precisión y evitar la molestia manual de buscar soluciones en línea.

Objetivos de aprendizaje

• Comprenda el sistema de múltiples agentes con razonamiento y cómo automatiza la detección de errores y la generación de soluciones de las capturas de pantalla.
• Explore el papel de la inteligencia artificial para mejorar la eficiencia de un sistema de múltiples agentes con razonamiento para la depuración de software.
• Aprenda cómo Griptape simplifica el desarrollo de sistemas de múltiples agentes con flujos de trabajo modulares.
• Implementar un sistema de múltiples agentes para detectar errores de codificación de capturas de pantalla utilizando modelos de IA.
• Utilice modelos de lenguaje de visión y LLM basados ​​en el razonamiento para la detección y explicación de errores automatizados.
• Construya e implementa agentes de IA especializados en búsqueda en la web, razonamiento y análisis de imágenes.
• Desarrolle flujos de trabajo estructurados para extraer, analizar y resolver errores de codificación de manera eficiente.
• Optimizar la seguridad, la escalabilidad y la confiabilidad en las implementaciones del sistema de múltiples agentes.

Este artículo fue publicado como parte del Blogathon de ciencias de datos.

Sistemas de múltiples agentes: una breve introducción

Los sistemas de múltiples agentes (MAS) representan marcos intrincados que consisten en numerosos agentes inteligentes interactivos, cada uno que posee habilidades y objetivos únicos. Estos agentes pueden tomar diversas formas, incluidas aplicaciones de software, entidades robóticas, drones, sensores e incluso humanos, o una combinación de estos elementos. El objetivo principal de MAS es abordar los desafíos que los agentes individuales luchan por manejar de forma independiente al aprovechar el poder de la inteligencia colectiva, la colaboración y los esfuerzos coordinados entre los agentes.

Características distintivas de los sistemas de múltiples agentes

• Autonomía: Cada agente funciona con un nivel de autogobierno, tomando decisiones basadas en su comprensión localizada de los alrededores.
• Descentralización: La autoridad se extiende entre los agentes, lo que permite que el sistema mantenga operaciones incluso si ciertas partes fallan.
• Autoorganización: Los agentes poseen la capacidad de ajustarse y organizarse de acuerdo con los comportamientos emergentes, lo que resulta en una distribución de tareas efectiva y una gestión de conflictos.
• Funcionalidad en tiempo real: MAS puede reaccionar rápidamente a las condiciones dinámicas sin requerir la supervisión humana, lo que los hace ideales para escenarios como la respuesta de emergencia y la regulación del tráfico.

Algunos ejemplos prácticos de sistemas de agentes múltiples

Los sistemas de múltiples agentes están transformando diversas industrias al permitir una colaboración inteligente entre los agentes autónomos. Aquí hay algunos ejemplos prácticos que muestran sus aplicaciones del mundo real.

• Agente para resolver consultas dinámicamente: Este es un sistema sofisticado de múltiples agentes diseñado para abordar las consultas de los clientes de manera efectiva. Comienza aprovechando su amplia base de conocimiento y, cuando sea necesario, recupera información pertinente de herramientas integradas para ofrecer respuestas precisas.
• Asignación dinámica de boletos: Este sistema avanzado de múltiples agentes optimiza el flujo de trabajo de administración de tickets dentro de la división de atención al cliente dirigiendo automáticamente los boletos de soporte entrantes a los agentes más apropiados. Utilizando la IA generativa, evalúa cada boleto basado en criterios establecidos, como categoría, gravedad y especialización de agentes.
• Agente para analizar las brechas en la base de conocimiento: Este sistema especializado de múltiples agentes tiene como objetivo mejorar la eficacia de la base de conocimiento mediante la identificación de desafíos de soporte recurrentes que requieren una mejor cobertura en los artículos existentes. Mediante el uso de IA generativa, este agente examina las tendencias en los boletos de soporte y las consultas de los clientes para identificar áreas que necesitan mejoras.

Construir sistemas de múltiples agentes con griptape

El marco GRIPTAPE optimiza el desarrollo de agentes de IA colaborativos al equilibrar la previsibilidad y la creatividad a través del diseño modular y los flujos de trabajo seguros.

Especialización y coordinación de agentes

Griptape permite a los desarrolladores definir agentes con roles distintos, como:

• Agentes de investigación: Recopilar datos utilizando herramientas como búsqueda web y raspado
• Agentes de escritor: Transformar ideas en narraciones adaptadas a audiencias específicas
• Agentes analíticos: Validar las salidas contra esquemas predefinidos o reglas comerciales

Los agentes interactúan a través de flujos de trabajo que paralelizan las tareas mientras mantienen las dependencias. Por ejemplo, los hallazgos de un agente de investigación pueden desencadenar múltiples agentes de escritores para generar contenido simultáneamente

Diseño de flujo de trabajo

El marco admite dos enfoques:

• Tuberías secuenciales: Para la ejecución de tareas lineales (por ejemplo, Ingestión de datos → Análisis → Informes)
• Flujos de trabajo basados ​​en DAG: Para la lógica de ramificación compleja donde los agentes se ajustan dinámicamente en función de las salidas intermedias

Seguridad y escalabilidad

Las salvaguardas clave incluyen:

• Manejo de datos fuera de prueba: Minimiza la exposición de información confidencial durante las interacciones LLM
• Controles de permiso: Restringe el uso de la herramienta basado en roles de agentes
• Integración de la nube: Despliega agentes de forma independiente a través de servicios como Griptape Cloud para escalado horizontal

Las mejores prácticas de implementación

• Use los conjuntos de reglas para hacer cumplir el comportamiento del agente (por ejemplo, estándares de formato, pautas éticas)
• Aprovechar los tipos de memoria: a corto plazo para tareas creativas, a largo plazo para procesos estructurados
• Pruebe los flujos de trabajo localmente antes de implementar en entornos distribuidos

La arquitectura modular de Griptape reduce la dependencia de la ingeniería rápida al priorizar el código de Python para la definición de lógica, lo que lo hace ideal para aplicaciones de grado empresarial como la automatización de atención al cliente y las tuberías de análisis de datos en tiempo real

Implementación práctica del desarrollo de un sistema de múltiples agentes para la resolución de errores de codificación

En este tutorial, crearemos un sistema de múltiples agentes dirigido a detectar automáticamente errores de las capturas de pantalla de codificación, específicamente utilizando Python para nuestro ejemplo. Este sistema no solo identificará errores, sino que también ofrecerá a los usuarios explicaciones claras sobre cómo resolverlos. A lo largo de este proceso, utilizaremos modelos de lenguaje de visión junto con modelos de lenguaje grande basados ​​en el razonamiento para mejorar la funcionalidad de nuestro marco de múltiples agentes.

Paso 1: Instalar e importar las bibliotecas necesarias

Primero instalaremos todas las bibliotecas requeridas a continuación:

!pip install griptape
!sudo apt update
!sudo apt install -y pciutils
!pip install langchain-ollama
!curl -fsSL https://ollama.com/install.sh | sh
!pip install ollama==0.4.2
!pip install "duckduckgo-search>=7.0.1"


import os
from griptape.drivers.prompt.ollama import OllamaPromptDriver
import requests
from griptape.drivers.file_manager.local import LocalFileManagerDriver
from griptape.drivers.prompt.openai import OpenAiChatPromptDriver
from griptape.loaders import ImageLoader
from griptape.structures import Agent
from griptape.tools import FileManagerTool, ImageQueryTool
from griptape.tasks import PromptTask, StructureRunTask
from griptape.drivers.structure_run.local import LocalStructureRunDriver
from griptape.structures import Agent, Workflow

from griptape.drivers.web_search.duck_duck_go import DuckDuckGoWebSearchDriver
from griptape.structures import Agent
from griptape.tools import PromptSummaryTool, WebSearchTool

Paso 2: ejecutar el servidor Ollama y extraer los modelos

El siguiente código inicia el servidor Ollama. También extraemos el modelo “MinicPM-V” de Ollama para que este modelo de visión pueda usarse para extraer texto de notas escritas a mano.

import threading
import subprocess
import time

def run_ollama_serve():
  subprocess.Popen(("ollama", "serve"))

thread = threading.Thread(target=run_ollama_serve)
thread.start()
time.sleep(5)

!ollama pull minicpm-v

Ahora también establecemos la tecla API de ai Abrir a continuación que se necesita para chatear con el modelo Ollama en Griptape

import os
os.environ("OPENAI_API_KEY") = ""

También aprovecharemos un poderoso LLM para ayudar con el razonamiento explicando el error de codificación y la solución proporcionada con contexto suficiente. Para esto, tiramos del modelo Phi4-Mini.

!ollama pull phi4-mini

Paso 3: Crear un agente para analizar las capturas de pantalla

Comenzamos con la creación de un agente para analizar las capturas de pantalla de los errores de codificación de Python. Este agente aprovecha un modelo de lenguaje de visión (MinicPM-V) en el backend.

images_dir = os.getcwd()


def analyze_screenshots():
      driver = LocalFileManagerDriver(workdir=images_dir)
      return Agent(
          tools=(
              FileManagerTool(file_manager_driver=driver),
              ImageQueryTool(
                  prompt_driver=OllamaPromptDriver(model="minicpm-v"), image_loader=ImageLoader(file_manager_driver=driver)
              ),
          ))

Paso 4: Creación de agentes para la búsqueda y el razonamiento web

Luego creamos dos agentes, uno para la búsqueda web de posibles soluciones del error de codificación y otro para razonamiento detrás del error y sus soluciones encontradas.

def websearching_agent():
   return Agent(
        tools=(WebSearchTool(web_search_driver=DuckDuckGoWebSearchDriver()), PromptSummaryTool(off_prompt=False)),
    )
    
    
def reasoning_agent():
	 return Agent(
	    prompt_driver=OllamaPromptDriver(
	        model="phi4-mini",
	    ))

Paso 5: Definición de tareas para analizar capturas de pantalla, encontrar soluciones y proporcionar razonamiento

Usamos capturas de pantalla así para la evaluación automática. Lo guardamos en nuestro directorio de trabajo actual como “sample.jpg”. Es una hoja de respuestas escrita a mano. Este sistema de agente primero extraerá errores de capturas de pantalla de codificación e identificará posibles soluciones. Luego proporcionará un razonamiento suficiente detrás de los errores y sus soluciones.

image_file_name = "pythonerror1.jpg"
team = Workflow()
screenshotanalysis_task= StructureRunTask(
        (
            """Extract IN TEXT FORMAT ALL THE LINES FROM THE GIVEN SCREEN SHOT %s"""%(image_file_name),
        ),
        id="research",
        structure_run_driver=LocalStructureRunDriver(
            create_structure=analyze_screenshots,
        ),
    )

findingsolution_task =StructureRunTask(
                (
                  """FIND SOLUTION TO ONLY THE CODING ERRORS FOUND in the TEXT {{ parent_outputs("research") }}. DO NOT INCLUDE ANY ADDITIONAL JUNK NON CODING  LINES WHILE FINDING THE SOLUTION.

                """,
                ),id="evaluate",
                structure_run_driver=LocalStructureRunDriver(
                    create_structure=websearching_agent,
                    )
                )

reasoningsolution_task = StructureRunTask(
                (
                  """ADD TO THE PREVIOUS OUTPUT, EXPANDED VERSION OF REASONING ON HOW TO SOLVE THE ERROR BASED ON {{ parent_outputs("evaluate") }}.
                  DO INCLUDE THE WHOLE OUTPUT FROM THE PREVIOUS AGENT {{ parent_outputs("evaluate") }}  AS WELL IN THE FINAL OUTPUT.
                
                
                """,
                ),
                structure_run_driver=LocalStructureRunDriver(
                    create_structure=reasoning_agent,
                    )
                )
            

Paso 6: Ejecutando el flujo de trabajo

Ahora ejecutaremos el flujo de trabajo.

screenshotanalysis_task.add_child(findingsolution_task)
findingsolution_task.add_child(reasoningsolution_task)
screenshotanalysis_task.add_child(reasoningsolution_task)  
 
team  = Workflow(
    tasks=(screenshotanalysis_task,findingsolution_task,reasoningsolution_task),
)
answer = team.run()
print(answer.output)

Captura de pantalla de entrada

Salida del sistema de agente

Certainly! Here is an expanded explanation of how you can solve this error in 
Python:
When working with strings and integers together, it's important that both elements
are either numbers (integers or floats) for numerical operations like addition. In
your case, you're trying to concatenate a string ("hello world") The error occurs
because Python does not allow direct concatenation of strings and integers without
explicitly handling them as separate types first (i.e., by conversion). The
solution is straightforward: convert both elements to com Here's an expanded
explanation along with your corrected code:
```python
try:
# Initialize variable 'a' as 1234 (an integer)
a = 1234
# Convert 'a' from int to str and then concatenate" hello world" print(str(a) +
"hello world")
except Exception as error: # Catch any exceptions that might occur print("Oops! An
exception has occured: ", error)
# Print the type of the caught exception for debugging purposes. print("Exception
TYPE:", type (error))
# Explicitly stating what class TypeError is expected in this context,
# though it's redundant since we've already captured and printed it above.
print("Exception TYPE: ")
In summary, converting an integer to a string before concatenation solves the issue
by ensuring both elements are strings. This allows for seamless addition
(concatenation) of these two pieces into one coherent output.
Remember that this approach is not limited just to adding integers and strings; it's
applicable whenever you need to concatenate different data types in Python,
provided they can be converted or handled as compatible formats first.

Como se ve en la salida anterior, no solo el error se explica correctamente con suficiente razonamiento, sino que la solución también se proporciona con suficiente razonamiento.

Análisis con otras consultas

Probemos con otra consulta captura de pantalla con un problema de codificación de pitón diferente

Salida del sistema de agente

Certainly! Here is an expanded explanation of how we can solve any potential issues
with this corrected version:
1. **Syntax Correction**: The original error was due to improper indentation, which
caused a `IndentationError. In Python, proper block structure and consistent
indentations are crucial for the interpreter. 2. **Handling ZeroDivisionError
Properly**:
- A division by zero is an exceptional case that needs special handling.
- Using try-except blocks allows us gracefully handle this exception without
crashing our program unexpectedly (i.e., `ZeroDivisionError").
3. **Logging and Debugging Information**:
- The use of the logging module (log.debug`) helps in tracking what values are being
processed, which is useful for debugging.
Here's a complete example with proper indentation:
```python
import logging
# Configure logger to display debug level messages.
logging.basicConfig(level-logging.DEBUG)
log = logging.getLogger(____name___)
def division(a, b):
log.debug(f"Dividing {a} by {b}.")
try:
return a / b # Attempt the division operation here
except ZeroDivisionError as e: # Catch and handle zero-division error specifically.
log.exception("Oh noes!") # Log an exception message with traceback
# Example usage of function to demonstrate logging output
if __name_ "_main_":
print(division(10, 2))
try:
division (5, 0) except Exception as e:
pass
# Should work fine
# This should raise a ZeroDivisionError and log it.
# Catch any unexpected exceptions (though unlikely here)

Como se ve en la salida anterior, el error se explica correctamente con suficiente razonamiento. Además, se proporciona una solución de codificación alternativa para evitar este error, junto con suficiente razonamiento.

Probemos con otra consulta captura de pantalla con un problema de codificación de Python diferente.

Salida del sistema de agente

Certainly! Here's an expanded version of how to solve this error based on the
previous output:
1. **Identify Missing Dependency:**
The error message indicates that there is a missing dependency, specifically for the
`packaging module which setuptools requires.
2. **Install 'packaging' Package Manually (if not already installed):**
***bash
pip install packaging
3. **Upgrade Setuptools to Ensure Compatibility:**
Upgrading setuptools can help resolve any compatibility issues and ensure that all
dependencies are correctly managed:
***bash
pip install --upgrade setuptools
4. **Re-run the Installation Command:**
After installing `packaging` manually (if it wasn't installed previously) or upgrading setuptools, re-execute your original installation command to see if this
resolves any issues.
5. **Verify Dependency Resolution and Reinstallation Attempts:**
If you encounter further errors related specifically to missing dependencies after
following the above steps:
- Check for additional required packages by reviewing error messages.
- Install those specific requirements using pip, e.g., `pip install package-name>`.
6. **Check Environment Consistency:**
Ensure that your Python environment is consistent and not conflicting with other
installations or virtual environments:
***bash
# List installed packages to verify consistency across different setups (if
applicable)
pip list
# If using a specific version of setuptools, ensure it's correctly configured:
7. **Consult Documentation:**
Refer to the official documentation for both `packaging and `setuptools if you
encounter persistent issues or need more detailed guidance on resolving complex
dependency problems.
8. **Seek Community Help (if needed):**
If after following these steps, you're still facing difficulties:
- Post a question with specific error messages in relevant forums like Stack
Overflow.
- Provide details about your environment setup and the commands you've run for
better assistance from community members or experts.
By carefully addressing each step above based on what you encounter during
installation attempts (as indicated by any new errors), you'll be able to resolve
missing dependencies effectively. This systematic approach ensures that all
required packages are correctly installed

Conclusión

La integración de un sistema de agentes múltiples (MAS) para detectar automáticamente los errores de codificación de las capturas de pantalla ofrece mejoras significativas en la eficiencia del desarrollador. Al aprovechar la IA y las herramientas como Griptape, este enfoque proporciona soluciones oportunas y precisas con un razonamiento detallado, ahorrando un tiempo valioso para los desarrolladores. Además, la flexibilidad y la escalabilidad de MAS se pueden aplicar en varias industrias, lo que permite la gestión de tareas sin problemas y una mayor productividad.

Control de llave

• La integración de un sistema automatizado para identificar errores de codificación de capturas de pantalla ahorra a los desarrolladores un tiempo significativo al proporcionar soluciones precisas con un razonamiento detallado, reduciendo la necesidad de una búsqueda de errores manuales.
• MAS es una arquitectura descentralizada que utiliza agentes autónomos para colaborar en la resolución de problemas complejos, mejorando la gestión de tareas y la escalabilidad en todas las industrias.
• El marco de Griptape simplifica el desarrollo de sistemas de múltiples agentes, que ofrece diseño modular, especialización de agentes, flujos de trabajo seguros y escalabilidad, lo que lo hace ideal para soluciones de IA de nivel empresarial.
• MAS puede adaptarse dinámicamente a las condiciones cambiantes, haciéndolas ideales para aplicaciones en tiempo real, como la detección de errores de codificación, la automatización de atención al cliente y el análisis de datos.

Preguntas frecuentes

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se usan a discreción del autor.