DI agentų kūrimas su OpenAI Node.js aplinkoje

DI agentų kūrimas su OpenAI ir Node.js (2025)

2025-aisiais dirbtinio intelekto agentai keičia (opens in new tab) kaip programos bendrauja su vartotojais ir automatizuoja procesus. Šiame gide sužinosite, kaip sukurti DI agentus su OpenAI Node.js SDK - pasitelkdami Node.js ir šiuolaikines sistemas galėsite kurti sistemas, kurios geba mąstyti, planuoti ir veikti savarankiškai.

Node.js - puikus pasirinkimas DI sprendimų kūrimui: tai greita, lanksti ir lengvai integruojama platforma. Naudodami naujausius OpenAI SDK, greitai sukursite agentus, kurie ne tik gali atlikti užduotis, bet ir jungiasi prie išorinių įrankių bei automatizuoja realius procesus.

Perskaitę šį vadovą išmoksite:

• Paruošti Node.js projektą su OpenAI integracija
• Įdiegti DI agentus su funkcijų kvietimu, galinčius vykdyti kelių žingsnių užduotis
• Naudoti Assistants API atminties funkcijas tęstiniams darbams
• Kurti lankščius, optimizuotus DI agentus, pasiruošusius paleidimui

Nesvarbu, ar esate kūrėjas, ar DI entuziastas, šis vadovas parodys konkrečius žingsnius, kaip kurti DI agentus naudojant OpenAI API.

GPT modelių aplinka 2025-ųjų pabaigoje

Šiame gide naudojami GPT-4.1 ir GPT-4.1-mini modeliai - tai vis dar plačiai taikomi, stabilūs ir ekonomiški variantai 2025-ųjų pabaigoje. Jie pasižymi puikiais loginio mąstymo bei kelių užduočių vykdymo gebėjimais, įskaitant darbą su įvairiais duomenų tipais (tekstu, vaizdais ir kt.).

Nors OpenAI šiais metais pristatė GPT-5 su dar pažangesnėmis galimybėmis, GPT-4.1 versijos išlieka patikimu pasirinkimu daugumai DI agentų - puikus našumo ir kainos balansas.

Naujausią modelių sąrašą rasite OpenAI dokumentacijoje (opens in new tab).

Kodėl verta kurti DI agentus 2025-aisiais?

Įsivaizduokite skaitmeninį komandos narį, kuris niekada nemiega, nieko nepamiršta ir auga kartu su jūsų verslu. Tokį efektą pasieksite kurdami OpenAI agentus su Node.js (opens in new tab) - jūsų programos ne tik apdoroja duomenis, bet ir mąsto, planuoja bei veikia savarankiškai.

DI sprendimai, kurie dar vakar atrodė kaip ateitis, šiandien tampa kasdienybe. Įmonės jau automatizuoja tyrimus, greitai aptarnauja klientų užklausas ir optimizuoja veiklą per kelias valandas. Dauguma programuotojų savo pirmą veikiantį DI agentą - su funkcijų kvietimu ir API integracija - Node.js aplinkoje gali sukurti vos per kelias valandas.

Kas pasikeitė 2025 metais?

OpenAI aplinka pasiekė visiškai naują lygį:

• GPT-4.1 ir GPT-4.1-mini užtikrina geresnį našumą už mažesnę kainą
• Struktūruota išvestis - visada teisingas JSON formatas
• Funkcijų kvietimai leidžia vienu metu naudoti kelis įrankius
• Srautinis atsakas suteikia momentinį grįžtamąjį ryšį
• Vaizdinės galimybės leidžia DI agentams vienu metu apdoroti tekstą ir vaizdus

Šio gido pagalba sukursite:

• DI agentą, galintį ieškoti internete, apdoroti duomenis ir priimti sprendimus
• Tikrą Node.js + OpenAI integraciją, ne tik pavyzdžius
• Paruoštą diegimui projektą su klaidų valdymu ir sąnaudų optimizavimu - tinkamą realiam naudojimui

Šis vadovas parodys, kaip sukurti DI agentą nuo nuulio iki visiškai automatizuoto sprendimo.

Pamatysite ir galimas klaidas bei kaip jas spręsti.

Ko reikia norint kurti DI agentus naudojant Node.js

Būtinos žinios

Kad būtų lengva naudotis šiuo gidu, turėtumėte gerai jaustis dirbdami su:

• JavaScript pagrindais - kintamaisiais, funkcijomis, objektais
• Async/await ir Promises - asinchroninio kodo valdymas
• ES moduliais (naudojant import ir export)
• Pagrindinių klaidų valdymu naudojant try/catch
• Node.js pagrindais - paketų diegimu (npm), skriptų paleidimu, aplinkos kintamųjų naudojimu

Jei esate kada nors kūrę paprastą Express serverį ar jungęsi prie API, jūs esate pasiruošę. Jei esate kūrę bazinį Node.js projektą, šis vadovas jums tikrai nebus iššūkis.

Įrankiai ir aplinkos paruošimas

Štai ko prireiks norint paruošti kūrimo aplinką:

• Node.js 20+ - tinkamiausia versija naujausiam OpenAI Node.js SDK
• • OpenAI paskyra ir API raktas - būtini DI agentų kūrimui ir testavimui
  • Pasirinktinai: paieškos API raktas (Serper, Brave arba Tavily), jei norite prieigos prie realių interneto duomenų
• Moderni kodo redagavimo programa - rekomenduojame VS Code dėl gero Node.js palaikymo

Greitas pasiruošimo sąrašas:

• Node.js 20+ įdiegtas (node -v)
• OpenAI API raktas paruoštas .env faile
• (Pasirinktinai) Serper API raktas interneto paieškai
• Įdiegta kodo redagavimo programa ir prieiga prie terminalo

Numatomas pasiruošimo laikas: 10-15 min. pradedant nuo nulio.

1 dalis: Node.js projekto paruošimas ir OpenAI integracija

Šios dalies pabaigoje turėsite veikiantį Node.js projektą, sujungtą su OpenAI API, mokėsite saugiai tvarkyti prieigos duomenis ir galėsite patikrinti ar viskas veikia tinkamai.

1 žingsnis: Node.js projekto sukūrimas

Atidarykite terminalą ir sukurkite naują projekto aplanką:

bash

mkdir openai-agent-2025
cd openai-agent-2025
npm init -y

Ką tik sukūrėte aplanką ir package.jsonfailą. package.json - tai jūsų projekto aprašas, kuriame žymimos priklausomybės ir nustatymai.

Kad įsijungtumėtė ES6 modulius, atidarykite package.json ir pridėkite:

json

{
"name": "openai-agent-2025",
"version": "1.0.0",
"type": "module",
"main": "index.js",
"scripts": {
"start": "node index.js",
"dev": "node --watch index.js"
}
}

"type": "module" leidžia naudoti modernią import sintaksę vietoj require().

2 žingsnis: Būtinos priklausomybės

Įdiekite OpenAI SDK ir aplinkos kintamųjų valdymo modulį:

bash

npm install openai dotenv

Kam reikalingi šie paketai:

• openai (v4.x) - oficialus OpenAI SDK su pilnu TypeScript palaikymu
• dotenv - įkelia aplinkos kintamuosius iš .env failo

Kūrimo aplinkoje taip pat įdiekite:

bash

npm install --save-dev jest @types/node

3 žingsnis: Apsaugokite savo prieigos raktus (API keys)

Sukurkite .env failą projekto šakninėje direktorijoje:

env

OPENAI_API_KEY=sk-proj-jūsų-tikras-raktas-čia
SERPER_API_KEY=jūsų-serper-raktas-čia

Svarbus saugumo žingsnis: pridėkite .env į .gitignore:

bash

echo ".env" >> .gitignore
echo "node_modules/" >> .gitignore

Kodėl verta naudoti aplinkos kintamuosius? Įsivaizduokite, kad paliekate namų raktą po kilimėliu - prasta idėja! API raktai turi būti saugomi .env faile, o ne įrašyti tiesiai į programos kodą. Tai - standartinė saugumo praktika.

⚠️ Svarbu: Niekada nesidalinkite savo .env failu - tai slapti raktai, elkitės su jais kaip su slaptažodžiais.

Kas nutiks, jei to nepaisysite? Jūsų prieigos raktai gali atsidurti GitHub, jie gali būti nuskenuoti botų ir per kelias valandas sukelti tūkstantines neteisėtas išlaidas.

4 žingsnis: Patikrinkite OpenAI ryšį

Sukurkite failą index.js ir pridėkite paprastą prisjungimo testą:

javascript

import 'dotenv/config';
import OpenAI from 'openai';

const openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY
});

async function testConnection() {
try {
console.log('Testing OpenAI connection...');

const response = await openai.chat.completions.create({
model: "gpt-4.1-mini", // Current mainstream, cost-effective model in late 2025. Consider GPT-5 for cutting-edge features.
messages: [
{
role: "user",
content: "Say hi and confirm you're working!"
}
],
max_tokens: 50 // Limit tokens to control costs
});

console.log('✅ Connection successful!');
console.log('Response:', response.choices[0].message.content);
console.log('Tokens used:', response.usage.total_tokens);

} catch (error) {
console.error('❌ Connection failed:');
console.error('Error:', error.message);

if (error.status === 401) {
console.error('Check your API key in .env file');
} else if (error.status === 429) {
console.error('Rate limit exceeded or insufficient credits');
}
}
}

testConnection();

Paleiskite testą:

bash

npm start

Laukiamas rezultatas:
Tikrinamas OpenAI ryšys...
✅ Ryšys sėkmingas!
Atsakymas: Labas! Dirbu puikiai ir esu pasiruošęs padėti.
Tokens used: 23

💡 Patarimas: prieš kuriant agentus su funkcijų kvietimais, visada pirmiausia patikrinkite, ar OpenAI ryšys veikia tinkamai.

⚠️ Svarbu: niekada nesidalykite savo .env failu, jeigu jame yra slapti API raktai.

Dažniausios klaidos ir kaip jas ištaisyti

5 žingsnis: Supraskite atsakymo objektą

Pažiūrėkime, ką grąžina OpenAI API:

javascript

{
id: 'chatcmpl-abc123',
object: 'chat.completion',
created: 1699999999,
model: 'gpt-4.1-mini',
choices: [
{
index: 0,
message: {
role: 'assistant',
content: 'Hi! I'm working perfectly...'
},
finish_reason: 'stop'
}
],
usage: {
prompt_tokens: 15,
completion_tokens: 8,
total_tokens: 23
}
}

Svarbiausi laukeliai:

• choices[0].message.content - DI atsakymo tekstas
• usage.total_tokens - kiek tokenų buvo sunaudota (tai lemia užklausos kainą)
• finish_reason - kodėl atsakymas baigėsi ("stop" - atsakymas baigtas, "length" - pasiektas max_tokens limitas)

💰 Kainos pavyzdys:
Naudojant gpt-4.1-mini (kaina $0.15 už 1M įvesties tokenų ir $0.60 už 1M išvesties tokenų), šis testas kainavo maždaug $0.000007 - mažiau nei centas.

💡 Patarimas: visada patikrinkite usage.total_tokens - tai padės stebėti sąnaudas ir optimizuoti agento veikimą dar ankstyvoje stadijoje.

Kas toliau?

Jūsų Node.js projektas jau tinkamai sukonfigūruotas ir sėkmingai bendrauja su OpenAI API. Pasitvirtinote, kad autentifikacija veikia, ir suprantate pagrindinį užklausos/atsakymo principą.

Kitoje dalyje kursime tikrą DI agentą, galintį naudoti įvairius įrankius, pradėsime nuo paieškos internete, naudojant realias API integracijas.

DI agentai vs pokalbių robotai - koks skirtumas?

Prieš pradėdami programuoti, verta aiškiai suprasti, kuo DI agentai skiriasi nuo paprastų pokalbių robotų.
Šis skirtumas svarbus tam, kad galėtumėte pasirinkti tinkamą sprendimą - kada pakanka paprasto chatbot, o kada verta kurti išmanesnį agentą.

Paprastas pokalbių robotas (Chat Completions API)

Ką jis daro: Veikia kaip paprastas tekstinis pokalbis - užduodate klausimą ir iškart gaunate atsakymą.

Pavyzdys:
Jūs: „Koks oras Vilniuje?“
Botas: „Neturiu prieigos prie realaus laiko duomenų,
bet lapkritį Vilniuje paprastai būna apie 3-5 °C.“

Pagrindinės savybės:
❌ Neišsaugo pokalbių istorijos
❌ Negali pasiekti išorinių duomenų
❌ Vienkartinės užklausos (klausimas → atsakymas)
✅ Greitas ir pigus sprendimas
✅ Puikiai tinka paprastiems klausimams ir atsakymams

Kada verta naudoti:

• DUK robotai su paruoštais atsakymais
• Turinio generavimas (pvz., tinklaraščio įrašai, el. laiškai)
• Tekstų analizė (santraukos, vertimai, duomenų analizė)
• Kodo pagalba (paaiškinimai, klaidų taisymas, pasiūlymai)

DI agentas (Function Calling + įrankiai)

Ką jis daro: Planuoja, veikia savarankiškai ir naudoja įvairius įrankius tam, kad pasiektų tikslą.

Pavyzdys:
Tu: „Koks oras Vilniuje?“
Agentas:
Galvoja: „Man reikia dabartinių orų duomenų.“
Veiksmas: Kreipiasi į orų API pagal koordinates.
Apdoroja gautus duomenis apie prognozę.
Atsako: „Šiuo metu Vilniuje +4 °C ir lengvas lietus.
Rytoj - apie +6 °C, dalinai debesuota.“

Pagrindinės savybės:
✅ Gali naudoti išorinius įrankius (API, duomenų bazes, paieškas)
✅ Mąsto keliais žingsniais ir planuoja veiksmus
✅ Sprendimus priima remdamasis gautais duomenimis
✅ Gali valdyti sudėtingus procesus ar darbo eigas
⚠️ Brangesnis kiekvienos užklausos vykdymas
⚠️ Reikalauja kruopštaus klaidų valdymo

Kada verta naudoti DI agentus:

• Tyrimams, kuriuose reikia kelių informacijos šaltinių
• Verslo procesų automatizavimui (pvz., sąskaitų apdorojimas, duomenų analizė)
• Klientų aptarnavimui su CRM sistemų integracija
• Bet kokioms užduotims, kur reikalingi realaus laiko duomenys

OpenAI Assistants API (pažangūs DI agentai)

Ką šis API suteikia: Nuolatinę atmintį, įdiegtus įrankius ir automatinį pokalbių gijų valdymą.

Pavyzdys:
Pirmadienis: „Išanalizuok šią pardavimų lentelę.“ (įkeliamas failas)
Antradienis: „Palygink su praėjusios savaitės duomenimis.“ (agentas prisimena ankstesnį failą)
Trečiadienis: „Kokia tendencija?“ [agentas prisimena visą pokalbį ir analizę] (opens in new tab)

Pagrindinės savybės:
✅ Išsaugo kontekstą tarp sesijų
✅ Turi įmontuotus įrankius (kodo interpretatorius, failų paieška)
✅ Automatiškai valdo pokalbių gijas
✅ Puikiai tinka tęstinėms užduotims
⚠️ Didesnės išlaidos dėl saugojimo ir skaičiavimo išteklių
⚠️ Sudėtingesnis paruošimas ir konfigūravimas

Kada verta naudoti Assistants API:

• Daugiasesijoms darbo eigoms (pvz., klientų aptarnavimui)
• Dokumentų analizei per tam tikrą laiką
• Asistentams, kurie mokosi naudotojo įpročių ir pageidavimų
• Sudėtingiems projektams, kuriems reikia atminties ir konteksto išlaikymo

Greitų sprendimų gidas

Šiame gide sukursime abu:

• 2 dalyje: DI agentą su funkcijų kvietimu (naudojant interneto paiešką)
• 3 dalyje: DI asistentą su nuolatine atmintimi (naudojant Assistants API)

Taip gausite pilną įrankių rinkinį bet kokiam DI automatizavimo projektui.

2 dalis: DI agento kūrimas su funkcijų kvietimu ir interneto paieška

Šios dalies pabaigoje turėsite veikiantį DI agentą, galintį ieškoti internete, apdoroti rezultatus ir atsakyti į klausimus naudodamas naujausią informaciją.

Supraskime agento veikimo ciklą

Prieš rašant kodą, verta suprasti, kaip mąsto (opens in new tab) agentai.
Įsivaizduokite virtuvės šefą:

• Jūs užsakote spagečius
• Šefas patikrina turimus ingredientus (įrankius)
• Pamato, kad trūksta pomidorų (reikia iškviesti įrankį)
• Nusiunčia padėjėją jų atnešti (vykdo funkciją)
• Galiausiai gauna produktą (rezultatas)
• Baigia gaminti patiekalą (galutinis atsakymas)

Taip atrodo agento veikimo ciklas (Agent Loop):

Vartotojo užklausa → Agentas mąsto → Ar reikia įrankio?
↓ Taip ↓ Ne
Vykdo Grąžina atsakymą
↓
Gautas rezultatas → Agentas Mąsto → Ciklas kartojasi

Svarbiausia įžvalga: agentas neveikia tiesiai iš taško A į B.
Jis sprendžia kiekviename žingsnyje - ar turi pakankamai informacijos, ar reikia pasitelkti kitus įrankius.

Agentų tipai 2025 metais

1. Reaktyvūs agentai

• Apdoroja kiekvieną užklausą atskirai
• Neturi atminties ar mokymosi gebėjimų
• Pvz.: paprastas DUK botas

2. Planuojantys agentai

• Skirsto užduotį į etapus prieš pradėdami veikti
• Kuria veiksmų planą
• Pvz.: kelionės planavimo asistentas

3. Įrankius naudojantys agentai (kuriame tokį šiame gide)

• Gali kviesti išorines funkcijas ar API
• Integruojasi su realaus pasaulio sistemomis
• Pvz.: tyrimų agentas, kuris ieško informacijos internete

4. Hibridiniai agentai

• Derina kelis metodus vienu metu
• Dauguma realių sistemų veikia būtent taip
• Pvz.: klientų aptarnavimo agentas su atmintimi ir prieiga prie įrankių

1 žingsnis: Apibrėžkite savo agento įrankius

Įrankiai - tai funkcijos, kurias DI agentas gali iškviesti, kai pats negali atlikti užduoties. Pavyzdžiui, informacijos paieška internete ar duomenų užklausa iš duomenų bazės.

Sukurkite failą tools.js:

javascript

// tools.js
export const tools = [
{
type: "function",
function: {
name: "search_web",
description: "Search the web for current information. Use this when you need up-to-date data, news, or facts that happened after your knowledge cutoff.",
parameters: {
type: "object",
properties: {
query: {
type: "string",
description: "The search query. Be specific and include relevant keywords."
},
num_results: {
type: "number",
description: "Number of results to return (1-10)",
default: 3
}
},
required: ["query"]
}
}
},
{
type: "function",
function: {
name: "calculate",
description: "Perform mathematical calculations. Use for any arithmetic or math operations.",
parameters: {
type: "object",
properties: {
expression: {
type: "string",
description: "Mathematical expression to evaluate (e.g., '2 + 2' or '15 * 23')"
}
},
required: ["expression"]
}
}
}
];

Kodėl įrankius verta struktūruoti būtent taip?
DI agentui reikia aiškių aprašymų, kad galėtų nuspręsti, kada ir kokį įrankį naudoti. Trumpai tariant - kuo tikslesnis aprašymas, tuo geresni sprendimai.

Blogo aprašymo pavyzdys:

javascript

description: "Search stuff" // Too vague

Gero aprašymo pavyzdys:

javascript

description: "Search the web for current information. Use this when you need up-to-date data, news, or facts that happened after your knowledge cutoff."

2 žingsnis: Įgyvendinkite įrankių veikimą (tikri API)

Dabar sukursime veikiančias funkcijų realizacijas.

Sukurkite failą tool-executor.js:

javascript

// tool-executor.js
import 'dotenv/config';

/**
* Atlieka paiešką internete naudodamas Serper API (Google rezultatai)
*/
async function searchWeb(query, numResults = 3) {
try {
const response = await fetch('https://google.serper.dev/search', {
method: 'POST',
headers: {
'X-API-KEY': process.env.SERPER_API_KEY,
'Content-Type': 'application/json'
},
body: JSON.stringify({
q: query,
num: numResults
})
});

if (!response.ok) {
throw new Error(`Serper API error: ${response.status}`);
}

const data = await response.json();

// Extract and format results
const results = data.organic?.slice(0, numResults).map(item => ({
title: item.title,
snippet: item.snippet,
link: item.link
})) || [];

return {
query,
results,
searchTime: new Date().toISOString()
};

} catch (error) {
console.error('Search error:', error.message);
return {
error: `Failed to search: ${error.message}`,
query
};
}
}

/**
* Saugiai įvertina matematines išraiškas
*/
function calculate(expression) {
try {
// Basic safety: only allow numbers and operators
if (!/^[\d\s+\-*/().]+$/.test(expression)) {
throw new Error('Invalid expression: only numbers and basic operators allowed');
}

// Using Function constructor as a safer alternative to eval
const result = new Function(`return ${expression}`)();

return {
expression,
result,
calculated: true
};

} catch (error) {
return {
expression,
error: `Calculation failed: ${error.message}`,
calculated: false
};
}
}

/**
* Nukreipia įrankių iškvietimus į jų atitinkamas funkcijas
*/
export async function executeFunction(functionName, functionArgs) {
console.log(`🔧 Executing tool: ${functionName}`);
console.log(`📝 Arguments:`, functionArgs);

switch (functionName) {
case 'search_web':
return await searchWeb(
functionArgs.query,
functionArgs.num_results
);

case 'calculate':
return calculate(functionArgs.expression);

default:
throw new Error(`Unknown function: ${functionName}`);
}
}

Kas vyksta šiame kode?

searchWeb() - atlieka paiešką naudodama Serper API, pateikdama tikrus „Google“ paieškos rezultatus.
calculate() - saugiai įvertina matematines išraiškas.
executeFunction() - nukreipia įrankių iškvietimus į tinkamą funkcijos realizaciją.

⚠️ Saugumo pastaba:
Funkcija calculate() patikrina įvestį, kad apsisaugotų nuo kodo injekcijų.
Niekada nenaudokite eval() tiesiogiai su vartotojo duomenimis!

3 žingsnis: Sukurkite pilną agento ciklą

Dabar sujunkime viską į vieną visumą - pridėsime agentui sprendimų priėmimo logiką.

Sukurkite failą agent.js:

javascript

// agent.js
import 'dotenv/config';
import OpenAI from 'openai';
import { tools } from './tools.js';
import { executeFunction } from './tool-executor.js';

const openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY
});

/**
* Agento ciklas - veikia tol, kol užduotis visiškai įvykdoma.
*/
export async function runAgent(userMessage, options = {}) {
const {
model = 'gpt-4.1-mini', // Cost-effective for most tasks
maxIterations = 5, // Prevent infinite loops
verbose = true // Log agent thinking
} = options;

const messages = [
{
role: 'system',
content: 'You are a helpful AI assistant with access to web search and calculation tools. Use tools when you need current information or need to perform calculations. Always provide clear, accurate answers.'
},
{
role: 'user',
content: userMessage
}
];

let iterationCount = 0;

while (iterationCount < maxIterations) {
iterationCount++;

if (verbose) {
console.log(`\n🤔 Agent thinking (iteration ${iterationCount})...`);
}

try {
// Call OpenAI with tools available
const response = await openai.chat.completions.create({
model,
messages,
tools,
tool_choice: 'auto', // Let AI decide when to use tools
});

const message = response.choices[0].message;
messages.push(message);

// Log token usage for cost tracking
if (verbose) {
console.log(`💰 Tokens used: ${response.usage.total_tokens}`);
}

// If no tool calls, we have final answer
if (!message.tool_calls || message.tool_calls.length === 0) {
if (verbose) {
console.log('✅ Agent finished thinking\n');
}
return {
answer: message.content,
iterations: iterationCount,
tokensUsed: response.usage.total_tokens
};
}

// Execute each tool call
if (verbose) {
console.log(`🔧 Agent needs to use ${message.tool_calls.length} tool(s)`);
}

for (const toolCall of message.tool_calls) {
const functionName = toolCall.function.name;
const functionArgs = JSON.parse(toolCall.function.arguments);

// Execute the tool
const result = await executeFunction(functionName, functionArgs);

if (verbose) {
console.log(`✓ Tool result:`, JSON.stringify(result, null, 2));
}

// Add tool result back to conversation
messages.push({
role: 'tool',
tool_call_id: toolCall.id,
content: JSON.stringify(result)
});
}

// Loop continues - agent will think about tool results

} catch (error) {
console.error('❌ Agent error:', error.message);
throw error;
}
}

// Hit max iterations without finishing
throw new Error(`Agent exceeded maximum iterations (${maxIterations})`);
}

Ką daro agentas?

• Išsiunčia vartotojo užklausą į GPT-4.1 kartu su prieinamais įrankiais.
• DI nusprendžia: „Ar man reikia panaudoti įrankį?“
• • Jei nereikia įrankių → pateikia galutinį atsakymą.
  • Jei reikia įrankių → inicijuoja įrankio iškvietimą.
• Vykdo įrankio funkciją ir įtraukia gautus rezultatus į pokalbį.
• Grįžta į pirmą žingsnį su nauja informacija.
• Kartojasi, kol surenka pakankamai duomenų galutiniam atsakymui.

Saugumo priemonės:

• maxIterations apsaugo nuo begalinių ciklų (kad nekainuotų per brangiai).
• verbose logging padeda suprasti, kaip agentas „mąsto“.
• Žetonų (token) naudojimo stebėjimas leidžia realiu laiku matyti išlaidas.

4 žingsnis: Išbandykite savo agentą

Atnaujinkite failą index.js, kad galėtumėte patikrinti, ar agentas veikia teisingai:

javascript

// index.js
import { runAgent } from './agent.js';

async function main() {
console.log('🚀 Starting OpenAI Agent Demo\n');
console.log('=' .repeat(50));

// Test 1: Simple question (no tools needed)
console.log('\n📝 Test 1: Simple question');
console.log('Question: "What is 15 multiplied by 23?"');

const result1 = await runAgent('What is 15 multiplied by 23?');
console.log('\n💬 Answer:', result1.answer);
console.log('📊 Stats:', `${result1.iterations} iterations, ${result1.tokensUsed} tokens`);

// Test 2: Requires web search
console.log('\n' + '='.repeat(50));
console.log('\n📝 Test 2: Current information');
console.log('Question: "What are the latest developments in AI agents?"');

const result2 = await runAgent(
'What are the latest developments in AI agents?',
{ verbose: true }
);
console.log('\n💬 Answer:', result2.answer);
console.log('📊 Stats:', `${result2.iterations} iterations, ${result2.tokensUsed} tokens`);

// Test 3: Multi-step reasoning
console.log('\n' + '='.repeat(50));
console.log('\n📝 Test 3: Complex task');
console.log('Question: "Search for Node.js best practices and calculate 100 * 12"');

const result3 = await runAgent(
'Search for Node.js best practices and calculate 100 * 12'
);
console.log('\n💬 Answer:', result3.answer);
console.log('📊 Stats:', `${result3.iterations} iterations, ${result3.tokensUsed} tokens`);
}

main().catch(console.error);

Paleiskite savo agentą

bash

npm start

Tikėtinas rezultatas:

🚀 Starting OpenAI Agent Demo

==================================================

📝 Testas 1: Paprastas klausimas

Klausimas: "Kiek bus 15 padauginta iš 23?"

🤔 Agentas mąsto (1 iteracija)...

🔧 Agentui reikia panaudoti 1 įrankį

🔧 Vykdomas įrankis: calculate

📝 Argumentai: { expression: '15 * 23' }

✓ Įrankio rezultatas: {

"expression": "15 * 23",

"result": 345,

"calculated": true

}

💰 Panaudota žetonų: 156

🤔 Agentas mąsto (2 iteracija)...

💰 Panaudota žetonų: 187

✅ Agentas baigė darbą

💬 Atsakymas: 15 padauginta iš 23 yra 345.

📊 Statistika: 2 iteracijos, 187 žetonų

Sveikiname!

Jūs sukūrėte veikiantį DI agentą, kuris:
✅ Savarankiškai nusprendžia, kada ir kokius įrankius naudoti
✅ Ieško internete, naudodamas tikras API integracijas
✅ Atlieka skaičiavimus saugiai
✅ Mąsto keliais žingsniais
✅ Stebi išlaidas ir iteracijas realiu laiku

Ką išmokote:

• Agento veikimo ciklą (mąsto → veikia → kartoja)
• Tikrą API integraciją (be „mock“ duomenų)
• Kaip vykdyti įrankius ir apdoroti rezultatus
• Kaip sekti kainą ir taikyti saugumo ribas

Toliau - 3 dalis: naudosime Assistants API, kad suteiktume agentui ilgalaikę atmintį tarp sesijų - paversdami jį tikru skaitmeniniu komandos nariu.

3 dalis: Nuolatinės atminties pridėjimas su OpenAI Assistants API

Šioje dalyje sukursite pažangų DI asistentą, kuris prisimena pokalbius, tvarko kelių sesijų procesus ir atlieka sudėtingas užduotis.

Kodėl verta naudoti Assistants API?

Ankstesnėje dalyje kurtas agentas, naudojantis funkcijų kvietimus, turėjo vieną trūkumą - jis neturėjo atminties tarp paleidimų. Kiekvienas pokalbis prasidėdavo nuo nulio.

Pavyzdys:
Pirmadienis, 9:00
Tu: „Išanalizuok šią pardavimų lentelę.“ (įkelia failą)
Agentas: „Pajamos per ketvirtą ketvirtį išaugo 15 %.“

Antradienis, 10:00
Tu: „Kokia buvo ta pajamų suma?“
Agentas: „Neturiu prieigos prie jokios lentelės.“

Agentas pamiršo.
Toks veikimas netinkamas:

• 🧑‍💻 Klientų aptarnavimui (reikia pokalbių istorijos)
• 📄 Dokumentų analizei per ilgesnį laiką
• 🤖 Asmeniniams asistentams, kurie turi „mokytis“ iš naudotojo
• 📆 Ilgiems projektams, kuriužems reikia tęstinumo

Assistants API sprendžia šią problemą

• Nuolatiniai pokalbių gijos (threads) - istorija saugoma ilgalaikiai
• Įmontuoti įrankiai - pvz., kodo interpretatorius, failų paieška
• Automatinė atmintis - kontekstas išlieka tarp sesijų
• Būsenos išsaugojimas - agentas tęsia darbą nuo ten, kur sustojo

Pokalbių API (Chat Completions) ir Assistants API palyginimas

1 žingsnis: Sukurkite savo pirmąjį asistentą

Sukurkite assistant.js:

javascript

// assistant.js
import 'dotenv/config';
import OpenAI from 'openai';

const openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY
});

/**
* Sukuria naują OpenAI asistentą su nurodytais įrankiais ir funkcijomis
*/
export async function createAssistant(options = {}) {
const {
name = 'Business Assistant',
instructions = 'You are a helpful business assistant. You can analyze data, search files, and help with calculations. Always provide clear, actionable insights.',
tools = [
{ type: 'code_interpreter' }, // Run Python code
{ type: 'file_search' } // Search uploaded files
],
model = 'gpt-4.1' // Use full GPT-4.1 for assistant features
} = options;

console.log('🔧 Creating assistant...');

const assistant = await openai.beta.assistants.create({
name,
instructions,
tools,
model,
temperature: 0.7
});

console.log('✅ Assistant created:', assistant.id);
return assistant;
}

/**
* Išvardija visus jūsų turimus asistentus
*/
export async function listAssistants() {
const assistants = await openai.beta.assistants.list({
limit: 20,
order: 'desc'
});

return assistants.data;
}

/**
* Grąžina konkretų asistentą pagal jo ID
*/
export async function getAssistant(assistantId) {
return await openai.beta.assistants.retrieve(assistantId);
}

/**
* Ištrina asistentą (cleanup)
*/
export async function deleteAssistant(assistantId) {
console.log(`🗑️ Deleting assistant: ${assistantId}`);
await openai.beta.assistants.del(assistantId);
console.log('✅ Assistant deleted');
}

Kas vyksta čia:

Code_interpreter leidžia vykdyti Python kodą - puikiai tinka duomenų analizei.

Pažangios galimybės - kodo interpretatoriaus įrankis

Kodo interpretatorius - tikras lūžio taškas DI agentų kūrime. Jis leidžia automatiškai atlikti sudėtingą duomenų analizę, valdyti skaičiuokles, kurti vizualizacijas ir vykdyti nestandartinius skaičiavimus - visa tai saugioje aplinkoje, be rankinio programavimo.

Naudodami šį įrankį, kūrėjai ir komandos gali automatizuoti sudėtingus darbo srautus bei atrasti įžvalgas, kurioms anksčiau būtų reikėję daug laiko ir techninių žinių.

Kadangi DI agentai toliau tobulėja, derindami natūralios kalbos supratimą, kodo vykdymą ir daugelio įrankių koordinavimą, jų galimybės priimti savarankiškus sprendimus bei vykdyti intelektualią automatizaciją vis sparčiau plečiasi.
Nesvarbu, ar kuriate tyrimo pagalbininką, klientų aptarnavimo agentą, turinio kūrimo asistentą, ar verslo procesų automatizaciją - naudodamiesi šiomis pažangiomis priemonėmis užtikrinsite, kad jūsų sprendimai išliks prisitaikantys, išplečiami ir pasiruošę realaus pasaulio iššūkiams.

Išvada - DI agentų ateitis Node.js aplinkoje

Dabar jau žinote, kaip kurti DI agentus su OpenAI - nuo API sujungimo iki atminties ir savarankiškumo suteikimo.

DI agentų kūrimas naudojant OpenAI SDK ir pastovios atminties funkcijas keičia programinės įrangos kūrimo principus 2025-aisiais. Šie agentai ne tik atsako - jie mąsto, integruojasi su išorinėmis sistemomis ir savarankiškai atlieka sudėtingas užduotis.

Nesvarbu, ar jūsų tikslas - tyrimų automatizavimas, klientų aptarnavimas, ar verslo procesų valdymas, šie įrankiai suteikia galimybę kurti intelektualius ir mastelio požiūriu lankstus sprendimus.

Jei jus domina, kaip DI gali pagreitinti verslo analitiką ir duomenų apdorojimą, peržiūrėkite mūsų projektą Dirbtinio intelekto agentų verslo analizės sprendimai (opens in new tab).

Naudodami Node.js OpenAI SDK, turite galingą ir lanksčią platformą, leidžiančią greitai sukurti patikimus DI agentus. Kaip matėte šiame gide, derindami API integracijas, klaidų valdymą, sąnaudų optimizaciją (opens in new tab) ir daugiapakopį mąstymą, atveriate naujas automatizavimo galimybes.

Pradėkite jau šiandien - išbandykite funkcijų kvietimus ir atmintį, ir pamatysite, kaip greitai galite sukurti DI agentus, kurie iš tikrųjų dirba už jus.

Dabar, kai išmokote kurti OpenAI DI agentus Node.js aplinkoje, metas atsakyti į dažniausiai užduodamus kūrėjų klausimus.

DUK - Dažniausiai užduodami klausimai

Kaip apsaugoti savo OpenAI API raktus?

API raktų saugumas - itin svarbus norint išvengti neteisėtos prieigos ir netikėtų išlaidų.
Geriausios praktikos:

• Laikykite raktus saugiai (opens in new tab), naudodami aplinkos kintamuosius arba slaptažodžių valdymo sistemas (pvz., AWS Secrets Manager ar Azure Key Vault).
• Niekada nekoduokite raktų tiesiogiai kode ir nesaugokite jų kliento pusėje.
• Įtraukite .env failus į .gitignore, kad jie nepatektų į viešas saugyklas.
• Apribokite prieigos teises, suteikdami tik būtinas API sritis (scope) ir naudodami vaidmenų pagrindu paremtą valdymą (RBAC).
• Periodiškai keiskite raktus, kad sumažintumėte riziką. Geriausia - automatizuoti šį procesą.
• Naudokite saugius protokolus (TLS/HTTPS), kad duomenys būtų apsaugoti perdavimo metu.
• Stebėkite naudojimą ir nustatykite limitus, kad laiku pastebėtumėte piktnaudžiavimą.

Laikydamiesi šių žingsnių, užtikrinsite kelių sluoksnių apsaugą ir sklandų vystymo procesą.

Skirtumas tarp Chat Completions ir Function-Calling DI agentų

Chat Completions API - tai paprasti, vieno žingsnio pokalbiai, kai modelis tiesiog atsako į pateiktą užklausą be išorinių įrankių ar atminties.
Tinka:

• DUK tipo pokalbiams
• Tekstų generavimui (pvz., straipsniai, el. laiškai)
• Santraukų ar vertimų kūrimui
• Paprastai kodo pagalbai (paaiškinimui ar siūlymams)

Function-calling DI agentai - pažangesni. Jie gali:

• Aptikti, kada reikia išorinio įrankio ar API, ir jį iškviesti pokalbio metu
• Vykdyti kelių žingsnių logiką bei planuoti veiksmus
• Išlaikyti kontekstą tarp užklausų (naudojant atmintį)
• Savarankiškai atlikti sudėtingas užduotis, pvz., duomenų analizę, paieškas ar sprendimų priėmimą

Tokie agentai leidžia kurti daug sudėtingesnes, protingesnes ir mastelio požiūriu efektyvesnes sistemas.

Kaip optimizuoti OpenAI API naudojimo kaštus?

Norėdami sumažinti išlaidas:

• Naudokite ekonomiškus modelius (pvz., GPT-4.1-mini) vystymo ir testavimo etapuose.
• Ribokite žetonų skaičių - nustatykite max_tokens ir apkarpykite nereikalingus įvesties duomenis.
• Grupuokite užklausas (batching) - mažiau API iškvietimų = mažesni kaštai.
• Stebėkite naudojimą realiu laiku per OpenAI valdymo skydelį arba API.
• Naudokite kešavimą, kai rezultatai dažnai kartojasi.
• Funkcijų kvietimus naudokite tik tada, kai būtina- išvengsite bereikalingų išteklių švaistymo.
• Nustatykite biudžetus ir įspėjimus, kad komanda laiku sureaguotų į viršytas ribas.

Protingas resursų valdymas leidžia naudotis OpenAI galia neišleidžiant daugiau nei reikia.

Ar galima naudoti nuolatinę atmintį tarp sesijų?

Taip, OpenAI Assistants API palaiko pastovią atmintį, kuri:

• Išsaugo pokalbių eigą ir kontekstą tarp sesijų
• Leidžia kurti ilgalaikius, tęstinius darbo srautus
• Įgalina DI agentus mokytis iš ankstesnių sąveikų ir pritaikyti atsakymus pagal vartotoją

Be šios funkcijos, kiekviena užklausa yra „statinė“ - agentas neprisimena ankstesnių sąveikų.
Naudodami atmintį, DI agentus paversite tikrais skaitmeniniais asistentais, gebančiais tęsti darbą nuo ten, kur buvo sustota.

Kaip dėl GPT-5?

GPT-5 - naujausios kartos OpenAI modelis.
Jis pasižymi:

• Dar pažangesniu loginio mąstymo ir kūrybiškumo lygiu
• Geresniu multimodaliniu supratimu (tekstai, vaizdai, garsas)
• Didesnėmis skaičiavimo sąnaudomis

Tuo tarpu GPT-4.1 ir GPT-4.1-mini vis dar išlieka populiariausi dėl puikaus kainos ir našumo santykio - idealūs sprendimams, kuriant patikimus DI agentus 2025-aisiais.

Norite sukurti savo DI agentą?

Mes padedame įmonėms kurti realiai veikiančius OpenAI sprendimus - nuo paprastų pokalbių agentų iki pažangių sistemų, gebančių mąstyti ir veikti savarankiškai.
Susisiekite su MYGOM komanda (opens in new tab) ir kartu paverskime jūsų idėją veikiančiu DI produktu.