De la zero la ingineria avansată a prompturilor cu Langchain în Python

Un aspect important al modelelor de limbaj mare (LLM) este numărul de parametri pe care aceste modele îi utilizează pentru învățare. Cu cât un model are mai mulți parametri, cu atât poate înțelege mai bine relația dintre cuvinte și fraze. Acest lucru înseamnă că modelele cu miliarde de parametri au capacitatea de a genera diverse formate de text creative și de a răspunde la întrebări deschise și provocatoare într-un mod informativ.

Modelele LLM, cum ar fi ChatGPT, care utilizează modelul Transformer, sunt competente în înțelegerea și generarea limbajului uman, făcându-le utile pentru aplicații care necesită înțelegere a limbajului natural. Cu toate acestea, ele nu sunt lipsite de limitări, care includ cunoștințe învechite, incapacitatea de a interacționa cu sisteme externe, lipsa înțelegerii contextului și, uneori, generarea de răspunsuri plauzibile dar incorecte sau fără sens, printre altele.

Abordarea acestor limitări necesită integrarea LLM cu surse de date externe și capacități, ceea ce poate prezenta complexități și poate solicita abilități extinse de codare și manipulare a datelor. Acest lucru, combinat cu provocările înțelegerii conceptelor de inteligență artificială și algoritmilor complexi, contribuie la curba de învățare asociată cu dezvoltarea de aplicații care utilizează LLM.

În ciuda acestor provocări, integrarea LLM cu alte instrumente pentru a forma aplicații LLM puternice ar putea redesena peisajul nostru digital. Potențialul unor astfel de aplicații este vast, incluzând îmbunătățirea eficienței și productivității, simplificarea sarcinilor, îmbunătățirea procesului de luare a deciziilor și oferirea de experiențe personalizate.

În acest articol, vom explora mai în profunzime aceste probleme, examinând tehnicile avansate de inginerie a prompturilor cu Langchain, oferind explicații clare, exemple practice și instrucțiuni pas cu pas despre cum să le implementăm.

Langchain, o bibliotecă de ultimă generație, aduce confort și flexibilitate în proiectarea, implementarea și ajustarea prompturilor. Pe măsură ce vom dezvălui principiile și practicile ingineriei prompturilor, veți învăța cum să utilizați funcțiile puternice ale Langchain pentru a valorifica punctele forte ale modelelor generative de inteligență artificială de ultimă generație, cum ar fi GPT-4.

Înțelegerea prompturilor

Înainte de a intra în detaliile tehnice ale ingineriei prompturilor, este esențial să înțelegem conceptul de prompturi și importanța lor.

Un ‘prompt‘ este o secvență de tokeni care sunt utilizați ca intrare pentru un model de limbaj, instruindu-l să genereze un anumit tip de răspuns. Prompturile joacă un rol crucial în direcționarea comportamentului unui model. Ele pot afecta calitatea textului generat, și atunci când sunt create corect, pot ajuta modelul să ofere rezultate informative, precise și specifice contextului.

Ingineria prompturilor este arta și știința proiectării de prompturi eficiente. Scopul este de a obține ieșirea dorită dintr-un model de limbaj. Prin selectarea și structurarea atentă a prompturilor, se poate ghida modelul spre generarea de răspunsuri mai precise și relevante. În practică, acest lucru implică ajustarea frazelor de intrare pentru a se potrivi cu prejudecățile de antrenament și structurale ale modelului.

Sophisticația ingineriei prompturilor variază de la tehnici simple, cum ar fi alimentarea modelului cu cuvinte cheie relevante, la metode mai avansate care implică proiectarea de prompturi complexe și structurate care utilizează mecanismele interne ale modelului în avantajul său.

Langchain: Cel mai rapid instrument de prompt în creștere

LangChain, lansat în octombrie 2022 de Harrison Chase, a devenit una dintre cele mai apreciate cadre deschise pe GitHub în 2023. Oferește o interfață simplificată și standardizată pentru integrarea modelelor de limbaj mare (LLM) în aplicații. De asemenea, oferă o interfață bogată în funcții pentru ingineria prompturilor, permițând dezvoltatorilor să experimenteze cu diferite strategii și să evalueze rezultatele. Prin utilizarea Langchain, puteți efectua sarcini de inginerie a prompturilor mai eficient și mai intuitiv.

LangFlow servește ca interfață de utilizator pentru orchestrarea componentelor LangChain într-un flux de execuție, permițând prototiparea și experimentarea rapidă.

LangChain umple o lacună crucială în dezvoltarea de aplicații de inteligență artificială pentru mase. Permite o varietate de aplicații de procesare a limbajului natural, cum ar fi asistenți virtuali, generatori de conținut, sisteme de întrebări și răspunsuri și multe altele, pentru a rezolva o gamă largă de probleme din lumea reală.

În loc să fie un model sau furnizor independent, LangChain simplifică interacțiunea cu diverse modele, extinzând capacitățile aplicațiilor LLM dincolo de limitările unui simplu apel API.

Arhitectura LangChain

Componentele principale ale LangChain includ Model I/O, Șabloane de prompt, Memorie, Agenta și Lanțuri.

Model I/O

LangChain facilitează o conexiune fără efort cu diverse modele de limbaj prin înfășurarea lor cu o interfață standardizată cunoscută sub numele de Model I/O. Acest lucru facilitează o comutare ușoară a modelului pentru optimizare sau performanță mai bună. LangChain suportă diverse furnizori de modele de limbaj, incluzând OpenAI, HuggingFace, Azure, Fireworks și multe altele.

Șabloane de prompt

Acestea sunt utilizate pentru a gestiona și optimiza interacțiunile cu LLM prin furnizarea de instrucțiuni concise sau exemple. Optimizarea prompturilor îmbunătățește performanța modelului, iar flexibilitatea lor contribuie semnificativ la procesul de intrare.

Un exemplu simplu de șablon de prompt:

<p>from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["subiect"],
template="Care sunt progresele recente în domeniul {subiect}?")
print(prompt.format(subiect="Procesarea limbajului natural"))</p>

Pe măsură ce progresăm în complexitate, întâlnim modele mai sofisticate în LangChain, cum ar fi modelul Reason și Act (ReAct). ReAct este un model vital pentru executarea acțiunilor unde agentul atribuie o sarcină uneltei potrivite, personalizează intrarea pentru aceasta și analizează ieșirea pentru a îndeplini sarcina. Exemplul de mai jos în Python demonstrează cum un prompt este structurat în LangChain, utilizând o serie de gânduri și acțiuni pentru a raționa o problemă și a produce un răspuns final:

PREFIX = """"""
FORMAT_INSTRUCTIONS = """"""
SUFFIX = """"""

Memorie

Memoria este un concept critic în LangChain, permițând LLM și uneltelor să rețină informații în timp. Acest comportament cu stare îmbunătățește performanța aplicațiilor LangChain prin stocarea răspunsurilor anterioare, interacțiunilor utilizatorului, stării mediului și obiectivelor agentului. Strategiile ConversationBufferMemory și ConversationBufferWindowMemory ajută la urmărirea conversației în întregime sau a părților recente. Pentru o abordare mai sofisticată, strategia ConversationKGMemory permite codificarea conversației ca graf de cunoștințe care poate fi reintrodus în prompturi sau utilizat pentru a prezice răspunsuri fără a apela modelul LLM.

Agenta

Un agent interacționează cu lumea prin executarea de acțiuni și sarcini. În LangChain, agenții combină unelte și lanțuri pentru executarea sarcinilor. Acesta poate stabili o conexiune cu lumea exterioară pentru recuperarea informațiilor pentru a completa cunoștințele LLM, depășind astfel limitările lor intrinseci. Agenții pot decide să transmită calcule unui calculator sau interpretor Python, în funcție de situație.

Agenții sunt echipați cu subcomponente:

• Unelte: Acestea sunt componente funcționale.
• Seturi de unelte: Colecții de unelte.
• Executori de agenți: Acesta este mecanismul de execuție care permite alegerea între unelte.

Agenții din LangChain urmează, de asemenea, modelul Zero-shot ReAct, unde decizia se bazează doar pe descrierea uneltei. Acest mecanism poate fi extins cu memorie pentru a lua în considerare istoricul conversației. Cu ReAct, în loc să cereți unui LLM să completeze textul, puteți solicita să răspundă într-un buclă de gândire/acțiune/observație.

Lanțuri

Lanțurile, așa cum sugerează și numele, sunt secvențe de operațiuni care permit bibliotecii LangChain să proceseze intrările și ieșirile modelului de limbaj în mod fluent. Aceste componente integrale ale LangChain sunt fundamental alcătuite din legături, care pot fi alte lanțuri sau primitive, cum ar fi prompturi, modele de limbaj sau utilități.

Imaginați-vă un lanț ca o bandă transportoare într-o fabrică. Fiecare pas pe această bandă reprezintă o anumită operațiune, care ar putea fi apelarea unui model de limbaj, aplicarea unei funcții Python la un text sau chiar solicitarea modelului într-un anumit mod.

LangChain categorizează lanțurile sale în trei tipuri: Lanțuri de utilitate, Lanțuri generice și Lanțuri de combinare a documentelor. Vom explora Lanțurile de utilitate și Lanțurile generice pentru discuția noastră.

• Lanțuri de utilitate sunt proiectate special pentru a extrage răspunsuri precise din modele de limbaj pentru sarcini bine definite. De exemplu, să luăm în considerare LLMMathChain. Acest lanț de utilitate permite modelelor de limbaj să efectueze calcule matematice. Acesta acceptă o întrebare în limbaj natural, iar modelul de limbaj generează în schimb un fragment de cod Python, care este apoi executat pentru a produce răspunsul.
• Lanțuri generice, pe de altă parte, servesc ca blocuri de construcție pentru alte lanțuri, dar nu pot fi utilizate în mod direct. Aceste lanțuri, cum ar fi LLMChain, sunt fundamentale și sunt adesea combinate cu alte lanțuri pentru a îndeplini sarcini complexe. De exemplu, LLMChain este frecvent utilizat pentru a interoga un obiect model de limbaj prin formatarea intrării pe baza unui șablon de prompt furnizat și apoi trecând-o modelului de limbaj.

Implementarea pas cu pas a ingineriei prompturilor cu Langchain

Vom parcurge procesul de implementare a ingineriei prompturilor utilizând Langchain. Înainte de a continua, asigurați-vă că ați instalat software-ul și pachetele necesare.

Puteți beneficia de instrumente populare cum ar fi Docker, Conda, Pip și Poetry pentru configurarea LangChain. Fișierele de instalare relevante pentru fiecare dintre aceste metode pot fi găsite în depozitul LangChain de pe https://github.com/benman1/generative_ai_with_langchain. Acesta include un Dockerfile pentru Docker, un requirements.txt pentru Pip, un pyproject.toml pentru Poetry și un fișier langchain_ai.yml pentru Conda.

În articolul nostru, vom utiliza Pip, gestionarul de pachete standard pentru Python, pentru a facilita instalarea și gestionarea bibliotecilor terțe. Dacă nu este inclus în distribuția dvs. Python, puteți instala Pip urmând instrucțiunile de la https://pip.pypa.io/.

Pentru a instala o bibliotecă cu Pip, utilizați comanda pip install nume_bibliotecă.

Cu toate acestea, Pip nu gestionează mediile în sine. Pentru a gestiona diferite medii, utilizăm instrumentul virtualenv.

În următoarea secțiune, vom discuta despre integrarea modelului.

Pașul 1: Configurarea Langchain

Mai întâi, trebuie să instalați pachetul Langchain. Utilizăm sistemul de operare Windows. Rulați următoarea comandă în terminal pentru a-l instala:

pip install langchain

Pașul 2: Importarea Langchain și a altor module necesare

Următorul, importați Langchain împreună cu alte module necesare. Aici, importăm și biblioteca transformers, care este utilizată pe scară largă în sarcinile de procesare a limbajului natural.

<p>import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Pașul 3: Încărcarea modelului preantrenat

Open AI

OpenAI modelele pot fi convenabil interfațate cu biblioteca LangChain sau cu biblioteca client OpenAI Python. Notabil, OpenAI oferă o clasă de încorporare pentru modelele de încorporare a textului. Două modele LLM cheie sunt GPT-3.5 și GPT-4, care se diferențiază în principal prin lungimea tokenului. Prețurile pentru fiecare model pot fi găsite pe site-ul OpenAI. Deși există modele mai sofisticate, cum ar fi GPT-4-32K, care au o acceptare mai mare a tokenului, disponibilitatea lor prin API nu este întotdeauna garantată.

Accesarea acestor modele necesită o cheie API OpenAI. Acest lucru poate fi realizat prin crearea unui cont pe platforma OpenAI, setarea informațiilor de facturare și generarea unei chei secrete noi.

<p>import os
os.environ["OPENAI_API_KEY"] = 'cheia_dvs_openai'</p>

După crearea cheii, o puteți seta ca variabilă de mediu (OPENAI_API_KEY) sau o puteți transmite ca parametru în timpul instanțierii clasei pentru apelurile OpenAI.

Luăm în considerare un script LangChain care demonstrează interacțiunea cu modelele OpenAI:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# LLM ia un prompt ca intrare și produce o completare
prompt = "cine este președintele Statelor Unite ale Americii?"
completare = llm(prompt)

<p>Președintele actual al Statelor Unite ale Americii este Joe Biden.</p>

În acest exemplu, un agent este inițializat pentru a efectua calcule. Agentul ia o intrare, o sarcină simplă de adăugare, o prelucrează utilizând modelul OpenAI furnizat și returnează rezultatul.

Hugging

Hugging Face este o bibliotecă gratuită de transformatori Python, compatibilă cu PyTorch, TensorFlow și JAX, și include implementări de modele cum ar fi BERT, T5 etc.

Hugging Face oferă, de asemenea, Hugging Face Hub, o platformă pentru găzduirea depozitelor de cod, modelelor de învățare automată, seturilor de date și aplicațiilor web.

Pentru a utiliza Hugging Face ca furnizor pentru modelele dvs., veți avea nevoie de un cont și de chei API, care pot fi obținute de pe site-ul lor. Tokenul poate fi făcut disponibil în mediul dvs. ca HUGGINGFACEHUB_API_TOKEN.

Luăm în considerare următorul fragment de cod Python care utilizează un model cu sursă deschisă dezvoltat de Google (GOOGL ), modelul Flan-T5-XXL:

from langchain.llms import HuggingFaceHub

<p>llm = HuggingFaceHub(model_kwargs={"temperature": 0.5, "max_length": 64}, repo_id="google/flan-t5-xxl")
prompt = "În ce țară se află Tokyo?"
completare = llm(prompt)
print(completare)</p>

Acest script ia o întrebare ca intrare și returnează un răspuns, demonstrând cunoștințele și capacitățile de predicție ale modelului.

Pașul 4: Ingineria prompturilor de bază

Pentru a începe, vom genera un prompt simplu și vom vedea cum răspunde modelul.

prompt = 'Traduceți următorul text în limba franceză: "{0}"'
text_de_intrare = 'Salut, cum eşti?'
input_ids = tokenizer.encode(prompt.format(text_de_intrare), return_tensors='pt')

<p>generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))</p>

În fragmentul de cod de mai sus, oferim un prompt pentru a traduce textul în limba franceză. Modelul de limbaj încearcă apoi să traducă textul dat pe baza promptului.

Pașul 5: Ingineria prompturilor avansată

În timp ce abordarea de mai sus funcționează bine, nu profită pe deplin de puterea ingineriei prompturilor. Să o îmbunătățim prin introducerea unor structuri de prompt mai complexe.

prompt = 'Ca traducător francez foarte competent, traduceți următorul text în limba franceză: "{0}"'
text_de_intrare = 'Salut, cum eşti?'
input_ids = tokenizer.encode(prompt.format(text_de_intrare), return_tensors='pt')

<p>generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))</p>

În acest fragment de cod, modificăm promptul pentru a sugera că traducerea este efectuată de un ‘traducător francez foarte competent’. Schimbarea promptului poate duce la traduceri îmbunătățite, deoarece modelul presupune acum o persoană competentă.

Construirea unui sistem de întrebări și răspunsuri pentru literatura academică cu Langchain

Vom construi un sistem de întrebări și răspunsuri pentru literatura academică utilizând LangChain, care poate răspunde la întrebări despre articole academice publicate recent.

Mai întâi, pentru a configura mediul nostru, instalăm dependențele necesare.

pip install langchain arxiv openai transformers faiss-cpu

Urmată de instalare, creăm un nou notebook Python și importăm bibliotecile necesare:

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

Nucleul sistemului nostru de întrebări și răspunsuri este capacitatea de a obține articole academice relevante legate de un anumit domeniu, aici considerăm Procesarea limbajului natural (NLP), utilizând baza de date academică arXiv. Pentru a face acest lucru, definim o funcție get_arxiv_data(max_results=10). Această funcție colectează rezumatele articolelor NLP recente de pe arXiv și le încorporează în obiecte de document LangChain, utilizând rezumatul ca conținut și ID-ul de intrare unic ca sursă.

Vom utiliza API-ul arXiv pentru a obține articole recente legate de NLP:

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

documents = []

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

return documents

Această funcție recuperează rezumatele articolelor NLP cele mai recente de pe arXiv și le convertește în obiecte de document LangChain. Utilizăm rezumatul articolului și ID-ul său unic (URL-ul articolului) ca conținut și sursă, respectiv.

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

Să definim corpusul nostru și să configurăm LangChain:

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

Cu sistemul nostru de întrebări și răspunsuri academic gata, putem testa-l prin a pune o întrebare:

print_answer("Care sunt progresele recente în NLP?")

Rezultatul va fi răspunsul la întrebarea dvs., citând sursele din care a fost extrasă informația. De exemplu:

<p>Progresele recente în NLP includ modelele de urmărire a instrucțiunilor și un cadru computațional nou pentru rezolvarea problemelor de flux de putere alternativă (ACOPF) utilizând unități de procesare grafică (GPU).
SURSE: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Puteți schimba ușor modele sau modifica sistemul în funcție de nevoile dvs. De exemplu, aici trecem la GPT-4, care ne oferă un răspuns mult mai bun și mai detaliat.

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

<p>Progresele recente în Procesarea limbajului natural (NLP) includ dezvoltarea modelelor de urmărire a instrucțiunilor pentru sarcini de căutare a informațiilor, cum ar fi răspunsurile la întrebări (QA). Aceste modele pot fi adaptate la diverse domenii de informații și sarcini fără antrenament suplimentar. Cu toate acestea, ele pot lupta pentru a se conforma cunoștințelor furnizate și pot halucina în răspunsurile lor. O altă evoluție este introducerea unui cadru computațional pentru rezolvarea problemelor de flux de putere alternativă (ACOPF) utilizând unități de procesare grafică (GPU). Acest cadru utilizează o abstracție de date single-instruction, multiple-data (SIMD) a programelor neliniare (NLP) și angajează o metodă de punct interior (IPM) cu o strategie de relaxare a inegalităților. Această strategie permite factorizarea matricei KKT fără pivotare numerică, ceea ce a împiedicat anterior paralelizarea algoritmului IPM.
SURSE: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Un token în GPT-4 poate fi atât de scurt cât un singur caracter sau atât de lung cât un singur cuvânt. De exemplu, GPT-4-32K poate procesa până la 32.000 de tokeni într-o singură execuție, în timp ce GPT-4-8K și GPT-3.5-turbo suportă 8.000 și 4.000 de tokeni, respectiv. Cu toate acestea, este important de remarcat că fiecare interacțiune cu aceste modele vine cu un cost care este direct proporțional cu numărul de tokeni procesați, fie că este vorba de intrare sau de ieșire.

În contextul sistemului nostru de întrebări și răspunsuri, dacă o piesă de literatură academică depășește limita maximă de tokeni, sistemul va eșua în a o procesa în întregime, afectând astfel calitatea și completitudinea răspunsurilor. Pentru a depăși această problemă, textul poate fi divizat în părți mai mici care se conformează limitei de tokeni.

FAISS (Facebook AI Similarity Search) (META ) ajută la găsirea rapidă a celor mai relevante fragmente de text legate de întrebarea utilizatorului. Acesta creează o reprezentare vectorială a fiecărui fragment de text și utilizează aceste vectori pentru a identifica și a recupera fragmentele cele mai asemănătoare cu reprezentarea vectorială a unei întrebări date.

Este important de reținut că, chiar și cu utilizarea unor instrumente precum FAISS, necesitatea de a diviza textul în fragmente mai mici din cauza limitărilor de tokeni poate duce uneori la pierderea contextului, afectând calitatea răspunsurilor. Prin urmare, gestionarea și optimizarea atentă a utilizării tokenilor sunt cruciale atunci când se lucrează cu aceste modele de limbaj mare.

pip install faiss-cpu langchain CharacterTextSplitter

După ce vă asigurați că bibliotecile de mai sus sunt instalate, rulați

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) # Acum putem utiliza mai multe date
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))

<p>search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())</p>

<p>chain = load_qa_with_sources_chain(OpenAI(temperature=0))</p>

<p>def print_answer(intrebare):
print(
chain(
{
"input_documents": search_index.similarity_search(intrebare, k=4),
"question": intrebare,
},
return_only_outputs=True,
)["output_text"]
)

Cu codul complet, acum avem un instrument puternic pentru a interoga literatura academică recentă în domeniul NLP.

Progresele recente în NLP includ utilizarea rețelelor neuronale profunde (DNN) pentru analiza automată a textului și sarcinile de procesare a limbajului natural (NLP) cum ar fi verificarea ortografică, detectarea limbii, extragerea entităților, detectarea autorului, răspunsurile la întrebări și alte sarcini.
SURSE: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1

Concluzie

Integrarea modelelor de limbaj mare (LLM) în aplicații a accelerat adoptarea în mai multe domenii, incluzând traducerea limbajului, analiza sentimentului și recuperarea informațiilor. Ingineria prompturilor este un instrument puternic în maximizarea potențialului acestor modele, iar Langchain conduce drumul în simplificarea acestei sarcini complexe. Interfața sa standardizată, șabloanele de prompt flexibile, integrarea robustă a modelului și utilizarea inovatoare a agenților și lanțurilor asigură rezultate optime pentru performanța LLM.

În ciuda acestor progrese, există câteva sfaturi de reținut. Pe măsură ce utilizați Langchain, este esențial să înțelegem că calitatea ieșirii depinde foarte mult de formularea promptului. Experimentarea cu diferite stiluri și structuri de prompt poate duce la rezultate îmbunătățite. De asemenea, rețineți că, deși Langchain suportă o varietate de modele de limbaj, fiecare are puncte forte și slăbiciuni. Alegerea celui potrivit pentru sarcina dvs. specifică este crucială. În cele din urmă, este important să rețineți că utilizarea acestor modele vine cu considerații de cost, deoarece procesarea tokenilor influențează direct costul interacțiunilor.

Pe măsură ce a fost demonstrat în ghidul pas cu pas, Langchain poate alimenta aplicații robuste, cum ar fi sistemul de întrebări și răspunsuri pentru literatura academică. Cu o comunitate de utilizatori în creștere și o importanță tot mai mare în peisajul surselor deschise, Langchain promite a fi un instrument cheie în valorificarea pe deplin a potențialului LLM, cum ar fi GPT-4.