top of page

Costruisci il tuo Agente IA con Python e LangChain: una Guida Passo Passo

Nell'affascinante mondo dell'intelligenza artificiale, gli agenti stanno emergendo come una delle frontiere più entusiasmanti. Questi programmi avanzati sono in grado di percepire l'ambiente circostante, agire al suo interno e prendere decisioni intelligenti per raggiungere obiettivi specifici. È un concetto che evoca scenari fantascientifici, ma che sta rapidamente diventando realtà grazie a framework come LangChain.



LangChain è uno strumento di sviluppo rivoluzionario che permette di creare agenti alimentati dall'incredibile potenza dei modelli di linguaggio di grandi dimensioni (LLM). Questi agenti possono essere addestrati per svolgere una vasta gamma di compiti, dall'analisi dei dati alla generazione di contenuti, fino alla risoluzione di problemi complessi. Il cuore pulsante di un agente LangChain è il suo LLM, che funge da "cervello" in grado di elaborare richieste e offrire risposte ragionate.


Ma cosa rende davvero speciali questi agenti è la loro capacità di interagire con il mondo circostante attraverso "strumenti". Questi strumenti sono essenzialmente funzioni o classi che consentono all'agente di compiere azioni come recuperare informazioni da un'API, aggiornare un calendario o eseguire query su un database. È come dotare l'agente di braccia e gambe virtuali per operare nell'ambiente digitale.


In questa guida approfondita, esploreremo il processo di creazione di un semplice agente matematico in LangChain. Passo dopo passo, costruiremo un agente in grado di eseguire operazioni aritmetiche di base come addizione, moltiplicazione e calcolo del quadrato di un numero. Anche se semplice, questo progetto ci consentirà di comprendere i concetti fondamentali alla base degli agenti LangChain e ci preparerà a sviluppare agenti più sofisticati in futuro.


Preparatevi a immergervi nel codice e a scoprire come definire strumenti personalizzati, combinarli in toolkit e integrarli con i modelli di linguaggio OpenAI. Lungo il percorso, imparerete anche a configurare prompt efficaci e a eseguire gli agenti tramite l'AgentExecutor di LangChain.


Che tu sia un principiante o un esperto, questa guida pratica ti fornirà una solida base per padroneggiare la creazione di agenti IA con LangChain.



Costruisci il tuo Agente IA con Python e LangChain: una Guida Passo Passo
Costruisci il tuo Agente IA con Python e LangChain: una Guida Passo Passo


Cos'è un Large Language Model (LLM)?

Un Large Language Model (LLM) è un modello di apprendimento automatico addestrato su enormi quantità di dati testuali. Questi modelli sono in grado di comprendere e generare linguaggio naturale in modo estremamente sofisticato. Esempi noti di LLM includono GPT-3 di OpenAI, LaMDA di Google.


Un LLM non è semplicemente un sistema di ricerca o un'enciclopedia digitale. È un modello generativo che riesce a produrre output originali e coerenti basandosi sul contesto fornito. Può svolgere compiti come riassumere testi, rispondere a domande, tradurre lingue e persino generare codice. La sua straordinaria capacità sta nel cogliere i pattern e le relazioni nascoste all'interno dei dati su cui è stato addestrato, permettendogli di fornire risposte sensate e pertinenti a richieste complesse. I LLM rappresentano un enorme passo avanti nell'elaborazione del linguaggio naturale e stanno alimentando molte delle applicazioni di intelligenza artificiale più avanzate di oggi.



La differenza tra LLM e Agenti IA

Sebbene i Large Language Model (LLM) siano estremamente potenti, da soli non possono compiere azioni concrete al di fuori della generazione di testo. Un LLM come ChatGPT può fornirti informazioni dettagliate su come prenotare un volo, ma non può effettivamente connettersi a un sito di prenotazione e acquistare il biglietto per te.

Gli Agenti IA, d'altra parte, sono sistemi che non solo comprendono richieste e generano risposte come un LLM, ma possono anche interagire con il mondo esterno attraverso una serie di "strumenti" o funzioni. Un agente IA connesso al tuo calendario, ad esempio, potrebbe non solo dirti quali impegni hai in programma, ma anche aggiungervi o modificarvi eventi su tua richiesta.



Gli agenti LangChain sfruttano la potenza di un LLM come "cervello" per comprendere le richieste e decidere quali azioni intraprendere. Tuttavia, a differenza di un semplice LLM, hanno accesso a toolkit di strumenti che gli permettono di interagire con API, database, calendari e altri sistemi esterni. Questa capacità di "agire" sul mondo esterno, oltre che comprendere e generare lingua, rende gli agenti IA estremamente versatili e potenti.


Costruisci il tuo Agente IA con Python e LangChain

LangChain è una libreria Python che semplifica la creazione di agenti IA altamente sofisticati. Permette di combinare la potenza di un LLM con una vasta gamma di strumenti e fonti dati, trasformando essenzialmente il modello di linguaggio in un "assistente virtuale" in grado di svolgere compiti complessi per tuo conto.


Setup ambiente di lavoro

Per iniziare a costruire il nostro agente con LangChain, dobbiamo prima configurare un ambiente di sviluppo Python. Ecco i passaggi:


1. Crea una nuova directory di progetto e un file Python:

mkdir simple-math-agent && cd simple-math-agent 
touch math-agent.py

2. Crea e attiva un ambiente virtuale Python:

python3 -m venv .venv
. .venv/bin/activate


3. Installa le librerie LangChain e langchain_openai:

pip install langchain langchain_openai

Con l'ambiente di lavoro configurato, siamo pronti per tuffarci nel fantastico mondo degli agenti LangChain!


Gli Strumenti: Il Cuore dell'Agente

Il punto di partenza più semplice sarà definire gli strumenti per il nostro agente matematico. Vogliamo dotarlo di strumenti per "addizione", "moltiplicazione" e "calcolo del quadrato", in modo che possa eseguire queste operazioni sulle domande che gli sottoporremo. Mantenendo gli strumenti semplici, possiamo concentrarci sui concetti fondamentali e costruire noi stessi gli strumenti, invece di affidarci a strumenti già esistenti e più complessi come il WikipediaTool, che funge da wrapper attorno all'API di Wikipedia e richiede di importarlo dalla libreria LangChain.


Ancora una volta, non stiamo cercando di fare nulla di straordinario qui. Stiamo solo mantenendo le cose semplici e assemblando i blocchi costitutivi principali di un agente in modo da comprendere come funzionano e far partire il nostro primo agente.


Creare lo Strumento "Addizione"

Iniziamo con lo strumento "add" (addizione). Il modo "bottom-up" per creare uno Strumento in LangChain sarebbe estendere la classe BaseTool, impostare i campi name e description sulla classe e implementare il metodo _run. Avrebbe questo aspetto:

from langchain_core.tools import BaseTool

class AddTool(BaseTool):

    name = "add" 

    description = "Somma due numeri"

    args_schema: Type[BaseModel] = AddInput

    return_direct: bool = True

    def _run(self, a: int, b: int, run_manager: Optional[CallbackManagerForToolRun] = None) -> str:

        return a + b



Come puoi vedere, dobbiamo implementare il metodo _run per mostrare ciò che il nostro strumento fa con i parametri che gli vengono passati.


Nota anche che richiede un modello pydantic per l'args_schema. Lo definiremo qui:

AddInput

    a: int = Field(description="primo numero")

    b: int = Field(description="secondo numero")

Semplificare con i Decorator

Ora, LangChain ci offre un modo più semplice per definire gli strumenti, invece di dover estendere la classe BaseTool ogni volta. Possiamo farlo con l'aiuto del decorator @tool. Definire lo strumento "add" in LangChain usando il decorator @tool avrebbe questo aspetto:

from langchain.tools import tool

@tool
def add(a: int, b: int) -> int:

    """Somma due numeri""" # questa docstring viene utilizzata come descrizione

    return a + b # le azioni che il nostro strumento esegue

Molto più semplice, vero? Dietro le quinte, il decorator usa magicamente il metodo fornito per estendere la classe BaseTool, proprio come abbiamo fatto in precedenza. Alcune cose da notare:

  • Il nome del metodo diventa anche il nome dello strumento

  • I parametri del metodo definiscono i parametri di input dello strumento

  • La docstring viene convertita nella descrizione dello strumento


Puoi accedere a queste proprietà anche sullo strumento:

print(add.name) # add
print(add.description) # Somma due numeri
print(add.args) # {'a': {'title': 'A', 'type': 'integer'}, 'b': {'title': 'B', 'type': 'integer'}}

Nota bene: la descrizione di uno strumento è molto importante, poiché è ciò che il modello di linguaggio utilizza per decidere se quello è lo strumento giusto per il lavoro. Una descrizione poco chiara potrebbe portare a non utilizzare lo strumento quando dovrebbe essere usato, o a utilizzarlo nei momenti sbagliati.



Altri Strumenti: Moltiplicazione e Quadrato

Con lo strumento "add" completato, passiamo alle definizioni degli strumenti "multiply" e "square":

@tool  
def multiply(a: int, b: int) -> int:
    """Moltiplica due numeri."""
    return a * b

@tool
def square(a) -> int:
    """Calcola il quadrato di un numero."""
    a = int(a)
    return a * a


Semplice, vero? Abbiamo definito i nostri tre strumenti personalizzati. Un caso d'uso più comune potrebbe essere l'utilizzo di alcuni degli strumenti già forniti ed esistenti in LangChain, che puoi vedere qui. Tuttavia, a livello di codice sorgente, sarebbero tutti creati e definiti utilizzando metodi simili a quelli descritti in precedenza.


E questa è tutta la parte relativa ai nostri Strumenti. È ora di combinarli in un Toolkit.



Il Toolkit: L'Arsenale dell'Agente

I toolkit possono sembrare qualcosa di sofisticato, ma in realtà sono molto semplici. Sono letteralmente una lista di strumenti. Possiamo definire il nostro toolkit come un array di strumenti in questo modo:

toolkit = [add, multiply, square]

Ed è tutto. Davvero diretto e niente di complicato.

Di solito, i toolkit sono gruppi di strumenti utili insieme e sarebbero d'aiuto per gli agenti che cercano di portare a termine determinati tipi di attività.


Ad esempio, un SQLToolkit potrebbe contenere uno strumento per generare una query SQL, uno per convalidare una query SQL e uno per eseguire una query SQL.


La pagina Integrations Toolkit nella documentazione di LangChain contiene un'ampia lista di toolkit sviluppati dalla community che potrebbero essere utili.



Il Large Language Model: Il Cervello dell'Agente

Come menzionato in precedenza, un LLM (Large Language Model) è il "cervello" di un agente. Decide quali strumenti chiamare in base alla domanda che gli viene posta e quali sono i prossimi passaggi migliori da intraprendere basandosi sulla descrizione di uno strumento. Decide anche quando ha raggiunto la risposta finale e quando è pronto a restituirla all'utente.


Impostiamo il nostro LLM qui:

from langchain_openai import ChatOpenAI 
llm = ChatOpenAI(model="gpt-3.5-turbo-1106", temperature=0)

Il Prompt di Sistema: La Guida dell'Agente

Infine, abbiamo bisogno di un prompt da passare al nostro agente, in modo che abbia un'idea generale di che tipo di agente è e quali tipi di attività dovrebbe risolvere.

Il nostro agente richiede un ChatPromptTemplate per funzionare (ne parleremo più avanti). Questo è l'aspetto di un semplice ChatPromptTemplate. La parte principale che ci interessa è il prompt di sistema, mentre il resto sono solo le impostazioni predefinite che siamo obbligati a passare.


Nel nostro prompt abbiamo incluso una risposta di esempio, mostrando all'agente come vogliamo che restituisca solo la risposta, senza aggiungere alcun testo descrittivo.

prompt = ChatPromptTemplate.from_messages(
   [
        ("system", """
          Sei un assistente matematico. Usa i tuoi strumenti per rispondere alle domande.
          Se non hai uno strumento per rispondere alla domanda, dichiaralo.

          Restituisci solo le risposte. Es:
          Umano: Quanto fa 1 + 1?
          IA: 2
        """),

        MessagesPlaceholder("chat_history", optional=True),
        ("human", "{input}"),
        MessagesPlaceholder("agent_scratchpad"),
    ]
)


Ecco fatto. Abbiamo impostato i nostri Strumenti e Toolkit, di cui il nostro agente avrà bisogno come parte della sua configurazione, in modo che conosca i tipi di azioni e capacità a sua disposizione. E abbiamo anche impostato l'LLM e il prompt di sistema.

Ora arriva la parte divertente: configurare il nostro Agente!



Scegliere il Tipo di Agente

LangChain offre diversi tipi di agenti che possono essere creati, con capacità di ragionamento e abilità differenti. Noi utilizzeremo l'agente più potente e avanzato attualmente disponibile: l'OpenAI Tools Agent. Come descritto nella documentazione, questo agente sfrutta anche i nuovi modelli OpenAI:


I nuovi modelli OpenAI sono stati addestrati per rilevare quando una o più funzioni devono essere chiamate e rispondere con gli input che dovrebbero essere passati a tali funzioni. In una chiamata API, puoi descrivere le funzioni e il modello sceglierà intelligentemente di restituire un oggetto JSON contenente gli argomenti per chiamare queste funzioni. L'obiettivo delle API OpenAI Tools è quello di restituire in modo più affidabile chiamate di funzione valide e utili rispetto a quanto si possa fare utilizzando un'API di completamento di testo o chat generica.


In altre parole, questo agente è bravo a generare la struttura corretta per chiamare funzioni e in grado di capire se per il nostro compito potrebbe essere necessaria più di una funzione (strumento). Questo agente ha anche la capacità di chiamare funzioni (strumenti) con più parametri di input, proprio come fanno i nostri strumenti. Alcuni agenti possono lavorare solo con funzioni che hanno un singolo parametro di input.


Se conosci la funzionalità di Function Calling di OpenAI, dove possiamo utilizzare l'LLM di OpenAI per generare i parametri corretti per chiamare una funzione, l'OpenAI Tools Agent che stiamo usando qui sfrutta parte di quella potenza per essere in grado di chiamare lo strumento corretto, con i parametri corretti.



Configurare l'Agente AI in LangChain

Per configurare un agente in LangChain, dobbiamo utilizzare uno dei metodi di factory forniti per creare l'agente di nostra scelta.


Il metodo di factory per creare un OpenAI Tools Agent è create_openai_tools_agent(). Richiede di passare l'llm, gli strumenti e il prompt che abbiamo impostato in precedenza. Inizializziamo quindi il nostro agente:

agent = create_openai_tools_agent(llm, toolkit, prompt)


Eseguire l'Agente con l'AgentExecutor

Infine, per eseguire gli agenti in LangChain, non possiamo semplicemente chiamare un metodo "run" direttamente su di essi. Devono essere eseguiti tramite un AgentExecutor.


Introduco l'AgentExecutor solo alla fine perché non credo sia un concetto critico per capire come funzionano gli agenti e portarlo subito all'inizio avrebbe solo reso il tutto più complicato del necessario, oltre a distogliere l'attenzione da alcuni concetti fondamentali.

L'AgentExecutor funge da runtime per gli agenti in LangChain e permette a un agente di continuare a funzionare finché non è pronto a restituire la risposta finale all'utente. In pseudo-codice, gli AgentExecutor fanno qualcosa di simile a (tratto direttamente dalla documentazione di LangChain):

next_action = agent.get_action(...)
while next_action != AgentFinish:
    observation = run(next_action)
    next_action = agent.get_action(..., next_action, observation)
return next_action


Sono essenzialmente un ciclo while che continua a chiamare i metodi next_action sull'agente, fino a quando l'agente non ha restituito la sua risposta finale.

Configuriamo quindi il nostro agente all'interno dell'AgentExecutor. Gli passiamo l'agente e dobbiamo passargli anche il toolkit. Impostiamo verbose a True in modo da avere un'idea di ciò che l'agente sta facendo durante l'elaborazione della nostra richiesta:

agent_executor = AgentExecutor(agent=agent, tools=toolkit, verbose=True)

Ed ecco fatto. Ora siamo pronti per passare comandi al nostro agente:

result = agent_executor.invoke({"input": "quanto fa 1 + 1?"})

Eseguiamo il nostro script e vediamo l'output dell'agente:


Poiché abbiamo impostato verbose=True sull'AgentExecutor, possiamo vedere le righe di Azione che il nostro agente ha intrapreso. Ha identificato che dovrebbe chiamare lo strumento "add", ha chiamato lo strumento "add" con i parametri richiesti e ci ha restituito il risultato.



Che emozione vedere il nostro agente in azione! Ora siamo pronti per testarlo con diverse richieste matematiche e vedere come si comporta.



Osservazioni

Dopo aver utilizzato un po' l'agente, ho notato quanto segue:

  • Quando gli venivano poste domande dirette per le quali aveva gli strumenti adatti, era piuttosto coerente nell'utilizzare gli strumenti corretti per il lavoro e nel restituire la risposta corretta. Quindi, piuttosto affidabile in questo senso.

  • Se la domanda era un po' complicata, come ad esempio la nostra domanda "5 elevato alla sesta", non sempre restituiva risultati corretti.

  • A volte poteva usare semplicemente la pura potenza dell'LLM per rispondere alla nostra domanda, senza invocare i nostri strumenti.


Il Futuro

Gli agenti, e i programmi che possono ragionare autonomamente, rappresentano un nuovo paradigma nella programmazione e credo che diventeranno una parte molto più importante di come verranno costruite molte cose. Ovviamente, la natura non deterministica (cioè non del tutto prevedibile) degli LLM significa che anche i risultati degli agenti ne soffriranno, mettendo in dubbio quanto possiamo contare su di loro per attività per le quali abbiamo bisogno di essere sicuri delle risposte che abbiamo.


Forse, man mano che la tecnologia maturerà, i loro risultati potranno essere sempre più prevedibili e potremmo sviluppare alcune soluzioni alternative per questo.


Posso anche immaginare che inizieranno a comparire librerie e pacchetti di tipo agente. Proprio come installiamo librerie e pacchetti di terze parti nel software, ad esempio tramite il gestore di pacchetti pip per Python o Docker Hub per le immagini Docker, potremmo iniziare a vedere lo sviluppo di una libreria e un gestore di pacchetti di agenti, con agenti sviluppati per essere molto bravi in compiti specifici, che potremmo quindi installare come pacchetti nella nostra applicazione.


Infatti, la libreria di Toolkit di LangChain per gli agenti, elencata nella loro pagina Integrations, sono insiemi di strumenti costruiti dalla community per essere utilizzati dalle persone, che potrebbero essere un primo esempio di librerie di tipo agente costruite dalla community.


Conclusione

Spero che questa sia stata un'introduzione utile per iniziare a costruire con gli agenti in LangChain. Ricorda, gli agenti sono fondamentalmente un cervello (l'LLM) e un insieme di strumenti, che possono utilizzare per svolgere attività nel mondo che li circonda.



Per chi vuole creare agenti IA per la propria azienda

Se siete interessati a creare agenti IA avanzati in grado di estrarre dati da database, interrogare file Excel o PDF, o svolgere altre attività complesse per la vostra azienda, potete prenotare una consulenza gratuita con i nostri esperti di IA Italia su:



I nostri consulenti esperti vi guideranno nell'implementazione delle migliori soluzioni di intelligenza artificiale per le vostre specifiche esigenze aziendali. Non lasciatevi sfuggire questa opportunità di sfruttare appieno il potenziale dell'IA per la crescita della vostra attività!

Comments

Rated 0 out of 5 stars.
No ratings yet

Add a rating
PCR (5).gif
PCR (4).gif
PCR.gif
PCR.gif
PCR.gif
PCR.gif
PCR (5).gif
3.gif
Vediamo se riesci a cliccarmi ! Nascondo una Sorpresa... (2).png

Ciao 

🤗 Articoli consigliati dalla nostra
Intelligenza Artificiale in base ai tuoi interessi

Correlazione Alta

Correlazione Media

Correlazione Bassa

Iscriviti

VUOI DIVENTARE UN MEMBRO DI INTELLIGENZA ARTIFICIALE ITALIA GRATUITAMENTE E TRARNE I SEGUENTI BENEFICI?

Corsi Gratis

più di 150 lezioni online

Dataset Gratis

più di 150o dataset

Ebook Gratis

più di 10 libri da leggere

Editor Gratis

un editor python online

Progetti Gratis

più di 25 progetti python

App Gratis

4 servizi web con I.A.

Unisciti Ora a oltre
1.000.000
di lettori e appassionanti d'I.A.

Tutto ciò che riguarda l'intelligenza Artificiale, in unico posto, in italiano e gratis.

MEGLIO DI COSI' NON SI PUO' FARE

Dopo l'iscrizione riceverai diversi Regali

Ecco altre letture proposte dal nostro motore di raccomandazione simili a

Costruisci il tuo Agente IA con Python e LangChain: una Guida Passo Passo

Correlazione Alta

Correlazione Media

Correlazione Bassa

VUOI SCRIVERE ARTICOLI INSIEME A NOI.

Grazie

bottom of page