Powrot do bloga
11 sierpnia 2026
published

LangChain od zera - jak zacząć budować aplikacje AI w Pythonie

Masz klucz API do GPT-4 albo Claude, odpaliłeś swoje pierwsze zapytanie przez requests i pomyślałeś: „Ok, fajnie. Ale jak z tego zrobić coś użytecznego?"....

Okladka: LangChain od zera - jak zacząć budować aplikacje AI w Pythonie

Masz klucz API do GPT-4 albo Claude, odpaliłeś swoje pierwsze zapytanie przez requests i pomyślałeś: „Ok, fajnie. Ale jak z tego zrobić coś użytecznego?". Dokładnie w tym miejscu byłem rok temu. I dokładnie w tym miejscu zaczyna się LangChain.

W tym artykule przejdę z Tobą od „co to w ogóle jest" do działającego kodu - z konkretnymi przykładami i moją opinią, kiedy LangChain się opłaca, a kiedy lepiej odpuścić.

Czytanie: ~15 min

Po co komu framework do rozmowy z AI

Proste zapytanie do API modelu językowego to kilka linijek kodu. Wysyłasz prompt, dostajesz odpowiedź. Ale w momencie, kiedy chcesz zbudować coś bardziej złożonego - na przykład aplikację, która czyta dokumenty firmowe i odpowiada na pytania o ich treść - zaczyna się problem.

Musisz zarządzić kontekstem rozmowy. Musisz podzielić duży dokument na fragmenty, które model ogarnie. Musisz gdzieś te fragmenty zapisać, żeby szybko je wyszukiwać. Musisz obsłużyć sytuację, kiedy model nie zna odpowiedzi i powinien sięgnąć po zewnętrzne narzędzie.

Nagle Twoje „kilka linijek kodu" rozrasta się do setek linii boilerplate'u. I każdy, kto buduje aplikację AI, pisze mniej więcej ten sam kod.

LangChain to framework w Pythonie (jest też wersja w TypeScript), który daje Ci gotowe klocki do budowania takich aplikacji. Zamiast pisać od zera logikę łączenia promptów, pamięci, wyszukiwania dokumentów i narzędzi - składasz to z komponentów.

Co LangChain robi pod spodem

LangChain nie jest modelem AI. To warstwa pośrednia między Twoim kodem a modelem. Coś jak Django dla web developmentu albo Entity Framework dla baz danych. Sam nie generuje tekstu - organizuje przepływ danych.

Wyobraź sobie taką sytuację: użytkownik zadaje pytanie o fakturę z marca. Twoja aplikacja musi:

  1. Wziąć pytanie użytkownika
  2. Przeszukać bazę dokumentów i znaleźć odpowiednią fakturę
  3. Wyciągnąć z niej istotne fragmenty
  4. Dodać je do prompta jako kontekst
  5. Wysłać to do modelu
  6. Zwrócić odpowiedź użytkownikowi

Każdy z tych kroków to osobny komponent w LangChain. Możesz je łączyć, zamieniać, konfigurować. Chcesz zmienić model z GPT-4 na Claude? Zmieniasz jedną linijkę. Chcesz zamienić bazę wektorową z Chroma na Pinecone? Też jedna zmiana.

Ta modularność jest główną siłą LangChain. I jednocześnie - jak się za chwilę przekonasz - źródłem największej krytyki.

Instalacja i pierwszy chain w 10 minut

Zanim wejdziemy głębiej, postawmy coś działającego. Potrzebujesz Pythona 3.9+ i klucza API do dowolnego modelu (OpenAI, Anthropic, cokolwiek).

pip install langchain langchain-openai

Najprostszy chain - pytanie do modelu z formatowanym promptem:

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

# Konfiguracja modelu
model = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

# Szablon prompta
prompt = ChatPromptTemplate.from_messages([
    ("system", "Jesteś ekspertem od {temat}. Odpowiadaj po polsku, zwięźle."),
    ("human", "{pytanie}")
])

# Łączenie w chain (operator | to pipe)
chain = prompt | model

# Uruchomienie
odpowiedz = chain.invoke({
    "temat": "finansów",
    "pytanie": "Jak prawidłowo zaksięgować leasing operacyjny?"
})

print(odpowiedz.content)

Operator | (pipe) to serce nowego API LangChain, które nazywa się LCEL (LangChain Expression Language). Działa jak pipe w bashu - wyjście jednego komponentu wchodzi jako wejście do następnego.

To prosty przykład, ale pokazuje wzorzec. Prompt przyjmuje zmienne, formatuje się, idzie do modelu. Każdy element tego łańcucha (chain - stąd nazwa) możesz wymienić na inny.

Cztery filary, na których stoi LangChain

Framework ma kilka głównych koncepcji. Nie musisz znać wszystkich od razu, ale warto wiedzieć, co jest do dyspozycji.

Prompty i szablony

Zarządzanie promptami to podstawa. Zamiast sklejać stringi ręcznie, definiujesz szablony z placeholderami. LangChain pilnuje formatowania, walidacji zmiennych i obsługi różnych typów wiadomości (system, user, assistant).

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "Analizuj dane finansowe. Format: {format}"),
    ("human", "Dane: {dane}\n\nPytanie: {pytanie}")
])

Brzmi banalnie, ale przy złożonych promptach z wieloma zmiennymi, few-shot examples i dynamicznym kontekstem - porządek w szablonach ratuje życie.

Pamięć (Memory)

Modele językowe nie pamiętają poprzednich rozmów. Każde zapytanie to nowa, czysta karta. LangChain daje kilka mechanizmów pamięci:

  • ConversationBufferMemory - przechowuje całą historię rozmowy. Proste, ale szybko zjada okno kontekstowe
  • ConversationSummaryMemory - model sam streszcza wcześniejszą rozmowę. Wolniejsze, ale oszczędza tokeny
  • ConversationBufferWindowMemory - pamięta ostatnie N wymian. Kompromis między dwoma powyższymi

W praktyce pamięć to po prostu mechanizm dopisywania poprzednich wiadomości do nowego prompta. Nic magicznego, ale fajnie mieć to obsłużone jedną linijką zamiast ręcznego zarządzania listą wiadomości.

RAG - Twoje dane plus model AI

RAG (Retrieval Augmented Generation) to wzorzec, który moim zdaniem ma największą wartość praktyczną w LangChain. Idea jest prosta: zamiast liczyć na to, że model „wie" odpowiedź z treningu, podajesz mu Twoje dokumenty jako kontekst.

Jak to działa krok po kroku:

  1. Bierzesz dokumenty (PDFy, strony www, pliki Markdown, cokolwiek)
  2. Dzielisz je na mniejsze fragmenty (chunks)
  3. Zamieniasz fragmenty na wektory (embeddings) - liczbowe reprezentacje treści
  4. Zapisujesz wektory w bazie wektorowej
  5. Kiedy przychodzi pytanie - wyszukujesz najbardziej powiązane fragmenty
  6. Dodajesz je do prompta i wysyłasz do modelu
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

# 1. Załaduj dokument
loader = PyPDFLoader("regulamin-firmy.pdf")
dokumenty = loader.load()

# 2. Podziel na fragmenty
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,   # znaków na fragment
    chunk_overlap=200  # nakładanie się fragmentów
)
fragmenty = splitter.split_documents(dokumenty)

# 3-4. Zamień na wektory i zapisz
baza = Chroma.from_documents(
    documents=fragmenty,
    embedding=OpenAIEmbeddings()
)

# 5-6. Wyszukaj i odpowiedz
retriever = baza.as_retriever(search_kwargs={"k": 4})

prompt = ChatPromptTemplate.from_messages([
    ("system", "Odpowiadaj na pytania na podstawie kontekstu. "
               "Jeśli nie wiesz - powiedz wprost."),
    ("human", "Kontekst: {kontekst}\n\nPytanie: {pytanie}")
])

model = ChatOpenAI(model="gpt-4o-mini")

Mój pierwszy RAG zbudowałem na regulaminie firmy - załadowałem 40-stronicowy PDF i po kilku minutach miałem chatbota, który odpowiadał na pytania pracowników o zasady urlopowe, delegacje, procedury. Oczywiście z zastrzeżeniem, że trzeba weryfikować odpowiedzi. Ale sam fakt, że gruby dokument nagle stał się przeszukiwalny w języku naturalnym - robi wrażenie.

Agenty - kiedy model sam decyduje, co robić

Agent to najtrudniejszy koncept w LangChain, ale i najbardziej potężny. W zwykłym chainie Ty definiujesz kolejność kroków. Agent dostaje zestaw narzędzi i sam decyduje, których użyć.

Załóżmy, że dajesz agentowi dostęp do kalkulatora, wyszukiwarki Google i bazy SQL. Użytkownik pyta: „Jaki był nasz przychód w Q1 i jak się ma do średniej branżowej?". Agent odpala zapytanie SQL po przychód, szuka w Google średniej branżowej, używa kalkulatora do porównania i formułuje odpowiedź.

Brzmi jak science fiction? Trochę tak, ale to działa. Nie zawsze idealnie - agenty potrafią się zapętlić, wybrać złe narzędzie albo wymyślić dane. Ale w kontrolowanych scenariuszach z dobrze zdefiniowanymi narzędziami dają spore możliwości.

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.tools import tool

@tool
def oblicz_marze(przychod: float, koszt: float) -> str:
    """Oblicza marżę procentową na podstawie przychodu i kosztu."""
    marza = ((przychod - koszt) / przychod) * 100
    return f"Marża wynosi {marza:.1f}%"

model = ChatOpenAI(model="gpt-4o")
narzedzia = [oblicz_marze]

agent = create_tool_calling_agent(model, narzedzia, prompt)
executor = AgentExecutor(agent=agent, tools=narzedzia)

wynik = executor.invoke({
    "input": "Oblicz marżę jeśli przychód 150000 a koszt 95000"
})

Kiedy LangChain ma sens, a kiedy to przerost formy

I tu dochodzimy do sedna, bo LangChain zbiera sporo krytyki. I część z niej jest uzasadniona.

Kiedy warto sięgnąć po LangChain:

  • Budujesz RAG na swoich dokumentach. LangChain ma dziesiątki loaderów do różnych formatów i integracje z popularnymi bazami wektorowymi
  • Potrzebujesz agenta z narzędziami. Framework obsługuje logikę decyzyjną za Ciebie
  • Chcesz szybko przetestować pomysł. Prototyp w LangChain postawisz szybciej niż pisząc od zera
  • Planujesz zmieniać modele. Abstrakcja nad API różnych providerów oszczędza refaktoringu

Kiedy lepiej odpuścić:

  • Proste zapytanie do API. Jeśli wysyłasz prompt i czekasz na odpowiedź, LangChain to overkill. Wystarczy SDK od OpenAI albo Anthropic
  • Potrzebujesz pełnej kontroli. Abstrakcje LangChain czasem ukrywają, co się dzieje pod spodem. Przy debugowaniu potrafi to frustrować
  • Zależy Ci na stabilności API. LangChain zmienia się szybko. Między wersjami 0.1 i 0.2 sporo rzeczy się zmieniło i migracja bywała bolesna
  • Mały projekt. Dodawanie frameworka do prostego skryptu to jak strzelanie z armaty do muchy

Sam wpadłem w pułapkę „muszę użyć LangChain, bo wszyscy używają". Przy jednym projekcie dla klienta zainstalowałem go, napisałem 200 linii kodu, a potem zdałem sobie sprawę, że mógłbym to samo osiągnąć w 40 liniach czystego Pythona z SDK Anthropic. Przepisałem i było czytelniej, szybciej i łatwiej do debugowania.

Ale przy innym projekcie - RAG na kilkuset dokumentach PDF z integracją do bazy wektorowej i pamięcią rozmowy - LangChain zaoszczędził mi pewnie dwa dni pracy. Wszystko zależy od skali i złożoności.

LangGraph - gdy chain to za mało

LangChain ma młodszego brata, który w ostatnich miesiącach przejął sporo uwagi: LangGraph. Różnica jest taka, że LangChain myśli w kategoriach łańcuchów (chain - jeden krok po drugim), a LangGraph pozwala budować grafy - przepływy z rozgałęzieniami, pętlami i warunkami.

Praktyczny przykład: agent do obsługi klienta, który na start klasyfikuje temat zgłoszenia. Jeśli reklamacja - sprawdza status zamówienia w bazie. Jeśli pytanie techniczne - szuka w dokumentacji. Jeśli żadne z powyższych - przekazuje do człowieka. Na każdym etapie może wrócić i dopytać.

Takiego przepływu z rozgałęzieniami i pętlami nie ogarniesz łatwo w zwykłym chainie. LangGraph daje Ci kontrolę nad stanem (state machine) i pozwala definiować warunki przejścia między krokami.

Jeśli dopiero zaczynasz - nie musisz od razu wskakiwać w LangGraph. Zacznij od LangChain, zrozum podstawy, a kiedy poczujesz ograniczenia chainów - LangGraph będzie naturalnym następnym krokiem.

LangSmith - bo debugowanie agentów to koszmar

Trzeci element układanki to LangSmith - platforma do monitorowania, debugowania i testowania aplikacji LLM. I muszę przyznać, że ten element ekosystemu doceniłem najbardziej.

Debugowanie aplikacji AI jest trudne. Model zwrócił złą odpowiedź - dlaczego? Może prompt był zły. Może kontekst z RAG nie trafił. Może model „hallucynował". Bez narzędzia do śledzenia tych kroków siedzisz i zgadujesz.

LangSmith loguje każdy krok w chainie - jaki prompt poszedł do modelu, co model zwrócił, ile tokenów zużyłeś, ile czasu zajął każdy krok. Widzisz dokładnie, gdzie coś poszło nie tak.

Darmowy tier wystarcza do nauki i prototypów (5000 trace'ów miesięcznie). Przy produkcji wchodzą plany płatne, ale do testów jest w zupełności wystarczający.

Jak zacząć - moja rekomendacja ścieżki

Jeśli dotarłeś do tego miejsca i zastanawiasz się, od czego konkretnie zacząć:

  1. Zainstaluj LangChain i odpal prosty chain - ten przykład z początku artykułu. Upewnij się, że działa, pobaw się promptami
  2. Zbuduj mini-RAG - weź jakiś PDF (regulamin, instrukcja, dokumentacja) i zrób przeszukiwalnego chatbota. To najszybszy sposób na zobaczenie realnej wartości
  3. Dodaj pamięć - rozszerz chatbota o historię konwersacji, żeby pamiętał kontekst rozmowy
  4. Pobaw się agentem - daj modelowi jedno proste narzędzie (kalkulator, wyszukiwarka) i zobacz, jak podejmuje decyzje
  5. Podłącz LangSmith - zacznij śledzić, co się dzieje w Twoich chainach

Nie próbuj ogarnąć wszystkiego naraz. LangChain ma ogromne API i setki integracji. Nikt nie zna ich wszystkich. Zacznij od problemu, który chcesz rozwiązać, i dobieraj narzędzia.

Alternatywy, o których warto wiedzieć

LangChain to nie jedyny framework do budowania aplikacji AI. Kilka alternatyw, z którymi miałem do czynienia:

  • LlamaIndex - mocniejszy w RAG, prostszy API, mniej elastyczny w agentach. Jeśli budujesz wyłącznie przeszukiwarkę dokumentów, może być lepszym wyborem
  • Haystack - framework od deepset, dobra dokumentacja, mniejsza społeczność. Solidna opcja, jeśli LangChain Cię irytuje
  • Czysty SDK (OpenAI, Anthropic) - bez frameworka, pełna kontrola, więcej kodu do napisania. Mój wybór przy prostszych projektach
  • Semantic Kernel (Microsoft) - jeśli siedzisz w .NET i Azure, naturalny wybór. Ja przy projektach w C# sięgam właśnie po niego zamiast LangChain

Osobiście używam LangChain do prototypów i RAG, a przy produkcyjnych aplikacjach coraz częściej sięgam po czysty SDK z własną warstwą abstrakcji. Ale to kwestia preferencji i skali.

Zamiast zakończenia

LangChain to solidne narzędzie, które rozwiązuje realny problem - budowanie aplikacji AI to więcej niż jedno zapytanie do API. Framework daje Ci klocki: prompty, pamięć, RAG, agenty. Składasz z nich to, czego potrzebujesz.

Nie jest idealny. API zmienia się szybko, abstrakcje bywają za grube, krzywa uczenia jest stroma. Ale jeśli chcesz zbudować coś więcej niż chatbota w konsoli i nie chcesz pisać całej infrastruktury od zera - LangChain daje Ci solidny punkt startu.

Zacznij od prostego chaina, zbuduj RAG na jednym dokumencie i zobacz, czy Ci się podoba. Najgorsze co może się stać to to, że nauczysz się, jak działają aplikacje AI od środka. A to wiedza, która procentuje niezależnie od frameworka.

Jeśli chcesz dostawać więcej takich artykułów - wpadaj na mój newsletter. Piszę o AI, automatyzacji i budowaniu narzędzi, które realnie pomagają w pracy.