Come costruire un chatbot LangChain con memoria? | Intelligenza-Artificiale

introduzione

I chatbot sono diventati parte integrante delle applicazioni moderne, fornendo agli utenti esperienze interattive e coinvolgenti. In questa guida creeremo un chatbot utilizzando LangChainun potente framework che semplifica il processo di lavoro grandi modelli linguistici. Il nostro chatbot avrà le seguenti caratteristiche principali:

• Memoria di conversazione per mantenere il contesto
• Prompt di sistema personalizzabili
• Possibilità di visualizzare e cancellare la cronologia chat
• Misurazione del tempo di risposta

Alla fine di questo articolo avrai un chatbot completamente funzionale che potrai personalizzare e integrare ulteriormente nei tuoi progetti. Che tu sia nuovo in LangChain o desideri espandere le tue capacità di sviluppo di applicazioni AI, questa guida ti fornirà una solida base per creare chatbot intelligenti e sensibili al contesto.

Panoramica

• Comprendere i concetti e le caratteristiche fondamentali di LangChain, inclusi concatenamento, memoria, prompt, agenti e integrazione.
• Installa e configura Python 3.7+ e le librerie necessarie per creare ed eseguire un chatbot basato su LangChain.
• Modifica le istruzioni del sistema, le impostazioni della memoria e i parametri della temperatura per personalizzare il comportamento e le capacità del chatbot.
• Integra la gestione degli errori, la registrazione, la convalida dell'input dell'utente e la gestione dello stato della conversazione per applicazioni chatbot robuste e scalabili.

Prerequisiti

Prima di immergerti in questo articolo, dovresti avere:

• Conoscenza di Python: Comprensione intermedia di Programmazione Python.
• Nozioni di base sull'API: Familiarità con i concetti e l'utilizzo delle API.
• Configurazione dell'ambiente: Capacità di configurare un ambiente Python e installare pacchetti.
• Conto OpenAI: Un account con OpenAI per ottenere una chiave API.

Requisiti tecnici

Per seguire questo tutorial, avrai bisogno di:

• Python 3.7+: Il nostro codice è compatibile con Python 3.7 o versioni successive.
• pip: Il programma di installazione del pacchetto Python, per installare le librerie richieste.
• Chiave API OpenAI: Dovrai registrarti per un account OpenAI e ottenere una chiave API.
• Editor di testo o IDE: Qualsiasi editor di testo o ambiente di sviluppo integrato di tua scelta.

Cos'è LangChain?

LangChain è un framework opensource progettato per semplificare lo sviluppo di applicazioni utilizzando modelli linguistici di grandi dimensioni (LLM). Fornisce una serie di strumenti e astrazioni che semplificano la creazione di applicazioni complesse e sensibili al contesto basate sull'intelligenza artificiale. Alcune caratteristiche chiave di LangChain includono:

• Concatenamento: Combina facilmente più componenti per creare flussi di lavoro complessi.
• Memoria: Implementa vari tipi di memoria per mantenere il contesto nelle conversazioni.
• Richiede: Gestisci e ottimizza le richieste per diversi casi d'uso.
• Agenti: Crea agenti IA in grado di utilizzare strumenti e prendere decisioni.
• Integrazione: Connettiti con origini dati e API esterne.

Ora che abbiamo spiegato cos'è LangChain, come lo utilizzeremo e i prerequisiti per questo tutorial, passiamo alla configurazione del nostro ambiente di sviluppo.

Impostazione dell'ambiente

Prima di immergerci nel codice, impostiamo il nostro ambiente di sviluppo. Dovremo installare diverse dipendenze per far funzionare il nostro chatbot.

Innanzitutto, assicurati di avere Python 3.7 o successivo installato sul tuo sistema. Quindi, crea una nuova directory per il tuo progetto e configura un ambiente virtuale:

Terminale:

mkdir langchainchatbot
cd langchainchatbot
python m venv venv
source venv/bin/activate

Ora installa le dipendenze richieste:

pip install langchain openai pythondotenv colorama

Successivamente, crea un file .env nella directory del tuo progetto per archiviare la chiave API OpenAI:

OPENAI_API_KEY=your_api_key_here

Sostituisci your_api_key_here con la tua chiave API OpenAI effettiva.

Comprendere la struttura del codice

La nostra implementazione del chatbot è composta da diversi componenti chiave:

• Importa istruzioni per le librerie e i moduli richiesti
• Funzioni di utilità per la formattazione dei messaggi e il recupero della cronologia della chat
• La funzione principale run_chatgpt_chatbot che configura ed esegue il chatbot
• Un blocco condizionale per eseguire il chatbot quando lo script viene eseguito direttamente

Analizziamo nel dettaglio ciascuno di questi componenti.

Implementazione del Chatbot

Esaminiamo ora i passaggi per implementare chatbot.

Passaggio 1: importazione delle dipendenze

Per prima cosa importiamo i moduli e le librerie necessarie:

import time
from typing import List, Tuple
import sys
from colorama import Fore, Style, init
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferWindowMemory
from langchain.schema import SystemMessage, HumanMessage, AIMessage
from langchain.schema.runnable import RunnablePassthrough, RunnableLambda
from operator import itemgetter

Queste importazioni ci forniscono gli strumenti di cui abbiamo bisogno per creare il nostro chatbot:

• tempo: Per misurare il tempo di risposta
• digitando: Per suggerimenti sul tipo
• sistema: Per operazioni relative al sistema
• colorama: Per aggiungere colore all'output della nostra console
• catena di lunghezza: Vari moduli per costruire il nostro chatbot
• operatore: Per la funzione itemgetter

Passaggio 2: definire le funzioni di utilità

Successivamente, definiamo alcune funzioni di utilità che ci aiuteranno a gestire il nostro chatbot:

def format_message(role: str, content: str) > str:
    return f"{role.capitalize()}: {content}"

def get_chat_history(memory) > List(Tuple(str, str)):
    return ((msg.type, msg.content) for msg in memory.chat_memory.messages)

def print_typing_effect(text: str, delay: float = 0.03):
    for char in text:
        sys.stdout.write(char)
        sys.stdout.flush()
        time.sleep(delay)
    print()

• format_message: formatta un messaggio con il ruolo (ad esempio, “Utente” o “AI”) e il contenuto
• get_chat_history: recupera la cronologia della chat dall'oggetto memoria
• print_typing_effect: crea un effetto di digitazione durante la stampa del testo sulla console

Passaggio 3: definizione della funzione principale di Chatbot

Il cuore del nostro chatbot è la funzione run_chatgpt_chatbot. Dividiamolo in sezioni più piccole:

def run_chatgpt_chatbot(system_prompt="", history_window=30, temperature=0.3):
     #Initialize the ChatOpenAI model
    model = ChatOpenAI(model_name="gpt3.5turbo", temperature=temperature)
     Set the system prompt
    if system_prompt:
        SYS_PROMPT = system_prompt
    else:
        SYS_PROMPT = "Act as a helpful AI Assistant"
     Create the chat prompt template
    prompt = ChatPromptTemplate.from_messages(
        (
            ('system', SYS_PROMPT),
            MessagesPlaceholder(variable_name="history"),
            ('human', '{input}')
        )
    )

Questa funzione esegue le seguenti operazioni:

• Inizializza il modello ChatOpenAI con la temperatura specificata.
• Imposta il prompt di sistema e il modello di prompt della chat.
• Crea una memoria di conversazione con la finestra della cronologia specificata.
• Imposta la catena di conversazione utilizzando RunnablePassthrough e RunnableLambda di LangChain.
• Inserisce un ciclo per gestire l'input dell'utente e generare risposte.
• Elabora comandi speciali come “STOP”, “HISTORY” e “CLEAR”.
• Misura il tempo di risposta e lo visualizza all'utente.
• Salva il contesto della conversazione in memoria.

Passaggio 5: esecuzione del chatbot

Infine, aggiungiamo un blocco condizionale per eseguire il chatbot quando lo script viene eseguito direttamente:

if __name__ == "__main__":
    run_chatgpt_chatbot()

Questo ci consente di eseguire il chatbot semplicemente eseguendo lo script Python.

Funzionalità avanzate

La nostra implementazione di chatbot include diverse funzionalità avanzate che ne migliorano la funzionalità e l'esperienza utente.

Cronologia chat

Gli utenti possono visualizzare la cronologia della chat digitando “HISTORY”. Questa funzionalità sfrutta ConversationBufferWindowMemory per archiviare e recuperare i messaggi precedenti:

elif user_input.strip().upper() == 'HISTORY':
    chat_history = get_chat_history(memory)
    print("\n Chat History ")
    for role, content in chat_history:
        print(format_message(role, content))
    print(" End of History \n")
    continue

Cancellazione della memoria della conversazione

Gli utenti possono cancellare la memoria della conversazione digitando “CLEAR”. Ciò reimposta il contesto e consente un nuovo inizio:

elif user_input.strip().upper() == 'CLEAR':
    memory.clear()
    print_typing_effect('ChatGPT: Chat history has been cleared.')
    continue

Misurazione del tempo di risposta

Il chatbot misura e visualizza il tempo di risposta per ogni interazione, dando agli utenti un'idea di quanto tempo impiega per generare una risposta:

start_time = time.time()
reply = conversation_chain.invoke(user_inp)
end_time = time.time()
response_time = end_time  start_time
print(f"(Response generated in {response_time:.2f} seconds)")

Opzioni di personalizzazione

La nostra implementazione del chatbot offre diverse opzioni di personalizzazione:

• Prompt di sistema: puoi fornire un prompt di sistema personalizzato per impostare il comportamento e la personalità del chatbot.
• Finestra cronologia: regola il parametro History_window per controllare quanti messaggi passati ricorda il chatbot.
• Temperatura: modifica il parametro della temperatura per controllare la casualità delle risposte del chatbot.

Per personalizzare queste opzioni, è possibile modificare la chiamata della funzione nel blocco if __name__ == “__main__”:

if __name__ == "__main__":
    run_chatgpt_chatbot(
        system_prompt="You are a friendly and knowledgeable AI assistant specializing in technology.",
        history_window=50,
        temperature=0.7
    )
import time
from typing import List, Tuple
import sys
import time
from colorama import Fore, Style, init
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferWindowMemory
from langchain.schema import SystemMessage, HumanMessage, AIMessage
from langchain.schema.runnable import RunnablePassthrough, RunnableLambda
from operator import itemgetter
def format_message(role: str, content: str) -> str:
    return f"{role.capitalize()}: {content}"
def get_chat_history(memory) -> List(Tuple(str, str)):
    return ((msg.type, msg.content) for msg in memory.chat_memory.messages)
def run_chatgpt_chatbot(system_prompt="", history_window=30, temperature=0.3):
    model = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=temperature)
    if system_prompt:
        SYS_PROMPT = system_prompt
    else:
        SYS_PROMPT = "Act as a helpful AI Assistant"
    prompt = ChatPromptTemplate.from_messages(
        (
            ('system', SYS_PROMPT),
            MessagesPlaceholder(variable_name="history"),
            ('human', '{input}')
        )
    )
    memory = ConversationBufferWindowMemory(k=history_window, return_messages=True)
    conversation_chain = (
        RunnablePassthrough.assign(
            history=RunnableLambda(memory.load_memory_variables) | itemgetter('history')
        )

        | prompt

        | model
    )    
    print_typing_effect("Hello, I am your friendly chatbot. Let's chat!")
    print("Type 'STOP' to end the conversation, 'HISTORY' to view chat history, or 'CLEAR' to clear the chat history.")
    while True:
        user_input = input('User: ')
        if user_input.strip().upper() == 'STOP':
           print_typing_effect('ChatGPT: Goodbye! It was a pleasure chatting with you.')
            break
        elif user_input.strip().upper() == 'HISTORY':
            chat_history = get_chat_history(memory)
            print("\n--- Chat History ---")
            for role, content in chat_history:
                print(format_message(role, content))
            print("--- End of History ---\n")
            continue
        elif user_input.strip().upper() == 'CLEAR':
            memory.clear()
            print_typing_effect('ChatGPT: Chat history has been cleared.')
            continue
        user_inp = {'input': user_input}
        start_time = time.time()
        reply = conversation_chain.invoke(user_inp)
        end_time = time.time()
        response_time = end_time - start_time
        print(f"(Response generated in {response_time:.2f} seconds)")
        print_typing_effect(f'ChatGPT: {reply.content}')
        memory.save_context(user_inp, {'output': reply.content})

if __name__ == "__main__":
    run_chatgpt_chatbot()

Produzione:

Migliori pratiche e suggerimenti

Quando lavori con questa implementazione di chatbot, prendi in considerazione le seguenti best practice e suggerimenti:

• Sicurezza della chiave API: Conserva sempre la chiave API OpenAI in una variabile di ambiente o in un file di configurazione sicuro. Non codificarlo mai nel tuo script.
• Gestione degli errori: Aggiungi blocchi tryException per gestire potenziali errori, come problemi di rete o limiti di velocità API.
• Registrazione: Implementa la registrazione per tenere traccia delle conversazioni e degli errori per il debug e l'analisi.
• Convalida dell'input dell'utente: Aggiungi una convalida dell'input più solida per gestire i casi limite e prevenire potenziali problemi.
• Stato della conversazione: Prendi in considerazione l'implementazione di un modo per salvare e caricare gli stati delle conversazioni, consentendo agli utenti di riprendere le chat in un secondo momento.
• Limitazione della velocità: Implementa la limitazione della velocità per evitare un numero eccessivo di chiamate API e gestire i costi.
• Conversazioni multigiro: Sperimenta diversi tipi di memoria in LangChain per gestire conversazioni più complesse e multigiro.
• Selezione del modello: Prova diversi modelli OpenAI (ad esempio GPT4) per vedere come influenzano le prestazioni e le capacità del chatbot.

Conclusione

In questa guida completa, abbiamo creato un potente chatbot utilizzando LangChain e GPT3.5turbo di OpenAI. Questo chatbot funge da solida base per applicazioni più complesse. Puoi estendere le sue funzionalità aggiungendo funzionalità come:

• Integrazione con API esterne per dati in tempo reale
• Elaborazione del linguaggio naturale per il riconoscimento delle intenzioni
• Interazioni multimodali (ad esempio, gestione di immagini o audio)
• Autenticazione e personalizzazione dell'utente

Sfruttando la potenza di LangChain e di modelli linguistici di grandi dimensioni, puoi creare sofisticate applicazioni di intelligenza artificiale conversazionale che forniscono valore agli utenti in vari domini. Ricorda di considerare sempre le implicazioni etiche quando distribuisci chatbot basati sull'intelligenza artificiale e assicurati che la tua implementazione aderisca alle linee guida sull'utilizzo di OpenAI e alle normative locali relative all'intelligenza artificiale e alla privacy dei dati.

Con queste basi, sei ben attrezzato per esplorare l'entusiasmante mondo dell'intelligenza artificiale conversazionale e creare applicazioni innovative che spingono i confini dell'interazione uomo-computer.

Domande frequenti