SmoLAGents: Twoje Małe, ale Potężne Agenty AI 🤖

Czujesz się przytłoczony skomplikowanymi frameworkami AI? Poznaj SmoLAGents – minimalistyczne rozwiązanie do budowy potężnych agentów AI. Zaledwie ~1000 linii kodu – to jak Marie Kondo w świecie frameworków, zostawiając tylko to, co sprawia radość (i jest funkcjonalne)!

Czym są SmoLAGents?

W swojej istocie SmoLAGents to biblioteka Pythona, która pozwala tworzyć agenty AI bez zbędnego obciążenia. To jak zestaw LEGO dla AI – otrzymujesz podstawowe klocki, aby budować agenty, które wykonują zadania, podejmują decyzje, a nawet piszą kod.

Dlaczego "smol"?

"Smol" w SmoLAGents to nie tylko uroczy slang internetowy – to filozofia. W świecie, gdzie frameworki AI często przypominają próbę połknięcia słonia, SmoLAGents stawia na zasadę „małe jest piękne”:

• Minimalistyczne abstrakcje: Bez labiryntu złożonych hierarchii
• Czytelny kod: ~1000 linii, które naprawdę możesz zrozumieć
• Zero zbędnych zależności: Tylko to, co niezbędne, nic więcej

Kluczowe funkcje 🚀

1. Uniwersalne wsparcie LLM Chcesz używać GPT-4? Llama? A może nowego modelu z Hugging Face? SmoLAGents współpracuje z nimi wszystkimi, wspierając modele od OpenAI, Anthropic i te dostępne w Hugging Face Hub.

2. Podejście „Code-First” W przeciwieństwie do innych frameworków, gdzie generowanie kodu jest dodatkiem, SmoLAGents traktuje je priorytetowo. Twoje agenty mogą pisać, wykonywać i debugować kod tak naturalnie, jak oddychanie.

3. Integracja z Hugging Face Udostępniaj i pobieraj narzędzia bezpośrednio z Hub, bo dobre agenty zasługują na dobre narzędzia. To jak App Store dla funkcji agentów!

4. Bezpieczeństwo przede wszystkim Kod jest uruchamiany w domyślnie bezpiecznym środowisku, aby uniknąć niespodziewanych komend, jak rm -rf /. Ty decydujesz, do czego agenty mają dostęp.

Najlepsze? Nie potrzebujesz doktoratu z AI, aby go używać. Jeśli potrafisz pisać w Pythonie i masz ciekawość, jesteś już gotowy, by zacząć budować ze SmoLAGents. Gotowy, by sprawić, że Twoje agenty AI będą działać mądrzej, nie ciężej? Zanurzmy się! 🏊‍♂️

Jak zacząć z SmoLAGents 🚀

Instalacja

pip install smolagents

Podstawowa konfiguracja

Aby stworzyć swojego pierwszego agenta, będziesz potrzebować:

1. Wybór modelu: Wybierz swoje zaplecze LLM

from smolagents import HfApiModel

# Użyj modelu Hugging Face
model = HfApiModel(model_id="meta-llama/Llama-3.3-70B-Instruct")

# W przypadku modeli z ograniczonym dostępem, dodaj swój token
model = HfApiModel(
    model_id="meta-llama/Llama-3.3-70B-Instruct",
    token="TWÓJ_TOKEN_HF"
)

2. Wybór narzędzi: Wybierz możliwości swojego agenta

from smolagents import DuckDuckGoSearchTool

# Pojedyncze narzędzie
tools = [DuckDuckGoSearchTool()]

# Lub użyj domyślnego zestawu narzędzi
tools = []  # Pusta lista + narzędzia bazowe

---

Tworzenie pierwszego agenta

Poniżej znajdziesz kompletny przykład tworzenia agenta do wyszukiwania w sieci:

from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel

# Inicjalizacja agenta z możliwością wyszukiwania
agent = CodeAgent(
    tools=[DuckDuckGoSearchTool()],
    model=HfApiModel(),
    add_base_tools=True  # Dodaje domyślny zestaw narzędzi
)

# Uruchom swoje pierwsze zadanie
response = agent.run(
    "Jaki jest najszybszy lądowy zwierzak i jak szybko biega?"
)

---

Uwagi dotyczące bezpieczeństwa 🔒

Domyślnie CodeAgent działa w bezpiecznym lokalnym środowisku. Dla dodatkowego bezpieczeństwa możesz:

• Używać use_e2b_executor=True dla piaskowanego środowiska
• Kontrolować importy za pomocą additional_authorized_imports=['requests', 'pandas']

---

Twój agent jest teraz gotowy do działania! Chcesz zobaczyć go w akcji? Spróbuj interfejsu Gradio:

from smolagents import GradioUI

GradioUI(agent).launch()

---

Zrozumienie systemów agencyjnych w SmoLAGents

Podstawowe pojęcia

Agenty AI to programy, w których wyjścia LLM sterują przepływem pracy. Agencja działa na spektrum:

1. Prosty procesor (☆☆☆): Wyjście LLM → bezpośrednie przetwarzanie
2. Router (★☆☆): Wyjście LLM → warunkowe rozgałęzienia
3. Wywoływacz narzędzi (★★☆): Wyjście LLM → wykonywanie funkcji
4. Agent wieloetapowy (★★★): Wyjście LLM → iteracyjna pętla wykonania
5. Agent wieloagentowy (★★★): Wyjście LLM → uruchamianie innych agentów

---

Architektura agentów

SmoLAGents implementuje dwie kluczowe architektury:

1. CodeAgent

while not task_complete:
    code = llm.generate_code(memory)
    result = execute_code(code)
    memory.append(result)

2. ToolCallingAgent

while not task_complete:
    action = llm.generate_action_json(memory)
    result = execute_tool(action)
    memory.append(result)

---

Komponenty i role

1. Silnik LLM: Generuje odpowiedzi i decyzje
2. Narzędzia: Zewnętrzne funkcje dostępne dla agenta
3. Parser: Wydobywa wykonywalne akcje z wyjścia LLM
4. Pamięć: Przechowuje historię rozmów i wykonania
5. Obsługa błędów: Zarządza niepowodzeniami i ponownymi próbami

---

Porównanie frameworków

SmoLAGents vs inne:

• Code-First: Używa kodu Pythona zamiast JSON do akcji
• Minimalistyczny: ~1000 linii kodu bazowego
• Elastyczny: Wspiera zarówno kodowanie, jak i wywoływanie narzędzi
• Bezpieczny: Domyślnie piaskowane środowisko

---

Kiedy używać agentów:

• ✅ Złożone, nieprzewidywalne przepływy pracy
• ✅ Zadania wymagające wielu kroków/narzędzi
• ⛔ Proste, deterministyczne procesy
• ⛔ Zadania z ustalonymi drzewami decyzyjnymi

---

Samokorygujący przykład Text-to-SQL

Implementacja

from smolagents import CodeAgent, HfApiModel, tool

@tool
def sql_engine(query: str) -> str:
    """Wykonaj zapytania SQL i zwróć wyniki jako string"""
    with engine.connect() as con:
        rows = con.execute(text(query))
        return "\\n".join(str(row) for row in rows)

agent = CodeAgent(
    tools=[sql_engine],
    model=HfApiModel("Qwen/Qwen2.5-Coder-32B-Instruct")
)

---

Obsługa błędów

1. Walidacja zapytania

try:
    # Walidacja składni SQL
    parsed_sql = sqlparse.parse(query)[0]
    if not valid_syntax(parsed_sql):
        raise SQLSyntaxError

    # Wykonaj zapytanie
    result = sql_engine(query)

except SQLError as e:
    # Agent generuje poprawione zapytanie
    corrected_query = agent.correct_sql(query, e)

2. Weryfikacja wyników

def verify_results(query_result):
    if not query_result.strip():
        return "Brak wyników. Może być konieczne doprecyzowanie zapytania."
    try:
        parsed = json.loads(query_result)
        validate_schema(parsed)
    except:
        return "Nieprawidłowy format wyniku"

---

Optymalizacja wydajności

1. Planowanie zapytań

• Używaj EXPLAIN do analizy zapytań
• Dodawaj odpowiednie indeksy
• Optymalizuj operacje JOIN

2. Buforowanie

from functools import lru_cache

@lru_cache(maxsize=100)
def cached_sql_query(query_hash):
    return sql_engine(query)

---

Dodatkowe zastosowania

1. Analiza danych

• Analiza szeregów czasowych
• Zapytania agregacyjne
• Obliczenia statystyczne

2. Automatyzacja zadań

• Generowanie raportów
• Walidacja danych
• Procesy ETL

3. Generowanie kodu

• Tworzenie schematów SQL
• Procedury składowane
• Migracje bazy danych

---

Przykład przeglądarki wieloagentowej

Architektura

# Inicjalizacja modelu
model = HfApiModel(model_id="Qwen/Qwen2.5-Coder-32B-Instruct")

# Agent wyszukiwania w sieci z narzędziami
web_agent = ToolCallingAgent(
    tools=[DuckDuckGoSearchTool(), visit_webpage],
    model=model,
    max_steps=10
)

# Zarządzany agent
managed_web_agent = ManagedAgent(
    agent=web_agent,
    name="search",
    description="Wykonuje wyszukiwania w sieci."
)

# Agent zarządzający
manager_agent = CodeAgent(
    tools=[],
    model=model,
    managed_agents=[managed_web_agent],
    additional_authorized_imports=["time", "numpy", "pandas"]
)

---

Kluczowe komponenty

1. Agent wyszukiwania w sieci

• Narzędzie DuckDuckGo Search
• Narzędzie do odwiedzania stron internetowych
• Format wywoływania narzędzi w JSON
• Limit 10 kroków na eksplorację

2. Agent zarządzający

• Koordynuje wyszukiwania w sieci
• Przetwarza wyniki
• Wykonuje obliczenia
• Obsługuje kod

---

Przykładowe zadanie

# Złożone pytanie badawcze
query = """
Jeśli szkolenia LLM będą nadal się rozwijać w obecnym tempie
do 2030 roku, jaka moc elektryczna w GW będzie wymagana?
"""

result = manager_agent.run(query)

---

Funkcje wydajnościowe

1. Przetwarzanie równoległe

• Agent zarządzający deleguje wyszukiwania
• Agent sieciowy eksploruje wiele stron jednocześnie
• Wyniki są skutecznie agregowane

2. Odzyskiwanie po błędach

• Nieudane wyszukiwania są powtarzane
• Eksplorowane są alternatywne źródła
• Sprawdzane są dane wyjściowe

3. Zarządzanie zasobami

• Limity kroków zapobiegają nieskończonym pętlom
• Efektywne przetwarzanie treści stron
• Skupione strategie wyszukiwania

4. Rozszerzalność

• Dodawanie wyspecjalizowanych agentów
• Integracja niestandardowych narzędzi
• Elastyczna dystrybucja zadań

---