Multi-Agent-System zur automatischen Codefehlererkennung

Kann KI Codierungsfehler erkennen und beheben, indem sie einen Screenshot analysieren? Mit einem Multi-Agent-System zur automatischen Codefehlererkennung lautet die Antwort Ja. Dieser modern Ansatz verwendet künstliche Intelligenz und Argumentation, um Codierungsfehler aus Bildern zu identifizieren, genaue Lösungen vorzuschlagen und die Logik dahinter zu erklären. Im Kern befindet sich ein dezentrales Multi-Agent-System, in dem autonome Agenten-wie AI-Modelle, Instruments oder Dienste-zusammenarbeiten. Jeder Agent sammelt Daten, trifft lokalisierte Entscheidungen und trägt zur Lösung komplexer Debugging -Aufgaben bei. Durch die Automatisierung dieses Prozesses können Entwickler Zeit sparen, die Genauigkeit verbessern und den manuellen Drawback vermeiden, on-line nach Lösungen zu suchen.

Lernziele

• Verstehen Sie das Multi-Agent-System mit Argumentation und der Automatisierung der Fehlererkennung und der Erzeugung von Lösungen von Screenshots.
• Erforschen Sie die Rolle der künstlichen Intelligenz bei der Verbesserung der Effizienz eines Multi-Agent-Methods mit Argumentation für das Debuggen von Software program.
• Erfahren Sie, wie Griptape die Entwicklung von Multi-Agent-Systemen mit modularen Workflows vereinfacht.
• Implementieren Sie ein Multi-Agent-System zum Erkennen von Codierungsfehlern von Screenshots mithilfe von AI-Modellen.
• Verwenden Sie Visionsprachmodelle und argumentationsbasierte Sichtsprachen Llms Für die automatisierte Fehlererkennung und Erklärung.
• Erstellen und Bereitstellen von KI -Agenten, die auf Websuche, Argumentation und Bildanalyse spezialisiert sind.
• Entwickeln Sie strukturierte Workflows, um Codierungsfehler effizient zu extrahieren, zu analysieren und zu lösen.
• Optimieren Sie die Sicherheit, Skalierbarkeit und Zuverlässigkeit bei den Implementierungen von Mehragentystemen.

Dieser Artikel wurde als Teil der veröffentlicht Information Science Blogathon.

Multi -Agenten -Systeme: Eine kurze Einführung

Multi-Agent-Systeme (MAS) repräsentieren komplizierte Rahmenbedingungen, die aus zahlreichen interaktiven intelligenten Agenten bestehen, die jeweils einzigartige Fähigkeiten und Ziele besitzen. Diese Agenten können verschiedene Formen annehmen, einschließlich Softwareanwendungen, Roboterentitäten, Drohnen, Sensoren und sogar Menschen oder eine Mischung dieser Elemente. Der Hauptzweck von MAS ist es, die Herausforderungen zu bewältigen, die einzelne Agenten Schwierigkeiten haben, unabhängig zu managen, indem sie die Macht der kollektiven Intelligenz, der Zusammenarbeit und der koordinierten Bemühungen der Agenten nutzen.

Unterscheidungsmerkmale von Multi-Agent-Systemen

• Autonomie: Jeder Agent funktioniert mit einem Maß an Selbstverwaltung und entscheidet auf der Grundlage seines lokalisierten Verständnisses der Umgebung.
• Dezentralisierung: Die Autorität wird über die Agenten verteilt, sodass das System den Betrieb aufrechterhalten kann, auch wenn bestimmte Teile ausfallen.
• Selbstorganisation: Die Agenten besitzen die Fähigkeit, sich nach neuem Verhalten anzupassen und zu arrangieren, was zu einer wirksamen Aufgabenverteilung und Konfliktmanagement führt.
• Echtzeitfunktionalität: MAS kann schnell auf dynamische Bedingungen reagieren, ohne dass die menschliche Kontrolle erforderlich ist, was sie preferrred für Szenarien wie die Notfallreaktion und die Verkehrsregulierung macht.

Einige praktische Beispiele für Multi -Agent -Systeme

Multi-Agent-Systeme verändern verschiedene Branchen, indem sie intelligente Zusammenarbeit zwischen autonomen Agenten ermöglichen. Hier sind einige praktische Beispiele, die ihre realen Anwendungen zeigen.

• Agent zur dynamischen Auflösung von Abfragen: Dies ist ein ausgeklügeltes Multi-Agent-System, mit dem Kundenanfragen effektiv behandelt werden sollen. Es beginnt damit, seine umfangreiche Wissensbasis zu nutzen und bei Bedarf relevante Informationen von integrierten Instruments abzurufen, um genaue Antworten zu liefern.
• Dynamische Zuordnung von Tickets: Dieses fortschrittliche Multi-Agent-System rationalisiert den Ticketverwaltungs-Workflow innerhalb der Kundendienstabteilung, indem sie eingehende Help-Tickets automatisch an die am besten geeigneten Agenten weiterleiten. Unter Verwendung generativer KI bewertet es jedes Ticket basierend auf festgelegten Kriterien wie Kategorie, Schweregrad und Agentenspezialisierung.
• Agent zur Analyse von Lücken in der Wissensbasis: Dieses spezielle Multi-Agent-System zielt darauf ab, die Wirksamkeit der Wissensbasis zu verbessern, indem rezidivierende Unterstützungsprobleme festgelegt werden, die in bestehenden Artikeln eine bessere Abdeckung erfordern. Durch die Verwendung von generativer KI untersucht dieser Agent Developments in Bezug auf Help -Tickets und Kundenanfragen, um Bereiche zu identifizieren, die verbessert werden müssen.

Aufbau von Multi-Agent-Systemen mit Griptape

Das Griptape -Framework rationalisiert die Entwicklung kollaborativer KI -Agenten, indem sie die Vorhersehbarkeit und Kreativität durch modulare Design und sichere Arbeitsabläufe ausbalancieren.

Agentenspezialisierung und Koordination

Mit Griptape können Entwickler Mittel mit unterschiedlichen Rollen definieren, wie z. B.:

• Forschungsagenten: Sammeln Sie Daten mithilfe von Instruments wie Websuche und Scraping
• Schriftstelleragenten: Verwandeln Sie Erkenntnisse in Erzählungen, die auf bestimmtes Publikum zugeschnitten sind
• Analytische Agenten: Validieren Sie Outputs gegen vordefinierte Schemas oder Geschäftsregeln

Agenten interagieren durch Workflows, die Aufgaben parallelisieren und gleichzeitig Abhängigkeiten aufrechterhalten. Zum Beispiel können die Ergebnisse eines Forschungsagenten mehrere Autoren -Agenten dazu veranlassen, Inhalte gleichzeitig zu generieren

Workflow -Design

Das Framework unterstützt zwei Ansätze:

• Sequentielle Pipelines: Für die lineare Aufgabenausführung (z. B. Datenaufnahme von Daten → Analyse → Berichterstattung)
• DAG-basierte Workflows: Für komplexe Verzweigungslogik, bei der Agenten basierend auf Zwischenausgängen dynamisch anpassen

Sicherheit und Skalierbarkeit

Zu den wichtigsten Sicherheitsvorkehrungen gehören:

• Off-Immediate-Datenhandhabung: Minimiert die Exposition von empfindlichen Informationen während der LLM -Wechselwirkungen
• Berechtigungskontrollen: Beschränken Sie die Werkzeugnutzung basierend auf Agentenrollen
• Cloud -Integration: Bereiten Sie Agenten unabhängig über Dienste wie Griptape Cloud für horizontale Skalierung ein

Finest Practices der Implementierung

• Verwenden Sie Regeln, um das Verhalten des Agenten durchzusetzen (z. B. Formatierungsstandards, ethische Richtlinien).
• Hebelgedächtnistypen: kurzfristig für kreative Aufgaben, langfristig für strukturierte Prozesse
• Testen Sie die Workflows lokal vor dem Einsatz in verteilten Umgebungen

Die modulare Architektur von Griptape reduziert das Vertrauen in das schnelle Engineering durch Priorisierung von Python-Code für die Logikdefinition und macht ihn preferrred für Anwendungen für Unternehmensqualität wie Buyer Help Automation und Echtzeit-Datenanalyse-Pipelines

Praktische Implementierung der Entwicklung eines Multi-Agent-Methods zur Auflösung von Codierungsfehlern

In diesem Tutorial werden wir ein Multi-Agent-System erstellen, das darauf abzielt, Fehler automatisch aus Screenshots zu erkennen, insbesondere Python für unser Beispiel. Dieses System identifiziert nicht nur Fehler, sondern bietet Benutzern auch klare Erklärungen zur Behebung. Während dieses Prozesses werden wir Imaginative and prescient-Sprachmodelle in Verbindung mit argumentationsbasierten großsprachigen Modellen verwenden, um die Funktionalität unseres Multi-Agent-Frameworks zu verbessern.

STEP1: Installieren und Importieren der erforderlichen Bibliotheken

Zuerst installieren wir alle erforderlichen Bibliotheken unten:

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


import os
from griptape.drivers.immediate.ollama import OllamaPromptDriver
import requests
from griptape.drivers.file_manager.native import LocalFileManagerDriver
from griptape.drivers.immediate.openai import OpenAiChatPromptDriver
from griptape.loaders import ImageLoader
from griptape.buildings import Agent
from griptape.instruments import FileManagerTool, ImageQueryTool
from griptape.duties import PromptTask, StructureRunTask
from griptape.drivers.structure_run.native import LocalStructureRunDriver
from griptape.buildings import Agent, Workflow

from griptape.drivers.web_search.duck_duck_go import DuckDuckGoWebSearchDriver
from griptape.buildings import Agent
from griptape.instruments import PromptSummaryTool, WebSearchTool

STEP2: Ausführen des Ollama -Servers und Ziehen der Modelle

Der folgende Code startet den Ollama -Server. Wir ziehen auch das „Minicpm-V“ -Modell von Ollama, damit dieses Visionsmodell verwendet werden kann, um Textual content aus handgeschriebenen Notizen zu extrahieren.

import threading
import subprocess
import time

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

thread = threading.Thread(goal=run_ollama_serve)
thread.begin()
time.sleep(5)

!ollama pull minicpm-v

Jetzt setzen wir auch den folgenden Open AI -API -Schlüssel, der benötigt wird, um mit dem Ollama -Modell auf Griptape zu chatten

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

Wir werden auch eine leistungsstarke LLM nutzen, um die Argumentation zu unterstützen, indem wir den Codierungsfehler und die bereitgestellte Lösung mit ausreichendem Kontext erklären. Dafür ziehen wir das PHI4-Mini-Modell.

!ollama pull phi4-mini

Schritt 3: Erstellen eines Agenten zur Analyse von Screenshots

Wir beginnen damit, einen Agenten zu erstellen, um Screenshots von Python -Codierungsfehlern zu analysieren. Dieser Agent nutzt ein Imaginative and prescient-Sprachmodell (Minicpm-V) im Backend.

images_dir = os.getcwd()


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

Schritt 4: Erstellen von Agenten für Websuche und Argumentation

Anschließend erstellen wir zwei Agenten, eine für die Suche nach Internet -Lösungen des Codierungsfehlers und eine für eine Argumentation hinter dem Fehler und seine gefundenen Lösungen.

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

Schritt 5: Aufgaben zur Analyse von Screenshots, das Finden von Lösungen und die Bereitstellung von Argumentation

Wir verwenden Screenshots So für die automatische Bewertung. Wir speichern es in unserem aktuellen Arbeitsverzeichnis als „pattern.jpg“. Es ist ein handgeschriebenes Antwortblatt. Dieses Agentensystem extrahiert zunächst Fehler aus dem Codieren von Screenshots und identifizieren mögliche Lösungen. Es wird dann eine ausreichende Begründung für die Fehler und ihre Lösungen darstellen.

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

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

                """,
                ),id="consider",
                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("consider") }}.
                  DO INCLUDE THE WHOLE OUTPUT FROM THE PREVIOUS AGENT {{ parent_outputs("consider") }}  AS WELL IN THE FINAL OUTPUT.
                
                
                """,
                ),
                structure_run_driver=LocalStructureRunDriver(
                    create_structure=reasoning_agent,
                    )
                )
            

Schritt6: Ausführen des Workflows

Jetzt werden wir den Workflow ausführen.

screenshotanalysis_task.add_child(findingsolution_task)
findingsolution_task.add_child(reasoningsolution_task)
screenshotanalysis_task.add_child(reasoningsolution_task)  
 
staff  = Workflow(
    duties=(screenshotanalysis_task,findingsolution_task,reasoningsolution_task),
)
reply = staff.run()
print(reply.output)

Eingabe -Screenshot

Ausgabe aus dem Agentensystem

Definitely! Right here is an expanded rationalization of how one can resolve this error in 
Python:
When working with strings and integers collectively, it is essential that each parts
are both numbers (integers or floats) for numerical operations like addition. In
your case, you are attempting to concatenate a string ("hi there world") The error happens
as a result of Python doesn't enable direct concatenation of strings and integers with out
explicitly dealing with them as separate varieties first (i.e., by conversion). The
answer is easy: convert each parts to com This is an expanded
rationalization alongside along with your corrected code:
```python
strive:
# Initialize variable 'a' as 1234 (an integer)
a = 1234
# Convert 'a' from int to str after which concatenate" hi there world" print(str(a) +
"hi there world")
besides Exception as error: # Catch any exceptions that may happen print("Oops! An
exception has occured: ", error)
# Print the kind of the caught exception for debugging functions. print("Exception
TYPE:", kind (error))
# Explicitly stating what class TypeError is predicted on this context,
# although it is redundant since we have already captured and printed it above.
print("Exception TYPE: <class 'TypeError'>")
In abstract, changing an integer to a string earlier than concatenation solves the difficulty
by making certain each parts are strings. This permits for seamless addition
(concatenation) of those two items into one coherent output.
Keep in mind that this strategy will not be restricted simply to including integers and strings; it is
relevant each time you'll want to concatenate completely different information varieties in Python,
supplied they are often transformed or dealt with as appropriate codecs first.

Wie aus der obigen Ausgabe hervorgeht, wird nicht nur der Fehler mit ausreichender Überlegung korrekt erklärt, sondern auch die Lösung wird mit genügend Argumentation versorgt.

Analyse mit anderen Abfragen

Versuchen wir es mit einer anderen Frage Screenshot mit einem anderen Python -Codierungsproblem

Ausgabe aus dem Agentensystem

Definitely! Right here is an expanded rationalization of how we are able to resolve any potential points
with this corrected model:
1. **Syntax Correction**: The unique error was attributable to improper indentation, which
brought on a `IndentationError. In Python, correct block construction and constant
indentations are essential for the interpreter. 2. **Dealing with ZeroDivisionError
Correctly**:
- A division by zero is an distinctive case that wants particular dealing with.
- Utilizing try-except blocks permits us gracefully deal with this exception with out
crashing our program unexpectedly (i.e., `ZeroDivisionError").
3. **Logging and Debugging Info**:
- Using the logging module (log.debug`) helps in monitoring what values are being
processed, which is beneficial for debugging.
This is an entire instance with correct indentation:
```python
import logging
# Configure logger to show debug degree messages.
logging.basicConfig(level-logging.DEBUG)
log = logging.getLogger(____name___)
def division(a, b):
log.debug(f"Dividing {a} by {b}.")
strive:
return a / b # Try the division operation right here
besides ZeroDivisionError as e: # Catch and deal with zero-division error particularly.
log.exception("Oh noes!") # Log an exception message with traceback
# Instance utilization of perform to display logging output
if __name_ "_main_":
print(division(10, 2))
strive:
division (5, 0) besides Exception as e:
cross
# Ought to work fantastic
# This could increase a ZeroDivisionError and log it.
# Catch any surprising exceptions (although unlikely right here)

Wie aus der obigen Ausgabe erdenkt, wird der Fehler korrekt mit ausreichender Argumentation erläutert. Darüber hinaus wird eine different Codierungslösung bereitgestellt, um diesen Fehler zusammen mit genügend Argumentation zu vermeiden.

Versuchen wir es mit einer anderen Frage Screenshot mit einem anderen Python -Codierungsproblem.

Ausgabe aus dem Agentensystem

Definitely! This is an expanded model of learn how to resolve this error based mostly on the
earlier output:
1. **Establish Lacking Dependency:**
The error message signifies that there's a lacking dependency, particularly for the
`packaging module which setuptools requires.
2. **Set up 'packaging' Bundle Manually (if not already put in):**
***bash
pip set up packaging
3. **Improve Setuptools to Guarantee Compatibility:**
Upgrading setuptools will help resolve any compatibility points and make sure that all
dependencies are accurately managed:
***bash
pip set up --upgrade setuptools
4. **Re-run the Set up Command:**
After putting in `packaging` manually (if it wasn't put in beforehand) or upgrading setuptools, re-execute your unique set up command to see if this
resolves any points.
5. **Confirm Dependency Decision and Reinstallation Makes an attempt:**
For those who encounter additional errors associated particularly to lacking dependencies after
following the above steps:
- Verify for extra required packages by reviewing error messages.
- Set up these particular necessities utilizing pip, e.g., `pip set up <missing-
package-name>`.
6. **Verify Setting Consistency:**
Make sure that your Python setting is constant and never conflicting with different
installations or digital environments:
***bash
# Listing put in packages to confirm consistency throughout completely different setups (if
relevant)
pip checklist
# If utilizing a particular model of setuptools, guarantee it is accurately configured:
7. **Seek the advice of Documentation:**
Discuss with the official documentation for each `packaging and `setuptools for those who
encounter persistent points or want extra detailed steerage on resolving advanced
dependency issues.
8. **Search Neighborhood Assist (if wanted):**
If after following these steps, you are still going through difficulties:
- Submit a query with particular error messages in related boards like Stack
Overflow.
- Present particulars about your setting setup and the instructions you have run for
higher help from neighborhood members or specialists.
By fastidiously addressing every step above based mostly on what you encounter throughout
set up makes an attempt (as indicated by any new errors), you'll resolve
lacking dependencies successfully. This systematic strategy ensures that every one
required packages are accurately put in

Abschluss

Die Integration eines Multi-Agent-Methods (MAS) zum automatischen Erkennen von Codierungsfehlern aus Screenshots bietet signifikante Verbesserungen der Effizienz der Entwickler. Durch die Nutzung von KI und Instruments wie Griptape bietet dieser Ansatz zeitnahe und genaue Lösungen mit detailliertem Denken und sparen Sie wertvolle Zeit für Entwickler. Darüber hinaus kann die Flexibilität und Skalierbarkeit von MAS in verschiedenen Branchen angewendet werden, wodurch ein nahtloses Aufgabenmanagement und die Produktivität verbessert werden können.

Key Takeaways

• Die Integration eines automatisierten Methods zur Identifizierung von Codierungsfehlern von Screenshots spart den Entwicklern erhebliche Zeit, indem sie genaue Lösungen mit detailliertem Denken bereitstellen und die Notwendigkeit einer manuellen Fehlersuche verringern.
• MAS ist eine dezentrale Architektur, die autonome Agenten nutzt, um zusammenzuarbeiten, um komplexe Probleme zu lösen, das Aufgabenmanagement und die Skalierbarkeit in allen Branchen zu verbessern.
• Das Griptape-Framework vereinfacht die Entwicklung von Multi-Agent-Systemen, bietet modulare Design, Agentenspezialisierung, sichere Arbeitsabläufe und Skalierbarkeit. Damit ist es preferrred für AI-Lösungen auf Unternehmensebene.
• MAS kann sich dynamisch an sich ändernde Bedingungen anpassen und sie preferrred für Echtzeitanwendungen wie Codierungsfehlererkennung, Kundensupportautomatisierung und Datenanalyse machen.

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Nibedita absolvierte 2014 ihren Grasp in Chemical Engineering von IIT Kharagpur und arbeitet derzeit als leitender Datenwissenschaftler. In ihrer aktuellen Eigenschaft arbeitet sie am Aufbau intelligenter ML-basierter Lösungen zur Verbesserung von Geschäftsprozessen.