Predstavte si rannú rutinu zamestnanca na zákazníckom servise stredne veľkej e-commerce firmy. Otvorí schránku s desiatkami e-mailov od zákazníkov. Jeden píše: „Dobrý deň, chcem zmeniť doručovaciu adresu na mojej objednávke #889211, pretože som zadal nesprávne PSČ. Ďakujem.“
Ak má firma nasadeného bežného AI chatbota, zamestnanec môže tento e-mail skopírovať do chatovacieho okna a chatbot mu vygeneruje peknú, zdvorilú odpoveď: „Samozrejme, doručovaciu adresu je možné zmeniť. Prosím, napíšte nám novú adresu a my ju v systéme aktualizujeme.“ Táto odpoveď je však pasívna. Chatbot sám o sebe nič nespraví. Nepristúpi do databázy, neoverí stav objednávky v ERP a neprepíše adresu v systéme dopravcu. Všetka reálna práca: vyhľadanie objednávky, overenie, či balík už nebol odovzdaný kuriérovi, manuálna úprava v systéme a odoslanie potvrdzujúceho e-mailu stále leží na pleciach zamestnanca.
V technologickom štúdiu nolimeo navrhujeme AI agentov (Agentic AI) pre back-office procesy. Na rozdiel od pasívneho chatbota agent nečaká len na to, aby sformuloval text. Má k dispozícii nástroje: API, databázové dopyty, integračné mostíky a rozhodovaciu logiku, ktorá určuje, kedy ich môže použiť.
Pri rovnakom e-maile agent prečíta text, pochopí zámer (intent) zákazníka, cez databázový dopyt vytiahne objednávku #889211, skontroluje jej stav, overí, či ešte nebola expedovaná, cez API dopravcu pripraví zmenu adresy, zapíše ju do ERP a pripraví potvrdzujúci e-mail. Pri nízkorizikových scenároch môže proces prebehnúť automaticky, pri sporných prípadoch zostáva schválenie na človeku.
V tomto technickom článku si vysvetlíme architektonický rozdiel medzi chatbotmi a agentmi, ukážeme si TypeScript pipeline a rozoberieme kontrolné mechanizmy pre bezpečné nasadenie agentických systémov do prevádzky.
1. Chatbot vs. AI Agent: Architektonické porovnanie
Na pochopenie rozdielu sa musíme pozrieť na tok dát a riadenie stavu (state management) v oboch systémoch.
A. Architektúra Chatbota (Pasívna Q&A)
Chatbot funguje v cykle Dopyt ──► Odpoveď (Request-Response).
- Nemá prístup k vonkajšiemu svetu ani k firemným systémom v reálnom čase (ak nepoužíva statický RAG pre čítanie dokumentov).
- Nedisponuje pamäťou na vykonávanie akcií, nevie manipulovať so stavom databáz.
- Jeho jediným cieľom je predpovedať nasledujúce najpravdepodobnejšie slovo na základe prijatého kontextu.
[ Používateľ ] ──► (Otázka) ──► [ LLM Model ] ──► (Textová odpoveď) ──► [ Používateľ ]
B. Architektúra autonómneho agenta
AI agent funguje v cykle Vnímanie ──► Rozhodovanie ──► Akcia ──► Vyhodnotenie (Sense-Think-Act-Observe Loop).
- Vnímanie (Sensors / Triggers): Agent reaguje na externé udalosti (webhooks, prichádzajúci e-mail, zmena v ERP, cron úloha).
- Rozhodovanie (Cognitive Planning): LLM model slúži ako „mozog“, ktorý na základe cieľa analyzuje situáciu a rozhoduje, ktorý nástroj (tool) má použiť.
- Akcia (Tools Execution): Agent reálne spúšťa kód: vykonáva SQL dopyty, volá externé API rozhrania, zapisuje súbory.
- Vyhodnotenie (Observation): Agent analyzuje výsledok spustenej akcie (napr. „API vrátilo úspech, zmena adresy bola zapísaná“) a na základe toho sa rozhoduje, či splnil cieľ, alebo musí vykonať ďalší krok.
┌──────────────────────────────────────┐
▼ │
[ Externý Trigger ] ──► [ LLM (Rozhodnutie) ] ──► [ Spustenie Nástroja (API/DB) ]
│
▼
(Cieľ splnený?) ──► [ Zápis & Odoslanie e-mailu ]
2. Technická implementácia AI agenta v TypeScript
Nasledujúca ukážka demonštruje zjednodušenú implementáciu autonómneho agenta v Node.js/TypeScript.
Využijeme OpenAI Tool Calling, pri ktorom model rozhodne, či potrebuje zavolať databázový dopyt pre overenie objednávky alebo nástroj na úpravu adresy. Následne vygeneruje e-mailovú odpoveď, ktorú pred odoslaním overíme pomocou knižnice Zod.
Definícia nástrojov a biznis logiky
// src/services/agent-tools.ts
import { z } from "zod";
// Dátové modely a typy pre náš systém
export const OrderStatusSchema = z.object({
orderId: z.string(),
customerEmail: z.string().email(),
status: z.enum(["PROCESSING", "SHIPPED", "DELIVERED", "CANCELLED"]),
shippingAddress: z.string(),
totalAmount: z.number(),
});
export type OrderStatus = z.infer<typeof OrderStatusSchema>;
// Fiktívna databáza objednávok (v reálnej aplikácii PostgreSQL / Prisma)
const mockDatabase: OrderStatus[] = [
{
orderId: "889211",
customerEmail: "[email protected]",
status: "PROCESSING",
shippingAddress: "Hlavná 15, 811 01 Bratislava",
totalAmount: 120.50
},
{
orderId: "991200",
customerEmail: "[email protected]",
status: "SHIPPED",
shippingAddress: "Okružná 4, 040 01 Košice",
totalAmount: 45.90
}
];
/**
* Nástroj 1: Vyhľadanie objednávky v databáze
*/
export async function getOrderDetails(orderId: string): Promise<OrderStatus | null> {
console.log(`[TOOL EXECUTION] Vyhľadávam objednávku v DB: ${orderId}`);
const order = mockDatabase.find(o => o.orderId === orderId);
return order || null;
}
/**
* Nástroj 2: Aktualizácia adresy v systéme
*/
export async function updateOrderAddress(orderId: string, newAddress: string): Promise<{ success: boolean; message: string }> {
console.log(`[TOOL EXECUTION] Aktualizujem adresu pre objednávku ${orderId} na: ${newAddress}`);
const orderIndex = mockDatabase.findIndex(o => o.orderId === orderId);
if (orderIndex === -1) {
return { success: false, message: "Objednávka nebola nájdená v databáze." };
}
const order = mockDatabase[orderIndex];
if (order.status === "SHIPPED" || order.status === "DELIVERED") {
return {
success: false,
message: `Nie je možné zmeniť adresu. Objednávka je už v stave: ${order.status}.`
};
}
mockDatabase[orderIndex].shippingAddress = newAddress;
return { success: true, message: "Doručovacia adresa bola úspešne zmenená." };
}
Hlavný riadiaci mechanizmus AI Agenta
// src/services/backoffice-agent.ts
import { OpenAI } from "openai";
import { getOrderDetails, updateOrderAddress } from "./agent-tools";
import { z } from "zod";
// Zod schéma pre finálny výstup z agenta na zaručenie bezpečnosti pred odoslaním e-mailu
const AgentEmailOutputSchema = z.object({
recipient: z.string().email(),
subject: z.string().min(5),
body: z.string().min(20),
actionTaken: z.string(),
requiresHumanReview: z.boolean(),
});
export class BackofficeAgent {
private openai: OpenAI;
private maxSteps = 5; // Ochrana proti nekonečným zacykleným dopytom (Agentic Loops)
constructor() {
this.openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
}
/**
* Spustí agenta pre spracovanie prichádzajúceho e-mailu
*/
public async handleCustomerRequest(customerEmail: string, emailContent: string): Promise<string> {
console.log(`[AGENT START] Spracovávam e-mail od ${customerEmail}`);
// Inicializácia kontextu konverzácie
const messages: any[] = [
{
role: "system",
content: `Ste autonómny AI agent pre podporu back-officu.
Vašou úlohou je vyriešiť požiadavku zákazníka pomocou dostupných nástrojov.
Pravidlá:
1. Ak zákazník žiada o zmenu adresy, najprv si vytiahnite detaily objednávky cez getOrderDetails.
2. Skontrolujte, či e-mail odosielateľa súhlasí s e-mailom priradeným k objednávke (bezpečnostné overenie).
3. Ak je stav objednávky PROCESSING, zmeňte adresu pomocou updateOrderAddress.
4. Ak je stav SHIPPED, adresu nemeňte, ospravedlňte sa a označte, že požiadavka vyžaduje ľudský zásah.
5. Na konci vygenerujte odpoveď vo formáte JSON zodpovedajúcom schéme s poliami recipient, subject, body, actionTaken, requiresHumanReview.`
},
{
role: "user",
content: `Prichádzajúci e-mail od: ${customerEmail}\nObsah e-mailu:\n"${emailContent}"`
}
];
// Definícia nástrojov pre OpenAI API
const tools = [
{
type: "function" as const,
function: {
name: "getOrderDetails",
description: "Vyhľadá detaily objednávky vrátane stavu a adresy na základe ID objednávky.",
parameters: {
type: "object",
properties: {
orderId: { type: "string", description: "6-miestne ID objednávky" }
},
required: ["orderId"]
}
}
},
{
type: "function" as const,
function: {
name: "updateOrderAddress",
description: "Zmení doručovaciu adresu objednávky v databáze, ak nie je expedovaná.",
parameters: {
type: "object",
properties: {
orderId: { type: "string" },
newAddress: { type: "string", description: "Kompletná nová adresa s ulicou, mestom a PSČ" }
},
required: ["orderId", "newAddress"]
}
}
}
];
let step = 0;
// Autonómny myšlienkový cyklus (Agentic Loop)
while (step < this.maxSteps) {
step++;
console.log(`[AGENT LOOP] Krok ${step}/${this.maxSteps}`);
const response = await this.openai.chat.completions.create({
model: "gpt-4o",
messages,
tools,
tool_choice: "auto",
temperature: 0.0 // Stabilita a deterministické správanie
});
const message = response.choices[0]?.message;
if (!message) throw new Error("Agent nevrátil žiadnu odpoveď.");
messages.push(message);
// Skontrolujeme, či model žiada o spustenie nejakého nástroja
const toolCalls = message.tool_calls;
if (!toolCalls || toolCalls.length === 0) {
// Ak model nežiada o žiadny nástroj, dospel k záveru a vygeneroval finálnu odpoveď
return this.finalizeAgentResponse(message.content || "", customerEmail);
}
// Spracovanie všetkých požadovaných volaní nástrojov
for (const toolCall of toolCalls) {
const functionName = toolCall.function.name;
const functionArgs = JSON.parse(toolCall.function.arguments);
let toolResult: any;
if (functionName === "getOrderDetails") {
toolResult = await getOrderDetails(functionArgs.orderId);
} else if (functionName === "updateOrderAddress") {
toolResult = await updateOrderAddress(functionArgs.orderId, functionArgs.newAddress);
}
// Výsledok nástroja pošleme späť do kontextu agenta
messages.push({
role: "tool",
tool_call_id: toolCall.id,
name: functionName,
content: JSON.stringify(toolResult)
});
}
}
throw new Error("Prekročený maximálny počet krokov agenta bez dosiahnutia výsledku.");
}
/**
* Zvaliduje finálny výstup z LLM a vráti čisté dáta pripravené na odoslanie
*/
private finalizeAgentResponse(rawContent: string, fallbackEmail: string): string {
try {
// LLM niekedy obalí JSON do markdown blokov ```json ... ```, očistíme ich
const cleanJsonStr = rawContent.replace(/```json/g, "").replace(/```/g, "").trim();
const rawObj = JSON.parse(cleanJsonStr);
// Prísna validácia pomocou Zod pred akoukoľvek komunikáciou smerom von
const validatedOutput = AgentEmailOutputSchema.parse(rawObj);
console.log(`[AGENT SUCCESS] Požiadavka spracovaná. Akcia: ${validatedOutput.actionTaken}`);
if (validatedOutput.requiresHumanReview) {
return `[HUMAN REVIEW REQUIRED] E-mail pripravený, ale vyžaduje schválenie operátorom.\n` +
`Subjekt: ${validatedOutput.subject}\nTelo:\n${validatedOutput.body}`;
}
return `[AUTO RESPONSE SENT] E-mail bol odoslaný zákazníkovi.\n` +
`Subjekt: ${validatedOutput.subject}\nTelo:\n${validatedOutput.body}`;
} catch (e) {
console.error("[AGENT ERROR] Zlyhalo finálne formátovanie alebo Zod validácia:", e);
return `[SYSTEM ERROR] Spracovanie zlyhalo. Presmerované na manuálnu podporu.`;
}
}
}
3. Riešenie hraničných stavov a kontrolné mechanizmy
Autonómia so sebou prináša riziká. Ak pustíme AI agenta do firemných systémov bez jasných zábran (guardrails), riskujeme poškodenie dát alebo neautorizované zmeny.
Tu sú tri piliere, na ktorých staviame bezpečnosť podobných integrácií:
3.1. Ochrana pred zacyklením (Agentic Loops)
Predstavte si situáciu, keď nástroj updateOrderAddress vráti chybu, napríklad „Neplatný formát PSČ“. Ak agent nie je správne navrhnutý, môže sa pokúsiť opraviť dopyt a spustiť nástroj znova. Pri opakovanom zlyhaní databázy by sa mohol dostať do slučky a zbytočne míňať API volania.
- Ako to riešime: V kóde (BackofficeAgent) máme podmienku
maxSteps = 5. Ak agent nevyrieši úlohu do piatich krokov, slučka sa preruší, chyba sa zapíše do logovacieho systému (napr. Winston/Sentry) a požiadavka sa odovzdá na manuálne doriešenie.
3.2. Bezpečnostná prevencia identity spoofingu
Čo ak niekto pošle e-mail z adresy [email protected] a požiada o zmenu adresy pre objednávku #889211, ktorá patrí zákazníkovi [email protected]?
- Ako to riešime: Agent má v systémovom prompte aj vo vnútornej logike pravidlo, že pred spustením nástroja na úpravu dát musí porovnať e-mail odosielateľa s e-mailom uloženým v databáze pre dané ID objednávky. Ak sa nezhodujú, systém akciu zablokuje a označí dopyt ako bezpečnostné riziko.
3.3. Brána "Human-in-the-Loop" (HITL) pre finančné operácie
Pri operáciách, ktoré zahŕňajú financie, napríklad storno objednávky, preplatenie faktúry, refundácia peňazí na účet alebo zmeny na objednávkach s vyššou hodnotou, nenechávame agenta rozhodovať bez schválenia človekom.
- Ako to riešime: Agent prejde všetkými fázami: pochopí požiadavku, overí status objednávky v databáze, pripraví storno v systéme a napíše koncept e-mailu pre zákazníka. Následne sa však celá táto transakcia zastaví pred finálnym zápisom a uloží sa do tabuľky
pending_approvals. Operátorovi v back-office vyskočí v internom rozhraní notifikácia, klikne na tlačidlo „Schváliť“ a až v tom momente sa asynchrónne spustí reálny zápis do databázy a odoslanie financií.
[ Agent pripraví Refund ] ──► [ Zápis do pending_approvals ]
│
(Čaká na operátora)
▼
[ Finálny zápis do ERP ] ◄── [ Kliknutie na "Schváliť" v UI ]
4. Výhody prechodu na agentickú AI architektúru
Prechod od pasívnych chatbotov k agentickej architektúre môže výrazne zmeniť efektivitu back-office procesov:
- Menej rutinného prepisovania: Zákaznícky servis a back-office trávia menej času kopírovaním dát medzi e-mailom, ERP systémom a administráciou e-shopu. Viac priestoru zostáva na zložité a neštandardné prípady.
- Rýchlejšia reakcia: Zmeny adries, kontroly objednávok alebo príprava odpovedí môžu prebiehať automatizovane aj mimo pracovných hodín, ak sú procesy dobre ohraničené.
- Lepšia konzistencia: Zod validácia a definované rozhrania nástrojov znižujú riziko, že systém zapíše neplatné dáta alebo pošle odpoveď v nesprávnom formáte.
Záver: AI agent má robiť prácu, nie len písať odpovede
AI chatboti sú užitoční na rýchle vyhľadávanie informácií a prípravu textov. Ak však chcete reálne znížiť manuálnu prácu v back-office, potrebujete agentov prepojených s databázami, ERP, e-mailmi a internými pravidlami.
Pri implementácii je kľúčové rozumieť nielen prompt engineeringu, ale hlavne softvérovej architektúre, typovej bezpečnosti, databázam a prístupovým právam. Jeden zle navrhnutý AI skript bez ochrany pred zacyklením alebo bez kontroly identity môže spôsobiť viac škody než úžitku.
Sme technologické štúdio nolimeo. Navrhujeme AI agentov, backend integrácie a automatizácie pre firmy, ktoré potrebujú prepojiť umelú inteligenciu s reálnymi systémami bez toho, aby stratili kontrolu nad dátami a procesmi.
Chcete zistiť, kde by AI agenti vedeli odbremeniť váš back-office? Napíšte nám a prejdeme si procesy, dáta aj bezpečný spôsob napojenia na vaše systémy.