Izgradnja Lokalnog Višeagentnog Sustava s TinyLlama: Vodič za Autonomnu Suradnju i Dekompoziciju Zadatka

U današnjem svijetu, gdje su brzina, učinkovitost i privatnost podataka ključni, razvoj pametnih sustava umjetne inteligencije koji mogu raditi autonomno i lokalno postaje sve važniji. Ovaj članak će vas voditi kroz proces dizajniranja i implementacije lokalnog višeagentnog sustava s TinyLlama, koristeći arhitekturu menadžera i agenata. Naučit ćete kako izgraditi sustav koji omogućuje strukturiranu dekompoziciju zadataka, autonomnu suradnju između AI agenata i inteligentne petlje zaključivanja, sve to bez oslanjanja na vanjske API-je ili internetsku vezu.

Fokusirat ćemo se na korištenje TinyLlama, malog, ali moćnog jezičnog modela, koji se može izvršavati izravno putem transformers biblioteke. Time stvaramo potpuno offline, lagan i transparentan sustav koji možemo prilagoditi, pregledati i proširiti prema vlastitim potrebama. Kroz detaljne primjere koda i objašnjenja, promatrat ćemo kako se svaka komponenta – od struktura zadataka i promptova agenata do sinteze rezultata – spaja u koherentan radni proces između čovjeka i AI-ja, koji imate pod potpunom kontrolom.

Zaronite s nama u fascinantan svijet autonomnih AI agenata i otkrijte kako možete iskoristiti snagu umjetne inteligencije na vašem lokalnom stroju!

Što je Lokalni Višeagentni Sustav Orkestracije i Zašto ga Trebamo?

U srcu modernog AI razvoja leži koncept agentnih sustava – modularnih komponenti sposobnih za razumijevanje, planiranje i izvršavanje specifičnih zadataka. Kada se ti agenti udruže, formiraju višeagentni sustav, gdje svaki agent ima specijaliziranu ulogu i surađuje s ostalima kako bi riješio složene probleme koji bi bili preveliki ili prezahtjevni za jednog agenta. Orkestracija se odnosi na proces koordinacije i upravljanja tim agentima kako bi se osiguralo da rade zajedno učinkovito i usklađeno.

Konkretno, lokalni višeagentni sustav s TinyLlama znači da se cijeli proces – od pokretanja jezičnog modela do koordinacije agenata – odvija na vašem računalu, bez slanja podataka na vanjske servere ili oblak. Ova arhitektura donosi niz značajnih prednosti, ali i neke izazove.

Prednosti Lokalnog Izvršavanja AI Sustava

Lokalno izvršavanje AI modela i višeagentnih sustava nudi kritične prednosti u kontekstu sigurnosti, privatnosti i kontrole:

• Privatnost i Sigurnost Podataka: Jedna od najvećih briga kod korištenja vanjskih AI API-ja je privatnost. Osjetljivi podaci često se moraju slati na servere trećih strana. Lokalno izvršavanje eliminira taj rizik, osiguravajući da vaši podaci nikada ne napuštaju vaše računalo. Ovo je ključno za tvrtke i pojedince koji rade s povjerljivim informacijama (npr. medicinski podaci, financijski izvještaji, osobni podaci).
• Smanjeni Operativni Troškovi: Korištenje cloud API-ja za velike jezične modele često dolazi s visokim troškovima po tokenu ili po upitu. Lokalni sustav, nakon početnog ulaganja u hardver (ako je potrebno), ima zanemarive operativne troškove, što ga čini ekonomičnijim na duge staze, posebno za intenzivnu upotrebu.
• Niska Latencija: Slanje podataka u oblak i čekanje na odgovor generira kašnjenje (latenciju). Lokalni sustavi nude gotovo trenutne odgovore, što je ključno za aplikacije koje zahtijevaju brzu interakciju ili obradu u stvarnom vremenu.
• Potpuna Kontrola i Prilagodba: Budući da imate pristup cijelom kodu i modelu, možete ga prilagoditi svojim specifičnim potrebama. To uključuje finetuning modela, promjenu arhitekture agenata, implementaciju posebnih sigurnosnih mjera ili integraciju s drugim lokalnim alatima. Fleksibilnost je neusporediva s ograničenjima API-ja.
• Offline Sposobnost: Nema interneta? Nema problema! Lokalni sustav funkcionira neovisno o mrežnoj povezanosti, što je idealno za terenski rad, putovanja ili okruženja s ograničenim pristupom internetu.

Uloga TinyLlama u Lokalnom Sustavu

Iako su veći modeli poput GPT-4 ili Llama 2 70B parametri izvan dosega prosječnog lokalnog hardvera, TinyLlama mijenja pravila igre. TinyLlama-1.1B-Chat-v1.0 je model s 1,1 milijardom parametara, obučen na 3 bilijuna tokena, dizajniran za učinkovitost i performanse na ograničenom hardveru. Njegove ključne prednosti uključuju:

• Niski Hardverski Zahtjevi: Može raditi na većini modernih računala s pristojnom količinom RAM-a i, idealno, GPU-om, čak i s relativno skromnim specifikacijama (npr. 8-16 GB RAM-a za CPU, ili GPU s 4-8 GB VRAM-a uz kvantizaciju).
• Brzo Zaključivanje: Zbog svoje veličine, TinyLlama generira odgovore znatno brže od većih modela na lokalnom hardveru, čime se smanjuje čekanje i poboljšava korisničko iskustvo.
• Dobre Performanse za Specifične Zadatke: Iako ne može konkurirati najvećim modelima u općoj inteligenciji, TinyLlama je iznimno sposobna za zadatke poput generiranja teksta, sumarizacije, prevođenja i, što je ključno za naš sustav, dekompozicije zadataka i usmjeravanja agenata, posebno kada je dobro promptana.
• Otvoreni Izvor (Open Source): Kao model otvorenog koda, TinyLlama omogućuje punu transparentnost i mogućnost modifikacije, što je u skladu s filozofijom lokalnog i prilagodljivog sustava.

Kombinacijom snage višeagentnog pristupa i učinkovitosti TinyLlama, možemo stvoriti robustan i fleksibilan lokalni višeagentni sustav s TinyLlama koji otvara vrata mnogim inovativnim primjenama.

Arhitektura Sustava: Od Temelja do Funkcionalnosti

Za izgradnju lokalnog višeagentnog sustava s TinyLlama, potrebna nam je jasna i modularna arhitektura. Ona se sastoji od nekoliko ključnih komponenti: struktura podataka za zadatke i agente, registar agenata, lokalni jezični model (LLM) i centralni menadžer agenata.

Postavljanje Temelja: Potrebne Biblioteke i Strukture Podataka

Prije nego što zaronimo u logiku, moramo osigurati da imamo sve potrebne alate i definirane osnovne entitete. Koristimo popularne Python biblioteke za rad s AI modelima i strukturiranim podacima.

!pip install transformers torch accelerate bitsandbytes -q

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
import json
import re
from typing import List, Dict, Any
from dataclasses import dataclass, asdict
from datetime import datetime

@dataclass
class Task:
   id: str
   description: str
   assigned_to: str = None
   status: str = "pending"
   result: Any = None
   dependencies: List[str] = None

def __post_init__(self):
       if self.dependencies is None:
           self.dependencies = []

@dataclass
class Agent:
   name: str
   role: str
   expertise: str
   system_prompt: str

U ovom početnom bloku koda radimo nekoliko ključnih stvari:

• Instalacija Biblioteka: Linija !pip install transformers torch accelerate bitsandbytes -q osigurava da imamo instalirane sve potrebne biblioteke.
  • transformers: Temeljna biblioteka tvrtke Hugging Face za rad s transformatorskim modelima, uključujući TinyLlama.
  • torch: PyTorch, popularan deep learning framework koji pogoni transformers.
  • accelerate: Biblioteka za jednostavnije distribuirano treniranje i inferencu PyTorch modela.
  • bitsandbytes: Ključna biblioteka za kvantizaciju modela, omogućujući nam pokretanje većih modela (ili učinkovitije TinyLlama) s manjim hardverskim zahtjevima (manje VRAM-a).
• Osnovne Strukture Podataka: Definiramo dvije ključne dataclass klase: Task i Agent.
  • Task: Predstavlja pojedinačni zadatak unutar sustava. Sadrži id, description, assigned_to (kojem agentu je dodijeljen), status (npr. “pending”, “in_progress”, “completed”), result (rezultat izvršenja zadatka) i dependencies (listu ID-jeva zadataka o kojima ovisi). Metoda __post_init__ osigurava da je dependencies uvijek lista, čak i ako nije inicijalno specificirana.
  • Agent: Predstavlja pojedinog AI agenta. Sadrži name, role (ulogu), expertise (područje stručnosti) i system_prompt (inicijalni prompt koji definira ponašanje i osobnost agenta).

Ove strukturirane entitete su temelj za čistu i efikasnu orkestraciju rada. Osiguravaju da svaki dio sustava ima dosljedan i pouzdan temelj za upravljanje zadacima i agentima. Uz te temelje, možemo graditi složeniju logiku i funkcionalnost.

Definiranje AI Agenata: Specijalizirane Uloge za Složene Zadatke

Snaga višeagentnog sustava leži u sposobnosti specijalizacije. Umjesto jednog “svemoćnog” AI-ja, imamo tim agenata, svaki obučen ili promptan da bude iznimno dobar u određenoj domeni. To poboljšava kvalitetu odgovora i učinkovitost. Definiramo globalni registar agenata, AGENT_REGISTRY, koji sadrži instance klase Agent.

AGENT_REGISTRY = {
   "researcher": Agent(
       name="researcher",
       role="Research Specialist",
       expertise="Information gathering, analysis, and synthesis",
       system_prompt="You are a research specialist. Provide thorough research on topics."
   ),
   "coder": Agent(
       name="coder",
       role="Software Engineer",
       expertise="Writing clean, efficient code with best practices",
       system_prompt="You are an expert programmer. Write clean, well-documented code."
   ),
   "writer": Agent(
       name="writer",
       role="Content Writer",
       expertise="Clear communication and documentation",
       system_prompt="You are a professional writer. Create clear, engaging content."
   ),
   "analyst": Agent(
       name="analyst",
       role="Data Analyst",
       expertise="Data interpretation and insights",
       system_prompt="You are a data analyst. Provide clear insights from data."
   )
}

Svaki agent u AGENT_REGISTRY ima jasno definiranu svrhu:

• Researcher (Istraživač): Specijaliziran za prikupljanje, analizu i sintezu informacija. Njegov system_prompt ga usmjerava da pruži temeljito istraživanje. Zamislite ga kako pretražuje lokalne dokumente, baze podataka ili simulira pretraživanje weba (iako u ovom lokalnom sustavu, ulazni podaci dolaze iz drugih agenata ili su predefinirani).
• Coder (Programer): Zadužen za pisanje čistog, učinkovitog i dobro dokumentiranog koda. Njegov prompt osigurava da se pridržava najboljih praksi kodiranja. Mogao bi generirati skripte, funkcije ili čak cijele programe na temelju specifikacija.
• Writer (Pisac): Fokusiran na stvaranje jasnog, angažirajućeg i profesionalnog sadržaja. Može pisati izvještaje, blog postove, korisničke priručnike ili marketinške materijale.
• Analyst (Analitičar): Njegova uloga je interpretacija podataka i pružanje jasnih uvida. Mogao bi analizirati rezultate istraživanja, prepoznati trendove ili izvući ključne zaključke iz strukturiranih podataka.

Ovakva modularnost omogućuje sustavu da efikasnije rješava složene zadatke. Na primjer, ako trebamo napisati blog post o novoj tehnologiji, sustav može prvo angažirati “researcher” agenta da prikupi informacije, zatim “analyst” agenta da ih sumira, i na kraju “writer” agenta da sastavi konačni članak. Ključ je u `system_prompt` koji svakom agentu daje specifičnu “osobnost” i “instrukcije” za obavljanje njegove uloge.

Srce Sustava: Lokalni LLM s TinyLlama

Centralni mozak našeg lokalnog višeagentnog sustava s TinyLlama je sam jezični model – TinyLlama. Kapsuliramo ga u klasu LocalLLM kako bismo pojednostavili interakciju i upravljanje. Ova klasa je odgovorna za učitavanje modela i tokenizera, kao i za izvođenje inferencije (generiranje teksta).

class LocalLLM:
   def init(self, model_name: str = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"):
       self.tokenizer = AutoTokenizer.from_pretrained(model_name)
       quantization_config = BitsAndBytesConfig(
           load_in_4bit=True,
           bnb_4bit_compute_dtype=torch.float16
       ) if torch.cuda.is_available() else None
       self.model = AutoModelForCausalLM.from_pretrained(
           model_name,
           quantization_config=quantization_config,
           device_map="auto",
           low_cpu_mem_usage=True,
           trust_remote_code=True if 'trust_remote_code' in AutoModelForCausalLM.config_class.from_pretrained(model_name).to_dict() else False
       )

def generate(self, prompt: str, max_new_tokens: int = 500, temperature: float = 0.7) -> str:
       messages = [
           {"role": "user", "content": prompt}
       ]
       input_ids = self.tokenizer.apply_chat_template(
           messages,
           tokenize=True,
           add_generation_prompt=True,
           return_tensors="pt"
       ).to(self.model.device)

outputs = self.model.generate(
           input_ids,
           max_new_tokens=max_new_tokens,
           do_sample=True,
           temperature=temperature,
           pad_token_id=self.tokenizer.eos_token_id
       )
       response = self.tokenizer.decode(outputs[0][input_ids.shape[-1]:], skip_special_tokens=True)
       return response

Detaljno objašnjenje klase LocalLLM:

• init(self, model_name):
  • self.tokenizer = AutoTokenizer.from_pretrained(model_name): Učitava tokenizator specifičan za odabrani model (u našem slučaju “TinyLlama/TinyLlama-1.1B-Chat-v1.0”). Tokenizator je odgovoran za pretvaranje teksta u numeričke ID-eve tokena koje model može razumjeti i obrnuto.
  • quantization_config = BitsAndBytesConfig(...): Ovo je ključni dio za lokalno izvršavanje. Kvantizacija smanjuje preciznost težina modela (npr. s 32-bitne float na 4-bitnu integer), dramatično smanjujući zahtjeve za memorijom GPU-a.
    • load_in_4bit=True: Omogućuje učitavanje modela u 4-bitnoj preciznosti.
    • bnb_4bit_compute_dtype=torch.float16: Određuje tip podataka za računske operacije, zadržavajući ih u 16-bitnoj float preciznosti radi boljih performansi.
    • Ovaj dio koda se izvršava samo ako je dostupna CUDA (NVIDIA GPU), jer bitsandbytes najbolje funkcionira s GPU-ima.
  • self.model = AutoModelForCausalLM.from_pretrained(...): Učitava sam TinyLlama model.
    • quantization_config=quantization_config: Primjenjuje konfiguraciju kvantizacije.
    • device_map="auto": Automatski distribuira slojeve modela na dostupne uređaje (GPU, CPU) radi optimalnog korištenja memorije.
    • low_cpu_mem_usage=True: Optimizira korištenje CPU memorije tijekom učitavanja modela.
    • trust_remote_code=...: Ponekad su modeli opremljeni prilagođenim modulima, pa je potrebno vjerovati daljinskom kodu. Ovaj dio provjerava je li to potrebno za TinyLlama model.
• generate(self, prompt, max_new_tokens, temperature): Ova metoda služi za generiranje teksta na temelju zadanog prompta.
  • messages = [{"role": "user", "content": prompt}]: Priprema prompt u formatu za chat modele (kao što je TinyLlama-Chat), simulirajući korisnikovu poruku.
  • input_ids = self.tokenizer.apply_chat_template(...): Tokenizira pripremljenu poruku, dodaje posebne tokene za chat formatiranje i pretvara je u tenzor koji je model spreman obraditi.
  • outputs = self.model.generate(...): Poziva metodu generiranja modela.
    • max_new_tokens: Maksimalan broj tokena koje model može generirati.
    • do_sample=True: Omogućuje uzorkovanje (sampling) za generiranje raznolikijih odgovora, umjesto uvijek istog najvjerojatnijeg.
    • temperature: Kontrolira kreativnost odgovora. Više temperature (npr. 0.8-1.0) rezultiraju kreativnijim, ali potencijalno manje koherentnim odgovorima; niže temperature (npr. 0.2-0.5) daju fokusiranije i predvidljivije odgovore.
    • pad_token_id=self.tokenizer.eos_token_id: Postavlja token za punjenje na “end of sequence” token, što je važno za serijsko generiranje i pravilno završavanje odgovora.
  • response = self.tokenizer.decode(...): Dekodira generirane ID-eve tokena natrag u čitljiv tekst, uklanjajući posebne tokene.

Korištenje TinyLlama s kvantizacijom omogućuje nam da imamo moćan jezični model koji pokreće cijeli sustav, a da pritom ostane dovoljno lagan za većinu lokalnih postavki. To je temeljna komponenta koja omogućuje autonomno zaključivanje i obradu unutar našeg lokalnog višeagentnog sustava s TinyLlama.

Orkestracija Zadatka: Menadžer Agenata u Akciji

Da bi lokalni višeagentni sustav s TinyLlama funkcionirao kao koherentna cjelina, potreban nam je centralni entitet koji će upravljati zadacima, dodjeljivati ih agentima, nadzirati njihov napredak i sintetizirati konačne rezultate. Tu ulogu preuzima AgentManager.

class AgentManager:
   def init(self, llm: LocalLLM, agent_registry: Dict[str, Agent]):
       self.llm = llm
       self.agents = agent_registry
       self.tasks: Dict[str, Task] = {}
       self.task_queue: List[str] = []
       self.task_id_counter = 0

def create_task(self, description: str, dependencies: List[str] = None) -> Task:
       task_id = f"task_{self.task_id_counter}"
       self.task_id_counter += 1
       new_task = Task(id=task_id, description=description, dependencies=dependencies)
       self.tasks[task_id] = new_task
       self.task_queue.append(task_id)
       return new_task

def decompose_task(self, high_level_task_description: str) -> List[Task]:
       prompt = f"""
       You are an expert task decomposer. Your goal is to break down a high-level task into a list of smaller, manageable sub-tasks.
       Each sub-task should be clear, concise, and assignable to one of the following specialized agents:
       {', '.join([f"{agent.name} ({agent.expertise})" for agent in self.agents.values()])}

For each sub-task, provide a description and a suggested agent. If a task depends on another, specify its dependency.
       The output should be a JSON array of objects, each with 'id', 'description', 'assigned_to', and 'dependencies' (a list of task IDs).
       Example:
       [
           {{"id": "task_0", "description": "Research market trends for AI tools.", "assigned_to": "researcher", "dependencies": []}},
           {{"id": "task_1", "description": "Draft a blog post outline based on research.", "assigned_to": "writer", "dependencies": ["task_0"]}}
       ]

High-level task: "{high_level_task_description}"
       Generated sub-tasks:
       """
       response = self.llm.generate(prompt, max_new_tokens=1000, temperature=0.5)

Extract JSON from the response
       json_match = re.search(r"\[\s\{.?\}\s\]", response, re.DOTALL)
       if json_match:
           try:
               sub_tasks_data = json.loads(json_match.group(0))
               tasks = []
               for task_data in sub_tasks_data:
Ensure unique task IDs if they are not sequential
                   current_task_id = f"task_{self.task_id_counter}"
                   self.task_id_counter += 1
                   task_data['id'] = current_task_id

new_task = Task(task_data)
                   self.tasks[new_task.id] = new_task
                   self.task_queue.append(new_task.id)
                   tasks.append(new_task)
               print(f"Decomposed task '{high_level_task_description}' into {len(tasks)} sub-tasks.")
               return tasks
           except json.JSONDecodeError as e:
               print(f"Error decoding JSON response from LLM: {e}\nResponse: {response}")
               return []
       else:
           print(f"No JSON found in LLM response: {response}")
           return []

def assign_task(self, task_id: str, agent_name: str):
       if task_id in self.tasks and agent_name in self.agents:
           self.tasks[task_id].assigned_to = agent_name
           print(f"Task {task_id} '{self.tasks[task_id].description}' assigned to {agent_name}.")
       else:
           print(f"Could not assign task {task_id} to {agent_name}. Task or agent not found.")

def execute_task(self, task_id: str) -> Any:
       task = self.tasks.get(task_id)
       if not task or task.status != "pending":
           return None

agent = self.agents.get(task.assigned_to)
       if not agent:
           print(f"No agent assigned to task {task_id} or agent not found.")
           task.status = "failed"
           return None

self.tasks[task_id].status = "in_progress"
       print(f"Executing task {task_id} with {agent.name}...")

Prepare the prompt for the agent
       agent_prompt = f"{agent.system_prompt}\n\nTask: {task.description}\n\nProvide your detailed output:"

Include results from dependencies if available
       dependency_results = []
       for dep_id in task.dependencies:
           dep_task = self.tasks.get(dep_id)
           if dep_task and dep_task.status == "completed" and dep_task.result:
               dependency_results.append(f"Result from {dep_id} ({self.agents[dep_task.assigned_to].name}): {dep_task.result}")

if dependency_results:
           agent_prompt += "\n\nRelevant previous results:\n" + "\n".join(dependency_results)

try:
           result = self.llm.generate(agent_prompt, max_new_tokens=1500, temperature=0.7) # More tokens for detailed output
           self.tasks[task_id].result = result
           self.tasks[task_id].status = "completed"
           print(f"Task {task_id} completed by {agent.name}.")
           return result
       except Exception as e:
           print(f"Error executing task {task_id} with agent {agent.name}: {e}")
           self.tasks[task_id].status = "failed"
           return None

def process_task_queue(self, max_iterations: int = 20):
       print("Starting task queue processing...")
       current_iteration = 0
       while self.task_queue and current_iteration < max_iterations:
           executable_tasks_this_iteration = []
           for task_id in list(self.task_queue): # Iterate over a copy to allow modification
               task = self.tasks[task_id]
               if task.status == "pending":
Check if all dependencies are met
                   dependencies_met = True
                   for dep_id in task.dependencies:
                       if dep_id not in self.tasks or self.tasks[dep_id].status != "completed":
                           dependencies_met = False
                           break


if dependencies_met:
                       executable_tasks_this_iteration.append(task_id)
                   else:
Move tasks with unmet dependencies to the end of the queue for later processing
                       self.task_queue.remove(task_id)
                       self.task_queue.append(task_id)


if not executable_tasks_this_iteration:
               print("No executable tasks in this iteration. Remaining tasks might have unmet dependencies or are already processed.")
               break # No progress can be made

for task_id in executable_tasks_this_iteration:
               task = self.tasks[task_id]
               if task.assigned_to is None:
If not pre-assigned (e.g., from manual create_task), assign it here
                   self._auto_assign_task(task_id)
               self.execute_task(task_id)
               if task.status == "completed" or task.status == "failed":
                   self.task_queue.remove(task_id)


current_iteration += 1
           print(f"Iteration {current_iteration} completed. Remaining tasks in queue: {len(self.task_queue)}")

if self.task_queue:
           print(f"Task queue not empty after {max_iterations} iterations. Remaining tasks: {[self.tasks[tid].description for tid in self.task_queue]}")
       else:
           print("All tasks processed successfully.")

def _auto_assign_task(self, task_id: str):
       task = self.tasks[task_id]
       best_agent = None
       best_score = -1

Simple keyword-based assignment or prompt the LLM to assign
For demonstration, we'll try to use LLM for assignment if task decomposition didn't do it.
       prompt = f"""
       A task needs to be assigned to the most suitable agent.
       Available agents and their expertise:
       {', '.join([f"{agent.name} ({agent.expertise})" for agent in self.agents.values()])}

Task description: "{task.description}"

Which agent is best suited for this task? Respond with only the agent's name (e.g., "researcher").
       """
       response = self.llm.generate(prompt, max_new_tokens=10, temperature=0.1).strip().lower()

if response in self.agents:
           self.assign_task(task_id, response)
       else:
           print(f"Could not automatically assign task {task_id}. LLM suggested: '{response}'. Defaulting to 'researcher'.")
           self.assign_task(task_id, "researcher") # Fallback to a default agent

def synthesize_results(self, main_goal: str) -> str:
       completed_tasks = [task for task in self.tasks.values() if task.status == "completed"]
       if not completed_tasks:
           return "No tasks were completed to synthesize results."

synthesis_prompt = f"""
       You are a Chief AI Officer. Your team of specialized agents has completed several sub-tasks related to the main goal: "{main_goal}".
       Review the results from each agent and synthesize them into a coherent, comprehensive final report or response.
       Ensure all key findings and outputs are integrated logically.

Agent Task Results:
       """
       for task in completed_tasks:
           synthesis_prompt += f"\n--- Task ID: {task.id} ---"
           synthesis_prompt += f"\nAgent: {task.assigned_to} ({self.agents[task.assigned_to].role})"
           synthesis_prompt += f"\nTask Description: {task.description}"
           synthesis_prompt += f"\nResult:\n{task.result}\n"

synthesis_prompt += "\n--- End of Results ---\n\n"
       synthesis_prompt += "Your synthesized final report/response:"

print("Synthesizing final results...")
       final_report = self.llm.generate(synthesis_prompt, max_new_tokens=2000, temperature=0.6)
       return final_report

Klasa AgentManager je srž orkestracije. Ona upravlja životnim ciklusom zadataka, od njihovog stvaranja do konačne sinteze rezultata.

Ključna Uloga AgentManagera

AgentManager ima sljedeće odgovornosti:

• Inicijalizacija (init): Prima instancu LocalLLM i registar agenata. Pohranjuje ih, zajedno s praznim rječnicima za aktivne zadatke (self.tasks), redom čekanja za zadatke (self.task_queue) i brojačem ID-jeva zadataka.
• Stvaranje Zadatka (create_task): Omogućuje dodavanje novog, jednostavnog zadatka u sustav. Automatski generira jedinstveni ID i postavlja početni status na “pending”.

Dekompozicija i Dodjela Zadatka

Ovo je jedna od najinteligentnijih funkcija menadžera:

• Dekompozicija Zadatka (decompose_task):
  • Prima opis složenog zadatka (npr. “Napiši detaljan izvještaj o trendovima u razvoju AI agenata.”).
  • Generira prompt za TinyLlama, dajući mu ulogu “stručnjaka za dekompoziciju zadataka”. Prompt uključuje popis dostupnih agenata i njihovu ekspertizu.
  • Zahtijeva od LLM-a da vrati strukturirani JSON izlaz koji definira manje pod-zadatke, preporučene agente za svaki pod-zadatak i eventualne ovisnosti između zadataka. Ovo je ključno za strukturiranu dekompoziciju zadatka i autonomnu suradnju.
  • Parsira JSON odgovor, stvara Task objekte i dodaje ih u self.tasks i self.task_queue.
  • Rukovanje greškama je implementirano za slučajeve kada LLM ne vrati validan JSON.
• Dodjela Zadatka (assign_task i _auto_assign_task):
  • assign_task: Omogućuje ručnu dodjelu zadatka specifičnom agentu.
  • _auto_assign_task: Ako zadatak nije unaprijed dodijeljen tijekom dekompozicije, menadžer koristi LLM da samostalno odredi najprikladnijeg agenta na temelju opisa zadatka i ekspertize agenata. Ovo je primjer autonomnog zaključivanja.

Izvršavanje i Nadgledanje Zadatka

Nakon što su zadaci dekomponirani i dodijeljeni, menadžer se brine za njihovo izvršavanje:

• Izvršavanje Zadatka (execute_task):
  • Provjerava status zadatka i dodijeljenog agenta.
  • Postavlja status zadatka na “in_progress”.
  • Formira prompt za agenta, uključujući njegov system_prompt (koji definira njegovu ulogu) i opis zadatka.
  • Ključno: Sakuplja i prilaže rezultate svih završenih zadataka od kojih trenutni zadatak ovisi. Ovo omogućuje inter-agentnu suradnju i prijenos znanja. Na primjer, “writer” agent može koristiti rezultate koje je generirao “researcher” agent.
  • Poziva self.llm.generate() da dobije rezultat od agenta.
  • Ažurira status zadatka na “completed” ili “failed” i pohranjuje rezultat.
• Obrada Reda Čekanja (process_task_queue):
  • Ovo je glavna petlja koja orkestrira cijeli proces. Iterira kroz red čekanja zadataka.
  • Za svaki zadatak provjerava jesu li ispunjene sve njegove ovisnosti. Tek kada su sve ovisnosti “completed”, zadatak se smatra izvršivim.
  • Zadaci s neispunjenim ovisnostima premještaju se na kraj reda čekanja, čekajući da se njihove ovisnosti riješe.
  • Izvršava sve zadatke koji su spremni za obradu.
  • Uklanja dovršene ili neuspjele zadatke iz reda čekanja.
  • Ovaj mehanizam osigurava autonomnu kolaboraciju i pravilan redoslijed izvršavanja, upravljajući složenim ovisnostima bez ručne intervencije.
  • Parametar max_iterations sprječava beskonačnu petlju u slučaju nepremostivih ovisnosti.

Sinteza i Konačni Rezultati

Kada su svi relevantni zadaci završeni, menadžer ima zadatak da objedini sve pojedinačne doprinose:

• Sinteza Rezultata (synthesize_results):
  • Prikuplja rezultate svih uspješno završenih zadataka.
  • Generira prompt za TinyLlama, dajući mu ulogu “glavnog AI službenika” (Chief AI Officer), koji treba pregledati sve rezultate i sintetizirati ih u koherentan, sveobuhvatan konačni izvještaj.
  • Predaje LLM-u opis glavnog cilja i sve prikupljene rezultate agenata.
  • Dobiveni izlaz je konačni odgovor sustava na inicijalni složeni zahtjev, demonstrirajući puni potencijal autonomnog zaključivanja i dekompozicije zadataka.

Ovakva složena arhitektura AgentManager klase, uz podršku LocalLLM i specijaliziranih agenata, omogućuje stvaranje dinamičnog i učinkovitog lokalnog višeagentnog sustava s TinyLlama, sposobnog za rješavanje problema koji nadilaze sposobnosti pojedinog AI modela.

Prednosti i Izazovi Lokalnih Višeagentnih Sustava s TinyLlama

Implementacija lokalnog višeagentnog sustava s TinyLlama donosi brojne inovativne mogućnosti, ali kao i svaka tehnološka odluka, ima svoje prednosti i izazove koje treba pažljivo razmotriti.

Značajne Prednosti

1. Privatnost i Sigurnost Podataka: Ovo je vjerojatno najveća prednost. Podaci nikada ne napuštaju vaše lokalno okruženje. Za tvrtke koje rukuju osjetljivim informacijama (financije, zdravstvo, osobni podaci) ili za pojedince koji cijene svoju privatnost, ovo je neprocjenjivo. Rizik od povrede podataka treće strane je eliminiran.
2. Smanjeni Operativni Troškovi: Nema API poziva, nema mjesečnih pretplata za korištenje cloud LLM-ova. Nakon početnog postavljanja, jedini “trošak” je električna energija. Ovo može donijeti značajne uštede, pogotovo za intenzivnu ili dugotrajnu upotrebu. Procjenjuje se da se troškovi mogu smanjiti za više od 90% u usporedbi s komercijalnim API-jima za sličan opseg operacija.
3. Niska Latencija i Brži Odgovori: Eliminacija mrežnih poziva znači gotovo trenutne odgovore. Za interaktivne aplikacije, chatbote ili automatizaciju procesa u stvarnom vremenu, niska latencija je presudna.
4. Potpuna Kontrola i Prilagodba: Imate potpunu kontrolu nad modelom i kodom. Možete finetunirati TinyLlama na vlastitim podacima, dodavati nove agente, mijenjati njihove promptove, prilagođavati logiku orkestracije i integrirati sustav s drugim lokalnim softverom. Ova razina fleksibilnosti je nedostižna kod zatvorenih API-ja.
5. Offline Sposobnost: Sustav radi neovisno o internetskoj vezi. Ovo je idealno za rad na udaljenim lokacijama, na brodovima, avionima, ili u okruženjima gdje je internetska povezanost nepouzdana ili nedostupna.
6. Transparentnost i Inspekcija: Budući da je sve lokalno i otvorenog koda (TinyLlama), možete u potpunosti pregledati kako sustav funkcionira, što je ključno za otklanjanje grešaka, sigurnosnu reviziju i bolje razumijevanje AI-ja.

Potencijalni Izazovi

1. Hardverski Zahtjevi (iako smanjeni): Iako je TinyLlama izuzetno učinkovita, lokalno izvršavanje višeagentnog sustava i dalje zahtijeva pristojan hardver. Idealno, potreban je GPU s nekoliko GB VRAM-a (npr. 8-12 GB) za optimalne performanse s 4-bitnom kvantizacijom. Na CPU-u može raditi, ali znatno sporije. To predstavlja početno ulaganje i može biti prepreka za korisnike sa starijim strojevima.
2. Ograničenja Performansi (u usporedbi s velikim modelima): TinyLlama, iako impresivna za svoju veličinu, ne može konkurirati najvećim cloud modelima (npr. GPT-4, Claude 3 Opus) u pogledu širine znanja, složenosti rezoniranja ili sposobnosti obrade vrlo dugačkih konteksta. Za zadatke koji zahtijevaju vrhunsku kreativnost, duboko razumijevanje nijansi ili iznimno kompleksno zaključivanje, veći modeli i dalje imaju prednost. Međutim, za mnoge praktične zadatke (sumarizacija, generiranje koda, strukturiranje podataka) TinyLlama je sasvim dovoljna.
3. Složenost Postavljanja i Održavanja: Postavljanje lokalnog AI sustava zahtijeva tehničko znanje (Python, konfiguracija hardvera, rješavanje ovisnosti). Održavanje, ažuriranje modela i biblioteka također zahtijeva aktivno upravljanje, za razliku od “plug-and-play” pristupa cloud API-jima.
4. Skalabilnost: Iako je sustav skalabilan u smislu dodavanja agenata, skalabilnost performansi je ograničena hardverom. Pokretanje desetaka ili stotina paralelnih AI agenata na jednom lokalnom stroju može brzo iscrpiti resurse. Za masovnu paralelnu obradu, cloud rješenja su još uvijek dominantna.
5. Potreba za Detaljnim Prompt Inženjeringom: Budući da je TinyLlama manji model, od njega se zahtijeva preciznije i pažljivije promptiranje kako bi se izvukli najbolji rezultati, posebno kod dekompozicije zadataka i sinteze. To zahtijeva vještine prompt inženjeringa.

Unatoč izazovima, prednosti lokalnog višeagentnog sustava s TinyLlama, posebno u kontekstu privatnosti i kontrole, čine ga iznimno atraktivnom opcijom za širok raspon primjena, otvarajući vrata novoj eri personalizirane i sigurne umjetne inteligencije.

Praktične Primjene i Budućnost Lokalnih Višeagentnih Sustava

Mogućnosti primjene lokalnog višeagentnog sustava s TinyLlama su raznolike i protežu se kroz mnoge industrije i osobne scenarije. Od automatizacije u istraživanju do personalnih AI asistenata, ovakav sustav ima potencijal revolucionirati način na koji komuniciramo s AI-jem.

Konkretni Primjeri Primjene

1. Personalni AI Asistent za Produktivnost: Zamislite AI asistenta koji vam pomaže u organizaciji posla. Agent istraživač prikuplja informacije o sastanku, agent pisac sažima ključne točke i piše e-mail, a agent analitičar analizira vaš kalendar i predlaže optimalno vrijeme za idući zadatak. Sve to se odvija lokalno, štiteći vašu privatnost.
2. Automatizirano Istraživanje i Izvještavanje: Za akademske istraživače ili analitičare, sustav može dekomponirati složeno istraživačko pitanje. Agent istraživač pretražuje lokalne baze podataka i dokumente, agent analitičar interpretira rezultate, a agent pisac sastavlja nacrt izvještaja, štedeći sate ručnog rada.
3. Razvoj Softvera i Generiranje Koda: Programeri mogu koristiti sustav za automatizaciju zadataka. Agent programer može generirati kod na temelju specifikacija, agent istraživač može pronaći relevantnu dokumentaciju, a agent analitičar može predložiti optimizacije ili testne slučajeve. S obzirom na to da je kod lokalno generiran, smanjuju se sigurnosni rizici uvođenja vanjskog koda.
4. Upravljanje Sadržajem i Kreativno Pisanje: Blogeri i marketinški stručnjaci mogu koristiti sustav za generiranje ideja, pisanje nacrta članaka, optimizaciju ključnih riječi i čak pisanje marketinških kampanja. Agent pisac piše, agent istraživač provjerava činjenice, a agent analitičar prati relevantne trendove.
5. Lokalna Analiza Podataka: Za tvrtke koje ne smiju slati osjetljive podatke u oblak, ovaj sustav može biti neprocjenjiv. Agent analitičar može analizirati interne financijske izvještaje, baze podataka klijenata ili operativne podatke, izvlačiti uvide i generirati izvještaje bez ikakvog prijenosa podataka.
6. Edukacija i Simulacija: Stvaranje interaktivnih obrazovnih alata ili simulatora gdje agenti preuzimaju uloge različitih stručnjaka, pružajući odgovore i smjernice na temelju lokalnog znanja.

Budućnost Lokalnih Višeagentnih Sustava

Budućnost lokalnih višeagentnih sustava s malim jezičnim modelima kao što je TinyLlama izgleda obećavajuće, a predviđa se nekoliko ključnih trendova:

1. Poboljšana Učinkovitost Modela: Nastavit će se razvoj manjih, ali sposobnijih LLM-ova. Modeli će postati još efikasniji u korištenju resursa, omogućujući pokretanje sofisticiranijih sustava na još skromnijem hardveru (npr. na pametnim telefonima i ugrađenim sustavima).
2. Finetuning i Specijalizacija: Lakoća finetuninga TinyLlama i sličnih modela na specifičnim domenama (npr. medicinski, pravni, tehnički podaci) omogućit će stvaranje visoko specijaliziranih lokalnih agenata s dubokim znanjem.
3. Integracija s Drugim Lokalnim Alatima: Očekuje se bolja integracija s lokalnim alatima za pretraživanje dokumenata (RAG – Retrieval Augmented Generation), alate za manipulaciju datotekama, lokalnim bazama podataka i drugim softverom, čime se proširuju sposobnosti agenata.
4. Naprednije Metode Orkestracije: Razvoj složenijih algoritama za planiranje, dekompoziciju i suradnju agenata, koji će omogućiti rješavanje još kompleksnijih i dinamičnijih problema.
5. “Perzistentni” Agenti: Agenti koji pamte dugoročne kontekste i uče iz interakcija, razvijajući se s korisnikom tijekom vremena.
6. Demokratizacija AI-ja: Sposobnost pokretanja naprednog AI-ja lokalno smanjit će ovisnost o velikim tehnološkim tvrtkama i učiniti AI pristupačnijim široj publici i manjim tvrtkama.

Korištenjem TinyLlama kao okosnice, demonstrirali smo kako se može izgraditi moćan, privatan i prilagodljiv lokalni višeagentni sustav s TinyLlama. Ova tehnologija ne samo da rješava današnje probleme privatnosti i troškova, već i postavlja temelje za budućnost decentralizirane i personalizirane umjetne inteligencije.

Zaključak

U ovom sveobuhvatnom vodiču, istražili smo fascinantan svijet lokalnih višeagentnih sustava s TinyLlama. Vidjeli smo kako, koristeći efikasnu arhitekturu menadžera i specijaliziranih agenata, možemo izgraditi robustan sustav sposoban za inteligentnu dekompoziciju zadataka, autonomnu suradnju i učinkovito zaključivanje – sve to bez ovisnosti o vanjskim API-jima. Kroz korištenje TinyLlama, jednog od najučinkovitijih malih jezičnih modela, osigurali smo da je sustav lagan, brz i u potpunosti transparentan, omogućujući nam potpunu kontrolu i prilagodbu.

Naglasili smo ključne prednosti lokalnog izvršavanja, poput neusporedive privatnosti podataka, značajnog smanjenja operativnih troškova, niske latencije i potpune autonomije. Iako postoje izazovi poput početnih hardverskih zahtjeva i ograničenja performansi u usporedbi s gigantskim cloud modelima, sposobnost implementacije AI rješenja koja su u potpunosti pod vašom kontrolom otvara vrata nebrojenim inovativnim primjenama u različitim domenama.

Od personalnih asistenata koji čuvaju vašu privatnost, preko automatiziranih alata za istraživanje i razvoj softvera, do sigurnih sustava za lokalnu analizu podataka – potencijal je ogroman. Vjerujemo da je budućnost umjetne inteligencije hibridna, s lokalnim rješenjima koja igraju sve važniju ulogu u osiguravanju etične, sigurne i pristupačne AI tehnologije za sve. Ovaj vodič je početna točka na tom putu, pružajući vam alate i znanje za izgradnju vlastitih autonomnih AI timova.

Često Postavljana Pitanja (FAQ)

1. Zašto koristiti TinyLlama umjesto većih modela poput Llama 2 70B ili GPT-4?

TinyLlama je odabran zbog svoje iznimne učinkovitosti i niskih hardverskih zahtjeva, što omogućuje lokalno izvršavanje na većini modernih računala. Veći modeli zahtijevaju znatno snažniji hardver (često skupe GPU-ove s puno VRAM-a) ili su dostupni samo putem cloud API-ja. Iako TinyLlama možda nema opću inteligenciju većih modela, za specifične zadatke dekompozicije, koordinacije i generiranja teksta, uz dobro promptiranje, pokazuje se vrlo sposobnom i idealna je za offline i privatne implementacije.

2. Koliko jak hardver mi je potreban za pokretanje ovog sustava?

Za optimalno iskustvo preporučuje se GPU (grafička kartica) s najmanje 8 GB VRAM-a (video memorije), npr. NVIDIA RTX 3050/4050 ili bolje. Uz 4-bitnu kvantizaciju (kako je prikazano u kodu), TinyLlama bi trebala stati u tu količinu memorije. Sustav može raditi i na CPU-u, ali će biti znatno sporiji. Za CPU izvršavanje, preporučuje se minimalno 16 GB RAM-a, po mogućnosti 32 GB, za prihvatljive performanse.

3. Mogu li ovaj sustav koristiti potpuno offline?

Da, to je jedna od ključnih prednosti. Nakon što jednom preuzmete TinyLlama model i sve potrebne biblioteke (putem pip install), sustav može raditi potpuno offline bez ikakve internetske veze. Podaci nikada ne napuštaju vaše računalo.

4. Kako mogu dodati nove agente ili prilagoditi postojeće?

Nove agente možete dodati jednostavnim proširenjem rječnika AGENT_REGISTRY, definirajući name, role, expertise i, najvažnije, prilagođeni system_prompt. Za prilagodbu postojećih, jednostavno modificirajte system_prompt ili expertise atribut za željenog agenta kako biste promijenili njegovo ponašanje i specijalizaciju.

5. Koje su granice ovog sustava?

Glavna ograničenja uključuju: (1) Performanse TinyLlama: Iako dobra za svoju veličinu, ne može parirati najvećim modelima u kompleksnosti rezoniranja ili generiranju iznimno kreativnog sadržaja. (2) Skalabilnost hardvera: Izvršavanje mnogih zadataka paralelno može iscrpiti lokalne hardverske resurse. (3) Ovisnost o prompt inženjeringu: Kvaliteta dekompozicije i sinteze uvelike ovisi o jasnoći i specifičnosti promptova za LLM.

6. Je li ovaj sustav spreman za produkcijsku upotrebu?

Kôd prikazan u članku je demonstrativan i služi kao temelj. Za produkcijsku upotrebu, sustav bi trebalo dodatno razviti i ojačati. To uključuje naprednije rukovanje greškama, robusnije parsiranje LLM izlaza, sofisticiranije mehanizme za dodjelu i praćenje zadataka, persistentno spremanje stanja zadataka i agenata te potencijalnu integraciju s drugim poslovnim sustavima.

7. Kako osigurati kvalitetu odgovora agenata?

Kvaliteta odgovora ovisi o nekoliko faktora:

• Dobar prompt inženjering: Jasni i precizni system_prompt-ovi za svakog agenta, te dobro strukturirani promptovi za dekompoziciju i sintezu.
• Odgovarajuća temperatura: Eksperimentirajte s parametrom temperature u LocalLLM.generate(). Niže vrijednosti (npr. 0.3-0.5) teže daju koherentnije, “činjenicama” orijentirane odgovore, dok više vrijednosti (npr. 0.7-1.0) potiču kreativnost.
• Finetuning (napredno): Ako imate specifičan skup podataka, možete finetunirati TinyLlama na njemu kako bi se bolje prilagodila vašim domenama i generirala kvalitetnije, relevantnije odgovore.
• Iterativni pristup: Ponekad će biti potrebno više iteracija ili prilagodbi zadataka ako prvi pokušaj ne rezultira željenim ishodom.