Creare agenti LangChain per automatizzare attività in Python

Setup

Prima di entrare nel vivo, configuriamo l’ambiente per il tutorial.

Per prima cosa, crea un nuovo ambiente Conda:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

Installa i pacchetti di LangChain e alcune librerie necessarie:

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Aggiungi il nuovo ambiente Conda a Jupyter come kernel:

$ ipython kernel install --user --name=langchain

Crea un file .env per archiviare segreti come le chiavi API:

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

Recupera la tua chiave API di OpenAI dal file .env:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Verifica che tutto funzioni correttamente interrogando GPT‑3.5 (il modello linguistico predefinito) di OpenAI:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

Ora siamo pronti per iniziare.

Cosa sono gli agenti LangChain?

Dedichiamo un momento a riflettere sul framework degli agenti. In particolare, vedremo come differisce dal paradigma tradizionale delle chain e quali sono i componenti di un agente. Capire perché serve scegliere un nuovo modo di costruire applicazioni ci preparerà a scrivere il codice.

Chain vs agenti

La caratteristica distintiva degli agenti è la loro capacità di scegliere il miglior ordine di azioni per risolvere un problema dato un insieme di strumenti.

Per esempio, supponiamo di avere quanto segue:

• Un'API meteo
• Modello ML per raccomandazioni di abbigliamento
• API Strava per percorsi in bici
• Database delle preferenze utente
• Modello di riconoscimento immagini
• Modello linguistico (generazione di testo)

La risoluzione dei problemi tradizionale prevede l’uso di una chain di strumenti selezionati dalla lista:

Chain 1: Consigli di abbigliamento basati sul meteo

1. Chiama l’API meteo
2. Inserisci i dati meteo nel modello ML per l’abbigliamento
3. Genera raccomandazioni di abbigliamento
4. Presenta i risultati all’utente

Chain 2: Suggeritore di percorsi in bici basato sul meteo

1. Chiama l’API meteo
2. Chiama l’API di Strava per i percorsi popolari
3. Filtra i percorsi in base alle condizioni meteo
4. Presenta i percorsi adatti all’utente

Chain 3: Analizzatore di foto di outfit

1. Ricevi la foto dell’outfit dell’utente
2. Usa un modello di riconoscimento immagini per identificare i capi
3. Confronta con il database delle preferenze dell’utente
4. Genera un feedback usando il modello di generazione di testo
5. Presenta l’analisi all’utente

Ogni chain risolve un problema specifico usando una sequenza di passaggi predefinita e un sottoinsieme degli strumenti disponibili. Non possono adattarsi oltre il loro ambito definito. Inoltre, richiedono tre rami di sviluppo separati, il che è inefficiente in termini di tempo e risorse.

Ora immagina un sistema agentico con accesso a tutti questi strumenti. Sarebbe in grado di:

1. Comprendere la richiesta o il problema dell’utente (tramite linguaggio naturale con un modello linguistico)
2. Valutare quali strumenti sono rilevanti per il problema (ragionamento)
3. Creare dinamicamente un flusso di lavoro usando gli strumenti più appropriati
4. Eseguire il flusso di lavoro, apportando modifiche in tempo reale se necessario (azione)
5. Valutare il risultato e imparare dalle interazioni passate

Per esempio, se un utente chiede: “Cosa dovrei indossare per il mio giro in bici oggi?”, l’agente potrebbe controllare l’API meteo, analizzare percorsi adatti tramite Strava, raccomandare l’abbigliamento appropriato considerando le preferenze passate dell’utente e generare una risposta personalizzata.

L’agente può:

• Gestire un’ampia varietà di problemi usando lo stesso set di strumenti
• Creare workflow su misura per ciascuna situazione
• Adattare l’approccio in base al contesto specifico e alle esigenze dell’utente
• Imparare dalle interazioni per migliorare le prestazioni future

La capacità di LangChain di trasformare i modelli linguistici—che da soli producono solo testo—in motori di ragionamento che sanno usare le risorse a disposizione per agire di conseguenza è una delle sue principali applicazioni. In breve, LangChain abilita lo sviluppo di agenti autonomi potenti che interagiscono con il mondo esterno.

Componenti chiave

Un agente LangChain è composto da vari componenti, come modelli chat, prompt template, strumenti esterni e altri costrutti correlati. Per costruire agenti efficaci, dobbiamo rivedere ciascun componente e capirne l’uso.

Modelli linguistici e chat

Creare un agente LangChain coinvolge molti elementi. Il primo e più ovvio è un modello linguistico.

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

I modelli linguistici, come GPT‑3.5 Turbo di OpenAI, accettano e generano stringhe. Tipicamente sono più datati e funzionano meglio per rispondere a singole domande dell’utente.

I modelli più nuovi e potenti sono di solito modelli chat, che possono accettare una sequenza di messaggi in input e restituire messaggi di chat in output (anziché usare testo semplice):

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

Detto altrimenti, i modelli chat consentono di avere conversazioni in linguaggio naturale. Nell’esempio sopra, inizializziamo GPT‑4o‑mini con un messaggio di sistema seguito da una richiesta dell’utente. Nota l’uso delle classi SystemMessage e HumanMessage.

L’output è un oggetto messaggio, che è il comportamento previsto dei modelli chat:

type(output)

langchain_core.messages.ai.AIMessage

print(output.content)

Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!

Inoltre, restituiscono altre metainformazioni utili accessibili con la dot‑notation:

output.dict()

{'content': "Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!",
'additional_kwargs': {},
'response_metadata': {'token_usage': {'completion_tokens': 38,
  'prompt_tokens': 21,
  'total_tokens': 59},
 'model_name': 'gpt-4o-mini-2024-07-18',
 'system_fingerprint': 'fp_48196bc67a',
 'finish_reason': 'stop',
 'logprobs': None},
'type': 'ai',
'name': None,
'id': 'run-fde829bf-8f5f-4926-a1ed-ab53609ce03a-0',
'example': False,
'tool_calls': [],
'invalid_tool_calls': [],
'usage_metadata': {'input_tokens': 21,
 'output_tokens': 38,
 'total_tokens': 59}}

La maggior parte degli agenti usa modelli chat per via della loro base di conoscenza aggiornata e delle capacità conversazionali. Tuttavia, per agenti semplici senza requisiti di memoria, modelli linguistici come GPT‑3.5 sono sufficienti.

Prompt template

Il modo più efficiente per interrogare modelli linguistici o chat è usare i prompt template. Ti permettono di strutturare le richieste in modo coerente e inserire variabili dinamicamente, rendendo le interazioni con il modello più flessibili e riutilizzabili.

In LangChain esistono molti tipi di prompt template, e il più basilare è la classe PromptTemplate. Può essere usata con modelli linguistici (testo semplice):

from langchain_core.prompts import PromptTemplate
query_template = "Tell me about {book_name} by {author}."
prompt = PromptTemplate(input_variables=["book_name", "author"], template=query_template)
prompt.invoke({"book_name": "Song of Ice and Fire", "author": "GRRM"})

StringPromptValue(text='Tell me about Song of Ice and Fire by GRRM.')

La classe richiede di creare una stringa con segnaposto per le variabili che vuoi sostituire usando la notazione tra parentesi. Poi devi passare questa stringa di template alla classe PromptTemplate insieme ai nomi delle variabili, costruendo così il tuo prompt.

Chiamare .invoke() con i valori delle variabili mostrerà come il tuo prompt sarà passato a un modello.

Passare questo prompt template a un modello linguistico richiede di concatenarlo usando l’operatore pipe:

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key)
# Create a chain
chain = prompt | llm
# Invoke the chain
output = chain.invoke({"book_name": "Deathly Hallows", "author": "J.K. Rowling"})
print(output[:100])

Deathly Hallows is the seventh and final book in the popular Harry Potter series, written by J.K. R

L’operatore pipe (|) fa parte del LangChain Expression Language (LCEL), pensato per concatenare più componenti e strumenti di LangChain.

type(chain)

langchain_core.runnables.base.RunnableSequence

Quando usi l’operatore pipe su oggetti LangChain, crei un’istanza della classe RunnableSequence. Una runnable sequence rappresenta una chain di oggetti che supportano il metodo .invoke(), come i prompt template e i modelli linguistici/chat.

Ora vediamo un’altra classe di prompt template per i modelli chat:

from langchain_core.prompts import ChatPromptTemplate

Abbiamo detto che i modelli chat richiedono una sequenza di messaggi in input. L’input iniziale è di solito un prompt di sistema che dice al modello chat come comportarsi. Quindi, usando la classe ChatPromptTemplate, possiamo creare facilmente modelli chat con personalità diverse:

chat_model = ChatOpenAI(api_key=api_key, model="gpt-4o-mini")
template = ChatPromptTemplate([
   ('system', 'You are a helpful AI bot. Your specialty is {specialty}.'),
   ('human', 'Explain the concept of {concept} based on your expertise.')
])

La classe richiede una lista di messaggi basati su ruoli come input. Ogni elemento della lista deve essere una tupla (ruolo, messaggio) con i segnaposto variabili definiti dove necessario.

Dopodiché possiamo usare lo stesso operatore pipe per creare modelli chat con comportamenti differenti:

specialties = ["psychology", "economics", "politics"]
concept = "time"
# Call the model with different personalities
for s in specialties:
   chain = template | chat_model
   output = chain.invoke({"specialty": s, "concept": concept})
   print(output.content[:100], end="\n" + "-" * 25 + '\n')

Time is a complex and multifaceted concept that has been explored from various perspectives, includi
-------------------------
In economics, the concept of time is multifaceted and plays a crucial role in various theories and m
-------------------------
While my primary focus is on politics, I can provide a brief overview of the concept of time as it m
-------------------------

Strumenti

In una sezione precedente abbiamo detto che gli agenti possono scegliere una combinazione di strumenti a disposizione per risolvere un determinato problema, con gli LLM come motori di ragionamento sotto il cofano.

LangChain offre integrazioni con decine di API e servizi popolari per consentire agli agenti di interagire con il resto del mondo. La maggior parte è disponibile nel pacchetto langchain_community, mentre alcune sono in langchain_core.

Per esempio, ecco come puoi usare lo strumento ArXiv per recuperare riassunti di articoli su vari argomenti:

!pip install -Uq arxiv  # Install arXiv Python SDK

from langchain_community.tools import ArxivQueryRun
tool = ArxivQueryRun()
print(tool.invoke('Photosynthesis')[:250])

Published: 2019-08-28
Title: Photosynthesis on Exoplanets and Exomoons from Reflected Light
Authors: Manasvi Lingam, Abraham Loeb
Summary: Photosynthesis offers a convenient means of sustaining biospheres. We
quantify the constraints for photosynthes

C’è un modo alternativo per caricare gli strumenti invece di importarli per nome di classe:

from langchain_community.agent_toolkits.load_tools import load_tools
tools = load_tools(["arxiv", "dalle-image-generator"])

Sopra stiamo caricando contemporaneamente sia lo strumento arXiv che il generatore di immagini Dall‑E usando la funzione load_tools(). Gli strumenti caricati con questa funzione hanno la stessa sintassi di utilizzo:

# Call arXiv
print(tools[0].invoke("Kaggle")[:150])

Published: 2020-06-06
Title: StackOverflow vs Kaggle: A Study of Developer Discussions About Data Science
Authors: David Hin
Summary: Software develop

# Generate an image with DallE
output_image_url = tools[1].invoke("A magnificent chain in a cartoon.")
output_image_url

'https://oaidalleapiprodscus.blob.core.windows.net/...'

La funzione load_tools richiede di conoscere i nomi stringa delle classi degli strumenti, come nell’esempio di ArxivQueryRun rispetto a 'arxiv'. Puoi controllare velocemente il nome stringa di qualsiasi strumento eseguendo la funzione get_all_tool_names:

from langchain_community.agent_toolkits.load_tools import get_all_tool_names
get_all_tool_names()[:10]

['sleep',
'wolfram-alpha',
'google-search',
'google-search-results-json',
'searx-search-results-json',
'bing-search',
'metaphor-search',
'ddg-search',
'google-lens',
'google-serper']

Nota che load_tools() è solo una scorciatoia. Quando costruisci agenti, è consigliato caricare gli strumenti usando il loro costruttore di classe, così da configurarli in base al comportamento specifico.

Workflow passo‑passo per creare agenti LangChain

Infine, in questa sezione vedremo come creare agenti LangChain passo dopo passo usando le conoscenze acquisite nelle sezioni precedenti.

Nei prossimi esempi costruiremo un agente in grado di spiegare qualsiasi argomento tramite tre media: testo, immagine o video. Più precisamente, in base alla domanda posta, l’agente deciderà in quale formato spiegare l’argomento.

Iniziamo. Ricordati di controllare come impostare l’ambiente, spiegato all’inizio dell’articolo. 

1. Definizione degli strumenti

Il primo passo dopo la configurazione dell’ambiente è definire gli strumenti che daremo al nostro agente. Importiamoli:

from langchain_community.tools import WikipediaQueryRun  # pip install wikipedia
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_community.tools import YouTubeSearchTool  # pip install youtube_search
from langchain_community.tools.openai_dalle_image_generation import (
   OpenAIDALLEImageGenerationTool
)
from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper

Stiamo importando cinque classi:

• WikipediaAPIWrapper: per configurare l’accesso all’API di Wikipedia
• WikipediaQueryRun: per generare riassunti di pagine Wikipedia
• YouTubeSearchTool: per cercare video su YouTube su determinati argomenti
• DallEAPIWrapper: per configurare l’accesso all’endpoint Dall‑E di OpenAI
• OpenAIDALLEImageGenerationTool: per generare immagini tramite prompt

Quando un utente interroga il nostro agente, questo deciderà se spiegare l’argomento usando un articolo di Wikipedia in formato testo, oppure creando un’immagine con Dall‑E per una comprensione visiva, o suggerendo video YouTube per un approfondimento.

Inizializziamoli, partendo dallo strumento Wikipedia:

wiki_api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=250)
wikipedia = WikipediaQueryRun(description="A tool to explain things in text format. Use this tool if you think the user’s asked concept is best explained through text.", api_wrapper=wiki_api_wrapper)
print(wikipedia.invoke("Mobius strip"))

Page: Möbius strip
Summary: In mathematics, a Möbius strip, Möbius band, or Möbius loop is a surface that can be formed by attaching the ends of a strip of paper together with a half-twist. As a mathematical object, it was discovered by Johann Benedi

Generatore di immagini Dall‑E:

dalle_api_wrapper = DallEAPIWrapper(model="dall-e-3", size="1792x1024")
dalle = OpenAIDALLEImageGenerationTool(
   api_wrapper=dalle_api_wrapper, description="A tool to generate images. Use this tool if you think the user’s asked concept is best explained through an image."
)
output = dalle.invoke("A mountain bike illustration.")
print(output)

Strumento di ricerca YouTube:

youtube = YouTubeSearchTool(
   description="A tool to search YouTube videos. Use this tool if you think the user’s asked concept can be best explained by watching a video."
)
youtube.run("Oiling a bike's chain")

"['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu', 'https://www.youtube.com/watch?v=T6xyn1FGHiU&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu']"

Presta particolare attenzione alle descrizioni degli strumenti. L’agente deciderà quale strumento usare in base alla descrizione che fornisci. 

Ora inseriremo gli strumenti in una lista:

tools = [wikipedia, dalle, youtube]

Possiamo già associare questo set di strumenti a un modello chat senza creare un agente:

chat_model = ChatOpenAI(api_key=api_key)
model_with_tools = chat_model.bind_tools(tools)

Proviamo a chiamare il modello con un messaggio semplice:

response = model_with_tools.invoke([HumanMessage("What's up?!")])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response: Hello! How can I assist you today?
Tools used in the response: []

L’output mostra che nessuno degli strumenti associati è stato usato nel generare la risposta. Ora facciamo una domanda specifica che costringa il modello a guardare oltre i suoi dati di addestramento:

response = model_with_tools.invoke([
   HumanMessage("Can you generate an image of a mountain bike?")
])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response:
Tools used in the response: [{'name': 'openai_dalle', 'args': {'query': 'mountain bike'}, 'id': 'call_92GBfmsYtPi9TpGuIOFB1pG8', 'type': 'tool_call'}]

Vediamo che non c’è output testuale, ma viene menzionato Dall‑E di OpenAI. Lo strumento non è ancora chiamato; il modello sta semplicemente suggerendo di usarlo. Per chiamarlo davvero—cioè per agire—dobbiamo creare un agente.

2. Creare un agente semplice

Dopo aver definito il modello e gli strumenti, creiamo l’agente. LangChain offre un’interfaccia di alto livello create_react_agent() dal pacchetto langgraph per creare rapidamente agenti ReAct (reason and act):

from langgraph.prebuilt import create_react_agent
system_prompt = SystemMessage("You are a helpful bot named Chandler.")
agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)

Durante l’inizializzazione dell’agente con un modello chat e una lista di strumenti, passiamo un prompt di sistema per dire al modello come comportarsi in generale. Ora è pronto a ricevere richieste:

from pprint import pprint
response = agent.invoke({"messages": HumanMessage("What's up?")})
pprint(response["messages"])

[HumanMessage(content="What's up?", id='133b9380-cfe1-495a-98f7-b835c874bd57'),
AIMessage(content='Hello! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 112, 'total_tokens': 122}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-0a920c15-39b4-4857-ab51-6ea905575dba-0', usage_metadata={'input_tokens': 112, 'output_tokens': 10, 'total_tokens': 122})]

Abbiamo ricevuto una risposta plausibile, ovvero un semplice testo senza chiamate a strumenti. Ora chiediamo qualcosa di più mirato:

response = agent.invoke({"messages": [
   HumanMessage('Explain how photosynthesis works.')
]})
print(len(response['messages']))

4

Questa volta ci sono quattro messaggi. Vediamo i nomi delle classi dei messaggi e il loro contenuto:

for message in response['messages']:
   print(
       f"{message.__class__.__name__}: {message.content}"
   )  # Print message class name and its content
   print("-" * 20, end="\n")

HumanMessage: Explain how photosynthesis works.
--------------------
AIMessage:
--------------------
ToolMessage: Page: Photosynthesis
Summary: Photosynthesis ( FOH-tə-SINTH-ə-sis) is a system of biological processes by which photosynthetic organisms, such as most plants, algae, and cyanobacteria, convert light energy, typically from sunlight, into the chemical
--------------------
AIMessage: Photosynthesis is a biological process where photosynthetic organisms like plants, algae, and cyanobacteria convert light energy, usually from sunlight, into chemical energy. This process involves capturing light energy through pigments like chlorophyll in plant cells and using it to convert carbon dioxide and water into glucose and oxygen. Glucose serves as a source of energy for the plant, while oxygen is released into the atmosphere as a byproduct. Photosynthesis is crucial for the survival of plants and the balance of oxygen and carbon dioxide in the atmosphere.
--------------------

Ecco! Il terzo messaggio proviene da una chiamata a uno strumento, ossia un riassunto di una pagina Wikipedia sulla fotosintesi. L’ultimo messaggio è del modello chat, che usa il contenuto della chiamata allo strumento per costruire la risposta.

Creiamo rapidamente una funzione per modularizzare gli ultimi passaggi fatti:

def execute(agent, query):
   response = agent.invoke({'messages': [HumanMessage(query)]})
  
   for message in response['messages']:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
      
       print("-" * 20, end="\n")
  
   return response

3. Raffinare il prompt di sistema

Ora aggiorniamo il nostro prompt di sistema con istruzioni dettagliate su come l’agente dovrebbe comportarsi:

system_prompt = SystemMessage(
   """
   You are a helpful bot named Chandler. Your task is to explain topics
   asked by the user via three mediums: text, image or video.
  
   If the asked topic is best explained in text format, use the Wikipedia tool.
   If the topic is best explained by showing a picture of it, generate an image
   of the topic using Dall-E image generator and print the image URL.
   Finally, if video is the best medium to explain the topic, conduct a YouTube search on it
   and return found video links.
   """
)

Ricreiamo l’agente con il nuovo prompt di sistema:

agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)
response = execute(agent, query='Explain the Fourier Series visually.')

HumanMessage: Explain the Fourier Series visually.
--------------------
AIMessage:
--------------------
ToolMessage: https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png?st=2024-08-09T18%3A36%3A46Z&se=2024-08-09T20%3A36%3A46Z&sp=r&sv=2024-08-04&sr=b&rscd=inline&rsct=image/png&skoid=d505667d-d6c1-4a0a-bac7-5c84a87759f8&sktid=a48cca56-e6da-484e-a814-9c849652bcb3&skt=2024-08-09T17%3A56%3A46Z&ske=2024-08-10T17%3A56%3A46Z&sks=b&skv=2024-08-04&sig=Ly8F4jvakFeEtpZ/6jMliLq%2BG3Xs%2Bz1AmX1sL06%2BQ3U%3D
--------------------
AIMessage: Here is a visual representation of the Fourier Series:
![Fourier Series](https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png)
The Fourier Series is a way to represent a function as the sum of simple sine waves. It is used in many areas of mathematics and physics to analyze and understand periodic phenomena.
--------------------

Fantastico, sulla base del nostro messaggio (che era molto istruttivo :), l’agente ha scelto lo strumento giusto per il compito. Ecco l’immagine generata:

4. Aggiungere memoria agli agenti

Al momento il nostro agente è stateless, ovvero non ricorda le interazioni precedenti:

response = execute(agent, query="What did I ask you in the previous query?")

HumanMessage: What did I ask you in the previous query?
--------------------
AIMessage: I'm sorry, I cannot remember the previous query as I don't have access to the conversation history. How can I assist you today?
--------------------

Il modo più semplice per aggiungere la cronologia dei messaggi agli agenti è usare la classe SqliteSaver di langgraph:

from langgraph.checkpoint.sqlite import SqliteSaver
memory = SqliteSaver.from_conn_string(':agent_history:')
agent = create_react_agent(chat_model, tools, checkpointer=memory, state_modifier=system_prompt)

Inizializziamo la memoria usando il metodo .from_conn_string() della classe SqliteSaver, che crea un file di database. Poi passiamo la memoria al parametro checkpointer della funzione create_react_agent().

Ora dobbiamo creare un dizionario di configurazione:

config = {'configurable': {'thread_id': 'a1b2c3'}}

Il dizionario definisce un thread ID per distinguere una conversazione dall’altra e viene passato al metodo .invoke() del nostro agente. Aggiorniamo quindi la funzione execute() per includere questo comportamento:

def execute(agent, query, thread_id="a1b2c3"):
   config = {"configurable": {"thread_id": thread_id}}
   response = agent.invoke({'messages': [HumanMessage(query)]}, config=config)
   for message in response["messages"]:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
       print("-" * 20, end="\n")
   return response
Let’s test it again:
response = execute(
   agent, query="Explain how to oil a bike's chain using a YouTube video", thread_id="123"
)

HumanMessage: Explain how to oil a bike's chain using a YouTube video
--------------------
AIMessage:
--------------------
ToolMessage: ['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D', 'https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D']
--------------------
AIMessage: I found a couple of YouTube videos that explain how to oil a bike chain:
1. [Video 1: How to oil a bike chain](https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
2. [Video 2: Step-by-step guide on oiling a bike chain](https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
You can watch these videos to learn how to oil your bike's chain effectively.
--------------------

Ora chiediamo all’agente delle richieste precedenti:

response = execute(agent, query='What have I asked you so far?', thread_id='123')
print(response)

{'messages': [HumanMessage(content="Explain how to oil a bike's chain using a YouTube video",     id='8254142b-fb77-4958-8ad9-0a0283c6611a'), ...
]

Come previsto, l’agente restituisce i messaggi precedenti! Ora ci serve solo un’interfaccia chat come quella di ChatGPT e abbiamo il nostro chatbot personalizzato.

Tendenze e sviluppi futuri

Nel corso dell’articolo abbiamo intravisto dove sta andando LangChain in termini di agenti. Fino a poco tempo fa, LangChain faceva principalmente uso della classe AgentExecutor ma sta venendo gradualmente sostituita dagli agenti di langgraph.

Gli agenti puri di LangChain vanno bene per iniziare, ma richiedono più righe di codice per costruire lo stesso agente rispetto a LangGraph. Inoltre, oltre un certo punto, il framework AgentExecutor non offrirà la flessibilità che ha LangGraph per costruire agenti complessi multi‑tool.

Ecco perché ora è un ottimo momento per cavalcare l’onda e partire direttamente con LangGraph.

Ti consigliamo vivamente di iniziare a usare anche LangSmith, che è diventato una parte centrale dell’ecosistema LangChain per costruire applicazioni LLM di livello produttivo. Ecco alcuni dei suoi principali vantaggi:

• Debug: LangSmith fornisce tracce dettagliate dell’esecuzione del tuo agente, rendendo più semplice identificare e correggere i problemi.
• Ottimizzazione delle prestazioni: con LangSmith puoi analizzare l’uso dei token, la latenza e altre metriche per ottimizzare l’efficienza del tuo agente.
• Testing e valutazione: LangSmith facilita la creazione e gestione di dataset di test, permettendoti di valutare rigorosamente le prestazioni del tuo agente su un’ampia gamma di scenari.
• Monitoraggio: negli ambienti di produzione, LangSmith offre capacità di monitoraggio in tempo reale, permettendoti di tracciare le prestazioni del tuo agente e rilevare rapidamente anomalie.

Ecco come iniziare con LangSmith:

1. Registrati per un account gratuito qui.
2. Imposta le variabili d’ambiente.

export LANGCHAIN_TRACING_V2="true"

export LANGCHAIN_API_KEY="..."

e sei pronto! Quando inizi a interrogare modelli linguistici/chat, LangSmith inizia a registrare varie metriche su ogni run:

Conclusione

In questo articolo abbiamo esplorato cosa rende gli agenti LangChain diversi dalle chain e i mattoni importanti per costruirli. Abbiamo prima introdotto cosa sono gli agenti e come differiscono dalle strutture più tradizionali delle chain in termini di flessibilità e capacità decisionali.

Poi abbiamo visto i componenti chiave da conoscere per costruire un agente: modelli chat, strumenti e prompt template. Infine, abbiamo esaminato due esempi che mostrano come costruire agenti semplici e avanzati. L’elaborazione del linguaggio naturale è in continua evoluzione e gli agenti LangChain sono all’avanguardia di questo progresso, aprendo la strada a una famiglia di AI ancora più intelligente e versatile.

Ecco alcune risorse correlate per migliorare le tue competenze su LangChain:

• Corso Developing LLM Applications with LangChain 
• Introduzione al Prompt Engineering con LangChain 
• Tutorial su come costruire applicazioni LLM con LangChain
• Creare un modello GPT con capacità di browsing usando gli strumenti di LangChain
• LangChain vs LlamaIndex: un confronto dettagliato

Grazie per la lettura!