Dynamiczna (choć na razie krótka) historia LangChain

LangChain to framework do tworzenia aplikacji korzystających z dużych modeli językowych (LLM). Został stworzony przez Harrisona Chase’a. Framework został po raz pierwszy wydany w październiku 2022 roku.

LangChain powstał jako otwarty projekt, który szybko zyskał popularność, przyciągając setki współtwórców na GitHubie, generując gorące dyskusje na Twitterze i aktywność na serwerze Discord projektu. W ciągu zaledwie sześciu miesięcy od wydania pierwszej wersji LangChain, projekt zyskał ponad 20 tys. gwiazdek na GitHubie, 10 tys. aktywnych członków na Discordzie, ponad 30 tys. obserwujących na Twitterze i – co najważniejsze – ponad 350 współtwórców.

Założyciele LangChain zdecydowali się na zbiórkę funduszy, aby sprostać rosnącemu zapotrzebowaniu społeczności na rozwój i wsparcie. Zauważyli, że połączenie LangChain z dużymi modelami językowymi otwiera nowe możliwości tworzenia niesamowitych produktów i aplikacji. Jednak zrozumieli również, że potrzebne jest więcej pracy i narzędzi, aby te aplikacje działały dobrze, zwłaszcza w środowisku produkcyjnym.

Z funduszami zebranymi w rundzie finansowania, LangChain planuje zainwestować agresywnie, aby nadążyć za przełomową pracą, którą społeczność wykonuje w budowaniu inteligentnych aplikacji. Celem jest prosty: umożliwić programistom tworzenie użytecznych aplikacji zasilanych przez modele językowe.

Benchmark, który poprowadził rundę finansowania, był pierwszym inwestorem w niektóre z najbardziej znanych oprogramowań open source, takich jak Docker, Confluent, Elastic, Clickhouse i wiele innych. Dzięki temu kapitałowi, LangChain ma zamiar zasilić swoje zasoby, aby wziąć projekt na kolejny poziom.

Do czego to potrzebne?

Oto kilka konkretnych przykładów zastosowań LangChain:

1. Automatyczne podsumowywanie dokumentów: LangChain może być używany do tworzenia aplikacji, która automatycznie podsumowuje długie dokumenty, takie jak artykuły naukowe, raporty biznesowe czy książki. Dzięki temu użytkownicy mogą szybko zrozumieć kluczowe punkty dokumentu bez konieczności czytania go w całości.
2. Interakcja z API: LangChain może być używany do tworzenia aplikacji, które pozwalają modelom językowym na interakcję z API. Na przykład, można stworzyć aplikację, która pozwala modelowi językowemu na wyszukiwanie informacji o pogodzie, wysyłanie wiadomości e-mail, czy zarządzanie danymi w bazie danych.
3. Automatyczne generowanie kodu: LangChain może być używany do tworzenia aplikacji, które automatycznie generują kod na podstawie opisu zadania. Na przykład, użytkownik mógłby opisać, co chce, żeby jego program zrobił, a aplikacja generowałaby odpowiedni kod.
4. Inteligentne asystenty: LangChain może być używany do tworzenia inteligentnych asystentów, które nie tylko odpowiadają na pytania, ale także podejmują działania, pamiętają interakcje i posiadają wiedzę na temat danych użytkownika.
5. Analiza i ekstrakcja informacji ze strukturalnych dokumentów: LangChain może być używany do tworzenia aplikacji, które analizują i ekstrahują informacje ze strukturalnych dokumentów, takich jak faktury, formularze czy umowy.

Powyższe przykłady to tylko niektóre z możliwości LangChain. Dzięki swojej modułowej strukturze i elastyczności, LangChain umożliwia tworzenie wielu różnych aplikacji, które wykorzystują potęgę dużych modeli językowych. LangChain idealnie nadaje się do tworzenia rozwiązań wymagających wielu kroków.

Rozpoczynamy pracę z LangChain

Rozpocznij o utworzenia nowego środowiska i instalacji pakietu langchain:

pip install langchain

LangChain jest frameworkiem, sam w sobie nie jest modelem językowym. Dlatego będziemy musieli go połączyć z przynajmniej jednym takim modelem. Zaczniemy od integracji z OpenAI, dlatego zainstalujemy pakiet:

pip install openai

Tworzymy lub edytujemy plik z kodem naszej aplikacji, do którego dodajemy kod:

from langchain.llms import OpenAI
llm = OpenAI(openai_api_key="OPENAI_API_KEY")

W miejscu OPENAI_API_KEY należy podać kod integracji z OpenAI. Jeśli nie masz klucza, możesz skorzystać z informacji zawartych w innym naszym artykule: Jak uruchomić własny ChatGPT z AutoGPT? w sekcji „Przygotowanie klucza do instalacji AutoGPT” znajdziesz potrzebne informacje.

W kolejnej linijce zadajmy pytanie do OpenAI przy użyciu LangChain:

text = "Jaka będzie najlepsza kolorystyka strony dla firmy zajmującej się sprzedażą zabawek?"
print(llm(text))

W konsoli otrzymamy odpowiedź od OpenAI. Na przykład: Kolorystyka powinna być lekka, kolorowa i przyciągająca uwagę. Dobrym wyborem będą pastelowe odcienie jasnego niebieskiego, różu i zieleni, które zostaną uzupełnione akcentami w mocniejszych kolorach, takich jak żółty lub pomarańczowy. Kolory te będą kojarzyły się z dzieciństwem i zabawą, co będzie dodatkowo wzmacniać przekaz marki.
Nic zaskakującego, prawda? Odpytywanie ChatGPT przez API to żadna sztuka. Zobaczmy zatem dalej, co oferuje LangChain.

Szablony promptów

Zazwyczaj, gdy pracujemy z dużymi modelami językowymi to nie przesyłamy bezpośrednio danych wprowadzonych przez użytkownika do modelu. Zazwyczaj konstruujemy prompty, które zawierają poszczególne informacje wprowadzone przez użytkownika. Do tego służą szablony w LangChain.

from langchain.prompts import PromptTemplate
prompt = PromptTemplate(
    input_variables=["company"],
    template="Jaka będzie najlepsza kolorystyka strony dla firmy zajmującej się: {company}?",
)

Z szablonu propmptu możemy skorzystać w taki sposób:

print(llm(prompt.format(company="sprzedaż zabawek")))
print(llm(prompt.format(company="usługi transportowe")))
print(llm(prompt.format(company="kantor i wymiana walut")))

Przykładowe odpowiedzi:

Najlepszą kolorystyką dla firmy zajmującej się sprzedażą zabawek będzie jasna i żywa kolorystyka, która będzie kojarzyć się z radością i zabawą. Idealnie sprawdzą się kolory takie jak: żółty, niebieski, różowy, zielony, czerwony, a także odcienie pastelowe, aby podkreślić delikatniejszy charakter strony.

Najlepszym rozwiązaniem w tym przypadku będzie wybór kolorystyki, która jest bezpieczna, jasna i przejrzysta. Dobrym wyborem będą głównie stonowane, neutralne barwy, takie jak biel, szarości, granaty oraz odcienie zieleni. Kolory te pozostają bezpieczne i zapewniają profesjonalny wygląd, który będzie przyciągał potencjalnych klientów. Poza tym dobrą opcją będzie dodanie do nich odrobiny żywych kolorów, takich jak żółty, czerwony czy niebieski, aby podkreślić wyjątkowo

Jednym z najlepszych rozwiązań w przypadku firmy zajmującej się kantorem lub wymianą walut będzie zastosowanie odcieni szarości, bieli oraz złota. Te kolory są kojarzone z bezpieczeństwem i profesjonalizmem, dzięki czemu nadają stronie wiarygodności i pomagają w budowaniu zaufania do marki. Dodatkowo, te trzy kolory razem tworzą świetny wygląd, który będzie przyciągał uwagę użytkowników i zapewni im wygodne korzystanie z naszej strony.

Szablony promptów są bazowymi typami z LangChain, ale także nie pokazują magi frameworka. Zatem zagłębmy się bardziej w kolejne elementy.

Łańcuchy

W LangChain, łańcuch (chain) składa się z ogniw (links), które mogą być prymitywami, takimi jak duże modele językowe (LLM), lub innymi łańcuchami.

Najbardziej podstawowym typem łańcucha jest LLMChain, który składa się z PromptTemplate (szablonu promptu) i LLM.

Rozszerzając poprzedni przykład, możemy skonstruować LLMChain, który przyjmuje dane wejściowe od użytkownika, formatuje je za pomocą PromptTemplate, a następnie przekazuje sformatowaną odpowiedź do LLM.

from langchain.llms import OpenAI
llm = OpenAI(openai_api_key="OPENAI_API_KEY")

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType

tools = load_tools(["serpapi", "llm-math"], llm=llm)

agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

agent.run("What is average sales price of 3 rooms flat in Bielsko-Biała? Give me a average price per square meter.")

Pamięć

Praca z dużym modelem językowym była by nieefektywna, gdyby model nie pamiętał historii konwersacji. Do tej pory, przykłady które prezentowaliśmy były bezstanowe (stateless). Czas przygotować łańcuch, który będzie pamiętał naszą rozmowę:

from langchain import ConversationChain

conversation = ConversationChain(llm=llm, verbose=True)

output = conversation.predict(input="Wygeneruj kod html & css z niebieskim przyciskiem z białym napisem: Kliknij tutaj")
print(output)

output = conversation.predict(input="Zmień kolor z niebieskiego na czerwony")
print(output)

W wyniku działania otrzymujemy kod html&css, który po wykonaniu pierwszej funkcji conversation.predict wygeneruje przycisk niebieski z białym napisem. W drugiej komendzie nie nie wspominamy o przycisku, nie dajemy kontekstu zadania, a jednak w odpowiedzi otrzymujemy kod przycisku z kolorem czerwonym zamiast niebieskiego.

> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:
Human: Wygeneruj kod html & css z niebieskim przyciskiem z białym napisem: Kliknij tutaj
AI:  Gotowe! Oto twój kod HTML i CSS:

<style>
  .button {
    background-color: #0000FF;
    color: #FFFFFF;
    padding: 10px;
    border-radius: 5px;
    font-size: 16px;
    font-weight: bold;
    text-align: center;
  }
</style>

<button class="button">Kliknij tutaj</button>
Human: Zmień kolor z niebieskiego na czerwony
AI:

> Finished chain.
 Gotowe! Oto twój nowy kod HTML i CSS:

<style>
  .button {
    background-color: #FF0000;
    color: #FFFFFF;
    padding: 10px;
    border-radius: 5px;
    font-size: 16px;
    font-weight: bold;
    text-align: center;
  }
</style>

<button class="button">Kliknij tutaj</button>

W LangChain mamy możliwość wykorzystania dwóch rodzajów pamięci: short term (krótka) i long term (długa). Temat pamięci w LangChain dokładniej omówimy w kolejnych wpisach na naszym blogu.

Chat

W poprzednim przykładzie wykorzystywaliśmy duży model językowy do generowania predykcji. Wykorzystaliśmy pamięć, aby utrzymać kontekst miedzy kolejnymi predykcjami. Mimo, iż poprzedni przykład wyglądał, jakbyśmy mogli prowadzić konwersację z modelem to LangChain do modelów konwersacyjnych (jak ChatGPT) przygotował inny, bardziej urozmaicony interfejs.

Dla chatu, możemy w LangChain wykorzystać kilka nowych typów „wiadomości” przekazywanych do modelu. Są to: AIMessage, HumanMessage, SystemMessage,ChatMessage.

from langchain.chat_models import ChatOpenAI
from langchain.schema import (
    AIMessage,
    HumanMessage,
    SystemMessage
)
chat = ChatOpenAI(temperature=0,openai_api_key="OPENAI_API_KEY")

messages = [
    SystemMessage(content="Act as a website creator. You have to create a new company website for me. I'm your client. Ask questions to know my expectations and needs."),
    HumanMessage(content="Hi! I need new website")
]
print(chat(messages))

messages2 = [
    SystemMessage(content="Act as a website creator. You have to create a new company website for me. I'm your client. Ask questions to know my expectations and needs."),
    HumanMessage(content="Im small IT company specialised in AI and deep learning. I would like to inform potential customers about offer and encourage them to visit blog and meet our knowledge and experience.")
]

print(chat(messages2))

W przykładzie powyżej, przekazujemy do modelu 2 rodzaje wiadomości: SystemMessage i HumanMessage. Do czego służą?

The system message helps set the behavior of the assistant. In the example above, the assistant was instructed with „You are a helpful assistant.”

„The user messages help instruct the assistant. They can be generated by the end users of an application, or set by a developer as an instruction.

Dokumentacja ChatGPT od OpenAI

W naszym przykładzie poprosiliśmy model, aby zachowywał się jak twórca stron internetowych i zadawał nam pytania, aby poznać nasze oczekiwania wobec nowej strony, którą stworzy.

Agenci z LangChain

Do tej pory wykorzystywaliśmy szablony promptów, łańcuchy lub chat do komunikacji z modelem. Za każdym razem dość sami określaliśmy polecenia i sposób ich wykonania. Do bardziej złożonych przypadków, gdy w zależności od informacji od użytkownika chcemy wykorzystać różne narzędzia służą w LangChain agenci. Agent ma dostęp do różnych narzędzi i agent może zdecydować o ich użyciu. Na przykład, w LangChain mamy standardowe narzędzia takie jak: dostęp do powłoki, dostęp do wyników wyszukiwania w Google / Bing, dostęp do systemu plików, możliwość wykonania requestu i pobrania jakieś zawartości z internetu i wielu innych.

Obecnie w LangChain występują dwa rodzaje agentów:

• Action agent – to rodzaj agentów, którzy decydują jaka akcja ma być podjęta i podejmują tą akcję, jedną na raz
• Plan-and-execute agents – ten rodzaj agentów najpierw opracowuje plan kroków do podjęcia, a następnie wykonuje krok po kroku

Agentów w LangChain również omówimy w osobnym wpisie na blogów bardziej szczegółowo.

Extras: Rozbudowany przykład chatu z pamięcią

Na koniec wprowadzenia do LangChain przygotowaliśmy przykład rozbudowanego chatu. Sami przeanalizujcie, jak działa ten kod i jak możecie wykorzystać LangChain w swoich projektach:

from langchain.prompts import (
    ChatPromptTemplate,
    MessagesPlaceholder,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate
)
from langchain.chains import ConversationChain
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory

prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template("Act as a website creator. You have to create a new company website for me. I'm your client. Ask questions to know my expectations and needs. At the end you need know all information to estimate an budget for website."),
    MessagesPlaceholder(variable_name="history"),
    HumanMessagePromptTemplate.from_template("{input}")
])

llm = ChatOpenAI(temperature=0,openai_api_key="OPENAI_API_KEY")
memory = ConversationBufferMemory(return_messages=True)
conversation = ConversationChain(memory=memory, prompt=prompt, llm=llm)

conversation.predict(input="Hi! I need new website")
# -> ""

conversation.predict(input="Im small IT company specialized in AI and deep learning. I would like to inform potential customers about offer and encourage them to visit blog and meet our knowledge and experience.")
# -> ""

conversation.predict(input="I have a logo. I prefer a dark color, dark navy blue and gradients.")
# -> ""