Strona główna / Artykuły

Systemy AI wieloagentowe z LangChain: Budowanie

Systemy AI wieloagentowe z LangChain: czym jest system wieloagentowy, kiedy kilka agentów pokonuje pojedynczego agenta LLM oraz jak budować i łączyć role.

Wydawca: REACTAPP.TOP11 min czytania2636 słów

Źródła: Multi-Agent AI Systems with LangChain: Building an Orchestrator That Delegates Work

Poniższe notatki przedstawiają praktyczną ścieżkę nauki dotyczącą „Systemów AI wieloagentowych z LangChain: tworzenie orkiestratora, który deleguje zadania”. Nacisk kładziony jest na umowy, sprawdzanie oraz miejsca na kod do wstawienia, a nie na motywacyjne aspekty. Podczas przechodzenia przez etap przeglądu najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zapisz czas wykonywania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega nieoczekiwanym rachunkom, gdy przechodzi się od demonstracji do wspólnych środowisk.

1. Czym jest system wieloagentowy?

Model „1 Co to jest etap?” funkcjonuje najlepiej, gdy traktowany jest jako mierzalna powierzchnia. Zapisz jeden idealny przypadek, jeden przypadek awarii oraz notatkę o cofnięciu działań, zanim rozszerzysz zakres. Trzymaj konfigurację poza kodem aplikacji. Pliki środowiskowe, magazyny tajnych danych oraz flagi funkcjonalne powinny znajdować się w jednym miejscu, które operatorzy mogą sprawdzić bez konieczności czytania całej struktury. Utrzymuj stan struktury w formie prostych, typizowanych elementów. Wplecione bloki danych ukrywają informację o tym, który węzeł zapisał dane w danym polu, co powoduje przerwanie kontynuacji działania po zakłóceniach.

User
  |
  v
Single Agent
  |
  +-- Search
  +-- Analyze
  +-- Calculate
  +-- Generate Report
                         User
                           |
                           v
                    +--------------+
                    | Main Agent   |
                    | Orchestrator |
                    +------+-------+
                           |
              +------------+------------+
              |                         |
              v                         v
       +-------------+           +-------------+
       | Math Agent  |           | Search Agent|
       +-------------+           +-------------+
              |                         |
          square()                  search()

2. Dlaczego używać wielu agentów?

Metoda 2 Dlaczego i kilku etapów działa najlepiej, gdy jest traktowana jako mierzalna struktura. Zapisz jeden idealny przypadek działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia działań, zanim rozszerzysz zakres analizy. Zdokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę przywracania do normalnego stanu. Próby ponownych działań, kontrolne punkty ludzkie oraz obsługa wiadomości nieodebranych stanowią część produktu, a nie elementy dodawane później. Utrzymuj stan grafu w prostej formie i z określonym typem danych. Wplecione struktury ukrywają informację o tym, który węzeł zapisał dane w danym polu, co powoduje przerwanie kontynuacji działania po zakłóceniach.

Database queries
Security analysis
Documentation search
Report generation
"I have a database question → call database agent."
"I have a security question → call security agent.""I need documentation → call documentation agent."

Jeden agent

Faza jednego agenta funkcjonuje najlepiej, gdy traktowana jest jako mierzalna powierzchnia. Zapisz jeden idealny przepis działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia działań, zanim rozszerzysz zakres. Wolno preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy jakiś krok zawiedzie, awaria powinna wskazywać na konkretną odpowiedzialność, a nie na skomplikowany łańcuch operacji. Utrzymuj stan grafu w prostej formie i z określonym typem danych. Wtórne struktury ukrywają informację o tym, który węzeł zapisał dane do którego pola, i powodują przerwę w kontynuacji działania po zakłóceniach.

                    LLM
                     |
       +-------------+-------------+
       |             |             |
    Database       Search       Security
       |             |             |
       +-------------+-------------+

Faza jednego agenta funkcjonuje najlepiej, gdy traktowana jest jako mierzalna powierzchnia. Zapisz jeden idealny przepis działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia działań, zanim rozszerzysz zakres. Zapisuj czasy wykonywania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega nieoczekiwanym rachunkom, gdy proces przechodzi z środowiska demonstracyjnego do współdzielonych środowisk.

Wielu agentów

W fazie wielu agentów należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie uruchomić dany krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Konfigurację należy przechowywać poza kodem aplikacji. Pliki środowiskowe, magazyny tajnych danych oraz flagi funkcjonalne powinny znajdować się w jednym miejscu, które operatorzy mogą sprawdzić bez konieczności czytania całej struktury. Zastosuj zatwierdzenie przez człowieka do połączeń, które powodują wydatki lub zmieniają dane produkcyjne. Połączenia ustalane w czasie kompilacji nie równają się pełności funkcjonalności biznesowej.

                      Main Agent
                    /     |      \
                   /      |       \
                  v       v        v
             DB Agent  Search   Security
                        Agent      Agent

3. Przykład: Dwa specjalistyczne agenty

Dla specjalnego etapu Przykładu Dwa nr 3 należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić ten krok od znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Należy udokumentować zarówno prawidłowy przebieg procesu, jak i ścieżki naprawcze. Próby ponownych działań, kontrolne punkty ludzkie oraz obsługa wiadomości błędnych stanowią część produktu, a nie elementy dodawane później. Konieczna jest ludzka akceptacja w przypadkach, gdy dochodzi do wydawania pieniędzy lub zmiany danych produkcyjnych. Połączenia realizowane w czasie kompilacji nie równają się kompletności rozwiązania biznesowego.

Calculate the square of a number
Calculate the square root of a number
@tool
def square_root(x: float) -> float:
    """Calculate the square root of a number"""
    return x ** 0.5
@tool
def square(x: float) -> float:
    """Calculate the square of a number"""
    return x ** 2
subagent_square_root = create_agent(
    model=llm,
    tools=[square_root]
)
subagent_square = create_agent(
    model=llm,
    tools=[square]
)
square_root()
square()

4. Najważniejsza część: Przekształcanie agentów w narzędzia

W fazie „4 The Important Part” należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić ten krok od znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Lepiej używać małych, testowalnych jednostek niż rozbudowanych skryptów. Gdy jakiś krok zawiedzie, powinno to wskazywać na konkretną odpowiedzialność, a nie na skomplikowaną strukturę procesów. Uwierzytelniaj się przy bramie wejściowej, a ponownie autoryzuj w warstwie danych. Sam token nie stanowi granicy pomiędzy poszczególnymi użytkownikami. W fazie „4 The Important Part” należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić ten krok od znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Zapisuj czas trwania operacji oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy proces przechodzi z środowiska demonstracyjnego do współdzielonych środowisk.

@tool
def call_subagent_square_root(x: float) -> float:
    """Call subagent 1 in order to calculate
    the square root of a number"""
    response = subagent_square_root.invoke(
        {
            "messages": [
                HumanMessage(
                    content=f"Calculate the square root of {x}"
                )
            ]
        }
    )    return response["messages"][-1].content
@tool
def call_subagent_square(x: float) -> float:
    """Call subagent 2 in order to calculate
    the square of a number"""
    response = subagent_square.invoke(
        {
            "messages": [
                HumanMessage(
                    content=f"Calculate the square of {x}"
                )
            ]
        }
    )    return response["messages"][-1].content
Main Agent
     |
     +-- call_subagent_square_root()
     |
     +-- call_subagent_square()

5. Tworzenie Orchestratora

Podczas przechodzenia przez 5 etapów tworzenia Orchestratora najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Trzymaj konfigurację poza kodem aplikacji. Pliki środowiskowe, magazyny tajnych danych oraz flagi funkcjonalne powinny znajdować się w jednym miejscu, które operatorzy mogą sprawdzić bez konieczności czytania całej struktury. Ustaw punkty kontrolne po kosztownych krokach. System powinien unikać ponownego naliczania opłat za tę samą wywołanie LLM, gdy operator próbuje ponownie uruchomić późniejszy węzeł.

main_agent = create_agent(
    model=llm,
    tools=[
        call_subagent_square_root,
        call_subagent_square
    ],
    system_prompt=
        "You are a helpful assistant who can call "
        "subagents to calculate the square root or "
        "square of a number."
)
                         User
                           |
                           |
                           v
                  +----------------+
                  |   Main Agent    |
                  |  Orchestrator   |
                  +-------+--------+
                          |
                 Tool selection
                    /          \
                   /            \
                  v              v
        +----------------+  +----------------+
        | Square Root    |  | Square         |
        | Subagent       |  | Subagent       |
        +-------+--------+  +-------+--------+
                |                  |
                v                  v
          square_root()        square()

6. Co się dzieje, gdy użytkownik zadaje pytanie?

Gdy przechodzisz przez etap 6 „What Happens When”, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zdokumentuj razem ścieżkę prawidłowego działania oraz ścieżkę naprawczą. Próby ponowne, kontrola przez ludzi oraz obsługa wiadomości błędnych stanowią część produktu, a nie elementy dodawane później. Ustal punkty kontrolne po kosztownych krokach. System powrotu nie powinien ponownie naliczać opłat za tę samą wywołanie LLM, gdy operator próbuje ponownie uruchomić późniejszy węzeł.

What is the square root of 456?
response = main_agent.invoke(
    {
        "messages": [
            HumanMessage(
                content="What is the square root of 456?"
            )
        ]
    }
)
call_subagent_square_root(x=456)
Calculate the square root of 456
square_root()
21.3541565
The square root of 456 is approximately 21.35.
User
 |
 | "What is the square root of 456?"
 v
Main Agent
 |
 | selects call_subagent_square_root
 v
Square Root Subagent
 |
 | invokes square_root(456)
 v
21.3541565
 |
 v
Main Agent
 |
 v
"The square root of 456 is approximately 21.35."

7. Gdzie mieści się LLM?

Gdy przechodzisz przez etap 7 Where Does the stage, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Wolno preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy jakiś krok się nie powiedzie, błąd powinien wskazywać na konkretną odpowiedzialność, a nie na skomplikowany łańcuch operacji. Zachowuj w pamięci tymczasowej stabilne instrukcje systemu oraz schematy narzędzi. Ponowne wysyłanie identycznego prefiksu to częsty powód marnotrawstwa zasobów. Gdy przechodzisz przez etap 7 Where Does the stage, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zapisuj czasy wykonywania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy proces przechodzi z środowiska demonstracyjnego do wspólnych środowisk.

llm = ChatOllama(
    model="llama3.2:latest",
    base_url="http://localhost:11434",
    temperature=0,
)
                Ollama / Llama
                     |
          +----------+----------+
          |                     |
          v                     v
     Main Agent            Subagents
     Orchestrator          Specialized
Main Agent       → powerful reasoning model
Security Agent   → security-specialized modelCoding Agent     → coding modelSimple Agent     → smaller/cheaper model

8. Multi-Agent Nie Oznacza Wielu LLM

Koncepcja 8 Multi-Agent Does Not funkcjonuje najlepiej, gdy jest traktowana jako mierzalna struktura. Zapisz jeden idealny przykład działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia działań przed rozszerzaniem zakresu. Konfigurację należy przechowywać poza kodem aplikacji. Pliki środowiskowe, skrypty przechowujące dane poufne oraz flagi funkcjonalne powinny znajdować się w jednym miejscu, aby operatorzy mogli je sprawdzić bez konieczności przeglądania całej struktury. Ustal limit tokenów na rundę i sesję. Narzędzia typu agentic intensywnie rozszerzają kontekst; sztywne ograniczenia zapobiegają temu, by demonstracje przerodziły się w nieoczekiwane rachunki.

Model A
  |
  +-- Agent 1
  +-- Agent 2
  +-- Agent 3
Model A → Agent 1
Model B → Agent 2
Model C → Agent 3
Agent =
    Model
  + Instructions
  + Tools
  + State/Context
  + Decision-making

9. Dlaczego Po prostu Nie Dać Wszystkich Narzędzi Jednemu Agentowi?

Faza „9 Dlaczego nie po prostu” działa najlepiej, gdy traktuje się ją jako mierzalną powierzchnię do analizy. Zapisz jeden idealny przypadek działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia działań, zanim rozszerzysz zakres analizy. Zdokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę naprawczą. Próby ponownych działań, kontrolne punkty ludzkie oraz obsługa wiadomości błędowych stanowią część produktu, a nie elementy dodawane później. Używaj narzędzi o wąskich schematach i wyraźnych etykietach dotyczących efektów ubocznych. Hostowie muszą wiedzieć, które wywołania zmieniają stan systemu, zanim dokonają automatycznej aprobaty.

                         Orchestrator
                              |
          +-------------------+-------------------+
          |                   |                   |
          v                   v                   v
    Database Agent       Security Agent      Research Agent
          |                   |                   |
       PostgreSQL          SIEM/Security       Web/MCP
                              |
                              v
                       Report Generator

10. Praca wielu agentów vs. sekwencyjny przepływ pracy

Etap 10 Multi-Agent vs Sequential funkcjonuje najlepiej, gdy traktowany jest jako mierzalna powierzchnia. Zapisz jeden idealny przepis działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia działań, zanim rozszerzysz zakres. Wolno preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy jakiś krok zawiedzie, awaria powinna wskazywać na konkretną odpowiedzialność, a nie na skomplikowany łańcuch operacji. Utrzymuj stan grafu w prostej formie i z określonym typem danych. Wtórne struktury ukrywają informację o tym, który węzeł zapisał dane w danym polu, i powodują przerwę w kontynuacji działania po zakłóceniach. Etap 10 Multi-Agent vs Sequential funkcjonuje najlepiej, gdy traktowany jest jako mierzalna powierzchnia. Zapisz jeden idealny przepis działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia działań, zanim rozszerzysz zakres. Zapisuj czasy wykonywania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega nieoczekiwanym rachunkom, gdy proces przechodzi z wersji demonstracyjnej do środowisk współdzielonych.

Sekwencyjny proces pracy

Dla etapu workflow sekwencyjnego należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie uruchomić dany krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Konfigurację należy przechowywać poza kodem aplikacji. Pliki środowiskowe, magazyny tajnych danych oraz flagi funkcjonalne powinny znajdować się w jednym miejscu, które operatorzy mogą sprawdzić bez konieczności czytania całej struktury. Zastosuj zatwierdzenie przez człowieka do operacji, które wiążą się z wydatkami lub zmianami w danych produkcyjnych. Połączenia ustalane w czasie kompilacji nie równają się pełności funkcjonalności biznesowej.

Step 1
  ↓
Step 2
  ↓
Step 3
  ↓
Step 4
Retrieve documents
      ↓
Analyze documents
      ↓
Generate report
      ↓
Send email

Zorganizowany system wielu agentów

W fazie zintegrowanego systemu wielu agentów należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić dany krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Należy udokumentować zarówno prawidłowy przebieg procesu, jak i ścieżki naprawcze. Próby ponownych działań, kontrola przez ludzi oraz obsługa wiadomości błędnych stanowią część produktu, a nie elementy dodawane później. Konieczna jest ludzka akceptacja w przypadku operacji, które powodują wydatki lub zmieniają dane produkcyjne. Połączenia realizowane w czasie kompilacji nie równają się kompletności rozwiązania biznesowego.

                     Orchestrator
                    /     |      \
                   /      |       \
               Agent A  Agent B  Agent C
Workflow = predefined control flow
Multi-Agent =
LLM-driven delegation between specialized agents

11. Architektura produkcyjna

W etapie 11 Architektury Produkcji należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić dany krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Należy preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy dany krok zawiedzie, powinno to wskazywać na konkretną odpowiedzialność, a nie na skomplikowany łańcuch operacji.

User
                           |
                           v
                 +-------------------+
                 | Orchestrator      |
                 | Agent             |
                 +---------+---------+
                           |
          +----------------+----------------+
          |                |                |
          v                v                v
    +-----------+    +-----------+    +-----------+
    | Research  |    | Security  |    | Database  |
    | Agent     |    | Agent     |    | Agent     |
    +-----+-----+    +-----+-----+    +-----+-----+
          |                |                |
          v                v                v
       Web/MCP          SIEM/APIs       PostgreSQL
          |                |                |
          +----------------+----------------+
                           |
                           v
                  +----------------+
                  | Final Response |
                  | / Report Agent |
                  +----------------+
Research Agent
    → web search
    → document retrieval
    → RAG
Security Agent
    → SIEM
    → vulnerability database
    → security APIsDatabase Agent
    → SQL
    → analyticsReport Agent
    → summarize
    → format
    → email

12. Główne wnioski

1. Specjalizacja agentów

Agent → one domain / capability

2. Pakowanie podagentów jako narzędzi

Main Agent
    |
    +-- Subagent Tool

3. Pozwalanie orkiestratorowi delegować zadania

4. Utrzymywanie prostoty interfejsów

Tool name
Description
Arguments
Result

5. Zacznij od prostoty

AI Orchestrator
                         |
        +----------------+----------------+
        |                |                |
    Research          Coding          Security
      Agent            Agent            Agent
        |                |                |
       MCP             GitHub          Security APIs
       RAG             Tools           SIEM

Zakończenie

User
  ↓
Main Agent
  ↓
Tool representing a subagent
  ↓
Specialized Subagent
  ↓
Domain-specific Tool
  ↓
Result
  ↓
Main Agent
  ↓
User

Lista kontrolna operacyjna

Pozycje pokrewne do przeczytania

  • Notatki praktyczne: Budowa agenta do głębokiego badania przy użyciu LangChain Deep Agents and — Krok po kroku instrukcja dotycząca Notatek praktycznych: Budowa agenta do głębokiego badania przy użyciu LangChain Deep Agents and: kontrakty, sprawdzenia oraz miejsca na kod do wklejenia dla zespołów wdrażających ten model.
  • Notatki praktyczne: 7 rzeczy, których żałuję, że nie wiedziałem przed stworzeniem agenta głosowego do użycia w produkcji — Krok po kroku instrukcja dotycząca Notatek praktycznych: 7 rzeczy, których żałuję, że nie wiedziałem przed stworzeniem agenta głosowego do użycia w produkcji: kontrakty, sprawdzenia oraz miejsca na kod do wklejenia dla zespołów wdrażających ten model.
  • Praktyczne notatki: Podtrzymywanie typesów frontendu i backendu w zgodzie z Typescriptem — Krok po kroku instrukcja dotycząca Praktycznych notatek: Podtrzymywanie typesów frontendu i backendu w zgodzie z Typescriptem: kontrakty, sprawdzenia oraz gotowe fragmenty kodu dla zespołów wdrażających ten wzorzec.
  • Praktyczne notatki: Jak wdrożyć CommNet dla ulepszonego uczenia się wielu agentów — Krok po kroku instrukcja dotycząca Praktycznych notatek: Jak wdrożyć CommNet dla ulepszonego uczenia się wielu agentów: kontrakty, sprawdzenia oraz gotowe fragmenty kodu dla zespołów wdrażających ten wzorzec.