Implementa un agente LangGraph ReAct di supporto IT con IBM Granite su watsonx.ai

Autori

Anna Gutowska

AI Engineer, Developer Advocate

IBM

In questo tutorial creiamo un agente AI ReACT (Reasoning and Action) con il framework open source LangGraph utilizzando un modello IBM Granite con IBM® watsonx.ai API in Python. Il caso d'uso sarà la gestione delle richieste di assistenza IT esistenti e la creazione di nuove.

Cos'è un agente ReAct?

Un agente di intelligenza artificiale (AI) è un sistema o programma in grado di eseguire autonomamente attività per conto di un utente o di un altro sistema, progettandone il workflow e utilizzando gli strumenti disponibili. Gli agenti di AI generativa utilizzano le tecniche avanzate di elaborazione del linguaggio naturale (NLP) dei modelli linguistici di grandi dimensioni (LLM) per comprendere e rispondere passo dopo passo agli input degli utenti e determinare quando ricorrere a strumenti esterni. Una componente chiave degli agenti AI è il ragionamento. Dopo avere acquisito nuove informazioni tramite il tool calling, l'intervento umano o altri agenti, il paradigma del ragionamento guida i passi successivi dell'agente.

Con ogni azione e risposta di ogni strumento, il paradigma ReACT (Reasoning and Action) indica agli agenti di "pensare" e pianificare i passi successivi. Questo ragionamento lento e graduale ci offre insight su come l'agente utilizza il contesto aggiornato per formulare conclusioni. Poiché questo processo di riflessione è continuo, viene spesso definito ciclo think-act-observe ed è un tipo di prompt chain-of-thought.

Utilizzo di LangGraph per creare agenti ReAct

Questo tutorial utilizza il framework LangGraph, un framework di agenti AI open source progettato per creare, implementare e gestire complessi workflow di agenti di AI generativa. La funzione predefinita create_react_agent fornita da LangGraph consente di creare facilmente un agente semplice e personalizzato. Gli agenti ReACT semplici, come quello di questo tutorial illustrato nella Figura 1, sono composti da due nodi. Un nodo è responsabile della chiamata del modello e l'altro nodo è responsabile dell'utilizzo degli strumenti. Gli strumenti comuni includono lo strumento predefinito LangChain Wikipedia, lo strumento DuckDuckGoSearchRun e persino la retrieval-augmented-generation (RAG). In caso di input di azioni complesse, è possibile aggiungere un altro nodo, come mostrato nella Figura 2. Questo nodo aggiuntivo avrebbe lo scopo di contribuire a garantire che l'agente restituisca un output strutturato.

Diagramma dell'architettura dell'agente ReAct Diagramma dell'architettura dell'agente ReAct

All'interno di LangGraph, la funzione "state" funge da banca di memoria che registra e tiene traccia di tutte le informazioni preziose elaborate da ogni iterazione del sistema di AI. Questi grafici stateful consentono agli agenti di ricordare informazioni passate e un contesto prezioso. La struttura ciclica del grafico ReAct viene utilizzata quando il risultato di una fase dipende dai passaggi precedenti del ciclo. I nodi, o "attori", nel grafico codificano la logica degli agenti e sono collegati da edge. Gli edge sono essenzialmente funzioni Python che determinano il nodo successivo da eseguire in base allo stato corrente.

Prerequisiti

Per creare un progetto  watsonx.ai è necessario un account IBM Cloud.

Passaggi

Per utilizzare l'application programming interface (API) watsonx, è necessario completare i seguenti passaggi. Nota: puoi accedere a questo tutorial anche su GitHub. 

Passaggio 1. Genera le tue credenziali watsonx.ai

  1. Accedi a watsonx.ai usando il tuo account IBM Cloud.

  2. Crea un'istanza di servizio watsonx.ai Runtime (seleziona l'area geografica appropriata e scegli il piano Lite, che è un'istanza gratuita).

  3. Genera una chiave API (application programming interface).

Passaggio 2. Configura il progetto nell'IDE

Per iniziare a implementare agenti su watsonx.ai facilmente, clona questo repository GitHub e accedi al progetto dell'agente ReAct di assistenza IT. Per farlo, puoi eseguire il seguente comando nel tuo terminale.

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

Installa quindi poetry se non lo hai già installato. Poetry è uno strumento per la gestione delle dipendenze e del packaging di Python.

pipx install --python 3.11 poetry

Quindi, attiva il tuo ambiente virtuale.

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

Anziché usare il comando pip install il pacchetto poetry ci permette di aggiungere dipendenze eseguendo il seguente comando nel terminale. Questo passaggio installa le dipendenze del repository riflesse nel file pyproject.toml nel tuo ambiente virtuale separato.

poetry install

L'aggiunta di una directory di lavoro a PYTHONPATH è necessaria per i passaggi successivi. Nel tuo terminale esegui:  

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

Per configurare il tuo ambiente, segui le istruzioni nel file README.md su Github. Questa configurazione richiede l'esecuzione di diversi comandi sull'IDE o sulla riga di comando.

Fase 3. Imposta le variabili di ambiente

Nel file config.toml troverai le seguenti credenziali vuote che devono essere compilate prima di tentare di implementare il tuo agente. I tuoi watsonx_apikey e watsonx_url sono stati inizializzati nella Fase 1 di questo tutorial. Segui quindi il semplice modulo che si trova nella pagina Developer Access per selezionare il tuo spazio di implementazione o crearne uno nuovo. Lì puoi recuperare lo space_id necessario per connettere il nostro agente all'implementazione watsonx.ai. Per finire, il tuo model_id è impostato sul modello 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/

Fase 4. Carica i tuoi dati su IBM Cloud Object Storage

Il nostro agente richiede una fonte di dati per fornire informazioni aggiornate e aggiungere nuovi dati. Memorizziamo il nostro file di dati in IBM Cloud Object Storage.

  1. Per prima cosa, accedi a IBM Cloud. Quindi, crea un nuovo progetto.
  2. Nel menu a sinistra, seleziona Elenco risorse. Utilizzando il pulsante Crea risorsa, crea una nuova istanza di Cloud Object Storage oppure usa semplicemente questo link.
  3. Apri l'istanza IBM Cloud Storage appena creata e crea un nuovo bucket. Per questo tutorial puoi selezionare il livello Smart, ovvero il livello gratuito. Quando richiesto, carica il tuo file. Per il file di esempio, fai riferimento al file tickets.csv nel repository GitHub collegato nella Fase 2.

Fase 5. Stabilisci la connessione dei dati

Per fornire all'agente ReACT la funzionalità di gestione dei ticket IT, dobbiamo connetterci alla nostra fonte di dati in IBM Cloud Object Storage. Per questo passaggio, possiamo utilizzare il comando ibm_boto3 library.

In tools.py il COS_ENDPOINT , COS_INSTANCE_CRN , BUCKET_NAME e CSV_FILE_NAME deve essere compilato con le informazioni corrette utilizzando i dettagli del bucket che si trovano nella tua istanza di Cloud Object Storage nella scheda 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,
  )

Fase 6. Crea i tuoi strumenti personalizzati

Il nostro agente sarà in grado di leggere e scrivere i dati nel file. Per prima cosa, creiamo insieme lo strumento per leggere i dati utilizzando il LangChain@tool decorator. 

Abbiamo aggiunto questo strumentofind_tickets altools.py file. Questo strumento recupera l'oggetto dati da Cloud Object Storage e lo restituisce come dataframe Pandas. In caso contrario, viene generata un'eccezione. 

  @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

 

Successivamente abbiamo aggiunto lo strumento 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.")

Questo strumento prende in considerazione come argomenti la descrizione del problema da parte dell'utente e l'urgenza del problema. Una nuova riga viene aggiunta al nostro file in COS con queste informazioni, quindi viene creato un nuovo ticket. In caso contrario, viene generata un'eccezione. 

Un ultimo strumento che dobbiamo aggiungere al nostro tools.py il file è lo strumento get_todays_date che utilizza il modulo datetime per restituire la data di oggi nel formato MM-DD-YYYY. Questo strumento sarà utile per accedere alla data corrente, che l'agente non ha altro modo di recuperare perché l'LLM non è stato addestrato su questi dati. 

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

Per garantire al nostro agente l'accesso a questi strumenti, li abbiamo aggiunti alla lista TOOLS nel file init.py del modulo . Questo elenco dovrebbe corrispondere ai contenuti del tuo modulo file nella directory src/langgraph_react_agent .

  from .tools import (
    find_tickets,
    get_todays_date,
    create_ticket
  )

  TOOLS = [
      find_tickets,
      get_todays_date,
      create_ticket
  ]


Questi strumenti vengono importati file agent.py e vengono passati alla funzione predefinita LangGraph create_react_agent che funge da esecutore dell'agente. Altri parametri includono il modello linguistico di grandi dimensioni inizializzato utilizzando la classe ChatWatsonx che consente di eseguire il tool calling su watsonx.ai, il memory saver e il prompt di sistema. Nota: alcuni prompt si comporteranno meglio di altri e quindi potrebbe essere richiesto un certo livello di prompt engineering a seconda dell'LLM scelto. 

Prima di distribuire il tuo agente, ricordati di completare tutte le informazioni necessarie nel file config.toml

Fase 7. Chatta con il tuo agente

Ci sono tre modi per chattare con il tuo agente.

Opzione 1. Interroga l'agente a livello locale


Esegui lo script per l'esecuzione del servizio di AI locale.

  poetry run python examples/execute_ai_service_locally.py


Opzione 2. Implementare l'agente sull'interfaccia di chat integrata in watsonx.ai


L'opzione finale consiste nell'accedere all'agente nello spazio di implementazione su watsonx.ai. Per fare questo, seleziona "Deployments" nel menu a sinistra. Quindi, seleziona il tuo spazio di implementazione, seleziona la scheda "Assets", seleziona il tuo assetonline ai_service e seleziona ancora una volta l'asset con il tag "wx-agent", quindi apri la scheda "Preview". Ora può chattare con l'agente nell'interfaccia di chat interattiva. Ognuna di queste tre opzioni dovrebbe produrre un output simile.

Opzione 3. Implementa e chatta con l'agente nel tuo IDE

Per eseguire lo script di implementazione, inizializza la variabile deployment_id  nel query_existing_deployment.py .zip

Il deployment_id della tua implementazione può essere ottenuto eseguendo il file script/deploy.py

Esegui quindi lo script di implementazione. 

  poetry run python scripts/deploy.py

Esegui ora lo script per interrogare l'implementazione.

  poetry run python examples/query_existing_deployment.py


Ai fini di questo tutorial, scegliamo l'opzione 2 e interroghiamo il nostro agente distribuito su watsonx.ai sotto forma di chatbot agentico. Forniamo all'agente alcuni prompt che richiederebbero l'uso di strumenti. Dopo avere seguito i passaggi elencati nell'opzione 3, dovresti vedere un'interfaccia di chat su watsonx.ai. Lì possiamo digitare il nostro prompt. 

Innanzitutto, verifichiamo se lo strumento create_ticket verrà richiamato correttamente. Chiediamo all'agente di creare un nuovo ticket.

Interrogazione dell'agente distribuito su watsonx.ai per creare una nuova richiesta di assistenza Interrogazione dell'agente distribuito su watsonx.ai per creare una nuova richiesta di assistenza

Come si può vedere nella risposta finale dell'agente, il sistema AI ha utilizzato con successo la risoluzione dei problemi per creare un nuovo ticket con lo strumento create_ticket . Avere la visibilità nel tool calling è utile ai fini del debug. Ora controlliamo se il ticket è stato aggiunto con successo al nostro file di dati che funge da knowledge base dell'agente. 

Interrogazione dell'agente distribuito su watsonx.ai per recuperare le richieste di assistenza recenti Interrogazione dell'agente distribuito su watsonx.ai per recuperare le richieste di assistenza recenti

Fantastico! L'agente ha aggiunto correttamente il ticket al file.

Conclusioni

In questo tutorial, hai creato un agente con il framework ReAct che utilizza il processo decisionale per risolvere attività complesse come il recupero e la creazione di richieste di assistenza. Esistono diversi modelli AI che consentono la chiamata di strumenti agentici come Gemini di Google, Granite di IBM e GPT-4 di OpenAI. Nel nostro progetto, abbiamo utilizzato un modello AI IBM Granite tramite l'API watsonx.ai. Il modello si è comportato come previsto sia a livello locale che quando è stato implementato su watsonx.ai. Come prossimo passo, controlla i modelli LlamaIndex e crewAI multiagente, disponibili nel repository watsonx-developer-hub GitHub per la creazione di agenti AI.

Soluzioni correlate
Sviluppo di agenti AI IBM 

Consenti agli sviluppatori di creare, distribuire e monitorare agenti AI con lo studio IBM watsonx.ai.

Esplora watsonx.ai
Agenti e assistenti AI di IBM

Migliora la produttività con uno dei set di funzionalità più completi del settore che aiuta le aziende a creare, personalizzare e gestire agenti e assistenti AI. 

Scopri gli agenti AI
IBM Granite

Ottieni un risparmio sui costi di oltre il 90% con i modelli più piccoli e aperti di Granite, progettati per l'efficienza degli sviluppatori. Questi modelli pensati per le imprese offrono prestazioni eccellenti rispetto ai benchmark di sicurezza e in un'ampia gamma di attività aziendali, dalla cybersecurity alla RAG.

Esplora Granite
Prossimi passi

Automatizza i tuoi workflow complessi e migliora la produttività con uno dei set di funzionalità più completi del settore che aiuta le aziende a creare, personalizzare e gestire agenti e assistenti AI. 

Esplora lo sviluppo di agenti watsonx.ai Scopri watsonx Orchestrate