Architektura LangChain i podstawowe abstrakcje
Uczestnicy poznają model komponentów LangChain, obejmujący LLM-y, ChatModels, PromptTemplates, OutputParsers i Runnables, oraz dowiedzą się, jak łączyć je w potoki.
Architektura LangChain i podstawowe abstrakcje to bezpłatna lekcja AI Engineering Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Engineering Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Engineering Academy zawiera 4 lekcji w sumie.
Czym właściwie jest LangChain
LangChain to framework do tworzenia aplikacji wykorzystujących modele językowe. Zamiast samodzielnie pisać surowe wywołania API i kod integracyjny, można korzystać z wielokrotnego użytku komponentów LangChain, które łączy się w potoki. Framework obsługuje wielu dostawców LLM (OpenAI, Anthropic, Cohere i modele lokalne) za pośrednictwem ujednoliconego interfejsu, dzięki czemu zmiana dostawcy wymaga minimalnych zmian w kodzie.
Przegląd modelu komponentów
LangChain porządkuje swoje elementy składowe w odrębne kategorie komponentów. LLMs i ChatModels opakowują dostawców modeli. PromptTemplates zarządzają dynamicznym tworzeniem promptów. OutputParsers przekształcają surowy tekst modelu w ustrukturyzowane obiekty języka Python. Runnables to uniwersalny interfejs, który łączy wszystko w kompozycyjne potoki.
LLMs a ChatModels
LangChain rozróżnia dwa interfejsy modeli. LLM przyjmuje prompt w postaci ciągu znaków i zwraca uzupełnienie również jako ciąg znaków — jest to starszy styl uzupełniania tekstu. ChatModel przyjmuje listę wiadomości (systemowych, użytkownika i AI) i zwraca obiekt wiadomości. Nowoczesne modele OpenAI, Anthropic i Gemini to modele ChatModel. W nowych aplikacjach należy preferować ChatModel.
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
llm = ChatOpenAI(model='gpt-4o-mini')
response = llm.invoke([
SystemMessage(content='You are a helpful assistant.'),
HumanMessage(content='What is LangChain?')
])
print(response.content)PromptTemplates: dynamiczne prompty
PromptTemplate umożliwia zdefiniowanie promptu ze zmiennymi zastępczymi, które są uzupełniane w czasie działania programu. ChatPromptTemplate działa tak samo w przypadku promptów w stylu konwersacji, zawierających wiele wiadomości. Szablony oddzielają strukturę promptu od wartości przekazywanych w czasie działania, dzięki czemu prompty można ponownie wykorzystywać, testować i łatwo przechowywać w systemie kontroli wersji.
from langchain_core.prompts import ChatPromptTemplate
template = ChatPromptTemplate.from_messages([
('system', 'You are an expert in {domain}.'),
('human', 'Explain {concept} in simple terms.')
])
# Fill in variables at runtime
messages = template.invoke({'domain': 'machine learning', 'concept': 'embeddings'})
print(messages)OutputParsers: kształtowanie wyników modelu
OutputParsers konwertują surowy tekstowy wynik modelu na ustrukturyzowane typy języka Python. StrOutputParser po prostu wyodrębnia ciąg zawierający treść. JsonOutputParser analizuje JSON. PydanticOutputParser sprawdza zgodność ze schematem Pydantic. Parsery generują również instrukcje dotyczące formatu, które można wstrzyknąć do promptów, aby nakierować model na oczekiwany format.
from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
from pydantic import BaseModel
class MovieReview(BaseModel):
title: str
rating: int
summary: str
parser = JsonOutputParser(pydantic_object=MovieReview)
# parser.get_format_instructions() returns JSON schema instructions
print(parser.get_format_instructions()[:200])Interfejs Runnable
Każdy komponent LangChain implementuje interfejs Runnable, który definiuje trzy kluczowe metody: invoke() do synchronicznych pojedynczych wywołań, stream() do strumieniowego przesyłania tokenów oraz batch() do równoległego przetwarzania wielu danych wejściowych. Ponieważ każdy komponent jest obiektem Runnable, wszystkie można jednolicie łączyć za pomocą operatora potoku.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model='gpt-4o-mini')
# Single call
result = llm.invoke('What is 2+2?')
# Streaming tokens
for chunk in llm.stream('Tell me a joke.'):
print(chunk.content, end='', flush=True)
# Batch processing
results = llm.batch(['What is Paris?', 'What is Rome?'])Tworzenie kompozycji za pomocą operatora potoku
Operator potoku (|) to cukier składniowy służący do tworzenia obiektów RunnableSequence. Gdy zapisuje Pan/Pani prompt | llm | parser, LangChain tworzy łańcuch, w którym wynik każdego kroku trafia jako dane wejściowe do następnego. Stanowi to podstawę LCEL — LangChain Expression Language — i zastępuje starsze, bardziej rozwlekłe klasy łańcuchów.
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_template('Summarize this in one sentence: {text}')
llm = ChatOpenAI(model='gpt-4o-mini')
parser = StrOutputParser()
# Chain composed with pipe operator
chain = prompt | llm | parser
result = chain.invoke({'text': 'LangChain is a framework for LLM applications...'})
print(result)Loadery dokumentów i dzielniki tekstu
W aplikacjach RAG LangChain udostępnia Document Loaders, które odczytują pliki w różnych formatach (PDF, Word, HTML, CSV) i zwracają listę obiektów Document z polami page_content i metadata. Następnie Text Splitters dzielą długie dokumenty na mniejsze fragmenty odpowiednie do tworzenia embeddingów i wyszukiwania.
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
loader = PyPDFLoader('report.pdf')
docs = loader.load() # List of Document objects
splitter = RecursiveCharacterTextSplitter(
chunk_size=500,
chunk_overlap=50
)
chunks = splitter.split_documents(docs)
print(f'Split {len(docs)} pages into {len(chunks)} chunks')Bazy wektorowe jako obiekty Runnable
LangChain opakowuje bazy danych wektorowych (Chroma, Pinecone, pgvector) w obiekty VectorStore, które udostępniają metodę similarity_search(). Każdy VectorStore można przekształcić w obiekt Runnable typu Retriever za pomocą .as_retriever(), dzięki czemu można go łączyć w łańcuchach LCEL. Retriever przyjmuje ciąg zapytania i zwraca k najbardziej trafnych dokumentów.
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)
# Convert to Retriever Runnable
retriever = vectorstore.as_retriever(
search_type='similarity',
search_kwargs={'k': 5}
)
results = retriever.invoke('How does LangChain work?')
for doc in results:
print(doc.page_content[:100])Callbacki i obserwowalność
System callbacków LangChain umożliwia podłączanie własnej obsługi do każdego zdarzenia podczas wykonywania łańcucha: rozpoczęcia działania LLM, strumieniowego przesyłania tokenów, zakończenia łańcucha czy wywołania narzędzia. Wbudowane callbacki obejmują StdOutCallbackHandler do logowania w konsoli. Integracje firm trzecich, takie jak LangSmith, są automatycznie dołączane za pomocą zmiennych środowiskowych i rejestrują pełne ślady wykonania bez zmian w kodzie.
from langchain.callbacks import StdOutCallbackHandler
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model='gpt-4o-mini',
callbacks=[StdOutCallbackHandler()]
)
# Now every call logs input/output automatically
# Or enable LangSmith tracing globally:
import os
os.environ['LANGCHAIN_TRACING_V2'] = 'true'
os.environ['LANGCHAIN_API_KEY'] = 'your-key'Pamięć i stan w łańcuchach
Domyślnie łańcuchy LangChain są bezstanowe — każde wywołanie jest niezależne. Aby dodać pamięć konwersacji, należy opakować łańcuch komponentem pamięci, który przechowuje historię rozmowy i wstrzykuje ją do łańcucha. RunnableWithMessageHistory to natywny dla LCEL sposób dodawania pamięci; przyjmuje funkcję get_session_history, która ładuje historię na podstawie identyfikatora sesji.
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import ChatMessageHistory
store = {} # session_id -> ChatMessageHistory
def get_session_history(session_id: str):
if session_id not in store:
store[session_id] = ChatMessageHistory()
return store[session_id]
with_history = RunnableWithMessageHistory(chain, get_session_history)
response = with_history.invoke(
{'input': 'Hi, my name is Alice'},
config={'configurable': {'session_id': 'user-1'}}
)Szybki sprawdzian
Sprawdź swoją wiedzę na temat architektury LangChain i podstawowych abstrakcji.
Podsumowanie lekcji
W tej lekcji poznał Pan/Pani: model komponentów LangChain, który organizuje LLM-y, PromptTemplates, OutputParsers i Retrievers jako obiekty Runnable ze zunifikowanym interfejsem; operator potoku (|), który za pomocą LCEL łączy obiekty Runnable w sekwencyjne łańcuchy; oraz callbacki, które zapewniają obserwowalność każdego kroku bez zmiany logiki biznesowej. W następnej części szczegółowo omówimy tworzenie łańcuchów za pomocą LCEL.
Często zadawane pytania
Czy lekcja „Architektura LangChain i podstawowe abstrakcje” jest bezpłatna?
Tak — pełny tekst „Architektura LangChain i podstawowe abstrakcje” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Engineering Academy, przejdź na CoddyKit PRO. Kurs AI Engineering Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Architektura LangChain i podstawowe abstrakcje”?
Uczestnicy poznają model komponentów LangChain, obejmujący LLM-y, ChatModels, PromptTemplates, OutputParsers i Runnables, oraz dowiedzą się, jak łączyć je w potoki. Ćwiczysz AI Engineering Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć AI Engineering Academy?
Nie wymagamy żadnego doświadczenia. AI Engineering Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Architektura LangChain i podstawowe abstrakcje”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji AI Engineering Academy?
Tak. Każda lekcja AI Engineering Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Architektura LangChain i podstawowe abstrakcje
- Tworzenie łańcuchów za pomocą LCEL
- Rozgałęzianie i równoległe łańcuchy
- Strumieniowanie danych wyjściowych w LangChain