Przepływ chatbota:
Użytkownik: "Zarezerwuj mi lot do Londynu"
Chatbot: "Polecam British Airways lub 
         Lufthansa. Możesz zarezerwować na ba.com 
         lub lufthansa.com."
Rezultat: Użytkownik wykonuje pracę

Przepływ agenta:
Użytkownik: "Zarezerwuj mi lot do Londynu na 
            konferencję w przyszłym tygodniu"
Agent: "Zarezerwowałem BA287, wtorek 
       wylot 09:15, przylot 10:30. 
       Dodałem do kalendarza, wysłałem 
       e-mail z potwierdzeniem i zaktualizowałem 
       system rozliczeń podróży.
       Razem: 1 800 zł, w ramach budżetu."
Rezultat: Praca wykonana

Chatboty: Dostarczają informacje
├── Odpowiadają na pytania
├── Pobierają dane
├── Dają rekomendacje
└── Wynik: Odpowiedzi tekstowe

Agenty AI: Wykonują akcje
├── Realizują zadania
├── Integrują się z systemami
├── Podejmują decyzje
├── Łączą wiele operacji
└── Wynik: Zmiany w rzeczywistości

Zadania informacyjne:
├── Wyszukiwanie i synteza danych
├── Generowanie raportów
├── Analiza dokumentów
├── Odpowiadanie na złożone pytania
└── Monitoring zmian

Zadania akcji:
├── Rezerwacja wizyt i terminów
├── Wysyłanie e-maili i wiadomości
├── Aktualizacja rekordów w bazach danych
├── Przetwarzanie zamówień i płatności
├── Tworzenie zgłoszeń i zadań
├── Generowanie dokumentów
└── Uruchamianie przepływów pracy

Zadania decyzyjne:
├── Kierowanie zapytań do właściwego działu
├── Priorytetyzacja według reguł
├── Zatwierdzanie w zdefiniowanych limitach
├── Eskalacja, gdy potrzeba
└── Uczenie się z wyników

┌─────────────────────────────────────────┐
│         ARCHITEKTURA AGENTA AI          │
└─────────────────────────────────────────┘

1. MÓZG (LLM)
   ├── Rozumie intencję użytkownika
   ├── Rozumuje o zadaniach
   ├── Planuje wieloetapowe akcje
   ├── Decyduje, których narzędzi użyć
   └── Generuje odpowiedzi

2. PAMIĘĆ
   ├── Historia konwersacji
   ├── Kontekst i preferencje użytkownika
   ├── Stan i postęp zadania
   ├── Nauczone wzorce
   └── Wiedza długoterminowa

3. NARZĘDZIA
   ├── Integracje API
   ├── Połączenia z bazami danych
   ├── Zewnętrzne serwisy
   ├── Operacje plikowe
   └── Funkcje niestandardowe

4. ORKIESTRACJA
   ├── Dekompozycja zadań
   ├── Wybór narzędzi
   ├── Obsługa błędów
   ├── Zarządzanie stanem
   └── Zabezpieczenia

5. INTERFEJSY
   ├── Czat (tekst, głos)
   ├── Endpointy API
   ├── Wyzwalacze czasowe
   ├── Webhooki zdarzeń
   └── Panel administracyjny

ReAct: Reasoning + Acting (Rozumowanie + Działanie)

Tradycyjny chatbot:
Wejście → Odpowiedź

Agent ReAct:
Wejście → Myśl → Działaj → Obserwuj → Myśl → Działaj → … → Odpowiedź

Przykład:
Użytkownik: "Jaki jest nasz najlepiej sprzedający się 
            produkt w tym miesiącu?"

Myśl agenta: "Muszę zapytać bazę sprzedaży o 
sprzedaż tego miesiąca według produktów."

Akcja agenta: Wywołaj narzędzie sales_query
Parametry: {period: "current_month", sort: "revenue_desc", limit: 1}

Obserwacja agenta: Wynik = {product: "Widget Pro", 
units: 2 340, revenue: 936 000}

Myśl agenta: "Mam odpowiedź. Użytkownik może też 
chcieć kontekstu, więc dodam porównanie z poprzednim miesiącem."

Akcja agenta: Wywołaj narzędzie sales_query  
Parametry: {period: "last_month", product: "Widget Pro"}

Obserwacja agenta: Wynik = {units: 1 890, revenue: 756 000}

Odpowiedź agenta: "Widget Pro to Wasz bestseller w tym 
miesiącu z 2 340 sprzedanymi sztukami (936 000 zł przychodu). 
To wzrost o 24% względem 1 890 sztuk w poprzednim miesiącu."

Struktura definicji narzędzia:
{
  "name": "create_calendar_event",
  "description": "Tworzy nowe wydarzenie w 
                  Kalendarzu Google użytkownika",
  "parameters": {
    "type": "object",
    "properties": {
      "title": {
        "type": "string",
        "description": "Tytuł wydarzenia"
      },
      "start_time": {
        "type": "string",
        "description": "Czas rozpoczęcia w formacie ISO"
      },
      "end_time": {
        "type": "string",
        "description": "Czas zakończenia w formacie ISO"
      },
      "attendees": {
        "type": "array",
        "items": {"type": "string"},
        "description": "Lista e-maili uczestników"
      }
    },
    "required": ["title", "start_time", "end_time"]
  }
}

Implementacja narzędzia:
async function create_calendar_event(params) {
  const { title, start_time, end_time, attendees } = params;
  
  const event = await googleCalendar.events.insert({
    calendarId: 'primary',
    requestBody: {
      summary: title,
      start: { dateTime: start_time },
      end: { dateTime: end_time },
      attendees: attendees?.map(email => ({ email }))
    }
  });
  
  return {
    success: true,
    event_id: event.id,
    link: event.htmlLink
  };
}

Dobre przypadki użycia dla agentów:
├── Powtarzalne zadania (duża objętość, spójne)
├── Wieloetapowe przepływy pracy (3+ kroki)
├── Potrzebna integracja systemowa
├── Reguły decyzyjne można skodyfikować
├── Jasne kryteria sukcesu
└── Umiarkowana złożoność (nietrywialne, niechaotyczne)

Pytania do odpowiedzi:
1. Jakie zadanie powinien wykonywać agent?
2. Do jakich systemów potrzebuje dostępu?
3. Jakie decyzje musi podejmować?
4. Jakie są tryby awarii?
5. Kiedy powinien eskalować do ludzi?

Przypadek użycia: Przetwarzanie przychodzących zamówień zakupu

Wejścia:
├── E-maile z zamówieniami od klientów
├── Baza danych klientów
├── System magazynowy
├── Reguły cenowe

Akcje:
├── Wyodrębnij szczegóły zamówienia z e-maila
├── Zwaliduj klienta i limit kredytowy
├── Sprawdź dostępność magazynową
├── Zastosuj odpowiednie ceny
├── Utwórz zamówienie w ERP
├── Wyślij potwierdzenie do klienta
├── Powiadom handlowca, jeśli wystąpią problemy

Kryteria sukcesu:
├── Zamówienia przetworzone w <5 minut
├── 95% automatycznego przetworzenia
├── Zero błędów cenowych
├── Potwierdzenie wysłane do klienta
└── Właściwa eskalacja, gdy potrzeba

Dla każdej wymaganej akcji:

1. Zdefiniuj interfejs narzędzia
   ├── Nazwa i opis
   ├── Parametry wejściowe
   ├── Format wyjściowy
   └── Warunki błędów

2. Zaimplementuj narzędzie
   ├── Połączenia API
   ├── Uwierzytelnianie
   ├── Transformacja danych
   └── Obsługa błędów

3. Przetestuj dokładnie
   ├── Ścieżka szczęśliwa
   ├── Przypadki brzegowe
   ├── Scenariusze błędów
   └── Wydajność

Pobieranie danych:
├── Zapytania bazodanowe
├── Wywołania API
├── Wyszukiwanie dokumentów
├── Odczyt plików
└── Scraping sieci

Tworzenie danych:
├── Tworzenie rekordów
├── Generowanie plików
├── Wysyłanie e-maili
├── Publikowanie wiadomości
└── Wyzwalanie powiadomień

Usługi zewnętrzne:
├── Operacje kalendarzowe
├── Przetwarzanie płatności
├── Usługi kurierskie
├── Platformy komunikacyjne
└── Zewnętrzne SaaS

Systemy wewnętrzne:
├── Aktualizacje ERP/CRM
├── Tworzenie zgłoszeń
├── Wyzwalacze przepływów pracy
├── Prośby o zatwierdzenie
└── Logowanie audytowe

Struktura promptu systemowego agenta:

TOŻSAMOŚĆ
Jesteś [Nazwa Agenta], asystentem AI pomagającym 
w [konkretna domena]. Pracujesz dla [Firma].

MOŻLIWOŚCI
Masz dostęp do tych narzędzi:
- [Narzędzie 1]: [opis]
- [Narzędzie 2]: [opis]
...

WYTYCZNE
1. Zawsze weryfikuj tożsamość klienta przed 
   dostępem do informacji o koncie.
2. Dla zamówień powyżej 40 000 zł wymagaj 
   zatwierdzenia menedżera przed przetworzeniem.
3. Jeśli magazyn jest niewystarczający, zaproponuj 
   alternatywy przed zamówieniem zaległym.
...

ESKALACJA
Eskaluj do człowieka gdy:
- Klient wyraża frustrację
- Prośba poza Twoimi możliwościami
- Błędy systemowe się utrzymują
- Wykryto nietypowe wzorce

Typy pamięci:

Krótkoterminowa (konwersacja):
├── Aktualne wiadomości konwersacji
├── Wyniki wywołań narzędzi
├── Stan i postęp zadania
└── Czyszczona na koniec konwersacji

Długoterminowa (trwała):
├── Preferencje klienta
├── Podsumowanie poprzednich interakcji
├── Nauczone wzorce
└── Przechowywana w bazie danych

Zarządzanie oknem kontekstu:
├── Podsumuj starsze wiadomości
├── Zachowaj ostatnie wiadomości dosłownie
├── Priorytetyzuj odpowiedni kontekst
└── Utrzymuj kluczowe fakty

Testy funkcjonalne:
□ Wszystkie narzędzia działają poprawnie
□ Wieloetapowe przepływy pracy się kończą
□ Obsługa błędów jest elegancka
□ Wyzwalacze eskalacji działają
□ Przypadki brzegowe obsłużone

Testy bezpieczeństwa:
□ Nie może wykonać nieautoryzowanych akcji
□ Respektuje granice uprawnień
□ Obsługuje antagonistyczne wejścia
□ Ograniczanie tempa działa
□ Logowanie audytowe rejestruje akcje

Testy wydajnościowe:
□ Czas odpowiedzi akceptowalny
□ Obsługuje równoległe żądania
□ Skaluje się pod obciążeniem
□ Koszt na interakcję śledzony

Wymagania implementacji:

Weryfikacja akcji:
├── Potwierdzaj destrukcyjne akcje
├── Podwójnie sprawdzaj duże wartości
├── Waliduj krytyczne parametry
└── Udział człowieka w pętli (HITL) dla wysokich stawek

Ograniczanie tempa:
├── Maks. liczba akcji na minutę
├── Maks. koszt na sesję
├── Okresy schładzania
└── Alerty na nietypowe wzorce

Model uprawnień:
├── Dostęp oparty na rolach
├── Uprawnienia na poziomie akcji
├── Ograniczenia na poziomie danych
└── Audyt wszystkich akcji

Fazowe wdrożenie:

Faza 1: Tryb cienia
├── Agent przetwarza równolegle z ludźmi
├── Wyniki porównywane, nie używane
├── Pomiar dokładności i bezpieczeństwa
└── Czas trwania: 1 tydzień

Faza 2: Tryb asystowany
├── Agent proponuje akcje
├── Człowiek przegląda i zatwierdza
├── Uczenie się z korekt
└── Czas trwania: 1-2 tygodnie

Faza 3: Nadzorowana autonomia
├── Agent działa niezależnie
├── Próbkowanie kontrolne
├── Obsługa wyjątków na miejscu
└── Czas trwania: 2-4 tygodnie

Faza 4: Pełna autonomia
├── Agent operuje niezależnie
├── Monitoring i alerty
├── Okresowe przeglądy
└── Stałe

Narzędzie: Wyszukiwanie klienta w CRM

Implementacja:
async function lookup_customer(params) {
  const { email, phone, company } = params;
  
  // Buduj zapytanie
  const query = new URLSearchParams();
  if (email) query.append('email', email);
  if (phone) query.append('phone', phone);
  if (company) query.append('company', company);
  
  // Wywołaj API CRM
  const response = await fetch(
    `${CRM_BASE_URL}/customers/search?${query}`,
    {
      headers: {
        'Authorization': `Bearer ${CRM_TOKEN}`,
        'Content-Type': 'application/json'
      }
    }
  );
  
  if (!response.ok) {
    throw new Error(`Wyszukiwanie CRM nie powiodło się: ${response.status}`);
  }
  
  const customers = await response.json();
  
  // Zwróć sformatowany wynik
  return {
    found: customers.length > 0,
    count: customers.length,
    customers: customers.map(c => ({
      id: c.id,
      name: c.name,
      email: c.email,
      status: c.account_status,
      tier: c.customer_tier
    }))
  };
}

Narzędzie: Sprawdzenie magazynu

Implementacja:
async function check_inventory(params) {
  const { product_id, warehouse } = params;
  
  const query = `
    SELECT 
      p.product_name,
      i.quantity_available,
      i.quantity_reserved,
      i.reorder_point,
      w.warehouse_name
    FROM inventory i
    JOIN products p ON i.product_id = p.id
    JOIN warehouses w ON i.warehouse_id = w.id
    WHERE p.sku = $1
    ${warehouse ? 'AND w.code = $2' : ''}
  `;
  
  const params = warehouse 
    ? [product_id, warehouse] 
    : [product_id];
  
  const result = await db.query(query, params);
  
  return {
    product: product_id,
    warehouses: result.rows.map(r => ({
      warehouse: r.warehouse_name,
      available: r.quantity_available - r.quantity_reserved,
      reserved: r.quantity_reserved,
      low_stock: r.quantity_available < r.reorder_point
    }))
  };
}

Automatyzacja obsługi klienta:

Pobieranie informacji:
├── Sprawdzanie statusu zamówienia
├── Informacje o koncie
├── Specyfikacje produktów
├── Wyjaśnienia polityk
└── Odpowiedzi FAQ

Akcje:
├── Aktualizacja danych kontaktowych
├── Przetwarzanie prostych zwrotów
├── Przyznawanie kredytów na koncie
├── Planowanie oddzwonień
├── Tworzenie zgłoszeń do wsparcia
└── Eskalacja do specjalistów

Decyzje:
├── Kierowanie do właściwego działu
├── Autoryzacja zwrotów w limitach
├── Identyfikacja klientów VIP
├── Priorytetyzacja pilnych spraw
└── Wykrywanie wzorców fraudowych

Automatyzacja procesu sprzedaży:

Zarządzanie leadami:
├── Kwalifikacja przychodzących leadów
├── Badanie firm prospektów
├── Przygotowanie briefów spotkań
├── Planowanie wizyt
└── Wysyłka wiadomości uzupełniających e-mail

Wsparcie transakcji:
├── Generowanie ofert
├── Konfiguracja produktów
├── Kalkulacja cen
├── Sprawdzanie magazynu
├── Przetwarzanie zamówień

Analityka:
├── Raporty pipeline
├── Analiza wygranych/przegranych
├── Aktualizacje prognoz
├── Monitoring konkurencji
└── Metryki wydajności

Automatyzacja operacyjna:

Harmonogramowanie:
├── Alokacja zasobów
├── Planowanie zmian
├── Rezerwacja sprzętu
├── Koordynacja spotkań
└── Planowanie konserwacji

Monitoring:
├── Kontrole zdrowia systemów
├── Przetwarzanie alertów
├── Tworzenie incydentów
├── Obsługa eskalacji
└── Raportowanie statusu

Przetwarzanie:
├── Realizacja zamówień
├── Przetwarzanie faktur
├── Zatwierdzanie wydatków
├── Komunikacja z dostawcami
└── Kontrole zgodności

Miesięczna korzyść = (zadania zautomatyzowane × minuty oszczędzone × koszt/min)
                   + (uniknięte błędy × koszt błędu)
                   - opłata miesięczna
Zwrot = koszt wdrożenia / miesięczna korzyść

1. Pojedyncza odpowiedzialność
   ├── Jeden agent = jedna domena
   ├── Jasne granice
   ├── Skupiony zestaw narzędzi
   └── Łatwiejsze utrzymanie

2. Bezpieczne awarie
   ├── Domyślnie przekazuj do człowieka
   ├── Nigdy nie trać danych klienta
   ├── Loguj wszystkie akcje
   └── Elegancka degradacja

3. Bądź przejrzysty
   ├── Wyjaśniaj akcje użytkownikom
   ├── Zapewniaj ścieżki audytu
   ├── Pokazuj rozumowanie, gdy to pomocne
   └── Przyznawaj się do ograniczeń

4. Ciągłe doskonalenie
   ├── Monitoruj wydajność
   ├── Ucz się z awarii
   ├── Aktualizuj na podstawie informacji zwrotnej
   └── Rozszerzaj możliwości stopniowo

Nadmierna automatyzacja:
├── Nie każde zadanie potrzebuje agenta
├── Niektóre rzeczy wymagają ludzkiego osądu
├── Zacznij małymi krokami, rozszerzaj ostrożnie
└── Mierz przed skalowaniem

Niedostateczne testowanie:
├── Przypadki brzegowe się zdarzą
├── Antagonistyczne wejścia istnieją
├── Systemy niespodziewanie się psują
└── Testuj obszernie przed uruchomieniem

Słaba obsługa błędów:
├── "Coś poszło nie tak" nie jest pomocne
├── Użytkownicy potrzebują jasnych kolejnych kroków
├── Zawsze miej ścieżkę awaryjną
└── Loguj szczegóły do debugowania

Ignorowanie kosztów:
├── Wywołania LLM się sumują
├── Monitoruj wydatki na bieżąco
├── Optymalizuj prompty
└── Buforuj, gdzie to możliwe

Dobre dopasowanie, jeśli:
□ Dużo powtarzalnych zadań
□ Wielosystemowe przepływy pracy
□ Jasne reguły decyzyjne
□ Mierzalne wyniki
□ Możliwości integracyjne

Może nie potrzebujesz agenta, jeśli:
□ Niska objętość (poniżej 100/miesiąc)
□ Proste jednoetapowe zadania
□ Już dobrze zautomatyzowane
□ Wysoce zmienne procesy