Agent AI na własnych danych – praktyczny przewodnik z Google ADK

To nie jest subtelna różnica. Chatbot mówi "temperatura w Warszawie to 15°C". Agent mówi "sprawdziłem pogodę, jest 15°C i pada, więc przesunąłem Twoje spotkanie outdoorowe na jutro i wysłałem powiadomienie uczestnikom".

Agent planuje, decyduje jakie narzędzia użyć, wykonuje akcje i iteruje aż do rozwiązania. I nie, nie jest to science fiction — możesz go zbudować w Pythonie w jedno popołudnie.

{% youtube "9v9KeJxewdQ" %}

Chatbot vs Agent — kluczowa różnica

Agent = LLM + narzędzia (tools) + planowanie + pętla wykonawcza.

Google ADK — Agent Development Kit

Google ADK to framework do budowy agentów AI. Dlaczego akurat ADK?

1. Prosty w użyciu — mniej boilerplate'u niż LangChain
2. Natywne tool use — łatwe definiowanie narzędzi
3. Wbudowane planowanie — agent sam decyduje które narzędzia użyć
4. Działa z różnymi LLM — Gemini, ale też Claude i GPT

Instalacja

Bash
Kopiuj
1
pip install google-adk

Budujemy agenta krok po kroku

Zbudujmy agenta, który pomaga zarządzać projektami — sprawdza status zadań, dodaje nowe i wysyła podsumowania.

Krok 1: Definiujemy narzędzia

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
from google.adk import Agent, Tool
import json

# Symulowana baza zadań
tasks_db = [
    {"id": 1, "title": "Deployment na produkcję", "status": "in_progress", "assignee": "Kacper"},
    {"id": 2, "title": "Code review PR #42", "status": "todo", "assignee": "Anna"},
    {"id": 3, "title": "Fix bug w logowaniu", "status": "done", "assignee": "Kacper"},
]

@Tool
def get_tasks(status: str = None, assignee: str = None) -> str:
    """Pobierz listę zadań. Opcjonalnie filtruj po statusie lub osobie."""
    filtered = tasks_db
    if status:
        filtered = [t for t in filtered if t["status"] == status]
    if assignee:
        filtered = [t for t in filtered if t["assignee"] == assignee]
    return json.dumps(filtered, ensure_ascii=False)

@Tool
def add_task(title: str, assignee: str) -> str:
    """Dodaj nowe zadanie do listy."""
    new_id = max(t["id"] for t in tasks_db) + 1
    task = {"id": new_id, "title": title, "status": "todo", "assignee": assignee}
    tasks_db.append(task)
    return f"Dodano zadanie #{new_id}: {title} (przypisane do {assignee})"

@Tool
def update_task_status(task_id: int, new_status: str) -> str:
    """Zmień status zadania. Dostępne statusy: todo, in_progress, done."""
    for task in tasks_db:
        if task["id"] == task_id:
            task["status"] = new_status
            return f"Zaktualizowano #{task_id}: status → {new_status}"
    return f"Nie znaleziono zadania #{task_id}"

Krok 2: Tworzymy agenta

Python
Kopiuj
1
2
3
4
5
6
7
8
9
agent = Agent(
    name="Project Manager",
    model="gemini-2.0-flash",
    tools=[get_tasks, add_task, update_task_status],
    system_prompt="""Jesteś asystentem zarządzania projektami.
    Pomagasz śledzić zadania, dodawać nowe i raportować status.
    Zawsze sprawdź aktualny stan przed udzieleniem odpowiedzi.
    Odpowiadaj po polsku, konkretnie."""
)

Krok 3: Rozmawiamy z agentem

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
# Agent sam decyduje jakie narzędzia użyć
response = agent.run("Co ma Kacper na dziś?")
# Agent: wywołuje get_tasks(assignee="Kacper")
# → "Kacper ma 2 zadania: 'Deployment na produkcję' (w trakcie) i 'Fix bug w logowaniu' (ukończone)"

response = agent.run("Dodaj zadanie: napisać testy do API, przypisz do Anny")
# Agent: wywołuje add_task(title="Napisać testy do API", assignee="Anna")
# → "Dodano zadanie #4: Napisać testy do API"

response = agent.run("Zamknij deployment Kacpra")
# Agent: wywołuje get_tasks(assignee="Kacper"), znajduje #1
# Agent: wywołuje update_task_status(task_id=1, new_status="done")
# → "Zaktualizowano: Deployment na produkcję → ukończony"

Zauważ: agent sam decyduje które narzędzie wywołać i z jakimi parametrami. Nie mówisz mu "użyj get_tasks" — mówisz "co ma Kacper na dziś" i on to interpretuje.

Agent na własnych danych — RAG + Tools

Najpotężniejszy agent łączy RAG (wyszukiwanie w dokumentach) z narzędziami (akcje):

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@Tool
def search_knowledge_base(query: str) -> str:
    """Przeszukaj bazę wiedzy firmy."""
    # Tu podłączasz vector store (Chroma, pgvector)
    results = vectorstore.similarity_search(query, k=3)
    return "\n".join(doc.page_content for doc in results)

@Tool
def send_email(to: str, subject: str, body: str) -> str:
    """Wyślij email do pracownika."""
    # Tu podłączasz SMTP
    return f"Email wysłany do {to}: {subject}"

agent = Agent(
    name="HR Assistant",
    model="gemini-2.0-flash",
    tools=[search_knowledge_base, send_email, get_tasks],
    system_prompt="Jesteś asystentem HR. Odpowiadasz na pytania pracowników na podstawie regulaminu firmy."
)

# Pracownik pyta o urlop
response = agent.run("Ile dni urlopu mi przysługuje?")
# Agent:
# 1. Szuka w bazie wiedzy: search_knowledge_base("urlop dni przysługujące")
# 2. Znajduje fragment regulaminu
# 3. Odpowiada na podstawie regulaminu

Pułapki agentów AI

1. Za dużo narzędzi

Agent z 50 narzędziami nie wie którego użyć. Trzymaj 5-10 dobrze zdefiniowanych narzędzi. Lepiej wyspecjalizowani agenci niż jeden omnibus.

2. Brak guardrails

Agent z dostępem do bazy danych bez ograniczeń to zaproszenie do katastrofy. Zawsze: read-only dla niebezpiecznych operacji, whitelisting dozwolonych akcji, potwierdzenie przed destrukcyjnymi operacjami.

3. Nieskończone pętle

Agent, który nie znajduje rozwiązania, może kręcić się w kółko. Ustaw limit iteracji (max 5-10 wywołań narzędzi per request).

4. Brak logowania

Loguj każde wywołanie narzędzia — co agent zrobił, jakie dane dostał, jak zinterpretował wynik. Bez tego debugowanie jest niemożliwe.

Kiedy agent, a kiedy prosty chatbot?

• Chatbot: FAQ, proste Q&A, summarization — wystarczy LLM + prompt
• RAG: Q&A na dokumentach — LLM + wyszukiwanie
• Agent: Gdy trzeba działać — wykonywać akcje, łączyć dane z wielu źródeł, podejmować decyzje

Nie buduj agenta jeśli chatbot wystarczy. Ale jeśli Twój chatbot ciągle mówi "nie mogę tego zrobić" — czas na agenta.

Podsumowanie

• Agent AI = LLM + narzędzia + planowanie — coś więcej niż chatbot
• Google ADK ułatwia budowę: definiujesz narzędzia jako funkcje Python
• Agent sam decyduje które narzędzia użyć i w jakiej kolejności
• Łącz RAG (baza wiedzy) + Tools (akcje) dla najpotężniejszych agentów
• Guardrails, logowanie i limity iteracji to must-have na produkcji

Agenty AI to przyszłość automatyzacji w firmie — nie zastępują ludzi, ale dają im supermoc. Zamiast klikać w 5 systemach, mówisz agentowi co chcesz osiągnąć.

Budowanie agentów łączy się z automatyzacją procesów. Na moim kursie n8n pokazuję jak budować agentów i integrować je z workflow automatyzacji.