Una monitor para construir una IA autocompletadora

A menudo, pasamos una cantidad significativa de tiempo tratando de comprender los bloques de código, comprender los parámetros y descifrar otros aspectos confusos del código. Pensé para mí mismo, ¿pueden los agentes de IA muy publicitados ayudarme a este respecto? El sistema que debía crear tenía un objetivo claro: proporcionar comentarios avíos, indicadores sobre variables duplicadas y, lo que es más importante, las funciones de prueba para ver las expectativas de la muestra yo mismo. Esto parece muy posible, ¿verdad? Diseñemos este sistema de agente utilizando el popular situación de Langgraph.

Langgraph para agentes

Langgraph, construido sobre Langchain, es un situación que se usa para crear y orquestar agentes de IA que usan gráficos con estado (el estado es una estructura de datos compartida utilizada en el flujo de trabajo). El manifiesto consta de nodos, bordes y estados. No profundizaremos en flujos de trabajo complejos; Crearemos un flujo de trabajo simple para este esquema. Langgraph admite múltiples LLM Proveedores como OpenAi, Géminis, antrópico, etc. Tenga en cuenta que me quedaré con Géminis en esta monitor. Las herramientas son un activo importante para los agentes que los ayudan a extender sus capacidades. ¿Qué es un Agente de IApreguntas? Los agentes de IA tienen viandas de LLM, lo que puede razonar o pensar para tomar decisiones y usar herramientas para completar la tarea. Ahora procedamos a diseñar el flujo y codificar el sistema.

Flujo de trabajo del sistema

El objetivo de nuestro sistema será sumar cadenas de documentación para las funciones y marcar cualquier problema como comentarios en el código. Encima, para que este sistema sea más inteligente, verificaremos si los comentarios ya existen para eliminar la suplemento de lo mismo utilizando el sistema de agente. Ahora, veamos el flujo de trabajo que usaré y profundizaré en él.

Entonces, como puede ver, tenemos un nodo de investigación que utilizará un agente que analizará el código de entrada y incluso «razón» si ya hay documentación presente. Luego usará el enrutamiento condicional usando el ‘estado’ para osar a dónde ir a continuación. Primero, el paso de documentación escribe el código en función del contexto que proporciona el nodo de investigación. Luego, el nodo de exploración prueba el código en múltiples casos de prueba utilizando el contexto compartido. Finalmente, el final nodo guardamano la información en exploración.txt y almacena el código documentado en code.py.

Codificando el sistema de agente

Requisitos previos

Necesitaremos la tecla API Géminis para ingresar a Géminis Modelos para potenciar el sistema de agente, y incluso la esencia de la API Tavily para la búsqueda web. Asegúrese de obtener sus llaves de los enlaces a continuación:

Géminis: https://aistudio.google.com/apikey
Tavily: https://app.tavily.com/home

Para un uso más claro, he colaborador el repositorio a GitHub, que puede clonar y usar:

https://github.com/bv-mounish-reddy/self-documenting-agentic-system.git

Asegúrese de crear un archivo .env y agregue sus claves API:

GOOGLE_API_KEY=

TAVILY_API_KEY=

Yo usé el gemini-2.5-flash En todo el sistema (que es sin cargo hasta cierto punto) y usó un par de herramientas para construir el sistema.

Definiciones de herramientas

En Langgraph, usamos el @tool interiorista para especificar que el código/función se utilizará como útil. Hemos definido estas herramientas en el código:

# Tools Definition

@tool

def search_library_info(library_name: str) -> str:

   """Search for library documentation and usage examples"""

   search_tool = TavilySearchResults(max_results=2)

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

   results = search_tool.invoke(query)

   formatted_results = ()

   for result in results:

       content = result.get('content', 'No content')(:200)

       formatted_results.append(f"Source: {result.get('url', 'N/A')}nContent: {content}...")

   return "n---n".join(formatted_results)

El agente de investigación utiliza esta útil para comprender la sintaxis asociada con el Pitón Bibliotecas utilizadas en el código de entrada y ver ejemplos de cómo se está utilizando.

@tool

def execute_code(code: str) -> str:

   """Execute Python code and return results"""

   python_tool = PythonREPLTool()

   try:

       result = python_tool.invoke(code)

       return f"Execution successful:n{result}"

   except Exception as e:

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

Esta útil ejecuta el código con las entradas definidas por el agente de exploración para realizar si el código funciona como se esperaba y para realizar las lagunas.

Nota: Estas funciones se definen utilizando las herramientas Langgraph incorporadas: PythonREPLTool() y TavilySearchResults().

Definición estatal

Los datos compartidos en el sistema deben tener una estructura clara para crear un buen flujo de trabajo. Estoy creando la estructura como un Typeddict con las variables que usaré en el sistema de agente. Las variables proporcionarán contexto a los nodos posteriores y incluso ayudarán con el enrutamiento en el sistema de agente:

# Simplified State Definition

class CodeState(TypedDict):

   """Simplified state for the workflow"""

   original_code: str

   documented_code: str

   has_documentation: bool

   libraries_used: List(str)

   research_analysis: str

   test_results: List(str)

   issues_found: List(str)

   current_step: str

Definiciones de agentes

Utilizamos un agente de estilo React (razonamiento y proceder) para el ‘agente de investigación’, que necesita memorizar y razonar. Un agente de estilo react se puede aclarar simplemente usando create_react_agent Funciona pasando los parámetros, y este agente se usará en el nodo. Observe que estamos pasando la útil previamente definida en el create_react_agent función. El nodo que usa este agente incluso actualiza algunas de las variables de estado, que se pasarán como contexto.

# Initialize Model

def create_model():

   """Create the language model"""

   return ChatGoogleGenerativeAI(

       model="gemini-2.5-flash",

       temperature=0.3,

       google_api_key=os.environ("GOOGLE_API_KEY")

   )

# Workflow Nodes

def research_node(state: CodeState) -> CodeState:

   """

   Research node: Understand code and check documentation

   Uses agent with search tool for library research

   """

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

   model = create_model()

   research_agent = create_react_agent(

       model=model,

       tools=(search_library_info),

       prompt=ChatPromptTemplate.from_messages((

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

           ("placeholder", "{messages}")

       ))

   )

   # Analyze the code

   analysis_input = {

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

   }

   result = research_agent.invoke(analysis_input)

   research_analysis = result("messages")(-1).content

   # Extract libraries using AST

   libraries = ()

   try:

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

       for node in ast.walk(tree):

           if isinstance(node, ast.Import):

               for apelativo in node.names:

                   libraries.append(apelativo.name)

           elif isinstance(node, ast.ImportFrom):

               module = node.module or ""

               for apelativo in node.names:

                   libraries.append(f"{module}.{apelativo.name}")

   except:

       pass

   # Check if code has documentation

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

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

               '#' in state('original_code'))

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

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

   return {

       **state,

       "libraries_used": libraries,

       "has_documentation": has_docs,

       "research_analysis": research_analysis,

       "current_step": "researched"

   }

Del mismo modo, definimos los otros agentes incluso para los nodos y ajustamos las indicaciones según sea necesario. Luego procedemos a aclarar los bordes y el flujo de trabajo incluso. Encima, observe que has_documents La variable es esencial para el enrutamiento condicional en el flujo de trabajo.

Futuro

Puede cambiar el código en la función principal y probar los resultados para usted. Aquí hay una muestra de la misma:

Código de entrada

sample_code = """

import math

import random

def calculate_area(shape, **kwargs):

   if shape == "circle":

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

   elif shape == "rectangle":

       return kwargs("width") * kwargs("height")

   else:

       return 0

def divide_numbers(a, b):

   return a / b

def process_list(items):

   total = 0

   for i in range(len(items)):

       total += items(i) * 2

   return total

class Calculator:

   def __init__(self):

       self.history = ()

   def add(self, a, b):

       result = a + b

       self.history.append(f"{a} + {b} = {result}")

       return result

   def divide(self, a, b):

       return divide_numbers(a, b)

calc = Calculator()

result = calc.add(5, 3)

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

division = calc.divide(10, 2)

items = (1, 2, 3, 4)

processed = process_list(items)

print(f"Results: {result}, {area:.2f}, {division}, {processed}")

"""

Salida de muestra

Observe cómo el sistema dice el casual El módulo se importa pero no se usa. El sistema agrega documentos, problemas de indicadores y incluso agrega comentarios en el código sobre cómo se utilizan las funciones.

Conclusión

Construimos un sistema de agente simple con el uso de Langgraph y entendió la importancia del estado, las herramientas y los agentes. El sistema precursor se puede mejorar con el uso de nodos, herramientas y refinamientos adicionales en las indicaciones. Este sistema incluso se puede extender para construir un sistema de depuración o un constructor de repositorio, con los nodos y herramientas correctas. Encima, recuerde que el uso de múltiples agentes incluso dará como resultado costos más altos cuando use un maniquí pagado, así que cree y use agentes que agregan valía a sus sistemas de agente y definan los flujos de trabajo con mucha anticipación.

Preguntas frecuentes