Kurs Python · Moduł 10: AI i modele językowe

LangChain - łańcuch, który spina wszystko

4 min czytania ·
W tej lekcji5

Umiesz już wywołać model i napisać dobry prompt. Ale prawdziwa aplikacja to coś więcej: pobierz szablon, wyślij do modelu, sparsuj odpowiedź, zapamiętaj rozmowę. LangChain spina te kroki w jedno - a robi to jednym, zaskakująco prostym pomysłem, który poznasz na początku.

pip install langchain langchain-openai langchain-anthropic

Klocek: model

Zacznijmy od najmniejszego klocka - samego modelu. W LangChain każdy dostawca (OpenAI, Anthropic) ma tę samą metodę invoke, więc zmiana modelu to zmiana jednej linii.

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage

llm = ChatOpenAI(model="gpt-5", temperature=0.7)

messages = [
    SystemMessage(content="Jesteś ekspertem od Safari."),
    HumanMessage(content="Opowiedz o słoniach.")
]
print(llm.invoke(messages).content)

Zwróć uwagę na invoke - to wspólne "uruchom" dla wszystkich klocków LangChaina. Za chwilę zobaczysz, że tak samo uruchamia się pojedynczy model, jak i cały złożony łańcuch. Ta jednolitość to fundament biblioteki.

Klocek: szablon promptu

Drugi klocek to szablon z lukami - Twój prompt z poprzedniej lekcji, ale wielokrotnego użytku. Zamiast sklejać napisy, wpisujesz {zmienne}.

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "Jesteś ekspertem od {dziedzina}."),
    ("human", "Opowiedz o {temat}.")
])

Luki {dziedzina} i {temat} wypełnisz dopiero przy uruchomieniu. Dzięki temu jeden szablon obsłuży setki pytań - a jako klocek LangChaina też ma invoke i da się połączyć z modelem. I tu wchodzi główny pomysł całej biblioteki.

Wielki pomysł: operator | (pipe)

Oto serce LangChaina. Klocki łączysz operatorem |, dokładnie jak rurę: wynik jednego wpływa do następnego. prompt | llm | parser czyta się "wypełnij prompt, wyślij do modelu, przerób odpowiedź".

from langchain_core.output_parsers import StrOutputParser

chain = prompt | llm | StrOutputParser()

result = chain.invoke({"dziedzina": "Safari", "temat": "lwy"})
print(result)

To ten sam invoke, co przy pojedynczym modelu - ale teraz uruchamia cały łańcuch naraz. Dane wpływają jako słownik z lukami, przechodzą przez szablon, model i parser, a wypływają jako gotowy tekst. StrOutputParser na końcu wyciąga sam tekst z odpowiedzi, żebyś nie pisał .content. Zapamiętaj ten wzór prompt | llm | parser - to on wraca w każdym kolejnym przykładzie.

Ten sam łańcuch, mocniejszy parser: wynik jako obiekt

Skoro parser to ostatni klocek rury, wystarczy go wymienić, by dostać nie tekst, lecz gotowy obiekt. Opisujesz oczekiwaną strukturę klasą, a LangChain dopilnuje formatu.

from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_core.output_parsers import JsonOutputParser

class AnimalInfo(BaseModel):
    name: str = Field(description="Nazwa zwierzęcia")
    habitat: str = Field(description="Siedlisko")
    population: int = Field(description="Populacja")

parser = JsonOutputParser(pydantic_object=AnimalInfo)

prompt = ChatPromptTemplate.from_messages([
    ("human", "{format_instructions}\n\nZwierzę: {animal}")
])
chain = prompt | llm | parser

result = chain.invoke({
    "animal": "Słoń afrykański",
    "format_instructions": parser.get_format_instructions()
})
print(result)  # {'name': 'Słoń afrykański', 'habitat': ..., 'population': ...}

Wciąż ten sam łańcuch prompt | llm | parser - zmienił się tylko ostatni klocek. Klasa AnimalInfo opisuje pola, jakich oczekujesz, a get_format_instructions wstrzykuje do promptu automatyczną instrukcję "zwróć JSON w tym kształcie". Wynik to od razu słownik Pythona, gotowy do użycia w kodzie - żadnego parsowania ręcznie.

Dokładanie pamięci do łańcucha

Domyślnie model nie pamięta poprzednich wiadomości - każde invoke startuje od zera. Żeby prowadził rozmowę, owijasz łańcuch klockiem zapisującym historię.

from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

history = ChatMessageHistory()

chain_with_history = RunnableWithMessageHistory(
    chain,
    lambda session_id: history,
    input_messages_key="input",
    history_messages_key="history"
)

chain_with_history.invoke(
    {"input": "Jestem na Safari w Kenii"},
    config={"configurable": {"session_id": "abc123"}}
)
response2 = chain_with_history.invoke(
    {"input": "Jakie zwierzęta mogę tu zobaczyć?"},
    config={"configurable": {"session_id": "abc123"}}
)

RunnableWithMessageHistory owija istniejący łańcuch i przy każdej turze dokłada wcześniejsze wiadomości. Dzięki temu w drugim pytaniu model wie, że "tu" znaczy Kenia - choć nie powtórzyłeś tego. session_id rozdziela rozmowy różnych użytkowników, żeby ich historie się nie mieszały.

Pamiętaj z tej lekcji jeden znak: |. LangChain to klocki - prompt, model, parser, pamięć - sklejane w rurę tym samym operatorem i uruchamiane tym samym invoke. Gdy to widzisz, każdy nowy element jest tylko kolejnym klockiem do dorzucenia.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Czym jest LangChain?

  2. 2. Czym jest LCEL (LangChain Expression Language)?

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż import ChatOpenAI z LangChain:

  • Edytor kodu

    Połącz PromptTemplate, LLM i OutputParser używając operatora |.

  • Klikanie w kolejności

    Kliknij w przyciski, aby stworzyć chain LCEL:

  1. PytanieLangChain
  2. Ułóż w kolejnościImport LangChain
  3. Zadanie z kodemLangChain Chain
  4. PytanieLCEL
  5. Kliknij w kolejnościLangChain chain

Przydatne artykuły