Ein Leitfaden zum Aufbau einer selbstdokumentierenden KI

Oft verbringen wir viel Zeit damit, Codeblöcke zu verstehen, die Parameter zu verstehen und andere verwirrende Aspekte des Codes zu entschlüsseln. Ich dachte mir, können mir die vielbezogenen KI-Agenten in dieser Hinsicht helfen? Das System, das ich erstellen sollte, hatte ein klares Ziel: hilfreiche Kommentare, Flaggen zu doppelten Variablen und vor allem Testfunktionen, um die Beispielausgaben selbst zu sehen. Das sieht sehr intestine aus, oder? Entwerfen wir dieses Agentensystem mit dem beliebten Langgraph -Framework.

Langgraph für Agenten

Langgraph, auf der Langchain basiert, ist ein Framework, mit dem AI -Agenten mit staatlichen Grafiken erstellt und orchestriert werden (Standing ist eine gemeinsame Datenstruktur, die im Workflow verwendet wird). Die Grafik besteht aus Knoten, Kanten und Zuständen. Wir werden uns nicht mit komplexen Workflows befassen. Wir werden einen einfachen Workflow für dieses Projekt erstellen. Langgraph unterstützt mehrere Llm Anbieter wie Openai, Gemini, Anthropic usw. Beachten Sie, dass ich in diesem Leitfaden an Gemini festhalten werde. Instruments sind ein wichtiger Vorteil für Agenten, die ihnen helfen, ihre Fähigkeiten zu erweitern. Was ist an AI -Agentfragst du? KI-Agenten sind LLM-Anbieter, was zu Entscheidungen, die die Aufgabe erledigen können, zu entscheiden oder zu überlegen können. Gehen wir nun mit dem Entwerfen des Flusses und dem Codieren des Methods fort.

Workflow des Methods

Ziel unseres Methods ist es, Dokumentationszeichenfolgen für Funktionen hinzuzufügen und Probleme im Code zu markieren. Um dieses System intelligenter zu machen, überprüfen wir außerdem, ob die Kommentare bereits vorhanden sind, um über das Agentensystem dasselbe hinzuzufügen. Schauen wir uns nun den Workflow an, den ich benutzen und eintauchen.

Wie Sie sehen, haben wir additionally einen Forschungsknoten, der einen Agenten verwendet, der den Eingabescode und auch den „Grund“ untersucht, wenn bereits Dokumentation vorhanden ist. Anschließend wird das bedingte Routing mit dem „Standing“ verwendet, um zu entscheiden, wohin als nächstes teilnehmen soll. Zunächst schreibt der Dokumentationsschritt den Code basierend auf dem Kontext, den der Forschungsknoten bereitstellt. Anschließend testet der Analyseknoten den Code in mehreren Testfällen unter Verwendung des gemeinsam genutzten Kontextes. Schließlich speichert der letzte Knoten die Informationen in Analyse.txt und speichert den dokumentierten Code in code.py.

Codierung des Agentensystems

Voraussetzungen

Wir brauchen den Gemini -API -Schlüssel, um auf die zuzugreifen Zwillinge Modelle, um das Agentensystem und auch den Tavily -API -Schlüssel für die Websuche zu versorgen. Stellen Sie sicher, dass Sie Ihre Schlüssel aus den folgenden Hyperlinks erhalten:

Zwillinge: https://aistudio.google.com/apikey
Tavy: https://app.tavily.com/residence

Zur einfacheren Verwendung habe ich das Repository zu GitHub hinzugefügt, das Sie klonen und verwenden können:

https://github.com/bv-mounter-reddy/self-documenting-agentic-System.git

Stellen Sie sicher, dass Sie eine .env -Datei erstellen und Ihre API -Schlüssel hinzufügen:

GOOGLE_API_KEY=

TAVILY_API_KEY=

Ich habe die benutzt Gemini-2,5-Flash Im gesamten System (das bis zu einem gewissen Grad frei ist) und ein paar Instruments zum Erstellen des Methods verwendet.

Werkzeugdefinitionen

In Langgraph verwenden wir die @device Dekorateur angeben, dass der Code/die Funktion als Werkzeug verwendet wird. Wir haben diese Instruments im Code definiert:

# Instruments Definition

@device

def search_library_info(library_name: str) -> str:

   """Seek for library documentation and utilization examples"""

   search_tool = TavilySearchResults(max_results=2)

   question = f"{library_name} python library documentation examples"

   outcomes = search_tool.invoke(question)

   formatted_results = ()

   for end in outcomes:

       content material = outcome.get('content material', 'No content material')(:200)

       formatted_results.append(f"Supply: {outcome.get('url', 'N/A')}nContent: {content material}...")

   return "n---n".be part of(formatted_results)

Dieses Instrument wird vom Forschungsagenten verwendet, um die mit dem verbundene Syntax zu verstehen Python Bibliotheken, die im Eingabescode verwendet werden und Beispiele dafür sehen, wie es verwendet wird.

@device

def execute_code(code: str) -> str:

   """Execute Python code and return outcomes"""

   python_tool = PythonREPLTool()

   attempt:

       outcome = python_tool.invoke(code)

       return f"Execution profitable:n{outcome}"

   besides Exception as e:

       return f"Execution failed:n{str(e)}"

Dieses Instrument führt den Code mit den vom Analyse Agent definierten Eingaben aus, um zu überprüfen, ob der Code wie erwartet funktioniert, und um nach Lücken zu überprüfen.

Notiz: Diese Funktionen werden mit den eingebauten Langgraph -Instruments definiert: PythonREPLTool() Und TavilySearchResults().

Zustandsdefinition

Die gemeinsam genutzten Daten im System müssen über eine klare Struktur verfügen, um einen guten Workflow zu erstellen. Ich erstelle die Struktur als TypedDict Mit den Variablen werde ich im Agentensystem verwenden. Die Variablen bieten einen Kontext für die nachfolgenden Knoten und helfen auch beim Routing im Agentensystem:

# Simplified State Definition

class CodeState(TypedDict):

   """Simplified state for the workflow"""

   original_code: str

   documented_code: str

   has_documentation: bool

   libraries_used: Checklist(str)

   research_analysis: str

   test_results: Checklist(str)

   issues_found: Checklist(str)

   current_step: str

Agentendefinitionen

Wir haben einen React (Argumenting and Appearing) -Stil -Agent für den „Forschungsagenten“ verwendet, der lernen und vergrößern muss. Ein Agent im React-Stil kann einfach mit Verwendung definiert werden create_react_agent Funktion durch Übergeben der Parameter, und dieser Agent wird im Knoten verwendet. Beachten Sie, dass wir das zuvor definierte Instrument in der übergeben create_react_agent Funktion. Der Knoten, der diesen Agenten verwendet, aktualisiert auch einige der Zustandsvariablen, die als Kontext übergeben werden.

# Initialize Mannequin

def create_model():

   """Create the language mannequin"""

   return ChatGoogleGenerativeAI(

       mannequin="gemini-2.5-flash",

       temperature=0.3,

       google_api_key=os.environ("GOOGLE_API_KEY")

   )

# Workflow Nodes

def research_node(state: CodeState) -> CodeState:

   """

   Analysis node: Perceive code and test documentation

   Makes use of agent with search device for library analysis

   """

   print("RESEARCH: Analyzing code construction and documentation...")

   mannequin = create_model()

   research_agent = create_react_agent(

       mannequin=mannequin,

       instruments=(search_library_info),

       immediate=ChatPromptTemplate.from_messages((

           ("system", PROMPTS("research_prompt")),

           ("placeholder", "{messages}")

       ))

   )

   # Analyze the code

   analysis_input = {

       "messages": (HumanMessage(content material=f"Analyze this Python code:nn{state('original_code')}"))

   }

   outcome = research_agent.invoke(analysis_input)

   research_analysis = outcome("messages")(-1).content material

   # Extract libraries utilizing AST

   libraries = ()

   attempt:

       tree = ast.parse(state('original_code'))

       for node in ast.stroll(tree):

           if isinstance(node, ast.Import):

               for alias in node.names:

                   libraries.append(alias.identify)

           elif isinstance(node, ast.ImportFrom):

               module = node.module or ""

               for alias in node.names:

                   libraries.append(f"{module}.{alias.identify}")

   besides:

       move

   # Test if code has documentation

   has_docs = ('"""' in state('original_code') or

               "'''" in state('original_code') or

               '#' in state('original_code'))

   print(f"  - Libraries discovered: {libraries}")

   print(f"  - Documentation current: {has_docs}")

   return {

       **state,

       "libraries_used": libraries,

       "has_documentation": has_docs,

       "research_analysis": research_analysis,

       "current_step": "researched"

   }

In ähnlicher Weise definieren wir die anderen Agenten auch für die Knoten und optimieren die Eingabeaufforderungen bei Bedarf. Anschließend definieren wir auch die Kanten und den Workflow. Beachten Sie das auch has_documents Variable ist für das bedingte Routing im Workflow von wesentlicher Bedeutung.

Ausgänge

Sie können den Code in der Hauptfunktion ändern und die Ergebnisse selbst testen. Hier ist ein Beispiel desselben:

Eingabescode

sample_code = """

import math

import random

def calculate_area(form, **kwargs):

   if form == "circle":

       return math.pi * kwargs("radius") ** 2

   elif form == "rectangle":

       return kwargs("width") * kwargs("top")

   else:

       return 0

def divide_numbers(a, b):

   return a / b

def process_list(objects):

   whole = 0

   for i in vary(len(objects)):

       whole += objects(i) * 2

   return whole

class Calculator:

   def __init__(self):

       self.historical past = ()

   def add(self, a, b):

       outcome = a + b

       self.historical past.append(f"{a} + {b} = {outcome}")

       return outcome

   def divide(self, a, b):

       return divide_numbers(a, b)

calc = Calculator()

outcome = calc.add(5, 3)

space = calculate_area("circle", radius=5)

division = calc.divide(10, 2)

objects = (1, 2, 3, 4)

processed = process_list(objects)

print(f"Outcomes: {outcome}, {space:.2f}, {division}, {processed}")

"""

Probenausgabe

Beachten Sie, wie das System das sagt, das zufällig Das Modul wird importiert, aber nicht verwendet. Das System fügt Docstrings hinzu, fügt Probleme und fügt auch Kommentare in den Code hinzu, wie die Funktionen verwendet werden.

Abschluss

Wir haben ein einfaches Agentensystem mit Verwendung von erstellt Langgraph und verstand die Bedeutung von Staat, Werkzeugen und Agenten. Das obige System kann durch die Verwendung zusätzlicher Knoten, Werkzeuge und Verfeinerungen in den Eingabeaufforderungen verbessert werden. Dieses System kann auch auf den Aufbau eines Debugging -Methods oder eines Repository -Builders mit den richtigen Knoten und Werkzeugen erweitert werden. Denken Sie auch daran, dass die Verwendung mehrerer Agenten bei der Verwendung eines bezahlten Modells zu höheren Kosten führt. Erstellen und verwenden Sie additionally Agenten, die Ihren Agentensystemen Mehrwert verleihen und die Workflows im Voraus definieren.

Häufig gestellte Fragen

Leidenschaft für Technologie und Innovation, Absolvent des Vellore Institute of Expertise. Derzeit arbeitet er als Knowledge Science Trainee und konzentriert sich auf die Datenwissenschaft. Es ist sehr interessiert an tiefem Lernen und generativen KI, bestrebt, modernste Techniken zu erforschen, um komplexe Probleme zu lösen und wirkungsvolle Lösungen zu schaffen.