Jak zbudować agenta AI z LangChain: przewodnik krok po kroku

Utwórz bezpieczny tymczasowy katalog roboczy

Przejście od dużych modeli językowych (LLM), które jedynie generują tekst, do agentów AI zdolnych do podejmowania działań, to jedno z najważniejszych wydarzeń we współczesnym tworzeniu oprogramowania. System agentowy postrzega otoczenie, podejmuje decyzje i korzysta z narzędzi, aby osiągać konkretne cele, wykraczając poza proste chatboty do pytań i odpowiedzi. LangChain, framework o otwartym kodzie źródłowym, stał się standardem do tworzenia takich zaawansowanych aplikacji, łącząc LLM z danymi zewnętrznymi, narzędziami i innymi LLM.

Ten poradnik to szczegółowy, krok po kroku opis tego, jak stworzyć agenta AI z LangChain. Poznasz fundamentalne koncepcje i przejdziesz przez praktyczną implementację, co pozwoli Ci tworzyć własnych autonomicznych agentów zdolnych do wykonywania rzeczywistych zadań.

Czego się nauczysz

Pod koniec tego poradnika zrozumiesz podstawowe zasady agentowego AI i frameworka LangChain. Będziesz w stanie skonfigurować środowisko programistyczne, połączyć się z LLM, zdefiniować niestandardowe narzędzia i stworzyć funkcjonalnego agenta za pomocą nowoczesnego API create_agent. Stworzysz i uruchomisz w pełni funkcjonalnego agenta AI, który może wchodzić w interakcję z lokalnym systemem plików na podstawie poleceń w języku naturalnym, co da Ci praktyczne podstawy do tworzenia bardziej złożonych automatyzacji.

1. Podstawy LangChain i kluczowe koncepcje

Zanim zagłębisz się w kod, ważne jest, aby zrozumieć, czym jest agent AI i jak LangChain upraszcza jego tworzenie. W swej istocie agent to system wykorzystujący LLM jako mechanizm rozumowania. Agent otrzymuje zapytanie użytkownika, proponuje LLM podjęcie decyzji o działaniu, wykonuje to działanie (często wywołując narzędzie), a następnie przetwarza wynik, aby sformułować odpowiedź. Cykl ten trwa aż do zakończenia zadania.

LangChain zapewnia standardowy framework do implementacji tego cyklu rozumowania, przede wszystkim poprzez wsparcie dla frameworka ReAct (Reason + Act). LangChain to wysokopoziomowe narzędzie zbudowane na LangGraph, niskopoziomowym frameworku orkiestracyjnym, który daje Ci szczegółową kontrolę nad przepływem pracy i stanem agenta.

Do stworzenia agenta z LangChain potrzebujesz czterech głównych komponentów:

1. LLM: Mechanizm rozumowania Twojego agenta.
2. Narzędzia: Funkcje umożliwiające agentowi interakcję ze światem zewnętrznym, takie jak API, bazy danych czy system plików.
3. Pętla agenta: Warstwa orkiestracyjna, która zarządza LLM, narzędziami i stanem.
4. Pamięć (punkty kontrolne): Możliwość zapisywania stanu agenta, pozwalająca mu zapamiętywać przeszłe interakcje w ramach dialogu.

2. Konfiguracja środowiska programistycznego

Na początek musisz zainstalować LangChain i jego główne zależności. Ten poradnik demonstruje proces w Pythonie, ale koncepcje i wysokopoziomowe wzorce są analogiczne dla użytkowników TypeScript.

Najpierw upewnij się, że w Twoim systemie zainstalowane są Python 3 i Pip. Dla systemów opartych na Debianie/Ubuntu możesz użyć następujących poleceń. Dla innych systemów operacyjnych postępuj zgodnie z odpowiednią metodą instalacji.

sudo apt update
sudo apt install python3 python3-pip

Następnie zainstaluj główne pakiety LangChain. Pakiet langchain to podstawowy framework. langchain-community zawiera narzędzia wspierane przez społeczność, a langgraph jest niezbędny do nowoczesnego API tworzenia agentów.

pip install langchain langgraph langchain-community

3. Integracja dużego modelu językowego

Pierwszym krokiem w tworzeniu Twojego agenta jest połączenie z LLM. LangChain obsługuje dziesiątki dostawców modeli, w tym Google Gemini, OpenAI, Anthropic i innych. Do tego poradnika użyjemy modelu Google Gemini.

Będziesz potrzebować klucza API z konsoli Gemini. Po jego uzyskaniu możesz zainstalować pakiet integracyjny Google GenAI i skonfigurować środowisko.

pip install -qU "langchain[google-genai]"

Teraz możesz napisać kod w Pythonie, aby zainicjować model. Moduł getpass jest używany do bezpiecznego zapytania o klucz API.

import getpass
import os
from langchain.chat_models import init_chat_model
from langchain_core.messages import HumanMessage, SystemMessage

if not os.environ.get("GOOGLE_API_KEY"):
    os.environ["GOOGLE_API_KEY"] = getpass.getpass("Wprowadź klucz API dla Google Gemini: ")

model = init_chat_model("gemini-2.0-flash", model_provider="google_genai")

Możesz sprawdzić konfigurację, wywołując model z prostym zapytaniem.

response = model.invoke("Kiedy rozpoczęła się rewolucja francuska?")
print(response.content)

4. Definiowanie narzędzi dla Twojego agenta

Narzędzia to to, co czyni agentów potężnymi. Pozwalają one LLM wykonywać działania wykraczające poza generowanie tekstu. W tym poradniku stworzymy agenta, który może zarządzać plikami na Twoim lokalnym komputerze za pomocą FileManagementToolkit z LangChain.

FileManagementToolkit jest częścią pakietu langchain-community, który już zainstalowałeś. Ten zestaw narzędzi pozwala określić, jakie operacje na plikach może wykonywać agent, takie jak odczyt, zapis i listowanie plików.

Zaimportuj niezbędne moduły i zdefiniuj narzędzia. Krytycznie ważnym środkiem bezpieczeństwa jest ograniczenie agenta do tymczasowego katalogu, a nie przyznanie mu pełnego dostępu do całego systemu plików.

from langchain_community.agent_toolkits import FileManagementToolkit
from tempfile import TemporaryDirectory

working_directory = TemporaryDirectory()

# Inicjalizacja zestawu narzędzi z wybranymi narzędziami i katalogiem głównym
tools = FileManagementToolkit(
    root_dir=str(working_directory.name),
    selected_tools=["read_file", "write_file", "list_directory"],
).get_tools()

5. Tworzenie agenta za pomocą create_agent

Gdy LLM i narzędzia są gotowe, możesz przystąpić do tworzenia agenta. Nowoczesnym i zalecanym sposobem tworzenia agentów w LangChain jest użycie funkcji create_agent.

Ta funkcja przyjmuje Twój model i listę narzędzi, a następnie tworzy wykonawcę agenta, który zarządza pętlą rozumowania. Upraszcza to proces, eliminując potrzebę ręcznego tworzenia agenta ReAct i wykonawcy.

from langchain.agents import create_agent

# Zmienne "model" i "tools" z poprzednich kroków.
agent = create_agent(
    model=model,
    tools=tools
)

Ta pojedyncza linia kodu tworzy złożonego agenta. Agent używa modelu, aby zdecydować, które narzędzie wywołać na podstawie danych wejściowych użytkownika. Może obsługiwać łańcuchy wywołań wielu narzędzi w celu wykonania złożonego zadania.

⚠️ Ważne: Chociaż LangChain może być używany ze starszymi metodami tworzenia agentów, takimi jak create_react_agent, API create_agent jest nowoczesnym, zalecanym podejściem i powinno być Twoim domyślnym wyborem do tworzenia nowych agentów.

6. Uruchamianie Twojego pierwszego agenta

Teraz, gdy agent jest stworzony, możesz go uruchomić, wywołując go z wiadomością użytkownika. Poniższe polecenia zademonstrują zdolność agenta do interakcji z systemem plików.

Zacznij od poproszenia agenta o wyświetlenie listy plików w bieżącym katalogu roboczym. Na razie katalog jest pusty.

input_message = {"role": "user", "content": "Wyświetl listę plików w bieżącym katalogu roboczym"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

Następnie wydaj agentowi polecenie utworzenia pliku o nazwie sample-file.txt.

input_message = {"role": "user", "content": "Utwórz plik o nazwie sample-file.txt"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

Na koniec poproś agenta o ponowne wyświetlenie listy plików. Teraz pokaże, że sample-file.txt istnieje.

input_message = {"role": "user", "content": "Wyświetl listę plików w bieżącym katalogu roboczym"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

Jak widzisz, agent z powodzeniem zinterpretował polecenia w języku naturalnym, wywołał odpowiednie narzędzia (list_directory, write_file) i dostarczył informację zwrotną o wykonanych działaniach. To prosta, ale potężna demonstracja tego, jak stworzyć agenta AI z LangChain.

7. Dodawanie pamięci agentowi

Jednym z kluczowych ograniczeń agenta bezstanowego jest to, że zapomina on cały kontekst po zakończeniu wywołania. Aby stworzyć agenta dialogowego, który może zapamiętywać przeszłe interakcje, konieczne jest dodanie pamięci. Osiąga się to za pomocą „punktu kontrolnego”, który zapisuje stan agenta.

LangGraph dostarcza klasę MemorySaver, która jest prostym punktem kontrolnym w pamięci. W środowisku produkcyjnym użyłbyś bardziej niezawodnej opcji, takiej jak PostgresSaver lub punkt kontrolny oparty na MongoDB, ale MemorySaver jest idealny do testowania i programowania.

Najpierw zaimportuj i zainicjuj punkt kontrolny.

from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()

Następnie odtwórz swojego agenta, przekazując checkpointer jako argument.

agent_with_memory = create_agent(
    model=model,
    tools=tools,
    checkpointer=checkpointer
)

Aby użyć pamięci, musisz podać thread_id w konfiguracji. Ten thread_id działa jako identyfikator dialogu, pozwalając agentowi utrzymywać oddzielną pamięć dla każdej oddzielnej rozmowy.

config = {"configurable": {"thread_id": "user-123"}}

agent_with_memory.invoke(
    {"messages": [{"role": "user", "content": "Mam na imię Alicja"}]},
    config=config
)

result = agent_with_memory.invoke(
    {"messages": [{"role": "user", "content": "Jak mam na imię?"}]},
    config=config
)
# Agent odpowiada: "Masz na imię Alicja."
print(result["messages"][-1].content)

To proste uzupełnienie pozwala Twojemu agentowi prowadzić dialogi z kontekstem, czyniąc go znacznie bardziej inteligentnym i użytecznym.

8. Poza podstawami: systemy wieloagentowe

W miarę postępów możesz napotkać zadania zbyt złożone dla jednego agenta. LangChain wspiera tworzenie złożonych systemów wieloagentowych, gdzie wyspecjalizowani agenci współpracują, aby rozwiązywać problemy. To potężny wzorzec architektoniczny dla złożonych przepływów pracy.

Subagenci to podstawowy wzorzec wieloagentowy, gdzie główny agent-superwizor koordynuje kilku wyspecjalizowanych subagentów, wywołując ich jako narzędzia. Na przykład jeden subagent może odpowiadać za badania, inny za tworzenie treści, a trzeci za weryfikację pracy.

Wzorzec	Jak to działa
Subagenci	Główny agent koordynuje subagentów jako narzędzia. Całe routowanie przechodzi przez głównego agenta, który decyduje, kiedy wywołać każdego subagenta.
Przekazanie kontroli	Zachowanie dynamicznie zmienia się w zależności od stanu, gdy wywołanie narzędzia inicjuje przełączenie na innego agenta lub konfigurację.
Umiejętności	Wyspecjalizowane prompty i wiedza są ładowane na żądanie do kontekstu jednego agenta.
Router	Krok routingu klasyfikuje dane wejściowe i kieruje je do jednego lub kilku wyspecjalizowanych agentów do przetworzenia.

Wybór odpowiedniego wzorca ma kluczowe znaczenie. Na przykład architektura subagentów doskonale nadaje się do równoległego wykonywania i rozproszonego programowania, podczas gdy wzorzec przekazania kontroli jest bardziej efektywny dla powtarzających się zapytań użytkowników w jednym dialogu. Użycie wzorca subagentów w aplikacji asystenta osobistego pozwala na izolację kontekstu – każdy subagent pracuje nad zadaniem w czystym oknie kontekstowym, zapobiegając rozrostowi pamięci głównego agenta.

Źródła

1. Chris Tozzi. "Build an AI agent with LangChain in this beginner tutorial." TechTarget, Sep 2025.
2. "Quickstart" LangChain Official Documentation.
3. "Multi-agent" LangChain Official Documentation.
4. "Workflows and agents" LangChain Official Documentation.
5. "langchain-fundamentals" LangChain Skills Documentation, GitHub.
6. "How to Build an AI Agent with LangChain and LangGraph: Build an Autonomous Starbucks Agent." freeCodeCamp, Dec 2025.
7. "Subagents" LangChain Official Documentation.
8. "LangChain Python Tutorial: A Complete Guide for 2026." The JetBrains Blog, Mar 2026.

— Editorial Team