Despliegue 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 (Reasoning and Action) con el marco LangGraph de código abierto mediante un  modelo IBM® Granite a través de la API IBM® watsonx.ai en Python. El caso de uso es gestionar los tickets de soporte de TI existentes y crear otros nuevos.

¿Qué es un agente ReAct?

Un agente de IA se refiere a un sistema o programa que es 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 de lenguaje natural (PLN) de modelos de lenguaje grandes (LLM) para comprender las entradas de los usuarios paso a paso y responder a ellas, y determinar cuándo recurrir a herramientas externas. Un componente central de los agentes de IA es el razonamiento. Al adquirir nueva información a través de llamadas a herramientas, intervención humana u otros agentes, el paradigma de razonamiento guía los siguientes pasos del agente.

Con cada acción y cada respuesta de herramienta, el paradigma ReAct (Reasoning and Action) instruye a los agentes a "pensar" y planificar sus siguientes pasos. Este razonamiento lento y paso a paso nos da insight de cómo el agente utiliza el contexto actualizado para formular conclusiones. Debido a que este proceso de reflexión es continuo, a menudo se lo denomina bucle pensar-actuar-observar y es una forma de instrucción de la cadena de pensamiento.

Uso de LangGraph para crear agentes ReAct

Este tutorial utilizará LangGraph, un marco de agentes de IA de código abierto diseñado para crear, desplegar y gestionar flujos de trabajo complejos de agentes de IA generativa. La función prediseñada create_react_agent LangGraph es una manera fácil de crear un agente simple y personalizado. Los agentes ReAct simples, como el de este tutorial y como se muestra en la Figura 1, se componen de dos nodos. Un nodo es responsable de llamar al modelo y el otro nodo, de usar herramientas. Las herramientas comunes incluyen la herramienta prediseñada LangChain Wikipedia, la herramienta DuckDuckGoSearchRun e incluso la generación aumentada por recuperación (RAG, por sus siglas en inglés). En los casos con entrada de acción compleja, se puede agregar otro nodo, como se ve en la Figura 2. Este nodo adicional serviría para ayudar a garantizar que el agente devuelva resultados estructurados.

Dentro de LangGraph, la característica de "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 gráficos con estado permiten a los agentes recordar información pasada y contexto valioso. La estructura cíclica del gráfico ReAct se aprovecha cuando el resultado de un paso depende de los pasos anteriores del ciclo. Los nodos, o "actores", en el gráfico codifican la lógica del agente y están conectados por bordes. Los bordes son esencialmente funciones de Python que determinan el siguiente nodo a ejecutar según el estado actual.

Requisitos previos

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

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. Iniciar sesión en watsonx.ai con su cuenta de IBM Cloud.

  2. Cree una instancia de servicio 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 desplegar fácilmente los primeros pasos con watsonx.ai, clone este repositorio de GitHub y acceda al proyecto del agente ReAct de soporte de TI. Puede ejecutar el siguiente comando en su terminal para hacerlo.

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 ha hecho. Poetry es una herramienta para gestionar dependencias y paquetes de Python.

pipx install --python 3.11 poetry

Luego, active su entorno virtual.

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

En lugar de usar el comando pip install, el paquete de Poetry nos permite agregar 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 agregar un directorio de trabajo a PYTHONPATH para los siguientes 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. Establezca las variables de entorno

En el archivo config.toml encontrará las siguientes credenciales en blanco que deben completarse antes de intentar desplegar su agente. Sus watsonx_apikey Y watsonx_url se inicializaron en el paso 1 de este tutorial. A continuación, siga el sencillo formulario que se encuentra en la página Acceso para desarrolladores para seleccionar su espacio de despliegue o crear uno nuevo. Allí, puede recuperar su space_id necesario para conectar nuestro agente al despliegue de watsonx.ai. Por último, su model_id está configurado para 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. Cargue sus datos en IBM Cloud Object Storage

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

  1. Primero,inicie sesión en IBM® Cloud. Luego, cree un nuevo proyecto.
  2. En el menú del lado izquierdo, seleccione Resource list. Con el botón Create resource, cree una nueva instancia de Cloud Object Storage o simplemente use este enlace.
  3. Abra su instancia de IBM Cloud Storage recién creada y cree un nuevo bucket. Para este tutorial, puede seleccionar Smart Tier, que es el nivel gratuito. Cuando se le indique, cargue su archivo. Para ver el archivo de muestra, consulte el archivo tickets.csv en el repositorio de GitHub vinculado en el paso 2.

Paso 5. Establezca su conexión de datos

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

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

  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. Cree sus herramientas personalizadas

Nuestro agente podrá leer y escribir datos en nuestro archivo. Primero, vamos a crear la herramienta para leer datos usando LangChain@tool decorator. 

Hemos agregado esta herramientafind_tickets altools.py archivo. Esta herramienta recupera el objeto de datos de Cloud Object Storage y lo devuelve como un marco de datos de 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 agregado 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 la descripción del problema por parte del usuario y la urgencia del problema como argumentos. Se agrega una nueva fila a nuestro archivo en COS con esta información y, por lo tanto, se crea un nuevo ticket. De lo contrario, se lanza una excepción. 

Una última herramienta que debemos agregar a nuestro tools.py archivo es 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 fue 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 otorgar a nuestro agente acceso a estas herramientas, las hemos agregado a la lista TOOLS en el archivo init.py del módulo de extensiones. Esta lista debe incluir el contenido de su del módulo de archivo 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 LangGraph prediseñada create_react_agent  que actúa como ejecutor del agente. Otros parámetros incluyen el modelo de lenguaje grande inicializado mediante la clase ChatWatsonx que permite llamar a la herramienta en watsonx.ai, el protector de memoria y la instrucción del sistema. Tenga en cuenta que algunas instrucciones se comportarán mejor que otras y, por lo tanto, es posible que se requiera cierto nivel de ingeniería rápida dependiendo del LLM que elija. 

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

Paso 7. Chatee con su agente

Hay tres formas de chatear con su agente.

Opción 1. Consulte al agente localmente


Ejecute el script para el servicio de IA local.

  poetry run python examples/execute_ai_service_locally.py


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


La última opción es acceder al agente en el espacio Deployments en watsonx.ai. Para ello, seleccione "Deployments" en el menú del lado izquierdo. Luego, seleccione su espacio de despliegue, la pestaña "Assets", elija su activoonline ai_service, seleccione el activo con la etiqueta "wx-agent" una vez más y, finalmente, abra la pestaña "Preview". Ahora puede chatear con el agente en la interfaz de chat interactivo. Cada una de estas 3 opciones debería tener resultados similares.

Opción 3. Despliegue y chatee con el agente en su IDE

Para ejecutar el script de despliegue, inicialice la variable deployment_id  en el archivo query_existing_deployment. py.

El deployment_id de su despliegue se puede obtener ejecutando el archivo scripts/deploy.py

A continuación, ejecute el script de despliegue. 

  poetry run python scripts/deploy.py

Luego, ejecute el script para consultar el despliegue.

  poetry run python examples/query_existing_deployment.py


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

Primero, probemos si la herramienta herramienta se invocará correctamente. Pidamos al agente que cree un nuevo ticket.

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 ticket con la herramienta herramienta. Tener la visibilidad de las llamadas a herramientas es útil para fines de depuración. Ahora, verifiquemos si el ticket se agregó correctamente a nuestro archivo de datos que sirve como base de conocimiento del agente. 

¡Excelente! El agente agregó correctamente el ticket al archivo.

Conclusión

En este tutorial, creó un agente con la infraestructura ReAct que utiliza la toma de decisiones para resolver tareas complejas, como recuperar y crear tickets de soporte. Existen varios modelos de IA que permiten llamadas de herramientas agénticas, como Gemini de Google, Granite de IBM y GPT-4 de OpenAI. En nuestro proyecto, utilizamos un modelo de IA de IBM Granite a través de la API watsonx.ai. El modelo se comportó como se esperaba tanto localmente como cuando se desplegó en watsonx.ai. Como siguiente paso, consulte las plantillas multiagente LlamaIndex y crewAI disponibles en el repositorio watsonx-developer-hub GitHub para crear agentes de IA.

Soluciones relacionadas
Desarrollo de agentes de IA de IBM 

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

Explore watsonx.ai
Agentes de IA y asistentes de IBM

Cree una productividad revolucionaria con uno de los conjuntos de capacidades más completos de la industria para ayudar a las empresas a crear, personalizar y gestionar asistentes y agentes de IA. 

Explore los agentes de IA
IBM Granite

Logre un ahorro de más del 90 % en costos de energía con los modelos más pequeños y abiertos de Granite, diseñados para mejorar la eficiencia de los desarrolladores. Estos modelos preparados para empresas ofrecen un rendimiento excepcional contra puntos de referencia de seguridad y en una amplia gama de tareas empresariales, desde la ciberseguridad hasta el RAG.

Explorar Granite
Dé el siguiente paso

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

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