Fra zero til avanceret prompt-engineering med Langchain i Python

En vigtig aspekt af Large Language Models (LLMs) er antallet af parametre, disse modeller bruger til at lære. Jo flere parametre en model har, jo bedre kan den forstå relationen mellem ord og fraser. Dette betyder, at modeller med milliarder af parametre har kapaciteten til at generere forskellige kreative tekstformater og besvare åbne og udfordrende spørgsmål på en informativ måde.

LLMs som ChatGPT, der udnytter Transformer-modellen, er dygtige til at forstå og generere menneskesprog, hvilket gør dem nyttige til anvendelser, der kræver naturlig sprogforståelse. Men de er ikke uden deres begrænsninger, som inkluderer forældet viden, manglende evne til at interagere med eksterne systemer, manglende kontekstforståelse og nogle gange genererer de plausibelt lydende, men forkerte eller meningsløse svar, blandt andre.

At løse disse begrænsninger kræver integration af LLMs med eksterne datakilder og funktioner, hvilket kan præsentere kompleksiteter og kræve omfattende kodning og datahåndteringsevner. Dette, kombineret med udfordringerne ved at forstå AI-koncepter og komplekse algoritmer, bidrager til den læringskurve, der er forbundet med udvikling af anvendelser, der bruger LLMs.

Ikke desto mindre kan integrationen af LLMs med andre værktøjer til at danne LLM-drevne anvendelser kunne gendefinere vores digitale landskab. Potentialet for sådanne anvendelser er stort, herunder forbedring af effektivitet og produktivitet, forenkling af opgaver, forbedring af beslutningstagning og tilbydning af personlige oplevelser.

I denne artikel vil vi dykke dybere ind i disse problemer, ved at udforske de avancerede teknikker for prompt-engineering med Langchain, og tilbyde klare forklaringer, praktiske eksempler og trin-for-trin-instruktioner om, hvordan man implementerer dem.

Langchain, en state-of-the-art-bibliotek, bringer bekvemmelighed og fleksibilitet til design, implementering og finjustering af prompts. Mens vi pakker principperne og praksis af prompt-engineering, vil du lære, hvordan du kan udnytte Langchains kraftfulde funktioner til at udnytte styrkerne i SOTA Generative AI-modeller som GPT-4.

Forståelse af Prompts

Før vi dykker ind i de tekniske aspekter af prompt-engineering, er det essentiel at forstå begrebet om prompts og deres betydning.

En ‘prompt‘ er en sekvens af tokens, der bruges som input til en sprogmodel, og instruerer den til at generere en bestemt type svar. Prompts spiller en afgørende rolle i at styre modellens adfærd. De kan påvirke kvaliteten af den genererede tekst, og når de er konstrueret korrekt, kan de hjælpe modellen med at give indsigtfulde, præcise og kontekstspecifikke resultater.

Prompt-engineering er kunsten og videnskaben om at designe effektive prompts. Målet er at fremkalde det ønskede output fra en sprogmodel. Ved at vælge og strukturere prompts omhyggeligt kan man guide modellen mod at generere mere præcise og relevante svar. I praksis indebærer dette at finjustere inputfraserne for at tilpasse modellens træning og strukturbiasser.

Sophistikationen af prompt-engineering spænder fra simple teknikker, såsom at føde modellen med relevante nøgleord, til mere avancerede metoder, der involverer design af komplekse, strukturerede prompts, der udnytter modellens interne mekanismer til sin fordel.

Langchain: Det Hurtigst Voksende Prompt-Værktøj

LangChain, lanceret i oktober 2022 af Harrison Chase, er blevet en af de højest vurderede open-source-rammer på GitHub i 2023. Det tilbyder en simplificeret og standardiseret interface for at inkorporere Large Language Models (LLMs) i anvendelser. Det tilbyder også en funktionel interface for prompt-engineering, der giver udviklere mulighed for at eksperimentere med forskellige strategier og evaluere deres resultater. Ved at bruge Langchain kan du udføre prompt-engineering-opgaver mere effektivt og intuitivt.

LangFlow fungerer som en brugergrænseflade for at orkestrere LangChain-komponenter i en eksekverbar flowchart, hvilket muliggør hurtig prototypering og eksperimenter.

LangChain fylder en kritisk lukke i AI-udvikling for masserne. Det muliggør en række NLP-anvendelser, såsom virtuelle assistenter, indholdsgenerering, spørgsmål-svar-systemer og mere, til at løse en række virkelige problemer.

I stedet for at være en selvstændig model eller leverandør simplificerer LangChain interaktionen med diverse modeller, og udvider mulighederne for LLM-anvendelser ud over begrænsningerne af en simpel API-kald.

LangChains Arkitektur

LangChains hovedkomponenter inkluderer Model I/O, Prompt-temaer, Hukommelse, Agenter og Kæder.

Model I/O

LangChain faciliterer en problemfri forbindelse til forskellige sprogmodeller ved at indpakke dem med en standardiseret interface kendt som Model I/O. Dette faciliterer en let model-skift for optimering eller bedre præstation. LangChain understøtter forskellige sprogmodel-leverandører, herunder OpenAI, HuggingFace, Azure, Fireworks og mere.

Prompt-temaer

Disse bruges til at styre og optimere interaktioner med LLMs ved at give korte instruktioner eller eksempler. Optimering af prompts forbedrer modellens præstation, og deres fleksibilitet bidrager betydeligt til inputprocessen.

Et simpelt eksempel på et prompt-tema:

<p>from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=[&amp;quot;emne&amp;quot;],
template=&amp;quot;Hvad er de seneste fremskridt i feltet {emne}?&amp;quot;)
print(prompt.format(emne=&amp;quot;Naturlig Sprogbehandling&amp;quot;))</p>

Da vi avancerer i kompleksitet, møder vi mere sofistikerede mønstre i LangChain, såsom Reason and Act (ReAct)-mønsteret. ReAct er et vitalt mønster for handlingseksekvering, hvor agenten tildeler en opgave til et passende værktøj, tilpasser input til det og parser output for at fuldføre opgaven. Det følgende Python-eksempel viser et ReAct-mønster. Det demonstrerer, hvordan en prompt er struktureret i LangChain, ved at bruge en række tanker og handlinger til at resonere gennem et problem og producere et endeligt svar:

PREFIX = """Besvar følgende spørgsmål ved hjælp af de givne værktøjer:"""
FORMAT_INSTRUCTIONS = """Følg denne format:
Spørgsmål: {input_spørgsmål}
Tanke: din første tanke om spørgsmålet
Handling: din valgte handling fra [{værktøjsnavne}]
Handling Input: din input for handlingen
Observation: handlingens udfald"""
SUFFIX = """Start!
Spørgsmål: {input}
Tanke:{agent_scratchpad}"""

Hukommelse

Hukommelse er et kritisk begreb i LangChain, der giver LLMs og værktøjer mulighed for at huske information over tid. Denne tilstandsbaserede adfærd forbedrer præstationen af LangChain-anvendelser ved at gemme tidligere svar, brugerinteraktioner, tilstands miljø og agentens mål. ConversationBufferMemory- og ConversationBufferWindowMemory-strategierne hjælper med at holde styr på hele eller seneste dele af en samtale. For en mere sofistikeret tilgang giver ConversationKGMemory-strategien mulighed for at kodificere samtalen som en viden graf, der kan føres tilbage til prompts eller bruges til at forudsige svar uden at kalde LLM.

Agenter

En agent interagerer med verden ved at udføre handlinger og opgaver. I LangChain kombinerer agenter værktøjer og kæder for opgave-eksekvering. Den kan etablere en forbindelse til den ydre verden for informationshentning for at supplere LLM-viden, og dermed overvinde deres indbyggede begrænsninger. De kan beslutte at overføre beregninger til en regnemaskine eller Python-fortolker afhængigt af situationen.

Agenter er udstyret med underkomponenter:

• Værktøjer: Disse er funktionelle komponenter.
• Værktøjskasser: Samlinger af værktøjer.
• Agent-eksekutorer: Dette er eksekveringsmekanismen, der giver mulighed for at vælge mellem værktøjer.

Agenter i LangChain følger også Zero-shot ReAct-mønsteret, hvor beslutningen baseres kun på værktøjets beskrivelse. Denne mekanisme kan udvides med hukommelse for at tage hensyn til hele samtalehistorien. Med ReAct kan du i stedet for at bede en LLM om at autofuldføre din tekst, bede den om at svare i en tanke/handling/observation-løkke.

Kæder

Kæder, som navnet antyder, er sekvenser af operationer, der giver LangChain-biblioteket mulighed for at behandle sprogmodel-input og -output uden problemer. Disse integrale komponenter af LangChain består grundlæggende af links, der kan være andre kæder eller primitiver som prompts, sprogmodeller eller hjælpemidler.

<p Forestil dig en kæde som en samlebånd i en fabrik. Hver trin på denne bånd repræsenterer en bestemt operation, der kunne være aktivering af en sprogmodel, anvendelse af en Python-funktion til en tekst eller endda promptning af modellen på en bestemt måde.

LangChain kategoriserer sine kæder i tre typer: Utility-kæder, Generiske kæder og Combine Documents-kæder. Vi vil dykke ind i Utility- og Generiske kæder til vores diskussion.

• Utility-kæder er specifikt designede til at trække præcise svar ud af sprogmodeller for snævert definerede opgaver. For eksempel, lad os tage et kig på LLMMathChain. Denne utility-kæde giver sprogmodeller mulighed for at udføre matematiske beregninger. Den accepterer et spørgsmål i naturligt sprog, og sprogmodellen genererer herefter en Python-kode, der derefter udføres for at producere svaret.
• Generiske kæder fungerer som byggeklodser for andre kæder, men kan ikke bruges direkte som selvstændige. Disse kæder, såsom LLMChain, er grundlæggende og kombineres ofte med andre kæder for at udføre komplekse opgaver. For eksempel bruges LLMChain ofte til at spørge en sprogmodel-objekt ved at formater input baseret på en given prompt-skabelon og derefter overføre det til sprogmodellen.

Trin-for-trin-Implementering af Prompt-Engineering med Langchain

Vi vil guide dig gennem processen med at implementere prompt-engineering med Langchain. Før du fortsætter, skal du sikre, at du har installeret de nødvendige software og pakker.

Du kan udnytte populære værktøjer som Docker, Conda, Pip og Poetry til at konfigurere LangChain. De relevante installationsfiler for hver af disse metoder kan findes i LangChain-repositoriet på https://github.com/benman1/generative_ai_with_langchain. Dette inkluderer en Dockerfile til Docker, en requirements.txt til Pip, en pyproject.toml til Poetry og en langchain_ai.yml-fil til Conda.

I vores artikel vil vi bruge Pip, den standard pakke-manager for Python, til at faciliterer installation og administration af tredjeparts-biblioteker. Hvis det ikke er inkluderet i din Python-distribution, kan du installere Pip ved at følge instruktionerne på https://pip.pypa.io/.

For at installere et bibliotek med Pip, brug kommandoen pip install bibliotek_navn.

Men Pip håndterer ikke miljøer på egen hånd. Til at håndtere forskellige miljøer bruger vi værktøjet virtualenv.

I den næste sektion vil vi diskutere model-integrationer.

Trin 1: Opsætning af Langchain

Først skal du installere Langchain-pakken. Vi bruger Windows OS. Kør følgende kommando i din terminal for at installere det:

pip install langchain

Trin 2: Import af Langchain og andre nødvendige moduler

Herefter skal du importere Langchain sammen med andre nødvendige moduler. Her importerer vi også transformers-biblioteket, der er omfattende brugt i NLP-opgaver.

<p>import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Trin 3: Indlæsning af Forudtrænet Model

Open AI

OpenAI-modeller kan konvenientlt kobles til LangChain-biblioteket eller OpenAI Python-klientbiblioteket. Bemærkelsesværdigt er, at OpenAI tilbyder en Embedding-klasse til tekst-embedding-modeller. To nøgle-LLM-modeller er GPT-3.5 og GPT-4, der primært adskiller sig i tokenlængde. Priser for hver model kan findes på OpenAIs website. Mens der er mere avancerede modeller som GPT-4-32K, der har højere tokenaccept, er deres tilgængelighed via API ikke altid garanteret.

Adgang til disse modeller kræver en OpenAI-API-nøgle. Dette kan gøres ved at oprette en konto på OpenAIs platform, opsætte betalingsinformation og generere en ny hemmelig nøgle.

<p>import os
os.environ[&amp;quot;OPENAI_API_KEY&amp;quot;] = &#039;din-openai-token&#039;</p>

Efter at have oprettet nøglen kan du sætte den som en miljøvariabel (OPENAI_API_KEY) eller overføre den som en parameter under klassens instantiation for OpenAI-kald.

Overvej et LangChain-manuskript for at demonstrere interaktionen med OpenAI-modellerne:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# LLM'en tager en prompt som input og producerer et svar
prompt = "hvem er præsidenten for USA?"
completion = llm(prompt)

<p>Den nuværende præsident for USA er Joe Biden.</p>

I dette eksempel initialiseres en agent til at udføre beregninger. Agenten tager et input, en simpel additionsopgave, behandler det ved hjælp af den tilgængelige OpenAI-model og returnerer resultatet.

Hugging

Hugging Face er et KOSTNINGSFRI Transformers Python-bibliotek, kompatibelt med PyTorch, TensorFlow og JAX, og inkluderer implementeringer af modeller som BERT, T5 osv.

Hugging Face tilbyder også Hugging Face Hub, en platform for hosting kode-repositorier, maskinlæringsmodeller, datasæt og web-applikationer.

For at bruge Hugging Face som en leverandør af dine modeller skal du have en konto og API-nøgler, der kan erhverves fra deres website. Tokenet kan gøres tilgængeligt i din miljø som HUGGINGFACEHUB_API_TOKEN.

Overvej følgende Python-eksempel, der anvender en åben kilde-model udviklet af Google (GOOGL ), Flan-T5-XXL-modellen:

from langchain.llms import HuggingFaceHub

<p>llm = HuggingFaceHub(model_kwargs={&amp;quot;temperature&amp;quot;: 0.5, &amp;quot;max_length&amp;quot;: 64},repo_id=&amp;quot;google/flan-t5-xxl&amp;quot;)
prompt = &amp;quot;I hvilket land ligger Tokyo?&amp;quot;
completion = llm(prompt)
print(completion)</p>

Dette manuskript tager et spørgsmål som input og returnerer et svar, der demonstrerer viden og prædiktionsevnerne i modellen.

Trin 4: Grundlæggende Prompt-Engineering

For at starte med vil vi generere en simpel prompt og se, hvordan modellen responderer.

prompt = 'Oversæt følgende engelsk tekst til fransk: "{0}"'
input_text = 'Hej, hvordan har du det?'
input_ids = tokenizer.encode(prompt.format(input_text), 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))

I ovenstående kodeeksempel giver vi en prompt til at oversætte engelsk tekst til fransk. Sprogmodellen forsøger herefter at oversætte den givne tekst baseret på prompten.

Trin 5: Avanceret Prompt-Engineering

Mens ovenstående tilgang virker fint, udnytter den ikke fuldt ud kraften af prompt-engineering. Lad os forbedre det ved at introducere mere komplekse prompt-strukturer.

prompt = 'Som en meget dygtig fransk oversætter, oversæt følgende engelsk tekst til fransk: "{0}"'
input_text = 'Hej, hvordan har du det?'
input_ids = tokenizer.encode(prompt.format(input_text), 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))

I dette kodeeksempel ændrer vi prompten til at antyde, at oversættelsen udføres af en ‘meget dygtig fransk oversætter’. Ændringen af prompten kan føre til forbedrede oversættelser, da modellen nu antager en persona af en ekspert.

Opbygning af et Akademisk Litteratur Spørgsmål-Svar-System med Langchain

Vi vil bygge et akademisk litteratur spørgsmål-svar-system med LangChain, der kan besvare spørgsmål om nyligt publicerede akademiske artikler.

Først skal vi opsætte vores miljø ved at installere de nødvendige afhængigheder.

pip install langchain arxiv openai transformers faiss-cpu

Efter installationen opretter vi et nyt Python-notepad og importerer de nødvendige biblioteker:

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

Kernen i vores spørgsmål-svar-system er evnen til at hente relevante akademiske artikler relateret til et bestemt område, herunder Naturlig Sprogbehandling (NLP), ved hjælp af arXiv akademisk database. For at udføre dette definerer vi en funktion get_arxiv_data(max_results=10). Denne funktion indsamler de seneste NLP-artikelsammenfattelser fra arXiv og indkapsler dem i LangChain-dokumentobjekter, ved at bruge sammenfattelsen som indhold og det unikke entry-id som kilde.

Vi vil bruge arXiv-API’en til at hente de seneste artikler relateret til NLP:

<p>def get_arxiv_data(max_results=10):
search = arxiv.Search(
query=&amp;quot;NLP&amp;quot;,
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={&amp;quot;kilde&amp;quot;: result.entry_id},
))</p>

return documents

Denne funktion henter sammenfattelserne af de seneste NLP-artikler fra arXiv og konverterer dem til LangChain-dokumentobjekter. Vi bruger artiklens sammenfattelse og dens unikke entry-id (URL til artiklen) som indhold og kilde, henholdsvis.

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

Lad os definere vores korpus og opsætte LangChain:

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

Med vores akademisk spørgsmål-svar-system nu klar, kan vi teste det ved at stille et spørgsmål:

print_answer("Hvad er de seneste fremskridt i NLP?")

Udgangen vil være svaret på dit spørgsmål, med henvisninger til kilderne, hvorfra informationen blev hentet. For eksempel:

<p>De seneste fremskridt i NLP inkluderer udviklingen af retriever-augmenterede instruktionsfølgende modeller til informationsøgende opgaver såsom spørgsmål-svar. Disse modeller kan tilpasses til forskellige informationsdomæner og opgaver uden yderligere finjustering. Men de kæmper ofte med at holde fast i den givne viden og kan hallucinere i deres svar. En anden udvikling er introduktionen af en beregningsramme for at løse alternativ strøm optimalt flow (ACOPF) problemer ved hjælp af grafikprocessorer (GPUs). Denne tilgang udnytter en single-instruction, multiple-data (SIMD) abstraktion af ikke-lineære programmer (NLP) og anvender en kondenseret-rum interior-point metode (IPM) med en ulighed afslapning strategi. Denne strategi giver mulighed for at faktorisere KKT-matrixen uden numerisk pivoting, hvilket tidligere har forhindret paralleliseringen af IPM-algoritmen.
KILDER: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1</p>

Du kan let skifte modeller eller ændre systemet efter dine behov. For eksempel, her skifter vi til GPT-4, der giver os et langt bedre og mere detaljeret svar.

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

<p>De seneste fremskridt i Naturlig Sprogbehandling (NLP) inkluderer udviklingen af retriever-augmenterede instruktionsfølgende modeller for informationsøgende opgaver såsom spørgsmål-svar. Disse modeller kan tilpasses til forskellige informationsdomæner og opgaver uden yderligere finjustering. Men de kæmper ofte med at holde fast i den givne viden og kan hallucinere i deres svar. En anden udvikling er introduktionen af en beregningsramme for at løse alternativ strøm optimalt flow (ACOPF) problemer ved hjælp af grafikprocessorer (GPUs). Denne tilgang udnytter en single-instruction, multiple-data (SIMD) abstraktion af ikke-lineære programmer (NLP) og anvender en kondenseret-rum interior-point metode (IPM) med en ulighed afslapning strategi. Denne strategi giver mulighed for at faktorisere KKT-matrixen uden numerisk pivoting, hvilket tidligere har forhindret paralleliseringen af IPM-algoritmen.
KILDER: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1</p>

En token i GPT-4 kan være så kort som ét tegn eller så lang som ét ord. For eksempel kan GPT-4-32K behandle op til 32.000 tokens i en enkelt kørsel, mens GPT-4-8K og GPT-3.5-turbo understøtter 8.000 og 4.000 tokens, henholdsvis. Men det er vigtigt at bemærke, at hver interaktion med disse modeller kommer med en omkostning, der er direkte proportional med antallet af tokens, der behandles, enten input eller output.

I konteksten af vores spørgsmål-svar-system, hvis en akademisk artikel overskrider den maksimale token-grænse, vil systemet ikke være i stand til at behandle den i sin helhed, og dermed påvirker kvaliteten og fuldstændigheden af svarene. For at arbejde rundt om dette problem kan teksten brydes ned i mindre dele, der overholder token-grænsen.

FAISS (Facebook AI Similarity Search) (META ) hjælper med at hurtigt finde de mest relevante tekstdele relateret til brugerens spørgsmål. Det opretter en vektorrepræsentation af hver tekstdel og bruger disse vektorer til at identificere og hente de dele, der er mest lignende vektorrepræsentationen af et givet spørgsmål.

Det er vigtigt at huske, at selv med brug af værktøjer som FAISS kan behovet for at dele teksten i mindre dele på grund af token-begrænsninger nogle gange føre til tab af kontekst, og dermed påvirker kvaliteten af svarene. Derfor er omhyggelig håndtering og optimering af token-brug afgørende, når man arbejder med disse store sprogmodeller.

pip install faiss-cpu langchain CharacterTextSplitter

Efter at have sikret, at ovenstående biblioteker er installeret, kør

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) # Vi kan nu bruge flere data
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(question):
print(
chain(
{
&amp;quot;input_documents&amp;quot;: search_index.similarity_search(question, k=4),
&amp;quot;question&amp;quot;: question,
},
return_only_outputs=True,
)[&amp;quot;output_text&amp;quot;]
)

Med koden fuldført har vi nu et kraftfuldt værktøj til at spørge om de seneste akademiske litteraturer inden for området NLP.

De seneste fremskridt i NLP inkluderer brugen af dybe neurale netværk (DNNs) til automatisk tekstanalyse og NLP-opgaver såsom stavekontrol, sproggenkendelse, enhedsudtrækning, forfattergenkendelse, spørgsmål-svar og andre opgaver.
KILDER: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1

Konklusion

Integrationen af Large Language Models (LLMs) i anvendelser har accelereret adoptionen af flere domæner, herunder sprogoversættelse, sentimentanalyse og informationshentning. Prompt-engineering er et kraftfuldt værktøj til at maksimere potentialet af disse modeller, og Langchain er førende i at simplificere denne komplekse opgave. Dets standardiserede interface, fleksible prompt-temaer, robust model-integration og den innovative brug af agenter og kæder sikrer optimale resultater for LLMs’ præstation.

Men selv med disse fremskridt er der nogle vigtige punkter at huske. Da du bruger Langchain, er det essentiel at forstå, at kvaliteten af output afhænger tungt af promptens formulering. At eksperimentere med forskellige prompt-stilarter og -strukturer kan føre til forbedrede resultater. Og husk, at selv om Langchain understøtter en række sprogmodeller, har hver sin styrker og svagheder. At vælge den rette model til din specifikke opgave er afgørende. Endelig er det vigtigt at huske, at brug af disse modeller kommer med omkostningsbetræninger, da token-behandling direkte påvirker omkostningerne af interaktioner.

Som demonstreret i trin-for-trin-guiden kan Langchain aktivere robuste anvendelser, såsom det akademiske litteratur spørgsmål-svar-system. Med en voksende brugerfællesskab og øget fremtræden i det åbne kilde-landskab lover Langchain at være et afgørende værktøj til at udnytte det fulde potentiale af LLMs som GPT-4.