LangChain - czym jest i do czego służy

Co to jest LangChain?

LangChain to otwartoźródłowy framework do budowy aplikacji i agentów AI opartych na dużych modelach językowych (LLM). Łączy model z narzędziami, danymi i pamięcią. Dzięki temu aplikacja nie kończy na wygenerowaniu tekstu: potrafi przeszukać firmowe dokumenty, wywołać API, zapisać wynik w bazie i przejść przez kilka kroków, zanim odpowie.

Framework działa w Pythonie oraz w JavaScripcie i TypeScripcie. Kod jest udostępniony na licencji MIT, więc korzystasz z niego bezpłatnie, także w projektach komercyjnych. Płacisz za modele, z których korzysta Twoja aplikacja, i ewentualnie za narzędzia towarzyszące, takie jak LangSmith.

LangChain wystartował w październiku 2022 roku jako projekt open source Harrisona Chase’a. Dziś rozwija go firma LangChain Inc., która w październiku 2025 roku pozyskała 125 mln USD przy wycenie 1,25 mld USD. Repozytorium w Pythonie ma na GitHubie ok. 148 tys. gwiazdek.

Najważniejszą zmianą ostatnich lat była wersja 1.0 z 22 października 2025 roku. Framework przestawił się wtedy z łańcuchów na agentów, a zespół zobowiązał się, że do wersji 2.0 nie wprowadzi zmian łamiących zgodność ze starszym kodem. Aktualna linia to LangChain 1.4 (wydanie 1.4.6 z 14 października 2026 roku).

Informacje w tym artykule opisują stan na 18 października 2026 roku.

Jak działa LangChain?

Dokumentacja LangChain opisuje agenta prostym wzorem: agent = model + harness. Harness to wszystko, co otacza model i nadaje mu sposób działania:

prompt systemowy, który określa rolę i zasady pracy modelu,
narzędzia (tools), czyli funkcje, po które model może sięgnąć,
middleware, czyli warstwa modyfikująca zachowanie agenta między kolejnymi krokami.

Sama praca agenta to pętla. Model dostaje zapytanie użytkownika i ocenia, czy potrzebuje narzędzia. Jeśli tak, wywołuje je, czyta wynik i decyduje, co dalej: sięga po kolejne narzędzie albo formułuje odpowiedź. Pętla powtarza się, dopóki zadanie nie zostanie rozwiązane albo agent nie dojdzie do ustawionego limitu kroków.

Pod spodem agent działa na LangGraph, niskopoziomowym silniku od tego samego zespołu. To dzięki niemu agent zapisuje stan rozmowy, strumieniuje odpowiedzi i potrafi wstrzymać pracę, żeby poczekać na decyzję człowieka.

We wcześniejszych wersjach frameworka centralnym pojęciem były łańcuchy (chains), czyli sztywne sekwencje: szablon promptu, wywołanie modelu, parser wyniku. Od wersji 1.0 klasy takie jak LLMChain czy ConversationChain przeniesiono do osobnego pakietu langchain-classic, który zapewnia zgodność ze starym kodem. Nowe projekty buduje się na funkcji create_agent, a ściśle zaplanowane, deterministyczne przepływy bezpośrednio w LangGraph.

Bądź na bieżąco z AI

Zapisz się na newsletter i otrzymuj najnowsze poradniki, recenzje narzędzi AI i rankingi prosto na swoją skrzynkę.

Bez spamu. Wypisz się w dowolnym momencie.

Jakie są podstawowe komponenty LangChain?

LangChain składa się z kilku elementów, z których budujesz działającą aplikację.

Modele to warstwa dostępu do LLM. Wszystkie mają jednolity interfejs, więc model wskazujesz nazwą (np. openai:gpt-5.5), a podmiana dostawcy nie wymaga przepisywania reszty kodu. Od wersji 1.1 każdy model ma też profil z opisem swoich możliwości, np. wielkości okna kontekstu czy obsługi ustrukturyzowanych odpowiedzi.

Narzędzia (tools) to zwykłe funkcje udostępnione modelowi: wyszukiwarka, kalkulator, zapytanie do bazy danych czy wywołanie firmowego API. Model sam decyduje, kiedy po nie sięgnąć, a opis funkcji podpowiada mu, do czego służy.

Middleware pozwala wpiąć się w działanie agenta pomiędzy jego krokami. Gotowe moduły obsługują m.in.:

streszczanie starszej części rozmowy, gdy kontekst robi się za długi,
zatwierdzanie wybranych działań przez człowieka (human-in-the-loop),
limity wywołań modelu i narzędzi, które chronią przed pętlami i nadmiernymi kosztami,
ponawianie nieudanych wywołań i przełączanie na model zapasowy,
wykrywanie i maskowanie danych osobowych.

Pamięć przechowuje kontekst. Pamięć krótkoterminowa trzyma historię jednego wątku rozmowy, a długoterminowa to, co ma przetrwać między sesjami, np. preferencje użytkownika.

Retrieval odpowiada za pobieranie informacji z zewnętrznych źródeł. To fundament techniki RAG (Retrieval-Augmented Generation), która wzbogaca odpowiedzi o treść firmowych dokumentów.

Ustrukturyzowane odpowiedzi (parametr response_format) wymuszają na modelu wynik w zadanym schemacie, np. klasie Pydantic. Zamiast parsować tekst, dostajesz sprawdzony obiekt z konkretnymi polami.

MCP jest od wersji 1.4 (wrzesień 2026) wbudowany w sam framework, w module langchain.mcp. Narzędzia z dowolnego serwera MCP podpinasz do agenta jak każde inne. Moduł ma na razie status beta.

Z tych elementów składasz typowe rozwiązania:

podsumowywanie dokumentów,
systemy pytań i odpowiedzi oparte na firmowej wiedzy,
wyciąganie danych z tekstu (faktur, umów, maili),
klasyfikację i analizę sentymentu,
generowanie treści,
agentów, którzy wykonują zadania w innych systemach.

Ta modułowość jest głównym powodem, dla którego programiści wybierają LangChain: elementy łączysz w dowolnej konfiguracji i wymieniasz pojedynczo, zamiast dostosowywać się do jednego sztywnego schematu.

Jak zainstalować LangChain i co jest potrzebne do startu?

Do pracy z LangChain w Pythonie potrzebujesz Pythona w wersji 3.10 lub nowszej. Na nowy projekt wybierz jednak nowszą wersję, bo Python 3.10 w październiku 2026 roku kończy okres wsparcia. Framework instalujesz przez pip albo uv:

pip install -U langchain

Integracje z dostawcami modeli są w osobnych pakietach. Dla OpenAI i Anthropic wygląda to tak:

pip install -U langchain-openai langchain-anthropic

Jeśli chcesz podpinać serwery MCP, doinstaluj dodatek:

pip install -U "langchain[mcp]"

W JavaScripcie i TypeScripcie potrzebujesz Node.js w wersji 22 lub nowszej, a pakiety instalujesz przez npm:

npm install langchain @langchain/core @langchain/openai

Poza samą biblioteką potrzebujesz klucza API do przynajmniej jednego modelu językowego, zapisanego w zmiennej środowiskowej (np. OPENAI_API_KEY albo ANTHROPIC_API_KEY). Modele open source możesz też uruchamiać lokalnie przez Ollamę i wtedy klucz nie jest potrzebny. Jeśli planujesz system oparty na RAG, dojdzie do tego baza wektorowa przechowująca embeddingi, np. Chroma, Pinecone, Qdrant albo PostgreSQL z rozszerzeniem pgvector.

Jak używać LangChain w praktyce?

Punktem wyjścia jest funkcja create_agent, w której wskazujesz model, narzędzia i prompt systemowy:

from langchain.agents import create_agent

def get_weather(city: str) -> str:
    """Sprawdza pogodę w podanym mieście."""
    return f"Pogoda w mieście {city}: słonecznie, 22°C."

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[get_weather],
    system_prompt="Jesteś pomocnym asystentem",
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Jaka pogoda jest w Warszawie?"}]}
)
print(result["messages"][-1].content)

Model dostaje pytanie, rozpoznaje, że potrzebuje narzędzia, wywołuje je i buduje odpowiedź na podstawie wyniku. Logika decyzyjna leży po stronie modelu, a Twoim zadaniem jest dostarczyć mu właściwe narzędzia i kontekst. Opis funkcji (docstring) nie jest ozdobnikiem: to z niego model dowiaduje się, kiedy po nią sięgnąć.

Model wskazujesz nazwą, więc zmiana dostawcy sprowadza się do zmiany jednego ciągu znaków. Ten sam agent zadziała na modelach OpenAI, Anthropic (np. Claude) czy Google, co pozwala porównywać jakość i koszty bez przepisywania aplikacji.

Jeśli wynik ma trafić dalej do systemu, a nie do człowieka, dodaj parametr response_format ze schematem odpowiedzi. Agent zwróci wtedy obiekt z polami, które zdefiniujesz, zamiast swobodnego tekstu.

Na początek najlepiej sprawdza się prosty agent z jednym narzędziem. Dopiero gdy zrozumiesz, jak przebiega pętla decyzyjna, warto dokładać middleware, pamięć i retrieval. Każdą zmianę sprawdzaj na tym samym zestawie pytań testowych, bo tylko wtedy widać, czy faktycznie poprawia jakość odpowiedzi.

Jakie są zastosowania LangChain?

LangChain sprawdza się wszędzie tam, gdzie model językowy ma pracować na Twoich danych albo w Twoich systemach, a nie tylko rozmawiać. Najczęstsze zastosowania to:

chatboty i asystenci, którzy prowadzą rozmowę i pamiętają jej kontekst,
wyszukiwanie w firmowej wiedzy (RAG), czyli odpowiedzi oparte na dokumentacji, regulaminach czy historii zgłoszeń, a nie na ogólnej wiedzy modelu,
agenci wykonujący zadania, którzy sprawdzają status zamówienia, zakładają zgłoszenie albo aktualizują rekord w CRM,
przetwarzanie dokumentów: streszczenia, porównania wersji, wyciąganie danych z umów i faktur,
generowanie treści: opisy produktów, szkice maili, odpowiedzi na zapytania klientów,
agenci badawczy, którzy przeszukują wiele źródeł i składają z nich raport.

Firmy i programiści uruchamiają takie aplikacje w chmurze albo lokalnie, także na modelach open source. Wybór modelu nie zamyka drogi: aplikację zbudowaną na jednym dostawcy przenosisz do innego zmianą konfiguracji.

Jak stworzyć chatbota za pomocą LangChain?

Chatbot w LangChain to agent z pamięcią rozmowy. Poza modelem i promptem systemowym potrzebujesz checkpointera, który zapisuje stan konwersacji:

from langchain.agents import create_agent
from langgraph.checkpoint.memory import InMemorySaver

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[],
    system_prompt="Jesteś asystentem obsługi klienta",
    checkpointer=InMemorySaver(),
)

config = {"configurable": {"thread_id": "1"}}
agent.invoke({"messages": [{"role": "user", "content": "Cześć, mam na imię Ola."}]}, config)
result = agent.invoke({"messages": [{"role": "user", "content": "Jak mam na imię?"}]}, config)
print(result["messages"][-1].content)

Parametr thread_id oddziela rozmowy od siebie, więc jeden agent obsłuży wielu użytkowników bez mieszania kontekstów. InMemorySaver trzyma stan w pamięci i nadaje się do testów. Na produkcji podmieniasz go na checkpointer zapisujący stan w bazie danych, np. PostgresSaver z pakietu langgraph-checkpoint-postgres.

Długie rozmowy z czasem przestają się mieścić w oknie kontekstu i coraz więcej kosztują. Wtedy przydaje się middleware do streszczania, które zastępuje starsze wiadomości krótkim podsumowaniem, a najnowsze zostawia bez zmian.

Jeśli chatbot ma odpowiadać na pytania o Twoje produkty czy procedury, dodaj RAG. Odpowiedzi powstają wtedy na podstawie firmowej dokumentacji, co wyraźnie podnosi ich trafność.

Jakie są zalety i wady LangChain?

LangChain zyskał popularność dzięki modułowości i elastyczności. Najważniejsze zalety to:

niezależność od dostawcy: ten sam kod działa z modelami OpenAI, Anthropic, Google, z Amazon Bedrock czy z modelami lokalnymi,
duży ekosystem: setki integracji z modelami, bazami wektorowymi, źródłami danych i narzędziami,
gotowe mechanizmy produkcyjne: zapisywania stanu, zatwierdzania przez człowieka, limitów i ponowień nie piszesz od zera,
stabilne API od wersji 1.0: zespół obiecał, że do wersji 2.0 nie będzie zmian łamiących zgodność,
licencja MIT i duża społeczność, więc odpowiedzi na typowe problemy łatwo znaleźć.

Korzystanie z LangChain wiąże się też z kilkoma trudnościami:

krzywa uczenia się: trzy warstwy (Deep Agents, LangChain, LangGraph) i własne pojęcia, które trzeba poznać,
narzut przy prostych zadaniach: pojedyncze wywołanie modelu nie potrzebuje frameworka, wystarczy SDK dostawcy,
nieaktualne poradniki: duża część materiałów w sieci opisuje API sprzed wersji 1.0, które nie działa już w głównym pakiecie,
szybkie zmiany w ekosystemie: sam LangChain jest stabilny, ale pakiety wokół niego, np. deepagents w wersjach 0.x, wciąż wprowadzają zmiany łamiące zgodność,
płatne narzędzia produkcyjne: monitoring i wdrożenia w LangSmith na większą skalę wymagają płatnego planu.

W skrócie, LangChain daje dużą elastyczność i bardzo szeroki wybór integracji, ale wymaga czasu na naukę. Najwięcej zyskasz przy aplikacjach z wieloma narzędziami, pamięcią i wymaganiami produkcyjnymi.

Jakie błędy mogą wystąpić podczas korzystania z LangChain?

Podczas pracy z LangChain najczęściej trafisz na kilka powtarzalnych problemów:

brak klucza API: model nie wystartuje, jeśli zmienna środowiskowa (np. OPENAI_API_KEY) nie jest ustawiona w środowisku, z którego uruchamiasz kod,
błędy importu w starym kodzie: przykłady sprzed wersji 1.0 (LLMChain, dawne retrievery) wymagają pakietu langchain-classic albo przepisania na create_agent,
niezgodne wersje pakietów: langchain, langchain-core i pakiety dostawców aktualizuj razem, bo rozjazd wersji kończy się błędami przy imporcie albo w trakcie działania,
stary sposób podpinania MCP: od wersji 1.4 MCPAdapter z modułu langchain.mcp zastępuje MultiServerMCPClient z osobnego pakietu langchain-mcp-adapters, więc starsze przykłady trzeba przepisać,
wyjątki w narzędziach: błąd rzucony przez narzędzie potrafi przerwać cały przebieg, a middleware do obsługi błędów zamienia go na komunikat, który model widzi i na który może zareagować,
problemy z parsowaniem odpowiedzi: zamiast wyciągać JSON z tekstu, użyj response_format.

Agenci potrafią też zachowywać się nieprzewidywalnie, np. wpadać w pętle i wywoływać w kółko to samo narzędzie. Chronią przed tym limity wywołań modelu i narzędzi (ModelCallLimitMiddleware, ToolCallLimitMiddleware) oraz limit kroków w LangGraph. Żeby znaleźć przyczynę takiego zachowania, potrzebujesz podglądu każdego kroku agenta, a ten daje LangSmith.

Jak LangChain wspiera automatyzację procesów?

LangChain pozwala budować agentów, którzy nie tylko odpowiadają na pytania, ale wykonują pracę w innych systemach: pobierają dane, podejmują decyzje według zasad opisanych w prompcie i zapisują wynik tam, gdzie trzeba. Ich narzędziami mogą być:

wyszukiwarki internetowe,
firmowe API (CRM, system zgłoszeń, sklep),
bazy danych,
serwery MCP udostępniające gotowe zestawy funkcji.

W automatyzacji procesów biznesowych liczy się kontrola. Dlatego ważnym elementem jest middleware human-in-the-loop: agent przygotowuje działanie, np. zwrot pieniędzy albo mail do klienta, i czeka, aż człowiek je zatwierdzi, poprawi albo odrzuci. Od wersji 1.4.6 (październik 2026) agent może się też zatrzymywać osobno przy każdym wywołaniu narzędzia, a nie tylko zbiorczo.

LangChain jest obecny także w narzędziach no-code. Węzły AI w n8n są zbudowane na JavaScriptowej wersji LangChain, więc agentów, pamięć i narzędzia składasz tam z klocków bez pisania kodu. Zespół LangChain ma też własne narzędzie tego typu, LangSmith Fleet (do marca 2026 roku Agent Builder). Agenta opisujesz w nim zwykłym językiem, a platforma dobiera instrukcje i narzędzia. Z takiego agenta korzystasz w czacie albo tam, gdzie pracujesz, np. w Slacku, a ważniejsze działania wymagają zatwierdzenia.

Agent najlepiej sprawdza się w procesach, które wymagają oceny treści: klasyfikacji zgłoszeń, wstępnej analizy dokumentów czy przygotowania odpowiedzi. Gdzie wystarczą sztywne reguły, prostszy przepływ bez modelu będzie tańszy i bardziej przewidywalny.

Jakie integracje są dostępne w LangChain?

LangChain ma setki integracji, które dzielą się na kilka grup:

dostawcy modeli: OpenAI, Anthropic, Google, Mistral, Amazon Bedrock, Azure, Hugging Face, a lokalnie Ollama,
bazy wektorowe: Chroma, Pinecone, Qdrant, PGVector i wiele innych, w których przechowujesz embeddingi do RAG,
źródła danych (document loaders): pliki PDF i Word, strony internetowe, bazy SQL, popularne aplikacje i API,
narzędzia: wyszukiwarki internetowe, Wikipedia, wykonywanie kodu, zapytania SQL,
serwery MCP: od wersji 1.4 podpinane przez wbudowany MCPAdapter, także z uwierzytelnianiem OAuth.

Integracje z największymi dostawcami mają własne pakiety (langchain-openai, langchain-anthropic, langchain-google-genai, langchain-aws), a mniejsze są zebrane w pakiecie langchain-community. Instalujesz tylko to, czego używasz.

Dzięki tej różnorodności aplikacja korzysta z danych tam, gdzie już leżą, i nie musisz ich wcześniej przenosić w jedno miejsce.

Jakie są różnice między LangChain a innymi frameworkami?

LangChain często zestawia się z n8n, platformą do automatyzacji przepływów pracy. Różnica jest zasadnicza: w n8n przepływ składasz klikaniem i sprawdza się to przy prostszych, powtarzalnych procesach, a LangChain wymaga kodu, ale daje pełną kontrolę nad każdym krokiem agenta. Te narzędzia zresztą się nie wykluczają, bo węzły AI w n8n same korzystają z LangChain.

Wśród frameworków dla programistów LangChain ma kilku poważnych konkurentów:

Framework	Na czym się skupia
LlamaIndex	dane i RAG: parsowanie dokumentów, indeksy, agenci pracujący na dokumentach
CrewAI	zespoły agentów z przypisanymi rolami, które wspólnie realizują zadanie
OpenAI Agents SDK	lekki framework od OpenAI, najlepiej zgrany z modelami tej firmy
Google ADK	zestaw Google do budowy agentów, zintegrowany z Gemini i Vertex AI
Microsoft Agent Framework	następca AutoGen i Semantic Kernel, zintegrowany z usługami Azure
Pydantic AI	framework od twórców Pydantic, nastawiony na typowanie i walidację danych

Na tym tle LangChain wyróżnia się niezależnością od dostawcy modeli, liczbą integracji i tym, że obok frameworka ma własne narzędzia do monitoringu i wdrożeń.

Wewnątrz samego ekosystemu LangChain masz trzy poziomy abstrakcji:

Deep Agents to gotowy agent z kompresją kontekstu, wirtualnym systemem plików, planowaniem zadań i możliwością powoływania podagentów,
LangChain (create_agent) daje elastyczną warstwę, którą dostosowujesz do własnego przypadku,
LangGraph to niskopoziomowa orkiestracja dla przepływów łączących kroki deterministyczne z agentowymi.

Warto uporządkować jedno nieporozumienie: MCP (Model Context Protocol) nie jest konkurencją dla LangChain. To otwarty standard opisujący, w jaki sposób modele łączą się z zewnętrznymi narzędziami i źródłami danych. LangChain go wspiera, od wersji 1.4 bezpośrednio w głównym pakiecie, więc serwery MCP podpinasz do agenta jak każde inne narzędzie.

Wybór zależy od tego, ile kontroli potrzebujesz, czy jesteś związany z jednym dostawcą modeli i czy zespół pracuje w kodzie, czy w interfejsie graficznym.

Jaka jest przyszłość LangChain?

LangChain przedstawia się dziś jako platforma do inżynierii agentów (the agent engineering platform) i skupia się na tym, żeby agenci działali niezawodnie na produkcji, a nie tylko w demach. Widać to po kierunku rozwoju ekosystemu:

Deep Agents rozwijają się najszybciej: w 2026 roku doszły m.in. asynchroniczne podagenty i piaskownice do wykonywania kodu, a wersja 0.7 z lipca 2026 roku odchudziła domyślne prompty (w teście opisanym przez zespół zużycie tokenów wejściowych spadło o 65%),
MCP trafił do głównego pakietu (wersja 1.4, wrzesień 2026) razem z obsługą OAuth i pytań zadawanych przez serwer w trakcie działania,
middleware standaryzuje kwestie, które wcześniej każdy zespół rozwiązywał po swojemu: limity, ochronę danych osobowych i zatwierdzanie decyzji przez człowieka; zatrzymywanie agenta przy każdym wywołaniu narzędzia ma zostać trybem domyślnym w następnej dużej wersji,
LangSmith Engine (publiczna beta od 13 maja 2026 roku) to agent, który przegląda ślady działania Twojej aplikacji, grupuje powtarzające się błędy, szuka ich przyczyny i proponuje poprawki, łącznie z gotowym pull requestem.

Kierunek jest czytelny: z biblioteki ułatwiającej wywołania modeli LangChain przesuwa się w stronę kompletnej platformy do budowy, testowania i utrzymania agentów AI. Dla zespołów oznacza to mniej własnej infrastruktury wokół modelu i szybszą drogę od prototypu do wdrożenia, ale też mocniejsze przywiązanie do jednego ekosystemu.

Jakie są możliwości zastosowania LangChain w e-commerce?

W e-commerce LangChain sprawdza się przede wszystkim tam, gdzie klient albo zespół sklepu zadaje pytania, na które odpowiedź leży w danych sklepu.

Obsługa klienta. Agent z narzędziem do sprawdzania zamówień odpowiada na pytania o status przesyłki, zwroty i dostępność produktów, korzystając z prawdziwych danych, a nie z ogólnej wiedzy modelu. Działania z konsekwencjami finansowymi, takie jak zwrot pieniędzy, warto przepuszczać przez zatwierdzenie przez człowieka.

Doradca produktowy. RAG na katalogu, opisach i specyfikacjach pozwala odpowiadać na pytania typu „który z tych laptopów dłużej działa na baterii” albo „czy ta kurtka nadaje się na deszcz”. Model może też korzystać z wyników istniejącego systemu rekomendacji i tłumaczyć klientowi, dlaczego dany produkt mu pasuje.

Opisy produktów. Generowanie opisów na podstawie parametrów (materiał, wymiary, przeznaczenie) z wymuszonym schematem odpowiedzi daje spójne teksty dla setek produktów naraz. Opisy warto jednak sprawdzać przed publikacją, bo model potrafi dopisać cechy, których produkt nie ma.

Analiza opinii. Agent przetwarza recenzje i zgłoszenia, grupuje je według problemów (rozmiar, jakość, dostawa) i wyłapuje trendy, zanim przełożą się na zwroty.

Przy danych klientów pamiętaj o RODO. Middleware do wykrywania danych osobowych maskuje je, zanim trafią do modelu, a dostawcę modelu i region przetwarzania danych warto sprawdzić przed wdrożeniem.

LangChain w e-commerce przekłada się na:

szybszą obsługę klienta,
mniej ręcznej pracy przy katalogu,
trafniejsze rekomendacje,
lepszy wgląd w opinie klientów.

Jakie są przykłady użycia LangChain w analizie danych?

LangChain pozwala pracować z danymi w języku naturalnym. Najpopularniejszy przykład to agent SQL: dostaje pytanie („ile zamówień złożono w zeszłym miesiącu w Krakowie?”), sprawdza schemat bazy, pisze zapytanie, wykonuje je i opisuje wynik. Takiemu agentowi daj dostęp tylko do odczytu, bo model może wygenerować zapytanie, którego się nie spodziewasz.

Inne zastosowania w analizie danych:

podsumowywanie obszernych dokumentów, np. raportów finansowych czy protokołów,
wyciąganie ustrukturyzowanych danych z tekstu: nazwisk, dat, kwot, numerów umów,
wymuszanie odpowiedzi w zadanym schemacie (response_format), dzięki czemu wynik od razu trafia do arkusza albo bazy,
klasyfikację dużych zbiorów tekstów, np. zgłoszeń do działu wsparcia,
porównywanie dokumentów i wyłapywanie różnic między wersjami.

Wyniki liczbowe zawsze opieraj na zapytaniu do danych, a nie na „pamięci” modelu. Agent, który sam wykonuje SQL i pokazuje użyte zapytanie, jest dużo łatwiejszy do sprawdzenia niż model szacujący wynik na podstawie kontekstu.

Co to jest RAG w kontekście LangChain?

RAG, czyli Retrieval-Augmented Generation, to technika, w której model odpowiada na podstawie informacji wyszukanych w Twojej bazie wiedzy, a nie tylko na podstawie danych treningowych. W LangChain składa się z dwóch etapów.

Indeksowanie robisz raz i powtarzasz, gdy dokumenty się zmieniają:

loader wczytuje dokumenty (PDF, strony www, pliki z dysku),
splitter dzieli je na mniejsze fragmenty, np. po 1000 znaków z zakładką,
model embeddingów zamienia fragmenty na wektory,
baza wektorowa zapisuje je do późniejszego wyszukiwania.

Wyszukiwanie i generowanie dzieje się przy każdym pytaniu. Pytanie użytkownika też zamieniane jest na wektor, baza zwraca najbardziej podobne fragmenty, a model dostaje je razem z pytaniem i na ich podstawie buduje odpowiedź.

W LangChain 1.x wyszukiwanie najczęściej daje się agentowi jako narzędzie. Model sam decyduje, kiedy przeszukać bazę, może zadać kilka zapytań i porównać wyniki. Przy dużych zbiorach dokumentów pomagają Deep Agents: odkładają znalezione fragmenty do wirtualnego systemu plików i rozdzielają ich analizę między podagentów, żeby nie zapchać kontekstu głównego agenta.

RAG wyraźnie podnosi trafność odpowiedzi w aplikacjach opartych na firmowej dokumentacji, ale ma słaby punkt. Treść dokumentów trafia do modelu jako kontekst, więc odpowiednio spreparowany dokument może przemycić polecenia dla modelu (tzw. pośredni prompt injection). Dlatego wyników agenta korzystającego z RAG nie traktuj jako zaufanych bez sprawdzenia, zwłaszcza gdy agent może wykonywać działania.

Jak monitorować i testować agentów AI w LangChain?

Do śledzenia i testowania agentów służy LangSmith, platforma od twórców LangChain. Śledzenie włączasz dwiema zmiennymi środowiskowymi:

export LANGSMITH_TRACING="true"
export LANGSMITH_API_KEY="twój-klucz"

Od tej chwili każdy przebieg agenta trafia do LangSmith jako ślad (trace), w którym widzisz:

prompt i historię wiadomości,
każde wywołanie narzędzia z argumentami i wynikiem,
odpowiedź modelu, czas działania i zużycie tokenów.

Na tej podstawie debugujesz nieprzewidziane zachowania. Do testów tworzysz zestawy danych z pytaniami i oczekiwanymi wynikami, a ewaluatory oceniają, czy nowa wersja agenta działa lepiej od poprzedniej. Na produkcji pomagają ewaluatory działające na bieżącym ruchu, kolejki do ręcznej oceny odpowiedzi oraz dashboardy z alertami. LangSmith nie jest ograniczony do LangChain: obsługuje też m.in. aplikacje pisane bezpośrednio na SDK OpenAI i Anthropic, CrewAI, Vercel AI SDK i Pydantic AI.

Cennik LangSmith (stan na październik 2026 roku):

Plan	Cena	Ślady w cenie	Użytkownicy
Developer	0 USD	5 tys. miesięcznie	1
Plus	39 USD za użytkownika miesięcznie	10 tys. miesięcznie	bez limitu
Enterprise	wycena indywidualna	indywidualnie	indywidualnie

Za ślady ponad limit płacisz według zużycia. Podstawowe ślady są przechowywane 14 dni, rozszerzone 180 dni. Plan Plus daje też jedno bezpłatne wdrożenie agenta w chmurze LangSmith i dostęp do LangSmith Engine. Engine jest rozliczany osobno: uruchamia się automatycznie co 6 godzin, a jedno uruchomienie kosztuje według szacunków LangChain ok. 7-45 USD. Przy pracy przez cały miesiąc to od ok. 840 do ponad 5000 USD, więc przed włączeniem warto to policzyć.

Monitorowanie pozwala budować stabilniejsze systemy: błędy widać, zanim zgłoszą je użytkownicy, a każdą poprawkę sprawdzasz na tych samych danych testowych.