un chatbot locale per i tuoi documenti con llama3 e langchain

Llama3 è un chatbot locale che puoi installare sulla tua intranet per rispondere alle domande dei tuoi colleghi e automatizzare i processi aziendali. Con Llama3, puoi creare un’esperienza di supporto clienti personalizzata e migliorare l’efficienza delle tue operazioni aziendali oltre a risparmiare tempo e risorse. In questo articolo esplorereremo come scaricare e utilizzare llama3 con python e langchain.

CODICE: llama3-local-pdf-chatbot su github

Cos’è Llama3?

Llama3 è un chatbot locale basato su ollama, un framework open-source per la creazione di chatbot in Python. Con Llama3, puoi creare un’interfaccia conversazionale per rispondere alle domande dei tuoi colleghi, automatizzare i processi aziendali e fornire supporto clienti personalizzato. Llama3 è altamente personalizzabile e può essere integrato con altri sistemi aziendali per migliorare l’efficienza delle operazioni.

Installare Llama3

Per installare llama3 in locale utilizzeremo ollama e langchain. Ollama è un software che consente di gestire numerosi modelli llm e di utilizzarli per creare chatbot personalizzati. Langchain è un framework open-source per la creazione di chatbot in Python. Per installare llama3, segui i seguenti passaggi:

1. Scarica e installa ollama sul tuo computer.
2. apri il terminale e scarica il modello llama3 utilizzando il comando ollama run llama3.

Installare i software necessari per il chatbot con langhain

Per installare i software necessari per il chatbot con langhain, è necessario aprire un terminale e installare i pacchetti necessari con i seguenti comandi (python deve essere installato sul tuo computer):

pip install langchain
pip install langchain-chroma
pip install langchain_community
pip install langchainhub
pip install -U -q gpt4all

Una volta installati i pacchetti, immaginiamo di voler creare un chatbot a cui poter fare domande su di un file PDF, in questo caso un manuale linux in PDF. Per fare ciò, possiamo utilizzare il seguente codice:

from langchain_community.document_loaders.pdf import PyPDFLoader

loader = PyPDFLoader("The_Linux_Users_Guide.pdf")
data = loader.load()
print(data)

A questo punto possiamo creare il vector store per il chatbot con il seguente codice:

from langchain_chroma import Chroma
from langchain.embeddings import GPT4AllEmbeddings
Chroma.from_documents(documents=data, embedding=GPT4AllEmbeddings(), persist_directory="./chroma_db")

Questo è una chiamata al metodo statico “from_documents” della classe “Chroma”. Questo metodo è progettato per creare uno vectorstore Chroma da una lista di documenti, con l’opzione di persistere questi dati in una directory specificata. Il metodo accetta diversi parametri, ma in questa chiamata specifica, ne vengono forniti esplicitamente solo tre: “documents”, “embedding” e “persist_directory”.

documents=data: Questo argomento passa una lista di documenti, a cui si fa riferimento tramite la variabile “data”, al metodo. Ci si aspetta che ogni documento in questa lista sia un’istanza della classe “Document”, contenente il contenuto del documento e, facoltativamente, i metadati ad esso associati.

embedding=GPT4AllEmbeddings(): Qui, viene creata un’istanza della classe “GPT4AllEmbeddings” e passata come argomento “embedding”. Ciò indica che il modello “GPT4AllEmbeddings” verrà utilizzato per convertire il testo di ciascun documento in una rappresentazione vettoriale. La classe “GPT4AllEmbeddings” è presumibilmente un’implementazione personalizzata o di terze parti che aderisce all’interfaccia “Embeddings” richiesta dal metodo “from_documents”. Questa interfaccia richiede all’implementazione di avere un metodo che prenda come input un pezzo di testo e restituisca la sua rappresentazione vettoriale.

persist_directory=”./chroma_db”: Questo argomento specifica la directory in cui deve essere persistito lo vectorstore Chroma creato. Fornendo l’argomento “persist_directory”, il metodo viene istruito a salvare lo vectorstore su disco, consentendone il riutilizzo in sessioni future senza la necessità di ricalcolare gli embedding. La directory ”./chroma_db” è relativa alla directory di lavoro corrente dello script.

Il metodo “from_documents”, come descritto nell’implementazione della funzione fornita, estrae prima il testo e i metadati da ciascun documento. Quindi delega la creazione effettiva dello vectorstore a un altro metodo, “from_texts”, passando i testi estratti, il modello di embedding e qualsiasi metadato aggiuntivo, ID documento e opzioni di configurazione. Il risultato è un oggetto vectorstore Chroma, che può essere utilizzato per varie applicazioni come ricerche di similarità, clustering o qualsiasi altra operazione supportata dall’API Chroma.

Questo approccio di separare le problematiche - estrarre dati da documenti e creare uno vectorstore - migliora la flessibilità e la riutilizzabilità del metodo. Consente l’utilizzo di diversi tipi di embedding e configurazioni di storage, a seconda delle specifiche esigenze dell’applicazione.

Configurazione del chatbot

Per configurare il chatbot dovremo costruire una catena di QA con il seguente codice:

from langchain_community.chat_models import ChatOllama
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import RetrievalQA
from langchain import hub

llm = ChatOllama(model="llama3")
prompt = hub.pull("rlm/rag-prompt")
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=GPT4AllEmbeddings())

qa_chain = RetrievalQA.from_chain_type(
        llm,
        retriever=vectorstore.as_retriever(),
        chain_type_kwargs={"prompt": prompt}
    )

question = "Explain what the manual is about."
result = qa_chain({"query": question ,})

print(result["result"] )

Spiegazione del codice

Importazioni (Imports):

from langchain_community.chat_models import ChatOllama
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import RetrievalQA
from langchain import hub

• langchain_community.chat_models.ChatOllama: Importa la classe ChatOllama per interagire con un modello di Large Language Model (LLM) come “llama3”.
• langchain_core.output_parsers.StrOutputParser: Importa la classe StrOutputParser per interpretare l’output dell’LLM come testo.
• langchain_core.prompts.ChatPromptTemplate: Importa la classe ChatPromptTemplate per definire i prompt da inviare all’LLM.
• langchain.chains.RetrievalQA: Importa la classe RetrievalQA per creare una catena di elaborazione per rispondere alle domande con recupero di informazioni.
• langchain.hub: Importa funzioni per accedere a risorse predefinite come prompt memorizzati.

Configurazione (Setup):

ecco come configurare il chatbot:

llm = ChatOllama(model='llama3')
prompt = hub.pull('rlm/rag-prompt')
vectorstore = Chroma(persist_directory='./chroma_db',   embedding_function=GPT4AllEmbeddings())

• llm = ChatOllama(model=“llama3”): Crea un’istanza di ChatOllama per interagire con il modello LLM “llama3”.
• prompt = hub.pull(“rlm/rag-prompt”): Recupera un prompt predefinito chiamato “rlm/rag-prompt” da un repository di prompt accessibile tramite hub. Questo prompt è probabilmente progettato per lavorare con modelli LLM per attività di recupero di informazioni (Reading Comprehension with Attention Gateways - RAG).
• vectorstore = Chroma(persist_directory=”./chroma_db”, embedding_function=GPT4AllEmbeddings()): Crea un’istanza di Chroma per memorizzare e recuperare rappresentazioni vettoriali di documenti.
  • persist_directory="./chroma_db" specifica la directory in cui memorizzare i dati del vectorstore su disco per un uso successivo.
  • embedding_function=GPT4AllEmbeddings() indica che verrà utilizzata la classe GPT4AllEmbeddings per creare rappresentazioni vettoriali del testo dei documenti.

Creazione della Catena di Elaborazione (Building the Processing Chain):

qa_chain = RetrievalQA.from_chain_type(
    llm,
    retriever=vectorstore.as_retriever(),
    chain_type_kwargs={"prompt": prompt}
)

• qa_chain = RetrievalQA.from_chain_type(…): Crea una catena di elaborazione di tipo RetrievalQA.
  • llm: L’istanza ChatOllama precedentemente creata, che verrà utilizzata per generare risposte.
  • retriever=vectorstore.as_retriever(): Specifica il vectorstore Chroma come componente di recupero della catena.
  • chain_type_kwargs={“prompt”: prompt}: Imposta il prompt rlm/rag-prompt recuperato in precedenza per essere utilizzato nella catena di recupero di informazioni.

Elaborazione della Domanda (Processing the Question):

question = "Explain what the manual is about."
result = qa_chain({"query": question})

• question = “Explain what the manual is about.”: Definisce la domanda da porre al sistema.
• result = qa_chain({“query”: question}): Elabora la domanda utilizzando la catena qa_chain. L’argomento del dizionario {"query": question} fornisce la domanda alla catena.

Visualizzazione del Risultato (Displaying the Result):

print(result["result"])

• print(result[“result”]): Stampa il risultato dell’elaborazione della domanda. Il risultato dovrebbe essere la spiegazione trovata nel manuale in base alla domanda e al recupero di informazioni effettuato utilizzando lo vectorstore.

Esecuzione

Per eseguire il codice, salvalo in un file Python (ad esempio chatbot.py) e eseguilo da un terminale o da un IDE Python. Assicurati di avere tutti i pacchetti necessari installati e i modelli LLM e i prompt disponibili per l’uso.

python chatbot.py

Il codice dovrebbe eseguire la catena di elaborazione per rispondere alla domanda specificata e visualizzare la spiegazione trovata nel manuale. Nel mio caso la risposta è stata:

This manual is about Linux and its users' guide, as hinted by Linus Torvalds providing "something to write this manual about"

Semplice ed efficace. Se invece dovessi chiedere “Tell me something about X Window System” la risposta sarebbe:

The X Window System is a distributed, graphical method of working developed at MIT and maintained by the X Consortium. It's a system with clients (programs like xterm) and servers that provide services to those programs. The window manager is a special client that manages window placement and movement.