Od podstaw do zaawansowanej inżynierii promptów z LangChain w Pythonie

Jednym z ważnych aspektów dużych modeli językowych (LLM) jest liczba parametrów, których używają do uczenia. Im więcej parametrów ma model, tym lepiej może zrozumieć relację między słowami i frazami. Oznacza to, że modele z miliardami parametrów mają możliwość generowania różnych kreatywnych formatów tekstu i odpowiadania na otwarte i trudne pytania w sposób informacyjny.

Modele LLM, takie jak ChatGPT, które wykorzystują model Transformer, są zdolne do zrozumienia i generowania języka ludzkiego, co sprawia, że są przydatne w aplikacjach wymagających zrozumienia języka naturalnego. Jednak mają one również ograniczenia, takie jak przestarzała wiedza, brak możliwości interakcji z zewnętrznymi systemami, brak zrozumienia kontekstu i czasami generowanie odpowiedzi, które brzmią prawdopodobnie, ale są niepoprawne lub nonsensowne, między innymi.

Nadrobienie tych ograniczeń wymaga integracji modeli LLM z zewnętrznymi źródłami danych i możliwościami, co może być skomplikowane i wymagać obszernych umiejętności programistycznych i zarządzania danymi. To, w połączeniu z wyzwaniami związanymi z zrozumieniem pojęć AI i złożonych algorytmów, przyczynia się do krzywej uczenia się związanej z tworzeniem aplikacji wykorzystujących modele LLM.

Niemniej, integracja modeli LLM z innymi narzędziami w celu utworzenia aplikacji wykorzystujących modele LLM może zrewolucjonizować nasz krajobraz cyfrowy. Potencjał takich aplikacji jest ogromny, w tym poprawa wydajności i produktywności, uproszczenie zadań, usprawnienie podejmowania decyzji i zapewnienie personalizowanych doświadczeń.

W tym artykule zagłębimy się w te problemy, eksplorując zaawansowane techniki inżynierii promptów z Langchain, oferując klarowne wyjaśnienia, praktyczne przykłady i krok-po-kroku instrukcje, jak je wdrożyć.

Langchain, biblioteka najnowszej generacji, przynosi wygodę i elastyczność w projektowaniu, wdrażaniu i dostosowywaniu promptów. Podczas gdy będziemy rozpakowywać zasady i praktyki inżynierii promptów, nauczysz się, jak wykorzystać potężne funkcje Langchain, aby wykorzystać zalety modeli generatywnych AI, takich jak GPT-4.

Zrozumienie promptów

Przed zanurzeniem się w technicznych aspektach inżynierii promptów, istotne jest zrozumienie pojęcia promptów i ich znaczenia.

Prompt to sekwencja tokenów używanych jako dane wejściowe do modelu językowego, nakazująca mu wygenerować określony typ odpowiedzi. Prompty odgrywają kluczową rolę w kierowaniu zachowaniem modelu. Mogą one wpłynąć na jakość wygenerowanego tekstu, a gdy są odpowiednio opracowane, mogą pomóc modelowi dostarczyć wglądu, dokładne i kontekstowo-specyficzne wyniki.

Inżynieria promptów to sztuka i nauka tworzenia skutecznych promptów. Celem jest wywołanie pożądanej odpowiedzi z modelu językowego. Poprzez staranne wybieranie i strukturyzowanie promptów, można nakierować model na generowanie bardziej dokładnych i istotnych odpowiedzi. W praktyce polega to na dostosowywaniu fraz wejściowych do upodobań i strukturalnych tendencji modelu.

Złożoność inżynierii promptów sięga od prostych technik, takich jak podawanie modelowi istotnych słów kluczowych, do bardziej zaawansowanych metod, które obejmują projektowanie złożonych, ustrukturyzowanych promptów, które wykorzystują wewnętrzną mechanikę modelu do jego korzyści.

Langchain: Najszybciej rozwijające się narzędzie prompty

LangChain, uruchomiony w październiku 2022 roku przez Harrisona Chase, stał się jednym z najwyżej ocenianych frameworków open-source na GitHub w 2023 roku. Oferuje uproszczony i standaryzowany interfejs do integrowania dużych modeli językowych (LLM) z aplikacjami. Zapewnia również funkcjonalny interfejs do inżynierii promptów, pozwalający deweloperom eksperymentować z różnymi strategiami i oceniać ich wyniki. Wykorzystując Langchain, możesz wykonywać zadania inżynierii promptów bardziej efektywnie i intuicyjnie.

LangFlow służy jako interfejs użytkownika do aranżowania składników LangChain w wykonalny diagram przepływu, umożliwiając szybkie prototypowanie i eksperymentowanie.

LangChain wypełnia istotną lukę w rozwoju AI dla mas. Umożliwia szereg aplikacji NLP, takich jak asystenci wirtualni, generatory treści, systemy odpowiedzi na pytania i wiele innych, aby rozwiązać szereg realnych problemów.

Zamiast być samodzielnym modelem lub dostawcą, LangChain upraszcza interakcję z różnymi modelami, rozszerzając możliwości aplikacji LLM poza ograniczenia prostego wywołania API.

Architektura LangChain

Główne składniki LangChain obejmują Model I/O, Prompt Templates, Memory, Agents i Chains.

Model I/O

LangChain ułatwia bezproblemową łączność z różnymi modelami językowymi, otaczając je standaryzowanym interfejsem zwanym Model I/O. Ułatwia to łatwą zmianę modelu w celu optymalizacji lub lepszej wydajności. LangChain obsługuje różnych dostawców modeli językowych, w tym OpenAI, HuggingFace, Azure, Fireworks i wiele innych.

Prompt Templates

Służą do zarządzania i optymalizacji interakcji z LLM poprzez zwięzłe instrukcje lub przykłady. Optymalizacja promptów poprawia wydajność modelu, a ich elastyczność znacznie przyczynia się do procesu wejściowego.

Prosty przykład szablonu promptu:

from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["subject"],
template="What are the recent advancements in the field of {subject}?")
print(prompt.format(subject="Natural Language Processing"))

Podczas gdy postępujemy w złożoności, spotykamy bardziej zaawansowane wzorce w LangChain, takie jak wzorzec Reason and Act (ReAct). ReAct jest istotnym wzorcem dla wykonania akcji, gdzie agent przydziela zadanie do odpowiedniego narzędzia, dostosowuje dane wejściowe i parsuje dane wyjściowe, aby osiągnąć zadanie. Poniższy przykład w Pythonie pokazuje wzorzec ReAct. Demonstruje, jak prompt jest strukturalizowany w LangChain, używając serii myśli i akcji, aby przemyśleć problem i wyprodukować ostateczną odpowiedź:

PREFIX = """Answer the following question using the given tools:"""
FORMAT_INSTRUCTIONS = """Follow this format:
Question: {input_question}
Thought: your initial thought on the question
Action: your chosen action from [{tool_names}]
Action Input: your input for the action
Observation: the action's outcome"""
SUFFIX = """Start!
Question: {input}
Thought:{agent_scratchpad}"""

Pamięć

Pamięć jest kluczowym pojęciem w LangChain, umożliwiającym LLM i narzędziom przechowywać informacje w czasie. To zachowanie stanowe poprawia wydajność aplikacji LangChain, przechowując poprzednie odpowiedzi, interakcje użytkownika, stan środowiska i cele agenta. Strategie ConversationBufferMemory i ConversationBufferWindowMemory pomagają śledzić pełne lub ostatnie części rozmowy. Dla bardziej zaawansowanego podejścia strategia ConversationKGMemory pozwala na zakodowanie rozmowy jako graf wiedzy, który może być wprowadzony z powrotem do promptów lub użyty do przewidywania odpowiedzi bez wywoływania LLM.

Agenci

Agent interaktywnie działa z otoczeniem, wykonując akcje i zadania. W LangChain agenci łączą narzędzia i łańcuchy do wykonania zadań. Może on ustanowić połączenie ze światem zewnętrznym w celu pobrania informacji, aby uzupełnić wiedzę LLM, tym samym pokonując ich wewnętrzne ograniczenia. Mogą one zdecydować o przekazaniu obliczeń do kalkulatora lub interpretera Pythona, w zależności od sytuacji.

Agenci są wyposażeni w podskładniki:

• Narzędzia: To są funkcjonalne składniki.
• Zestawy narzędzi: Zbiory narzędzi.
• Wykonawcy agentów: To jest mechanizm wykonawczy, który pozwala na wybór między narzędziami.

Agenci w LangChain również podążają za wzorcem Zero-shot ReAct, gdzie decyzja opiera się tylko na opisie narzędzia. Ten mechanizm może być rozszerzony o pamięć, aby wziąć pod uwagę pełną historię rozmowy. Z ReAct, zamiast prosić LLM o uzupełnienie tekstu, możesz nakazać mu odpowiedzieć w pętli myśl/akcja/obserwacja.

Łańcuchy

Łańcuchy, jak sama nazwa wskazuje, są sekwencjami operacji, które pozwalają bibliotece LangChain na płynne przetwarzanie danych wejściowych i wyjściowych modelu językowego. Te podstawowe składniki LangChain składają się zasadniczo z linków, które mogą być innymi łańcuchami lub prymitywami, takimi jak prompty, modele językowe lub narzędzia.

Wyobraź sobie łańcuch jako taśmę produkcyjną w fabryce. Każdy krok na tej taśmie reprezentuje określoną operację, która może być wywołaniem modelu językowego, zastosowaniem funkcji Pythona do tekstu lub nawet nakazaniem modelowi odpowiedzi w określony sposób.

LangChain klasyfikuje swoje łańcuchy na trzy typy: łańcuchy użytowe, łańcuchy ogólne i łańcuchy łączące dokumenty. Będziemy się zajmować łańcuchami użytowymi i ogólnymi.

• Łańcuchy użytowe są specjalnie zaprojektowane do wyodrębniania precyzyjnych odpowiedzi z modeli językowych dla wąsko określonych zadań. Na przykład, weźmy pod uwagę LLMMathChain. Ten łańcuch użytowy umożliwia modelom językowym wykonywanie obliczeń matematycznych. Akceptuje pytanie w języku naturalnym, a model językowy generuje wówczas fragment kodu Pythona, który jest następnie wykonywany w celu uzyskania odpowiedzi.
• Łańcuchy ogólne, z drugiej strony, służą jako bloki budulcowe dla innych łańcuchów, ale nie mogą być używane samodzielnie. Te łańcuchy, takie jak LLMChain, są podstawowe i często łączone z innymi łańcuchami w celu wykonania złożonych zadań. Na przykład, LLMChain jest często używany do zapytania obiektu modelu językowego, formatując dane wejściowe na podstawie podanego szablonu promptu i przekazując je do modelu językowego.

Krok-po-kroku wdrożenie inżynierii promptów z Langchain

Przewodzimy Cię przez proces wdrożenia inżynierii promptów przy użyciu Langchain. Przed kontynuowaniem upewnij się, że zainstalowałeś niezbędne oprogramowanie i pakiety.

Możesz skorzystać z popularnych narzędzi, takich jak Docker, Conda, Pip i Poetry, do konfigurowania LangChain. Odnośne pliki instalacyjne dla każdej z tych metod można znaleźć w repozytorium LangChain pod adresem https://github.com/benman1/generative_ai_with_langchain. Obejmuje to Dockerfile dla Dockera, requirements.txt dla PIPA, pyproject.toml dla Poetria i plik langchain_ai.yml dla Condy.

W naszym artykule użyjemy PIPA, standardowego menedżera pakietów Pythona, do ułatwienia instalacji i zarządzania bibliotekami zewnętrznymi. Jeśli nie jest on zawarty w Twojej dystrybucji Pythona, możesz zainstalować Pip, postępując zgodnie z instrukcjami na stronie https://pip.pypa.io/.

Aby zainstalować bibliotekę za pomocą PIPA, użyj polecenia pip install nazwa_biblioteki.

Jednak Pip nie zarządza środowiskami samodzielnie. Aby zarządzać różnymi środowiskami, używamy narzędzia virtualenv.

W następnej sekcji będziemy omawiać integrację modeli.

Krok 1: Konfigurowanie Langchain

Najpierw musisz zainstalować pakiet Langchain. Używamy systemu operacyjnego Windows. Uruchom następujące polecenie w terminalu, aby go zainstalować:

pip install langchain

Krok 2: Importowanie Langchain i innych niezbędnych modułów

Następnie importuj Langchain wraz z innymi niezbędnymi modułami. Tutaj importujemy również bibliotekę transformers, która jest szeroko stosowana w zadaniach NLP.

import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Krok 3: Załaduj wstępnie wytrenowany model

Open AI

Modele OpenAI można łatwo integrować z biblioteką LangChain lub biblioteką kliencką OpenAI dla Pythona. OpenAI udostępnia klasę Embedding do modeli osadzania tekstu. Dwa kluczowe modele LLM to GPT-3.5 i GPT-4, różniące się głównie długością obsługiwanego kontekstu. Ceny poszczególnych modeli można znaleźć na stronie OpenAI. Choć istnieją bardziej zaawansowane modele, takie jak GPT-4-32K obsługujące większą liczbę tokenów, ich dostępność przez API nie zawsze jest gwarantowana.

Dostęp do tych modeli wymaga klucza API OpenAI. Można go uzyskać, zakładając konto na platformie OpenAI, konfigurując dane rozliczeniowe i generując nowy tajny klucz.

import os
os.environ["OPENAI_API_KEY"] = 'your-openai-token'

Po utworzeniu klucza możesz ustawić go jako zmienną środowiskową (OPENAI_API_KEY) lub przekazać jako parametr podczas tworzenia instancji klasy do wywołań OpenAI.

Rozważmy skrypt LangChain pokazujący interakcję z modelami OpenAI:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# The LLM takes a prompt as an input and outputs a completion
prompt = "who is the president of the United States of America?"
completion = llm(prompt)

<p>The current President of the United States of America is Joe Biden.</p>

W tym przykładzie inicjalizowany jest agent wykonujący obliczenia. Agent przyjmuje proste zadanie dodawania, przetwarza je za pomocą podanego modelu OpenAI i zwraca wynik.

Hugging

Hugging Face to bezpłatna biblioteka Transformers dla Pythona, zgodna z PyTorch, TensorFlow i JAX, zawierająca implementacje modeli takich jak BERT, T5 i inne.

Hugging Face oferuje również Hugging Face Hub — platformę do hostowania repozytoriów kodu, modeli uczenia maszynowego, zbiorów danych i aplikacji internetowych.

Aby korzystać z Hugging Face jako dostawcy modeli, potrzebujesz konta i kluczy API dostępnych na jego stronie. Token można udostępnić w środowisku jako HUGGINGFACEHUB_API_TOKEN.

Rozważmy poniższy fragment kodu Pythona, który wykorzystuje otwarty model opracowany przez Google (GOOGL ) — model 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 which country is Tokyo?"
completion = llm(prompt)
print(completion)

Skrypt przyjmuje pytanie i zwraca odpowiedź, pokazując wiedzę i możliwości predykcyjne modelu.

Krok 4: Podstawowa inżynieria promptów

Na początek wygenerujemy prosty prompt i zobaczymy, jak model na niego zareaguje.

prompt = 'Translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
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))

W powyższym fragmencie kodu podajemy prompt nakazujący przetłumaczenie angielskiego tekstu na francuski. Model językowy następnie próbuje przetłumaczyć podany tekst zgodnie z promptem.

Krok 5: Zaawansowana inżynieria promptów

Choć powyższe podejście działa poprawnie, nie wykorzystuje w pełni możliwości inżynierii promptów. Ulepszmy je, wprowadzając bardziej złożone struktury promptów.

prompt = 'As a highly proficient French translator, translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
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))

W tym fragmencie kodu zmieniamy prompt, aby zasugerować, że tłumaczenie wykonuje doświadczony tłumacz języka francuskiego. Zmiana promptu może poprawić tłumaczenie, ponieważ model przyjmuje teraz rolę eksperta.

Budowanie systemu Q&A literatury akademickiej z Langchain

Będziemy budować system Q&A literatury akademickiej z LangChain, który może odpowiedzieć na pytania dotyczące ostatnio opublikowanych prac akademickich.

Po pierwsze, aby skonfigurować nasze środowisko, instalujemy niezbędne zależności.

pip install langchain arxiv openai transformers faiss-cpu

Następnie tworzymy nowy notes Pythona i importujemy niezbędne biblioteki:

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

Sercem naszego systemu Q&A jest zdolność do pobierania istotnych prac akademickich związanych z określoną dziedziną, tutaj rozważamy Przetwarzanie Języka Naturalnego (NLP), przy użyciu bazy danych arXiv. Aby to osiągnąć, definiujemy funkcję get_arxiv_data(max_results=10). Ta funkcja gromadzi najnowsze podsumowania prac NLP z arXiv i zakoduje je w obiekty dokumentów LangChain, używając podsumowania jako zawartości i unikalnego identyfikatora wejścia jako źródła.

Będziemy używać API arXiv do pobierania ostatnich prac związanych z 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

Ta funkcja pobiera podsumowania najnowszych prac NLP z arXiv i konwertuje je w obiekty dokumentów LangChain. Używamy podsumowania pracy i jej unikalnego identyfikatora (URL do pracy) jako zawartości i źródła, odpowiednio.

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

Teraz zdefiniujmy nasz korpus i skonfigurujmy LangChain:

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

Z naszym systemem Q&A gotowym do użycia, możemy go przetestować, zadając pytanie:

print_answer("What are the recent advancements in NLP?")

Wynik będzie odpowiedzią na Twoje pytanie, cytując źródła, z których informacje zostały pobrane. Na przykład:

<p>Recent advancements in NLP include Retriever-augmented instruction-following models and a novel computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs).
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Możesz łatwo przełączyć się między modelami lub zmodyfikować system zgodnie z Twoimi potrzebami. Na przykład, tutaj zmieniamy na GPT-4, co daje nam znacznie lepszą i bardziej szczegółową odpowiedź.

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

<p>Recent advancements in Natural Language Processing (NLP) include the development of retriever-augmented instruction-following models for information-seeking tasks such as question answering (QA). These models can be adapted to various information domains and tasks without additional fine-tuning. However, they often struggle to stick to the provided knowledge and may hallucinate in their responses. Another advancement is the introduction of a computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs). This approach utilizes a single-instruction, multiple-data (SIMD) abstraction of nonlinear programs (NLP) and employs a condensed-space interior-point method (IPM) with an inequality relaxation strategy. This strategy allows for the factorization of the KKT matrix without numerical pivoting, which has previously hampered the parallelization of the IPM algorithm.
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1</p>

Token w GPT-4 może być tak krótki, jak jeden znak, lub tak długi, jak jedno słowo. Na przykład, GPT-4-32K może przetwarzać do 32 000 tokenów w jednym przebiegu, podczas gdy GPT-4-8K i GPT-3.5-turbo obsługują odpowiednio 8 000 i 4 000 tokenów. Jednak należy pamiętać, że każda interakcja z tymi modelami wiąże się z kosztem, który jest bezpośrednio proporcjonalny do liczby przetworzonych tokenów, zarówno wejściowych, jak i wyjściowych.

W kontekście naszego systemu Q&A, jeśli fragment literatury akademickiej przekracza maksymalny limit tokenów, system nie będzie w stanie go przetworzyć w całości, co wpłynie na jakość i kompletność odpowiedzi. Aby rozwiązać ten problem, tekst można podzielić na mniejsze części, które spełniają limit tokenów.

FAISS (Facebook AI Similarity Search) (META ) pomaga w szybkim znalezieniu najbardziej istotnych fragmentów tekstu związanych z zapytaniem użytkownika. Tworzy reprezentację wektorową każdego fragmentu tekstu i używa tych wektorów do identyfikacji i pobierania fragmentów najbardziej podobnych do reprezentacji wektorowej danego pytania.

Jednak należy pamiętać, że nawet z użyciem narzędzi takich jak FAISS, konieczność podziału tekstu na mniejsze części z powodu limitu tokenów może czasami prowadzić do utraty kontekstu, co wpłynie na jakość odpowiedzi. Dlatego też staranne zarządzanie i optymalizacja użycia tokenów są kluczowe podczas pracy z dużymi modelami językowymi.

pip install faiss-cpu langchain CharacterTextSplitter

Po upewnieniu się, że powyższe biblioteki są zainstalowane, uruchom

 
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) # We can now use feed more 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))

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"]
    )

Z kodem kompletnym, mamy teraz potężne narzędzie do zapytywania najnowszej literatury akademickiej w dziedzinie NLP.

Recent advancements in NLP include the use of deep neural networks (DNNs) for automatic text analysis and natural language processing (NLP) tasks such as spell checking, language detection, entity extraction, author detection, question answering, and other tasks.
SOURCES: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1

Podsumowanie

Integracja dużych modeli językowych (LLM) z aplikacjami przyspieszyła ich przyjęcie w wielu dziedzinach, w tym tłumaczeniu języka, analizie nastrojów i wyszukiwaniu informacji. Inżynieria promptów jest potężnym narzędziem w maksymalizowaniu potencjału tych modeli, a Langchain jest liderem w uproszczeniu tego złożonego zadania. Jego standaryzowany interfejs, elastyczne szablony promptów, solidna integracja modeli i innowacyjne użycie agentów i łańcuchów zapewniają optymalne wyniki dla wydajności LLM.

Jednak pomimo tych postępów, istnieją pewne wskazówki, które należy pamiętać. Podczas korzystania z Langchain, istotne jest zrozumienie, że jakość wyjściowa zależy głównie od sformułowania promptu. Eksperymentowanie z różnymi stylami i strukturami promptów może prowadzić do lepszych wyników. Również pamiętaj, że Langchain obsługuje wiele modeli językowych, a każdy z nich ma swoje mocne i słabe strony. Wybór odpowiedniego modelu do Twojego konkretnego zadania jest kluczowy. Na koniec, pamiętaj, że korzystanie z tych modeli wiąże się z kosztami, ponieważ przetwarzanie tokenów wpływa bezpośrednio na koszt interakcji.

Jak pokazano w przewodniku krok po kroku, Langchain może napędzać solidne aplikacje, takie jak system Q&A literatury akademickiej. Z rosnącą społecznością użytkowników i rosnącym znaczeniem w krajobrazie open-source, Langchain obiecuje być kluczowym narzędziem w wykorzystaniu pełnego potencjału LLM, takich jak GPT-4.