Implemente un agente LangGraph ReAct de soporte de TI con IBM Granite en watsonx.ai

Autores

Anna Gutowska

AI Engineer, Developer Advocate

IBM

En este tutorial, creará un agente de IA ReAct (razonamiento y acción) con el marco de código abierto LangGraph utilizando un modelo IBM® Granite a través de la API IBM® watsonx.ai  en Python. El caso de uso consiste en gestionar los tiques de soporte técnico existentes y crear otros nuevos.

¿Qué es un agente ReAct?

Un agente de inteligencia artificial (IA) es un sistema o programa capaz de realizar tareas de forma autónoma en nombre de un usuario u otro sistema mediante el diseño de su flujo de trabajo y el uso de las herramientas disponibles. Los agentes de IA generativa utilizan las técnicas avanzadas de procesamiento del lenguaje natural (PLN) de los modelos de lenguaje de gran tamaño (LLM) para comprender y responder paso a paso a las entradas de los usuarios y determinar cuándo recurrir a herramientas externas. Un componente fundamental de los agentes de IA es el razonamiento. Tras adquirir nueva información mediante la llamada a herramientas, la intervención humana u otros agentes, el paradigma de razonamiento guía los próximos pasos del agente.

Con cada acción y cada respuesta de la herramienta, el paradigma ReAct (razonamiento y acción) instruye a los agentes para que "piensen" y planifiquen sus próximos pasos. Este razonamiento lento y paso a paso nos proporciona conocimientos sobre cómo el agente utiliza el contexto actualizado para formular conclusiones. Dado que este proceso de reflexión es continuo, a menudo se denomina "bucle pensar-actuar-observar" y es una forma de incitación a la cadena de pensamiento.

Uso de LangGraph para crear agentes ReAct

Este tutorial utilizará el marco LangGraph, un marco de agente de IA de código abierto diseñado para crear, implementar y gestionar flujos de trabajo complejos de agentes de IA generativa. La función prediseñada create_react_agent proporcionada por LangGraph es una forma sencilla de crear un agente personalizado básico. Los agentes ReAct simples, como el que se muestra en este tutorial, tal y como se describe en la Figura 1, se componen de dos nodos. Uno de ellos se encarga de llamar al modelo y el otro de utilizar las herramientas. Entre las herramientas más comunes se encuentran la herramienta LangChain Wikipedia prediseñada, la herramienta DuckDuckGoSearchRun e incluso la generación aumentada por recuperación (RAG). En casos con entradas de acciones complejas, se puede añadir otro nodo, como se ve en la Figura 2. Este nodo adicional serviría para garantizar que el agente devuelva una salida estructurada.

Dentro de LangGraph, la característica "estado" sirve como un banco de memoria que registra y rastrea toda la información valiosa procesada por cada iteración del sistema de IA. Estos grafos con estado permiten a los agentes recordar información pasada y contexto valioso. La estructura cíclica del grafo ReAct se aprovecha cuando el resultado de un paso depende de los pasos anteriores del bucle. Los nodos, o "actores", en el grafo codifican la lógica del agente y están conectados por aristas. Las aristas son esencialmente funciones de Python que determinan el siguiente nodo que se ejecutará en función del estado actual.

Requisitos previos

Necesita una cuenta de IBM Cloud para crear un proyecto watsonx.ai.

Pasos

Para utilizar la interfaz de programación de aplicaciones (API) de watsonx, deberá completar los siguientes pasos. Tenga en cuenta que también puede acceder a este tutorial en GitHub. 

Paso 1. Genere sus credenciales de watsonx.ai

  1. Inicie sesión en watsonx.ai utilizando su cuenta de IBM Cloud.

  2. Cree una instancia de servicio de watsonx.ai Runtime (seleccione la región adecuada y elija el plan Lite, que es una instancia gratuita).

  3. Genere una clave de interfaz de programación de aplicaciones (API).

Paso 2. Configure el proyecto en su IDE

Para dar los primeros pasos con la implementación de agentes en watsonx.ai con facilidad, clone este repositorio de GitHub y acceda al proyecto del agente ReAct de soporte de TI. Para ello, puede ejecutar el siguiente comando en su terminal.

git clone git@github.com:IBM/ibmdotcom-tutorials.git
cd react-agent-langgraph-it-support/base/langgraph-react-agent/

A continuación, instale poetry si aún no lo tiene instalado. Poetry es una herramienta para gestionar las dependencias y los paquetes de Python.

pipx install --python 3.11 poetry

Después, active su entorno virtual.

source $(poetry -q env use 3.11 && poetry env info --path)/bin/activate

En lugar de utilizar el comando pip install el paquete poetry nos permite añadir dependencias ejecutando el siguiente comando en la terminal. Este paso instala las dependencias del repositorio reflejadas en el archivo pyproject.toml en su entorno virtual independiente.

poetry install

Es necesario añadir un directorio de trabajo a PYTHONPATH para los próximos pasos. En su terminal, ejecute:  

export PYTHONPATH=$(pwd):${PYTHONPATH}

Para configurar el entorno, siga las instrucciones del archivo README.md en Github. Esta configuración requiere que se ejecuten varios comandos en su IDE o línea de comandos.

Paso 3. Establecer las variables de entorno

En el archivo config.toml encontrará las siguientes credenciales en blanco que debe rellenar antes de intentar implementar el agente. Su watsonx_apikey y watsonx_url se inicializaron en el paso 1 de este tutorial. A continuación, siga las instrucciones del sencillo formulario que encontrará en la página Acceso para desarrolladores para seleccionar su espacio de implementación o crear uno nuevo. Allí podrá recuperar su space_id , necesario para conectar nuestro agente a la implementación de watsonx.ai. Por último, su model_id está configurado en el modelo IBM Granite 3.2.

[deployment]
  watsonx_apikey = ""
  watsonx_url = ""  # should follow the format: `https://{REGION}.ml.cloud.ibm.com`
  space_id = "" # found in the "Manage" tab of your Deployment or in the Developer Access page here: https://dataplatform.cloud.ibm.com/developer-access

[deployment.custom]
# during creation of deployment additional parameters can be provided inside `CUSTOM` object for further referencing
# please refer to the API docs: https://cloud.ibm.com/apidocs/machine-learning-cp#deployments-create
  model_id = "ibm/granite-3-2-8b-instruct"
  thread_id = "thread-1" # More info here: https://langchain-ai.github.io/langgraph/how-tos/persistence/

Paso 4. Subir datos a IBM Cloud Object Storage

Nuestro agente necesita una fuente de datos para proporcionar información actualizada y añadir nuevos datos. Almacenaremos nuestro archivo de datos en IBM® Cloud Object Storage.

  1. En primer lugar, inicie sesión en IBM® Cloud. A continuación, cree un nuevo proyecto.
  2. En el menú de la izquierda, seleccione Lista de recursos. Con el botón Crear recurso, cree una nueva instancia de Cloud Object Storage o simplemente utilice este enlace.
  3. Abra la instancia de IBM Cloud Storage que acaba de crear y cree un nuevo bucket. Para este tutorial, puede seleccionar Smart Tier, que es el nivel gratuito. Cuando se le indique, suba su archivo. Para el archivo de ejemplo, consulte el archivo tickets.csv en el repositorio de GitHub vinculado en el paso 2.

Paso 5. Establecer conexión de datos

Para proporcionar al agente ReAct la funcionalidad de gestión de tiques de TI, debemos conectarnos a nuestra fuente de datos en IBM Cloud Object Storage. Para este paso, podemos utilizar la biblioteca ibm_boto3 .

En tools.py , COS_ENDPOINT , COS_INSTANCE_CRN , BUCKET_NAME y CSV_FILE_NAME deben completarse con la información adecuada con los detalles del bucket que se encuentran en su instancia de Cloud Object Storage en la pestaña Configuración. 

  COS_ENDPOINT = ""       #find in your COS bucket configuration
  COS_INSTANCE_CRN = ""   #find in your COS bucket configuration
  BUCKET_NAME = ""        #find in your COS bucket configuration
  CSV_FILE_NAME = "filename.csv" #you can use the provided tickets.csv sample file 

  cos = ibm_boto3.client(
      "s3",
      ibm_api_key_id=dep_config["watsonx_apikey"],
      ibm_service_instance_id=COS_INSTANCE_CRN,
      config=Config(signature_version="oauth"),
      endpoint_url=COS_ENDPOINT,
  )

Paso 6. Crear herramientas personalizadas

Nuestro agente podrá leer y escribir datos en nuestro archivo. En primer lugar, creemos la herramienta para leer datos utilizando el decorador LangChain@tool

Hemos añadido esta herramientafind_tickets al archivotools.py . Esta herramienta recupera el objeto de datos de Cloud Object Storage y lo devuelve como un marco de datos Pandas. De lo contrario, se lanza una excepción. 

  @tool 
  def find_tickets():
      """Returns a list of of all tickets."""
      try:
          response = cos.get_object(Bucket=BUCKET_NAME, Key=CSV_FILE_NAME)
          csv_data = pd.read_csv(response['Body']) 
          print("Ticket file loaded successfully:")
          return csv_data
      except Exception as e:
          print(f"Error loading file from COS: {e}")
          return None

 

A continuación, hemos añadido la herramienta create_ticket

  @tool 
def create_ticket(issue: str, urgency:str):
    """Creates a tickets for a customer issue. Request a detailed explanation of the customer issue and urgency level before creating a ticket.
    
    Args:
        issue (str): A description of the issue.
        urgency (str): A category value for the level of urgency. Can be "low", "medium", or "high".
    
    Returns:
        The new ticket.
    """
    try:
        # retrieve the existing item to reload the contents
        response = cos.get_object(Bucket=BUCKET_NAME, Key=CSV_FILE_NAME)
        existing_body_df = pd.read_csv(response['Body'])
        new_ticket = {"issue": issue, "date_added":datetime.now().strftime("%m-%d-%Y"), "urgency":urgency, "status":"open"}
        # Add a new row (i.e. ticket) using loc[]
        existing_body_df.loc[len(existing_body_df)] = new_ticket

        cos.put_object(Bucket=BUCKET_NAME, Key=CSV_FILE_NAME, Body=existing_body_df.to_json())
        return "New ticket successfully created!"
    except Exception as e:
        print("Unable to create new ticket. Please try again.")

Esta herramienta toma como argumentos la descripción del problema proporcionada por el usuario y la urgencia del mismo. Se añade una nueva fila a nuestro archivo en COS con esta información y, de este modo, se crea un nuevo tique. De lo contrario, se lanza una excepción. 

Una última herramienta que debemos añadir a nuestro archivo tools.py es la herramienta get_todays_date , que utiliza el módulo datetime para devolver la fecha de hoy en formato MM-DD-AAAA. Esta herramienta será útil para acceder a la fecha actual, que el agente no tiene otra forma de recuperar porque el LLM no se ha entrenado con estos datos. 

  @tool
  def get_todays_date():
    """Returns today's date in MM-DD-YYYY format."""
    date = datetime.now().strftime("%m-%d-%Y")
    return date 

Para conceder a nuestro agente acceso a estas herramientas, las hemos añadido a la lista TOOLS del archivo init.py del módulo de extensiones . Esta lista debe ser el contenido de su archivo de extensiones en el directorio src/langgraph_react_agent .

  from .tools import (
    find_tickets,
    get_todays_date,
    create_ticket
  )

  TOOLS = [
      find_tickets,
      get_todays_date,
      create_ticket
  ]


Estas herramientas se importan en el archivo agent.py y se pasan a la función prediseñada LangGraph create_react_agent  , que actúa como ejecutor del agente. Otros parámetros incluyen el modelo de lenguaje de gran tamaño inicializado mediante la clase ChatWatsonx , que permite llamar a herramientas en watsonx.ai, el ahorrador de memoria y la instrucción del sistema. Tenga en cuenta que algunas instrucciones funcionarán mejor que otras, por lo que es posible que sea necesario cierto nivel de prompt engineering en función del LLM que elijan. 

Antes de implementar su agente, recuerde completar toda la información necesaria en el archivo config.toml

Paso 7. Chatear con el agente

Hay tres formas de chatear con su agente.

Opción 1. Consultar al agente localmente


Ejecute el script para la ejecución del servicio de IA local.

  poetry run python examples/execute_ai_service_locally.py


Opción 2. Implementar el agente en la interfaz de chat integrada en watsonx.ai


La última opción es acceder al agente en el espacio Implementaciones en watsonx.ai. Para ello, seleccione "Implementaciones" en el menú de la izquierda. A continuación, seleccione el espacio de implementación, seleccione la pestaña "Activos", seleccione su activoonline ai_service , seleccione el activo con la etiqueta "wx-agent" una vez más y, por último, abra la pestaña "Vista previa". Ahora puede chatear con el agente en la interfaz de chat interactiva. Cada una de estas tres opciones debería dar un resultado similar.

Opción 3. Implementar y chatear con el agente en su IDE

Para ejecutar el script de implementación, inicialice la variable deployment_id  en el archivo query_existing_deployment.py .

Puede obtener el deployment_id de su implementación ejecutando el archivo scripts/deploy.py .

A continuación, ejecute el script de implementación. 

  poetry run python scripts/deploy.py

Después, ejecute el script para consultar la implementación.

  poetry run python examples/query_existing_deployment.py


A efectos de este tutorial, elijamos la opción 2 y consultemos a nuestro agente implementado en watsonx.ai en forma de chatbot agéntico. Proporcionemos al agente algunas instrucciones que requieran el uso de herramientas. Tras seguir los pasos indicados en la opción 3, debería ver una interfaz de chat en watsonx.ai. Allí, podemos escribir nuestra instrucción. 

En primer lugar, comprobemos si la herramienta create_ticket se invoca correctamente. Pidamos al agente que cree un nuevo tique.

Como puede ver en la respuesta final del agente, el sistema de IA utilizó con éxito la resolución de problemas para crear un nuevo tique con la herramienta create_ticket . Tener visibilidad de las llamadas a las herramientas es útil para fines de depuración. Ahora, comprobemos si el ticket se ha añadido correctamente a nuestro archivo de datos que sirve como base de conocimientos del agente. 

¡Genial! El agente ha añadido correctamente el tique al archivo.

Conclusión

En este tutorial, ha creado un agente con el marco ReAct que utiliza la toma de decisiones para resolver tareas complejas, como recuperar y crear tiques de soporte. Existen varios modelos de IA que permiten la llamada a herramientas de agentes, como Gemini de Google, Granite de IBM y GPT-4 de OpenAI. En nuestro proyecto, hemos utilizado un modelo de IA Granite de IBM a través de la API watsonx.ai. El modelo se comportó según lo esperado tanto a nivel local como cuando se implementó en watsonx.ai. Como próximo paso, consulte las plantillas LlamaIndex y crewAI multiagente disponibles en el repositorio GitHub watsonx-developer-hub para crear agentes de IA.

Soluciones relacionadas
Desarrollo de agentes de IA de IBM 

Permita a los desarrolladores crear, implementar y monitorizar agentes de IA con el estudio IBM watsonx.ai.

Explore watsonx.ai
Agentes y asistentes de IA de IBM

Cree una productividad sin precedentes con uno de los conjuntos de capacidades más completos del sector para ayudar a las empresas a crear, personalizar y gestionar agentes y asistentes de IA. 

Explore los agentes de IA
IBM Granite

Ahorre más de un 90 % en costes con los modelos más pequeños y abiertos de Granite, diseñados para la eficiencia de los desarrolladores. Estos modelos listos para uso empresarial ofrecen un rendimiento excepcional frente a los puntos de referencia de seguridad y en una amplia gama de tareas empresariales, desde la ciberseguridad hasta RAG.

Explore Granite
Dé el siguiente paso

Automatice sus flujos de trabajo complejos y cree una productividad revolucionaria con uno de los conjuntos de capacidades más completos del sector para ayudar a las empresas a crear, personalizar y gestionar agentes de IA y asistentes. 

Explore el desarrollo de agentes de watsonx.ai Descubra watsonx Orchestrate