Zero to Advanced Prompt Engineering with Langchain in Python’ Da zero a avanzato nell’ingegneria dei prompt con Langchain in Python.

From Zero to Advanced Prompt Engineering with Langchain in Python

Un aspetto importante dei Large Language Models (LLM) è il numero di parametri che questi modelli utilizzano per l’apprendimento. Più parametri ha un modello, migliore è la sua capacità di comprendere la relazione tra parole e frasi. Ciò significa che i modelli con miliardi di parametri hanno la capacità di generare vari formati di testo creativi e rispondere in modo informativo a domande aperte e complesse.

I LLM come ChatGPT, che utilizzano il modello Transformer, sono competenti nella comprensione e generazione del linguaggio umano, rendendoli utili per applicazioni che richiedono la comprensione del linguaggio naturale. Tuttavia, non sono privi di limitazioni, che includono la conoscenza obsoleta, l’incapacità di interagire con sistemi esterni, la mancanza di comprensione del contesto e talvolta la generazione di risposte che sembrano plausibili ma sono errate o prive di senso, tra le altre.

Per affrontare queste limitazioni è necessario integrare i LLM con fonti di dati esterne e capacità, che possono presentare complessità e richiedere competenze di programmazione e gestione dei dati estese. Ciò, unito alle sfide legate alla comprensione dei concetti di intelligenza artificiale e degli algoritmi complessi, contribuisce alla curva di apprendimento associata allo sviluppo di applicazioni utilizzando i LLM.

Tuttavia, l’integrazione dei LLM con altri strumenti per creare applicazioni basate su LLM potrebbe ridefinire il nostro panorama digitale. Il potenziale di tali applicazioni è vasto e include il miglioramento dell’efficienza e della produttività, la semplificazione delle attività, il potenziamento del processo decisionale e l’offerta di esperienze personalizzate.

In questo articolo approfondiremo questi argomenti, esplorando le tecniche avanzate di progettazione di prompt con Langchain, offrendo spiegazioni chiare, esempi pratici e istruzioni passo-passo su come implementarle.

Langchain, una libreria all’avanguardia, offre comodità e flessibilità nella progettazione, implementazione e ottimizzazione dei prompt. Mentre esaminiamo i principi e le pratiche della progettazione di prompt, imparerai come utilizzare le potenti funzionalità di Langchain per sfruttare i punti di forza dei modelli di intelligenza artificiale generativi SOTA come GPT-4.

Comprensione dei prompt

Prima di addentrarci nelle tecniche di progettazione di prompt, è essenziale comprendere il concetto di prompt e la sua importanza.

Un ‘prompt’ è una sequenza di token utilizzati come input per un modello di linguaggio, istruendolo a generare un tipo specifico di risposta. I prompt svolgono un ruolo cruciale nel guidare il comportamento di un modello. Possono influire sulla qualità del testo generato e, se realizzati correttamente, possono aiutare il modello a fornire risultati interessanti, accurati e specifici del contesto.

La progettazione dei prompt è l’arte e la scienza di creare prompt efficaci. L’obiettivo è ottenere l’output desiderato da un modello di linguaggio. Selezionando e strutturando attentamente i prompt, è possibile guidare il modello verso la generazione di risposte più accurate e pertinenti. Nella pratica, ciò comporta un’ottimizzazione delle frasi di input per adattarle all’addestramento del modello e ai suoi bias strutturali.

La complessità della progettazione dei prompt varia dalle tecniche semplici, come fornire al modello parole chiave rilevanti, a metodi più avanzati che coinvolgono la progettazione di prompt complessi e strutturati che sfruttano le meccaniche interne del modello a proprio vantaggio.

Langchain: Lo Strumento di Prompt in Più Rapida Crescita

LangChain, lanciato nell’ottobre 2022 da Harrison Chase, è diventato uno dei framework open-source più apprezzati su GitHub nel 2023. Offre un’interfaccia semplificata e standardizzata per incorporare Large Language Models (LLM) nelle applicazioni. Fornisce inoltre un’interfaccia ricca di funzionalità per la progettazione di prompt, consentendo agli sviluppatori di sperimentare diverse strategie ed valutare i risultati. Utilizzando Langchain, è possibile svolgere attività di progettazione di prompt in modo più efficace e intuitivo.

LangFlow funge da interfaccia utente per orchestrare i componenti di LangChain in un diagramma di flusso eseguibile, consentendo prototipazione rapida e sperimentazione.

LangChain colma una lacuna fondamentale nello sviluppo di intelligenza artificiale per le masse. Consente una serie di applicazioni di elaborazione del linguaggio naturale (NLP) come assistenti virtuali, generatori di contenuti, sistemi di domande e risposte e altro ancora, per risolvere una serie di problemi reali.

Al contrario di essere un modello o un provider autonomo, LangChain semplifica l’interazione con diversi modelli, estendendo le capacità delle applicazioni LLM oltre i limiti di una semplice chiamata API.

L’Architettura di LangChain

I principali componenti di LangChain includono Model I/O, Prompt Templates, Memory, Agents e Chains.

Modello I/O

LangChain facilita una connessione senza soluzione di continuità con vari modelli di linguaggio avvolgendoli con un’interfaccia standardizzata nota come Modello I/O. Ciò facilita un cambio di modello senza sforzo per ottimizzazione o miglioramento delle prestazioni. LangChain supporta vari fornitori di modelli di linguaggio, tra cui OpenAI, HuggingFace, Azure, Fireworks e altri.

Modelli di Prompt

Questi vengono utilizzati per gestire e ottimizzare le interazioni con LLM fornendo istruzioni o esempi concisi. L’ottimizzazione dei prompt migliora le prestazioni del modello e la loro flessibilità contribuisce significativamente al processo di input.

Un semplice esempio di un modello di prompt:

from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["soggetto"],
template="Quali sono gli sviluppi recenti nel campo del {soggetto}?")
print(prompt.format(soggetto="Elaborazione del Linguaggio Naturale"))

Man mano che avanziamo nella complessità, incontriamo modelli più sofisticati in LangChain, come il pattern Reason and Act (ReAct). ReAct è un pattern vitale per l’esecuzione di azioni in cui l’agente assegna un compito a uno strumento appropriato, personalizza l’input per esso e analizza il suo output per completare il compito. L’esempio in Python di seguito mostra un pattern ReAct. Mostra come un prompt è strutturato in LangChain, utilizzando una serie di pensieri e azioni per ragionare su un problema e produrre una risposta finale:

PREFIX = """Rispondi alla seguente domanda utilizzando gli strumenti forniti:"""
FORMAT_INSTRUCTIONS = """Segui questo formato:
Domanda: {input_question}
Pensiero: il tuo pensiero iniziale sulla domanda
Azione: l'azione scelta tra [{tool_names}]
Input dell'azione: il tuo input per l'azione
Osservazione: l'esito dell'azione"""
SUFFIX = """Inizia!
Domanda: {input}
Pensiero:{agent_scratchpad}"""

Memoria

La memoria è un concetto fondamentale in LangChain, che consente a LLM e strumenti di conservare informazioni nel tempo. Questo comportamento persistente migliora le prestazioni delle applicazioni LangChain memorizzando le risposte precedenti, le interazioni dell’utente, lo stato dell’ambiente e gli obiettivi dell’agente. Le strategie ConversationBufferMemory e ConversationBufferWindowMemory aiutano a tenere traccia delle parti complete o recenti di una conversazione, rispettivamente. Per un approccio più sofisticato, la strategia ConversationKGMemory consente di codificare la conversazione come un grafo di conoscenza che può essere reinserito nei prompt o utilizzato per prevedere le risposte senza chiamare il LLM.

Agenti

Un agente interagisce con il mondo eseguendo azioni e compiti. In LangChain, gli agenti combinano strumenti e catene per l’esecuzione dei compiti. Possono stabilire una connessione con il mondo esterno per il recupero delle informazioni per aumentare le conoscenze di LLM, superando così le loro limitazioni intrinseche. Possono decidere di passare i calcoli a una calcolatrice o un interprete Python a seconda della situazione.

Gli agenti sono dotati di sottocomponenti:

Strumenti: Questi sono componenti funzionali.
Kit di strumenti: Raccolte di strumenti.
Esecutori di agenti: Questo è il meccanismo di esecuzione che consente di scegliere tra gli strumenti.

Gli agenti in LangChain seguono anche il pattern Zero-shot ReAct, in cui la decisione si basa solo sulla descrizione dello strumento. Questo meccanismo può essere esteso con la memoria al fine di tenere conto dell’intera cronologia della conversazione. Con ReAct, invece di chiedere a un LLM di completare automaticamente il tuo testo, puoi chiedergli di rispondere in un ciclo di pensiero/azione/osservazione.

Catene

Le catene, come suggerisce il termine, sono sequenze di operazioni che consentono alla libreria LangChain di elaborare input e output dei modelli di linguaggio in modo fluido. Questi componenti fondamentali di LangChain sono fondamentalmente composti da collegamenti, che possono essere altre catene o primitive come prompt, modelli di linguaggio o utilità.

Immagina una catena come un nastro trasportatore in una fabbrica. Ogni passo su questo nastro rappresenta una determinata operazione, che potrebbe essere l’invocazione di un modello di linguaggio, l’applicazione di una funzione Python a un testo o persino l’interrogazione del modello in un modo particolare.

LangChain categorizza le sue catene in tre tipi: catene di utilità, catene generiche e catene di combinazione di documenti. Approfondiremo le catene di utilità e generiche per la nostra discussione.

Le catene di utilità sono specificamente progettate per estrarre risposte precise dai modelli di linguaggio per compiti definiti in modo stretto. Ad esempio, prendiamo in considerazione la catena LLMMathChain. Questa catena di utilità consente ai modelli di linguaggio di eseguire calcoli matematici. Accetta una domanda in linguaggio naturale e il modello di linguaggio genera un frammento di codice Python che viene quindi eseguito per produrre la risposta.
Le catene generiche, d’altra parte, fungono da blocchi di base per altre catene ma non possono essere utilizzate direttamente da sole. Queste catene, come ad esempio la catena LLMChain, sono fondamentali e vengono spesso combinate con altre catene per completare compiti complessi. Ad esempio, la catena LLMChain viene utilizzata frequentemente per interrogare un oggetto di modello di linguaggio formattando l’input in base a un modello di prompt fornito e quindi passandolo al modello di linguaggio.

Implementazione step-by-step di Prompt Engineering con Langchain

Ti guideremo attraverso il processo di implementazione del prompt engineering utilizzando Langchain. Prima di procedere, assicurati di aver installato il software e i pacchetti necessari.

Puoi sfruttare strumenti popolari come Docker, Conda, Pip e Poetry per configurare LangChain. I file di installazione pertinenti per ciascuno di questi metodi possono essere trovati all’interno del repository di LangChain su https://github.com/benman1/generative_ai_with_langchain. Questo include un Dockerfile per Docker, un requirements.txt per Pip, un pyproject.toml per Poetry e un file langchain_ai.yml per Conda.

Nel nostro articolo useremo Pip, il gestore di pacchetti standard per Python, per facilitare l’installazione e la gestione delle librerie di terze parti. Se non è incluso nella tua distribuzione di Python, puoi installare Pip seguendo le istruzioni su https://pip.pypa.io/.

Per installare una libreria con Pip, utilizza il comando pip install nome_libreria.

Tuttavia, Pip non gestisce gli ambienti da solo. Per gestire diversi ambienti, utilizziamo lo strumento virtualenv.

Nella prossima sezione, parleremo delle integrazioni del modello.

Step 1: Configurazione di Langchain

Prima di tutto, devi installare il pacchetto di Langchain. Stiamo usando il sistema operativo Windows. Esegui il seguente comando nel tuo terminale per installarlo:

pip install langchain

Step 2: Importazione di Langchain e altri moduli necessari

Successivamente, importa Langchain insieme ad altri moduli necessari. Qui, importiamo anche la libreria transformers, che viene ampiamente utilizzata nelle attività di NLP.

import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Step 3: Caricamento del Modello Preallenato

Open AI

I modelli OpenAI possono essere comodamente interfacciati con la libreria LangChain o la libreria client Python di OpenAI. In particolare, OpenAI fornisce una classe Embedding per i modelli di embedding di testo. Due modelli LLM chiave sono GPT-3.5 e GPT-4, che differiscono principalmente per la lunghezza dei token. I prezzi per ciascun modello possono essere trovati sul sito web di OpenAI. Sebbene ci siano modelli più sofisticati come GPT-4-32K che hanno una maggiore accettazione dei token, la loro disponibilità tramite API non è sempre garantita.

Per accedere a questi modelli è necessaria una chiave API di OpenAI. Puoi ottenerla creando un account sulla piattaforma di OpenAI, configurando le informazioni di fatturazione e generando una nuova chiave segreta.

import os
os.environ["OPENAI_API_KEY"] = 'la-tua-chiave-openai'

Dopo aver creato correttamente la chiave, puoi impostarla come variabile d’ambiente (OPENAI_API_KEY) o passarla come parametro durante l’istanziazione della classe per le chiamate a OpenAI.

Considera uno script di LangChain per mostrare l’interazione con i modelli OpenAI:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# LLM prende un prompt in input e restituisce un completamento
prompt = "chi è il presidente degli Stati Uniti d'America?"
completion = llm(prompt)

L'attuale Presidente degli Stati Uniti d'America è Joe Biden.

In questo esempio, un agente viene inizializzato per eseguire dei calcoli. L’agente prende in input un semplice compito di addizione, lo elabora utilizzando il modello OpenAI fornito e restituisce il risultato.

Hugging Face

Hugging Face è una libreria Python GRATUITA per Transformers, compatibile con PyTorch, TensorFlow e JAX, e include implementazioni di modelli come BERT, T5, ecc.

Hugging Face offre anche l’Hugging Face Hub, una piattaforma per ospitare repository di codice, modelli di apprendimento automatico, set di dati e applicazioni web.

Per utilizzare Hugging Face come fornitore per i tuoi modelli, avrai bisogno di un account e di chiavi API, che possono essere ottenute dal loro sito web. Il token può essere reso disponibile nel tuo ambiente come HUGGINGFACEHUB_API_TOKEN.

Considera il seguente frammento di codice Python che utilizza un modello open-source sviluppato da Google, il modello Flan-T5-XXL:

  from langchain.llms import HuggingFaceHub
llm = HuggingFaceHub(model_kwargs={"temperature": 0.5, "max_length": 64}, repo_id="google/flan-t5-xxl")
prompt = "In quale paese si trova Tokyo?"
completion = llm(prompt)
print(completion)

Questo script prende una domanda in input e restituisce una risposta, mostrando le capacità di conoscenza e previsione del modello.

Passaggio 4: Semplice ingegnerizzazione della richiesta

Per iniziare, genereremo una semplice richiesta e vedremo come il modello risponde.

  prompt = 'Traduci il seguente testo inglese in francese: "{0}"'
input_text = 'Ciao, come stai?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')
generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

Nel frammento di codice sopra, forniamo una richiesta per tradurre il testo inglese in francese. Il modello di linguaggio cerca quindi di tradurre il testo dato in base alla richiesta.

Passaggio 5: Ingegnerizzazione avanzata della richiesta

Sebbene l’approccio sopra funzioni bene, non sfrutta appieno il potere dell’ingegnerizzazione della richiesta. Miglioreremo introducendo strutture di richiesta più complesse.

  prompt = 'Come traduttore francese altamente competente, traduci il seguente testo inglese in francese: "{0}"'
input_text = 'Ciao, come stai?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')
generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

In questo frammento di codice, modifichiamo la richiesta per suggerire che la traduzione sia effettuata da un “traduttore francese altamente competente”. Il cambiamento nella richiesta può portare a traduzioni migliorate, poiché il modello ora assume una personalità di esperto.

Costruzione di un sistema di domande e risposte sulla letteratura accademica con LangChain

Costruiremo un sistema di domande e risposte sulla letteratura accademica utilizzando LangChain che può rispondere alle domande su articoli accademici recentemente pubblicati.

In primo luogo, per configurare il nostro ambiente, installiamo le dipendenze necessarie.

  pip install langchain arxiv openai transformers faiss-cpu

Dopo l’installazione, creiamo un nuovo notebook Python e importiamo le librerie necessarie:

  from langchain.llms import OpenAI
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.docstore.document import Document
import arxiv

Il nucleo del nostro sistema di domande e risposte è la capacità di recuperare articoli accademici pertinenti relativi a un certo campo, qui consideriamo l’Elaborazione del Linguaggio Naturale (NLP), utilizzando il database accademico arXiv. Per fare ciò, definiamo una funzione get_arxiv_data(max_results=10) . Questa funzione raccoglie i riassunti degli articoli NLP più recenti da arXiv e li incapsula in oggetti Document di LangChain, utilizzando il riassunto come contenuto e l’id unico dell’articolo come origine.

Utilizzeremo l’API di arXiv per recuperare gli articoli recenti relativi a NLP:

  def get_arxiv_data(max_results=10):
    search = arxiv.Search(
        query="NLP",
        max_results=max_results,
        sort_by=arxiv.SortCriterion.SubmittedDate,
    )

    documents = []

    for result in search.results():
        documents.append(Document(
            page_content=result.summary,
            metadata={"source": result.entry_id},
        ))
    return documents

Questa funzione recupera i riassunti degli articoli NLP più recenti da arXiv e li converte in oggetti Document di LangChain. Utilizziamo il riassunto dell’articolo e il suo id unico (URL dell’articolo) come contenuto e origine, rispettivamente.

  def print_answer(question):
    print(
        chain(
            {
                "input_documents": sources,
                "question": question,
            },
            return_only_outputs=True,
        )["output_text"]
    )

Definiamo il nostro corpus e configuriamo LangChain:

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(temperature=0))

Ora che il nostro sistema di domande e risposte accademiche è pronto, possiamo testarlo facendo una domanda:

print_answer("Quali sono gli ultimi sviluppi in NLP?")

La risposta sarà la risposta alla tua domanda, citando le fonti da cui è stata estratta l’informazione. Ad esempio:

Gli ultimi sviluppi in NLP includono modelli di istruzione con recupero migliorato e un nuovo framework computazionale per risolvere i problemi di flusso di potenza ottimale a corrente alternata (ACOPF) utilizzando le unità di elaborazione grafica (GPU).
FONTI: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Puoi facilmente cambiare modelli o modificare il sistema secondo le tue esigenze. Ad esempio, qui stiamo passando a GPT-4 che ci dà una risposta molto migliore e dettagliata.

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(model_name="gpt-4",temperature=0))

Gli ultimi sviluppi nel Natural Language Processing (NLP) includono lo sviluppo di modelli di istruzione con recupero migliorato per compiti di ricerca di informazioni come il question answering (QA). Questi modelli possono essere adattati a vari domini e compiti informativi senza ulteriori sintonizzazioni. Tuttavia, spesso faticano a rimanere fedeli alla conoscenza fornita e possono creare risposte in modo fantasioso. Un altro sviluppo è l'introduzione di un framework computazionale per risolvere i problemi di flusso di potenza ottimale a corrente alternata (ACOPF) utilizzando le unità di elaborazione grafica (GPU). Questo approccio utilizza una singola istruzione, multiplo dato (SIMD) astrazione di programmi non lineari (NLP) e utilizza un metodo di punto interno (IPM) a spazio condensato con una strategia di rilassamento delle disuguaglianze. Questa strategia consente la fattorizzazione della matrice KKT senza pivoting numerico, che in passato ha ostacolato la parallelizzazione dell'algoritmo IPM.
FONTI: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Un token in GPT-4 può essere lungo quanto un singolo carattere o quanto una singola parola. Ad esempio, GPT-4-32K può elaborare fino a 32.000 token in una singola esecuzione, mentre GPT-4-8K e GPT-3.5-turbo supportano rispettivamente 8.000 e 4.000 token. Tuttavia, è importante notare che ogni interazione con questi modelli comporta un costo direttamente proporzionale al numero di token elaborati, che siano input o output.

Nel contesto del nostro sistema di domande e risposte, se un pezzo di letteratura accademica supera il limite massimo di token, il sistema non riuscirà a elaborarlo completamente, influenzando quindi la qualità e la completezza delle risposte. Per risolvere questo problema, il testo può essere suddiviso in parti più piccole che rispettino il limite di token.

FAISS (Facebook AI Similarity Search) aiuta a trovare rapidamente i frammenti di testo più rilevanti relativi alla query dell’utente. Crea una rappresentazione vettoriale di ogni frammento di testo e utilizza questi vettori per identificare e recuperare i frammenti più simili alla rappresentazione vettoriale di una determinata domanda.

È importante ricordare che anche con l’uso di strumenti come FAISS, la necessità di dividere il testo in frammenti più piccoli a causa dei limiti dei token può talvolta comportare la perdita di contesto, influenzando la qualità delle risposte. Pertanto, una gestione attenta e un’ottimizzazione dell’uso dei token sono cruciali quando si lavora con questi grandi modelli di linguaggio.

pip install faiss-cpu langchain CharacterTextSplitter

Dopo aver assicurato che le librerie sopra indicate siano installate, esegui

from langchain.embeddings.openai import OpenAIEmbeddings 
from langchain.vectorstores.faiss import FAISS 
from langchain.text_splitter import CharacterTextSplitter 
documents = get_arxiv_data(max_results=10) # Ora possiamo alimentare più dati
document_chunks = []
splitter = CharacterTextSplitter(separator=" ", chunk_size=1024, chunk_overlap=0)
for document in documents:
    for chunk in splitter.split_text(document.page_content):
        document_chunks.append(Document(page_content=chunk, metadata=document.metadata))
search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())
chain = load_qa_with_sources_chain(OpenAI(temperature=0))
def print_answer(question):
    print(
        chain(
            {
                "input_documents": search_index.similarity_search(question, k=4),
                "question": question,
            },
            return_only_outputs=True,
        )["output_text"]
    )

Con il codice completo, ora abbiamo uno strumento potente per interrogare la più recente letteratura accademica nel campo dell’elaborazione del linguaggio naturale (NLP).

Gli avanzamenti recenti nell'NLP includono l'uso di reti neurali profonde (DNN) per l'analisi automatica del testo e le attività di elaborazione del linguaggio naturale (NLP) come il controllo ortografico, il rilevamento della lingua, l'estrazione di entità, il rilevamento dell'autore, la risposta alle domande e altre attività.
FONTI: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1

Conclusioni

L’integrazione dei Modelli di Linguaggio Estesi (LLM) nelle applicazioni ha accelerato l’adozione in diversi settori, tra cui la traduzione linguistica, l’analisi del sentiment e il recupero delle informazioni. L’ingegneria delle prompt è uno strumento potente per massimizzare il potenziale di questi modelli e Langchain sta aprendo la strada semplificando questo compito complesso. La sua interfaccia standardizzata, i modelli di prompt flessibili, l’integrazione robusta dei modelli e l’uso innovativo di agenti e catene garantiscono risultati ottimali per le prestazioni dei LLM.

Tuttavia, nonostante questi progressi, ci sono alcuni consigli da tenere a mente. Quando si utilizza Langchain, è essenziale capire che la qualità dell’output dipende fortemente dalla formulazione del prompt. Sperimentare con diversi stili e strutture di prompt può portare a risultati migliori. Inoltre, ricordate che mentre Langchain supporta una varietà di modelli linguistici, ognuno ha i suoi punti di forza e di debolezza. Scegliere quello giusto per il vostro compito specifico è cruciale. Infine, è importante ricordare che l’utilizzo di questi modelli comporta considerazioni di costo, poiché l’elaborazione dei token influenza direttamente il costo delle interazioni.

Come dimostrato nella guida passo-passo, Langchain può alimentare applicazioni robuste, come il sistema di domande e risposte sulla letteratura accademica. Con una comunità di utenti in crescita e una crescente importanza nel panorama open-source, Langchain promette di essere uno strumento fondamentale per sfruttare appieno il potenziale dei LLM come GPT-4.

langchain,NLP,Prompt Engineering,python