როგორ შევქმნათ ხელოვნური ინტელექტის აგენტი

მოკლე პასუხი: პრაქტიკაში მომუშავე ხელოვნური ინტელექტის აგენტის შესაქმნელად, ის კონტროლირებად ციკლად უნდა ჩაითვალოს: მიიღეთ შეყვანა, გადაწყვიტეთ შემდეგი მოქმედება, გამოიძახეთ ვიწრო მასშტაბის ინსტრუმენტი, დააკვირდით შედეგს და გაიმეორეთ მანამ, სანამ „დასრულებული“ შემოწმება არ გაივლის. ის თავის ადგილს იმსახურებს, როდესაც დავალება მრავალსაფეხურიანია და ინსტრუმენტებზეა ორიენტირებული; თუ მას ერთი მოთხოვნა წყვეტს, გამოტოვეთ აგენტი. დაამატეთ მკაცრი ხელსაწყოების სქემები, ნაბიჯების ლიმიტები, ჟურნალირება და ვალიდატორი/კრიტიკოსი, რათა როდესაც ხელსაწყოები ვერ ხერხდება ან შეყვანილი ინფორმაცია ბუნდოვანია, აგენტი ციკლის ნაცვლად ესკალაციას იწყებს.

ძირითადი დასკვნები:

კონტროლერის ციკლი : შეყვანის → მოქმედება → გამეორების დაკვირვება მკაფიო გაჩერების პირობებით და მაქსიმალური ნაბიჯებით.

ხელსაწყოების დიზაინი : შეინარჩუნეთ ხელსაწყოების ვიწრო, აკრეფილი, ნებართვებით აღჭურვილი და დამოწმებული რეჟიმი, რათა თავიდან აიცილოთ „ნებისმიერი რამის გაკეთების“ ტიპის ქაოსი.

მეხსიერების ჰიგიენა : გამოიყენეთ კომპაქტური მოკლევადიანი მდგომარეობა პლუს გრძელვადიანი აღდგენა; მოერიდეთ სრული ტრანსკრიპტების გადაყრას.

ბოროტად გამოყენების წინააღმდეგობა : დაამატეთ დაშვებულთა სიები, სიჩქარის ლიმიტები, იდეპოტენცია და „მშრალი გაშვება“ სარისკო ქმედებებისთვის.

ტესტირებადობა : სცენარების ნაკრების შენარჩუნება (ჩავარდნები, გაურკვევლობა, ინექციები) და ყოველი ცვლილების შემდეგ მათი ხელახლა გაშვება.

---

1) რა არის ხელოვნური ინტელექტის აგენტი, ჩვეულებრივი ადამიანის თვალსაზრისით 🧠

ხელოვნური ინტელექტის აგენტი არის ციკლი. LangChain-ის „აგენტების“ დოკუმენტაცია

სულ ესაა. მარყუჟი, რომლის შუაშიც ტვინია.

შეყვანა → ფიქრი → მოქმედება → დაკვირვება → გამეორება . რეაგირების ნაშრომი (მიზეზი + მოქმედება)

სად:

• შეყვანილი ინფორმაცია არის მომხმარებლის მოთხოვნა ან მოვლენა (ახალი ელ.ფოსტა, დახმარების ბილეთი, სენსორის პინგი).

• ფიქრი არის ენობრივი მოდელი, რომელიც მსჯელობს შემდეგ ნაბიჯზე.

• Act არის ინსტრუმენტის გამოძახება (შიდა დოკუმენტების ძიება, კოდის გაშვება, ბილეთის შექმნა, პასუხის შედგენა). OpenAI ფუნქციის გამოძახების სახელმძღვანელო

• დაკვირვება ინსტრუმენტის გამომავალ მონაცემებს კითხულობს.

• გამეორება არის ის ნაწილი, რაც მას „საუბრის“ ნაცვლად „აგენტიურ“ შეგრძნებას სძენს. LangChain-ის „აგენტების“ დოკუმენტაცია

ზოგიერთი აგენტი ძირითადად ჭკვიანი მაკროა. სხვები უფრო ახალგაზრდა ოპერატორების მსგავსად მოქმედებენ, რომლებსაც შეუძლიათ ამოცანების გადაჭრა და შეცდომების აღმოფხვრა. ორივე მნიშვნელოვანია.

ასევე, სრული ავტონომია არ გჭირდებათ. სინამდვილეში... ალბათ არ გსურთ 🙃

---

2) როდის უნდა შექმნათ აგენტი (და როდის არა) 🚦

შექმენით აგენტი, როდესაც:

• სამუშაო მრავალსაფეხურიანია და იცვლება იმის მიხედვით, თუ რა მოხდება შუა გზაზე.

• სამუშაოს სჭირდება ინსტრუმენტების გამოყენება (მონაცემთა ბაზები, CRM სისტემები, კოდის შესრულება, ფაილების გენერირება, ბრაუზერები, შიდა API-ები). LangChain-ის „ინსტრუმენტების“ დოკუმენტაცია

• თქვენ გსურთ განმეორებადი შედეგები დამცავი ბარიერების გამოყენებით და არა მხოლოდ ერთჯერადი პასუხებით.

• თქვენ შეგიძლიათ განსაზღვროთ „დასრულებული“ ისე, რომ კომპიუტერი შეამოწმებს, თუნდაც უხეშად.

არ შექმნათ აგენტი, როდესაც:

• მარტივი მოთხოვნა + პასუხი ამ პრობლემას აგვარებს (ნუ გადააჭარბებთ ინჟინერიას, თორემ მოგვიანებით საკუთარ თავს შეგძულდებათ).

• თქვენ გჭირდებათ სრულყოფილი დეტერმინიზმი (აგენტები შეიძლება იყვნენ თანმიმდევრულები, მაგრამ არა რობოტული).

• თქვენ არ გაქვთ არანაირი ხელსაწყო ან მონაცემი დასაკავშირებლად - მაშინ ეს ძირითადად მხოლოდ ვიბრაციებია.

მოდით, გულახდილები ვიყოთ: „ხელოვნური ინტელექტის აგენტის პროექტების“ ნახევარი შეიძლება იყოს სამუშაო პროცესი რამდენიმე განშტოების წესით. თუმცა, ზოგჯერ ვიბრაციასაც აქვს მნიშვნელობა 🤷♂️

---

3) რა ხდის ხელოვნური ინტელექტის აგენტს კარგ ვერსიას ✅

აი, თქვენ მიერ მოთხოვნილი განყოფილება „რა ქმნის კარგ ვერსიას“, თუმცა ცოტა პირდაპირი ვიქნები:

ხელოვნური ინტელექტის აგენტის კარგი ვერსია კი არ , ვინც ყველაზე რთულად ფიქრობს. არამედ ის, რომელიც:

• იცის, რა შეუძლია გააკეთოს (ფარგლების საზღვრები)

• საიმედოდ იყენებს ინსტრუმენტებს (სტრუქტურირებული ზარები, ხელახალი ცდები, ტაიმ-აუტები) OpenAI ფუნქციის გამოძახების სახელმძღვანელო AWS „ტაიმ-აუტები, ხელახალი ცდები და უკუსვლა რხევის დროს“

• ინარჩუნებს მდგომარეობის სისუფთავეს (მეხსიერება, რომელიც არ ლპება) LangChain „მეხსიერების მიმოხილვა“

• განმარტავს თავის ქმედებებს (აუდიტის კვალი და არა საიდუმლო მსჯელობის დემპინგი) NIST AI RMF 1.0 (სანდოობა და გამჭვირვალობა)

• შესაბამისად ჩერდება (დასრულების შემოწმება, მაქსიმალური ნაბიჯები, ესკალაცია) LangChain-ის „აგენტების“ დოკუმენტები

• უსაფრთხოდ ვერ ხერხდება (დახმარებას ითხოვს, ავტორიტეტის ჰალუცინაციები არ აქვს) NIST AI RMF 1.0

• ტესტირებადია (შეგიძლიათ გაუშვათ ის წინასწარ დაგეგმილ სცენარებზე და შეაფასოთ შედეგები)

თუ თქვენი აგენტის შემოწმება შეუძლებელია, ეს არსებითად ძალიან თავდაჯერებული სათამაშო აპარატია. გართობა წვეულებებზე, საშინელი წარმოება 😬

---

4) აგენტის ძირითადი საშენი ბლოკები („ანატომია“ 🧩)

მყარი აგენტების უმეტესობას აქვს ეს ნაწილები:

ა) კონტროლერის ციკლი 🔁

ეს არის ორკესტრის ხელმძღვანელი:

• გოლის გატანა

• ჰკითხეთ მოდელს შემდეგი მოქმედების შესახებ

• გაშვების ინსტრუმენტი

• დაკვირვების დამატება

• გაიმეორეთ დასრულებამდე LangChain-ის „აგენტების“ დოკუმენტები

ბ) ხელსაწყოები (ანუ შესაძლებლობები) 🧰

ხელსაწყოები აგენტის ეფექტურობის განმსაზღვრელია: LangChain-ის „ინსტრუმენტების“ დოკუმენტაცია

• მონაცემთა ბაზის მოთხოვნები

• ელფოსტის გაგზავნა

• ფაილების ამოღება

• გაშვებული კოდი

• შიდა API-ების გამოძახება

• ცხრილებში ან CRM-ში წერა

გ) მეხსიერება 🗃️

ორი სახეობა მნიშვნელოვანია:

• მოკლევადიანი მეხსიერება : მიმდინარე გაშვების კონტექსტი, ბოლო ნაბიჯები, მიმდინარე გეგმა

• გრძელვადიანი მეხსიერება : მომხმარებლის პრეფერენციები, პროექტის კონტექსტი, მოძიებული ცოდნა (ხშირად ჩაშენებული ფაილების + ვექტორული საცავის მეშვეობით) RAG ქაღალდი

დ) დაგეგმვისა და გადაწყვეტილების მიღების პოლიტიკა 🧭

მაშინაც კი, თუ ამას „დაგეგმვას“ არ უწოდებთ, მეთოდი გჭირდებათ:

• საკონტროლო სიები

• ReAct-ის სტილის „დაფიქრდი და შემდეგ გამოიყენე ინსტრუმენტი“ ReAct-ის ნაშრომი

• დავალებების გრაფიკები

• ხელმძღვანელისა და მუშაკის ურთიერთობის ნიმუშები

• ხელმძღვანელი-მუშაკის შაბლონები Microsoft AutoGen (მრავალაგენტიანი ჩარჩო)

ე) დამცავი ღობეები და შეფასება 🧯

• ნებართვები

• უსაფრთხო ხელსაწყოების სქემები OpenAI სტრუქტურირებული გამომავალი

• გამომავალი ვალიდაცია

• ნაბიჯების ლიმიტები

• ხე-ტყე

• NIST AI RMF 1.0- ის ტესტები

დიახ, ეს უფრო ინჟინერიაა, ვიდრე შთაგონება. რაც... ერთგვარად მთავარი აზრია.

---

5) შედარების ცხრილი: აგენტის შექმნის პოპულარული გზები 🧾

ქვემოთ მოცემულია რეალისტური „შედარების ცხრილი“ - რამდენიმე უცნაურობით, რადგან რეალური გუნდები უცნაურები არიან 😄

ინსტრუმენტი / ჩარჩო	აუდიტორია	ფასი	რატომ მუშაობს	შენიშვნები (პატარა ქაოსი)
LangChain	მშენებლები, რომლებსაც მოსწონთ ლეგოს სტილის კომპონენტები	უფასო + ინფრასტრუქტურა	დიდი ეკოსისტემა ხელსაწყოებისთვის, მეხსიერებისთვის, ჯაჭვებისთვის	თუ ყველაფერს ნათლად არ დაასახელებ, სწრაფად მიირთმევ სპაგეტის
ლამას ინდექსი	RAG-ის მძიმე გუნდები	უფასო + ინფრასტრუქტურა	ძლიერი მოძიების ნიმუშები, ინდექსირება, კონექტორები	შესანიშნავია, როდესაც თქვენი აგენტი ძირითადად „ძებნას + მოქმედებას“ ეწევა... რაც საკმაოდ გავრცელებულია
OpenAI ასისტენტების სტილის მიდგომა	გუნდები, რომლებიც უფრო სწრაფ მომზადებას ეძებენ	გამოყენებაზე დაფუძნებული	ჩაშენებული ხელსაწყოს გამოძახების შაბლონები და გაშვების მდგომარეობა	ზოგიერთ კუთხეში ნაკლებად მოქნილი, მაგრამ ბევრი აპლიკაციისთვის სუფთა	OpenAI ახორციელებს API-ს OpenAI ასისტენტების ფუნქციის გამოძახებას
სემანტიკური ბირთვი	დეველოპერები, რომლებსაც სურთ სტრუქტურირებული ორკესტრირება	თავისუფალი	უნარების/ფუნქციების ზუსტი აბსტრაქცია	„საწარმოს მოწესრიგებულობის“ შეგრძნებაა - ზოგჯერ ეს კომპლიმენტია 😉
ავტოგენერაცია	მრავალაგენტიანი ექსპერიმენტატორები	თავისუფალი	აგენტ-აგენტს შორის თანამშრომლობის ნიმუშები	შეუძლია ზედმეტად ისაუბროს; დააწესოს მკაცრი წესები შეწყვეტის შესახებ
CrewAI	„აგენტების გუნდების“ გულშემატკივრები	თავისუფალი	როლები + დავალებები + გადანაწილება ადვილად გამოსახატავია	საუკეთესოდ მუშაობს, როდესაც დავალებები მკვეთრია და არა ფაფუკი
თივის ზვინი	ძიება + მილსადენები	თავისუფალი	მყარი მილსადენები, მოპოვება, კომპონენტები	ნაკლები „აგენტური თეატრი“, მეტი „პრაქტიკული ქარხანა“
საკუთარი ხელით შექმენი (მორგებული ციკლი)	კონტროლის მოყვარულები (მოსიყვარულეები)	შენი დრო	მინიმალური მაგია, მაქსიმალური სიცხადე	როგორც წესი, საუკეთესო გრძელვადიანი... სანამ ყველაფერს თავიდან არ გამოიგონებ 😅

ერთი გამარჯვებული არ არსებობს. საუკეთესო არჩევანი დამოკიდებულია იმაზე, თქვენი აგენტის მთავარი სამუშაოა მონაცემების მოძიება , ინსტრუმენტების გამოყენება , მრავალაგენტიანი კოორდინაცია თუ სამუშაო პროცესის ავტომატიზაცია .

---

6) როგორ შევქმნათ ხელოვნური ინტელექტის აგენტი ეტაპობრივად (რეცეპტი) 🍳🤖

ეს ის ნაწილია, რომელსაც ადამიანების უმეტესობა გამოტოვებს და შემდეგ უკვირს, რატომ იქცევა აგენტი საკუჭნაოში ენოტივით.

ნაბიჯი 1: განსაზღვრეთ სამუშაო ერთი წინადადებით 🎯

მაგალითები:

• „მომხმარებლის პასუხის შემუშავება პოლიტიკისა და ბილეთის კონტექსტის გამოყენებით, შემდეგ კი დამტკიცების მოთხოვნა.“

• „გამოიკვლიეთ შეცდომის ანგარიში, გაამრავლეთ იგი და შესთავაზეთ გამოსწორების გზა.“

• „არასრულყოფილი შეხვედრების ჩანაწერები დავალებებად, მფლობელებად და ვადებად აქციეთ.“

თუ თქვენ არ შეგიძლიათ მისი მარტივად განსაზღვრა, თქვენს აგენტსაც არ შეუძლია. ანუ, შეუძლია, მაგრამ ის იმპროვიზაციას გააკეთებს და იმპროვიზაცია არის ის, სადაც ბიუჯეტი კვდება.

ნაბიჯი 2: განსაზღვრეთ ავტონომიის დონე (დაბალი, საშუალო, ცხარე) 🌶️

• დაბალი ავტონომია : გთავაზობთ ნაბიჯებს, ადამიანის დაწკაპუნებები „ამტკიცებს“

• საშუალო : ხელსაწყოების გაშვება, გამომავალი მონაცემების ნახაზი, გაურკვევლობის შემთხვევაში ესკალაცია

• მაღალი : ასრულებს სრულ კავშირს, მხოლოდ გამონაკლისებზე აგზავნის პინგს ადამიანებს.

დაიწყეთ სასურველზე დაბალით. მოგვიანებით ყოველთვის შეგიძლიათ გაზარდოთ.

ნაბიჯი 3: აირჩიეთ თქვენი მოდელის სტრატეგია 🧠

როგორც წესი, თქვენ ირჩევთ:

• ერთი ძლიერი მოდელი ყველაფრისთვის (მარტივი)

• ერთი ძლიერი მოდელი + უფრო პატარა მოდელი იაფი საფეხურებისთვის (კლასიფიკაცია, მარშრუტიზაცია)

• საჭიროების შემთხვევაში, სპეციალიზებული მოდელები (ხედვა, კოდი, მეტყველება)

ასევე გადაწყვიტეთ:

• მაქსიმალური ტოკენები

• ტემპერატურა

• ნებას რთავთ თუ არა შინაგანად მსჯელობის გრძელ კვალს (შეგიძლიათ, მაგრამ არ გაამჟღავნოთ საბოლოო მომხმარებლებისთვის ნედლი აზროვნების ჯაჭვი)

ნაბიჯი 4: განსაზღვრეთ ინსტრუმენტები მკაცრი სქემებით 🔩

ინსტრუმენტები უნდა იყოს:

• ვიწრო

• აკრეფილი

• ნებართვით

• დადასტურებული OpenAI სტრუქტურირებული შედეგები

do_anything(input: string) სახელწოდების ინსტრუმენტის ნაცვლად , შექმენით:

• search_kb(query: string) -> შედეგები[]

• create_ticket(სათაური: სტრიქონი, ტექსტი: სტრიქონი, პრიორიტეტი: ნუმერაცია) -> ticket_id

• send_email(to: string, subject: string, body: string) -> status OpenAI ფუნქციის გამოძახების სახელმძღვანელო

თუ აგენტს ჯაჭვურ ხერხს მისცემთ, ნუ გაგიკვირდებათ, როდესაც ის ღობის მოხსნით ჰეჯსაც გასხვლის.

ნაბიჯი 5: ააგეთ კონტროლერის ციკლი 🔁

მინიმალური ციკლი:

1. დაიწყეთ მიზნით + საწყისი კონტექსტით

2. ჰკითხეთ მოდელს: „შემდეგი მოქმედება?“

3. თუ ინსტრუმენტის გამოძახება - ინსტრუმენტის შესრულება

4. დაკვირვების დამატება

5. შეამოწმეთ გაჩერების მდგომარეობა

6. გაიმეორეთ (მაქსიმალური ნაბიჯებით) LangChain-ის „აგენტების“ დოკუმენტები

დამატება:

• ტაიმ-აუტები

• ხელახალი მცდელობები (ფრთხილად - ხელახალი მცდელობები შეიძლება ციკლურად განმეორდეს) AWS „ტაიმ-აუტები, ხელახალი მცდელობები და უკან დახევა რხევით“

• ინსტრუმენტის შეცდომის ფორმატირება (მკაფიო, სტრუქტურირებული)

ნაბიჯი 6: მეხსიერების ფრთხილად დამატება 🗃️

მოკლევადიანი: კომპაქტური „მდგომარეობის შეჯამების“ განახლება ყოველ ნაბიჯზე. LangChain-ის „მეხსიერების მიმოხილვა“
გრძელვადიანი: მდგრადი ფაქტების შენახვა (მომხმარებლის პარამეტრები, ორგანიზაციის წესები, სტაბილური დოკუმენტები).

ზოგადი წესი:

• თუ ის ხშირად იცვლება - მოკლევადიანი შეინახეთ

• თუ სტაბილურია - შეინახეთ დიდი ხნის განმავლობაში

• თუ მგრძნობიარეა - შეინახეთ მინიმალურად (ან საერთოდ არ შეინახოთ)

ნაბიჯი 7: დაამატეთ დადასტურება და „კრიტიკოსის“ საშვი 🧪

იაფი, პრაქტიკული ნიმუში:

• აგენტი წარმოქმნის შედეგს

• ვალიდატორი ამოწმებს სტრუქტურას და შეზღუდვებს

• კრიტიკული მოდელის არასავალდებულო მიმოხილვები გამოტოვებული ნაბიჯების ან პოლიტიკის დარღვევების შემთხვევაში NIST AI RMF 1.0

იდეალური არ არის, მაგრამ შოკისმომგვრელი რაოდენობით სისულელეს იჭერს.

ნაბიჯი 8: ჩაიწერეთ ყველაფერი, რისი არჩაწერის გამოტოვებასაც ინანებთ 📜

ჟურნალი:

• ხელსაწყოს გამოძახებები + შეყვანები + გამომავალი

• მიღებული გადაწყვეტილებები

• შეცდომები

• საბოლოო შედეგები

• ტოკენები და შეყოვნება OpenTelemetry-ის დაკვირვებადობის პრაიმერი

მომავალი - მადლობას გეტყვით. აწმყო - დაივიწყებთ. ეს უბრალოდ ცხოვრებაა 😵💫

---

7) ინსტრუმენტებზე დარეკვა, რომელიც სულს არ გაგიტეხავს 🧰😵

ხელსაწყოების გამოძახებისას „როგორ შევქმნათ ხელოვნური ინტელექტის აგენტი“ ნამდვილ პროგრამული უზრუნველყოფის ინჟინერიად იქცევა.

ხელსაწყოები საიმედო გახადეთ (სანდოობა კარგია)

საიმედო ინსტრუმენტებია:

• დეტერმინისტული

• ვიწრო მასშტაბის

• ადვილი შესამოწმებელია

• Stripe-ის „იდემპოტენტი მოთხოვნების“ ხელახლა გაშვება

დაამატეთ დამცავი მოაჯირები ხელსაწყოების ფენაზე და არა მხოლოდ მოთხოვნები

მინიშნებები თავაზიანი წინადადებებია. ხელსაწყოს ვალიდაცია ჩაკეტილი კარია. OpenAI სტრუქტურირებული გამომავალი

გააკეთე:

• დაშვებულთა სიები (რომელი ინსტრუმენტების გაშვება შეიძლება)

• შეყვანის ვალიდაცია

• ტარიფის ლიმიტები OpenAI ტარიფის ლიმიტების სახელმძღვანელო

• ნებართვების შემოწმება თითოეული მომხმარებლის/ორგანიზაციისთვის

• „მშრალი გაშვების რეჟიმი“ სარისკო ქმედებებისთვის

ნაწილობრივი უკმარისობის დიზაინი

ხელსაწყოები ვერ ხერხდება. ქსელები ირყევა. ავტორიზაციის ვადა იწურება. აგენტმა უნდა:

• შეცდომების ინტერპრეტაცია

• ხელახალი ცდა საჭიროების შემთხვევაში შეფერხებით Google Cloud-ის ხელახალი ცდის სტრატეგია (შეფერხება + რხევა)

• ალტერნატიული ინსტრუმენტების არჩევა

• ესკალაცია, როდესაც ჩიხში ხართ

ჩუმად ეფექტური ხრიკი: დააბრუნეთ სტრუქტურირებული შეცდომები, როგორიცაა:

• ტიპი: ავტორიზაციის_შეცდომა

• ტიპი: ვერ_იპოვეს

• type: rate_limited
  ამგვარად, მოდელს შეუძლია ინტელექტუალურად რეაგირება პანიკის ნაცვლად.

---

8) მეხსიერება, რომელიც გეხმარებათ და არა გაწუხებთ 👻🗂️

მეხსიერება ძლიერია, მაგრამ ის ასევე შეიძლება ნაგვის ყუთად იქცეს.

მოკლევადიანი მეხსიერება: შეინარჩუნეთ კომპაქტური

გამოყენება:

• ბოლო N ნაბიჯი

• მიმდინარე შეჯამება (განახლდება ყოველ ციკლში)

• მიმდინარე გეგმა

• მიმდინარე შეზღუდვები (ბიუჯეტი, დრო, პოლიტიკა)

თუ ყველაფერს კონტექსტში განვიხილავთ, შემდეგს მივიღებთ:

• უფრო მაღალი ღირებულება

• უფრო ნელი ლატენტობა

• მეტი დაბნეულობა (დიახ, მაშინაც კი)

გრძელვადიანი მეხსიერება: აღდგენა „შევსების“ ნაცვლად

„გრძელვადიანი მეხსიერების“ უმეტესობა უფრო მეტად ასე გამოიყურება:

• ჩანერგვები

• ვექტორების მაღაზია

• გაძლიერებული გენერაციის (RAG) RAG ქაღალდის

აგენტი არ იმახსოვრებს. ის ყველაზე მნიშვნელოვან ფრაგმენტებს შესრულების დროს ითხოვს. LlamaIndex „შესავალი RAG-ში“

პრაქტიკული მეხსიერების წესები

• შეინახეთ „პრეფერენციები“ როგორც აშკარა ფაქტები: „მომხმარებელს მოსწონს პუნქტებიანი შეჯამებები და სძულს ემოჯიები“ (ლოლ, თუმცა აქ არა 😄)

• შეინახეთ „გადაწყვეტილებები“ დროის ნიშნულებით ან ვერსიებით (წინააღმდეგ შემთხვევაში, წინააღმდეგობები გროვდება)

• არასოდეს შეინახოთ საიდუმლოებები, თუ ნამდვილად არ გჭირდებათ

და აი, ჩემი არასრულყოფილი მეტაფორა: მეხსიერება მაცივარს ჰგავს. თუ მას არასდროს გაწმენდ, საბოლოოდ შენს სენდვიჩს ხახვისა და სინანულის გემო ექნება.

---

9) დაგეგმვის ნიმუშები (მარტივიდან ელეგანტურამდე) 🧭✨

დაგეგმვა უბრალოდ კონტროლირებადი დაშლაა. ნუ გახდით მას მისტიკურს.

ნიმუში A: საკონტროლო სიის დამგეგმავი ✅

• მოდელი აჩვენებს ნაბიჯების სიას

• ეტაპობრივად ასრულებს

• განახლებების საკონტროლო სიის სტატუსი

შესანიშნავია დამწყებთათვის. მარტივი, ტესტირებადი.

ნიმუში B: ReAct ციკლი (მიზეზი + მოქმედება) 🧠→🧰

• მოდელი განსაზღვრავს შემდეგ ხელსაწყოს გამოძახებას

• აკვირდება გამომავალს

• ReAct-ის ნაშრომის გამეორება

ეს არის აგენტის კლასიკური განცდა.

ნიმუში C: ხელმძღვანელი-მუშაკი 👥

• ხელმძღვანელი მიზანს ამოცანებად ყოფს

• მუშები ასრულებენ სპეციალიზებულ დავალებებს

• ზედამხედველი აერთიანებს შედეგებს Microsoft AutoGen (მრავალაგენტიანი ჩარჩო)

ეს ღირებულია, როდესაც დავალებები პარალელიზებადია, ან როდესაც გსურთ სხვადასხვა „როლები“, როგორიცაა:

• მკვლევარი

• კოდირების სპეციალისტი

• რედაქტორი

• ხარისხის კონტროლის შემმოწმებელი

ნიმუში D: დაგეგმვა-შემდეგ განხორციელება გადაგეგმვით 🔄

• გეგმის შექმნა

• შესრულება

• თუ ხელსაწყოს შედეგები რეალობას შეცვლის, გადაგეგმეთ

ეს აგენტს ხელს უშლის ჯიუტად მიჰყვეს ცუდი გეგმას. ადამიანებიც ასე იქცევიან, თუ დაღლილები არ არიან, რა შემთხვევაშიც ისინიც ცუდ გეგმებს მისდევენ.

---

10) უსაფრთხოება, საიმედოობა და სამსახურიდან გათავისუფლების თავიდან აცილება 🔐😅

თუ თქვენს აგენტს შეუძლია ქმედებების განხორციელება, უსაფრთხოების დიზაინი გჭირდებათ. „არ არის კარგი, რომ გქონდეთ“. საჭიროა. NIST AI RMF 1.0

მკაცრი ლიმიტები

• მაქსიმალური ნაბიჯები ერთ სირბილზე

• ხელსაწყოს მაქსიმალური გამოძახებები წუთში

• მაქსიმალური ხარჯი სესიაზე (ტოკენების ბიუჯეტი)

• შეზღუდული ინსტრუმენტები დამტკიცების მიღმა

მონაცემთა დამუშავება

• შესვლის წინ მგრძნობიარე მონაცემების რედაქტირება

• ცალკეული გარემო (განვითარების vs წარმოების)

• ყველაზე დაბალი პრივილეგიის მქონე ინსტრუმენტის ნებართვები

ქცევითი შეზღუდვები

• აიძულეთ აგენტი, მოიხსენიოს შიდა მტკიცებულებების ფრაგმენტები (არა გარე ბმულები, მხოლოდ შიდა მითითებები)

• დაბალი ნდობის შემთხვევაში, საჭიროა გაურკვევლობის ნიშნები

• მოითხოვეთ „დასვით დამაზუსტებელი კითხვა“, თუ შეყვანილი ინფორმაცია ბუნდოვანია

სანდო აგენტი არ არის ყველაზე თავდაჯერებული. ის არის ის, ვინც იცის, როდის ვარაუდობს... და ამას თავად ამბობს.

---

11) ტესტირება და შეფასება (ნაწილი, რომელსაც ყველა გაურბის) 🧪📏

შეუძლებელია გააუმჯობესო ის, რისი გაზომვაც არ შეგიძლია. დიახ, ეს ფრაზა უაზროა, მაგრამ გამაღიზიანებლად სიმართლეა.

სცენარების ნაკრების შექმნა

შექმენით 30-100 სატესტო შემთხვევა:

• ბედნიერი გზები

• კიდის შემთხვევები

• „ხელსაწყოების გაუმართაობის“ შემთხვევები

• ორაზროვანი მოთხოვნები

• შეჯიბრებითი მოთხოვნები (სწრაფი ინექციის მცდელობები) OWASP ტოპ 10 LLM აპლიკაციებისთვის OWASP LLM01 სწრაფი ინექცია

ქულების შედეგები

გამოიყენეთ ისეთი მეტრიკები, როგორიცაა:

• დავალების წარმატების მაჩვენებელი

• დასრულების დრო

• ინსტრუმენტის შეცდომის აღდგენის მაჩვენებელი

• ჰალუცინაციების სიხშირე (მტკიცებულებები მტკიცებულებების გარეშე)

• ადამიანის მიერ დამტკიცების მაჩვენებელი (ზედამხედველობის რეჟიმში ყოფნის შემთხვევაში)

რეგრესიული ტესტები მოთხოვნებისა და ხელსაწყოებისთვის

ნებისმიერ დროს, როდესაც შეცვლით:

• ინსტრუმენტის სქემა

• სისტემის ინსტრუქციები

• აღდგენის ლოგიკა

• მეხსიერების ფორმატი
  . ხელახლა გაუშვით პაკეტი.

აგენტები მგრძნობიარე არსებები არიან. ოთახის მცენარეების მსგავსად, მაგრამ უფრო ძვირი.

---

12) განლაგების ნიმუშები, რომლებიც თქვენს ბიუჯეტს არ დაზოგავს 💸🔥

დაიწყეთ ერთი სერვისით

• აგენტის კონტროლერის API

• ხელსაწყოების მომსახურება მის უკან

• ჟურნალირება + მონიტორინგი OpenTelemetry-ის დაკვირვებადობის სახელმძღვანელო

ხარჯების კონტროლის ადრეულ ეტაპზე დამატება

• ქეშირების მოძიების შედეგები

• საუბრის მდგომარეობის შეკუმშვა შეჯამებებით

• მარშრუტიზაციისა და მოპოვებისთვის უფრო მცირე მოდელების გამოყენება

• „ღრმა აზროვნების რეჟიმის“ შეზღუდვა ურთულესი ნაბიჯებით

საერთო არქიტექტურის არჩევანი

• უპატრონო კონტროლერი + გარე მდგომარეობის საცავი (DB/redis)

• ხელსაწყოს გამოძახებები, სადაც შესაძლებელია , იდემპოტენტია.

• გრძელი დავალებების რიგში დაყენება (რათა ვებ-მოთხოვნა სამუდამოდ ღია არ იყოს)

ასევე: შექმენით „დამბლოკავი“. ის მანამ არ დაგჭირდებათ, სანამ ნამდვილად, ნამდვილად არ დაგჭირდებათ 😬

---

13) დასკვნითი შენიშვნები - მოკლე ვერსია, თუ როგორ შევქმნათ ხელოვნური ინტელექტის აგენტი 🎁🤖

თუ სხვა არაფერი გახსოვთ, ეს დაიმახსოვრეთ:

• ხელოვნური ინტელექტის აგენტის შექმნის პროცესი ძირითადად მოდელის გარშემო უსაფრთხო მარყუჟის შექმნას გულისხმობს. LangChain-ის „აგენტების“ დოკუმენტაცია

• დაიწყეთ მკაფიო მიზნით, დაბალი ავტონომიით და მკაცრი ინსტრუმენტებით. OpenAI სტრუქტურირებული გამომავალი

• მეხსიერების დამატება აღდგენის გზით და არა კონტექსტის დაუსრულებელი შევსებით. RAG ქაღალდი

• დაგეგმვა შეიძლება მარტივი იყოს - საკონტროლო სიები და ხელახალი დაგეგმვა ბევრ რამეს გააკეთებს.

• ჟურნალირება და ტესტები აგენტის ქაოსს ისეთ რამედ აქცევს, რისი გადატანაც შესაძლებელია. OpenTelemetry-ის დაკვირვებადობის სახელმძღვანელო

• დამცავი ბარიერები კოდშია და არა მხოლოდ მოთხოვნებში. OWASP-ის 10 საუკეთესო LLM აპლიკაციები

აგენტი არ არის მაგია. ეს არის სისტემა, რომელიც საკმარისად ხშირად იღებს კარგ გადაწყვეტილებებს, რომ ღირებული იყოს... და აღიარებს დამარცხებას, სანამ ის ზიანს მიაყენებს. გარკვეულწილად, ჩუმად დამამშვიდებელია 😌

და კი, თუ სწორად ააწყობთ, ეს პატარა ციფრული სტაჟიორის დაქირავებას ჰგავს, რომელიც არასდროს სძინავს, ხანდახან პანიკაშია და უყვარს საბუთების კეთება. ანუ, ფაქტობრივად, სტაჟიორი.

---

ხშირად დასმული კითხვები

რას წარმოადგენს ხელოვნური ინტელექტის აგენტი, მარტივად რომ ვთქვათ?

ხელოვნური ინტელექტის აგენტი არსებითად არის ციკლი, რომელიც მეორდება: იღებს შეყვანის მონაცემებს, იღებს გადაწყვეტილებას შემდეგ ნაბიჯზე, იყენებს ინსტრუმენტს, კითხულობს შედეგს და იმეორებს დასრულებამდე. „აგენტის“ ნაწილი მოქმედებასა და დაკვირვებაში მოდის და არა მხოლოდ ჩეთზე. ბევრი აგენტი უბრალოდ ჭკვიანი ავტომატიზაციაა ინსტრუმენტებზე წვდომით, ზოგი კი უფრო ახალგაზრდა ოპერატორის მსგავსად იქცევა, რომელსაც შეუძლია შეცდომებისგან გამოსწორება.

როდის უნდა შევქმნა ხელოვნური ინტელექტის აგენტი მხოლოდ მოთხოვნის გამოყენების ნაცვლად?

აგენტის შექმნა აუცილებელია მაშინ, როდესაც სამუშაო მრავალსაფეხურიანია, იცვლება შუალედური შედეგების მიხედვით და საჭიროებს საიმედო ინსტრუმენტების გამოყენებას (API, მონაცემთა ბაზები, ბილეთების გაგზავნა, კოდის შესრულება). აგენტები ასევე სასარგებლოა, როდესაც გსურთ განმეორებადი შედეგები დამცავი ბარიერებით და „დასრულების“ შემოწმების გზით. თუ მარტივი სწრაფი რეაგირება მუშაობს, აგენტი, როგორც წესი, არასაჭირო ხარჯებს და დამატებით ჩავარდნის რეჟიმებს წარმოადგენს.

როგორ შევქმნა ხელოვნური ინტელექტის აგენტი, რომელიც ციკლებში არ იჭედება?

გამოიყენეთ მკაცრი გაჩერების პირობები: მაქსიმალური ნაბიჯები, ხელსაწყოს მაქსიმალური გამოძახებები და მკაფიო დასრულების შემოწმებები. დაამატეთ სტრუქტურირებული ხელსაწყოს სქემები, ტაიმ-აუტები და ხელახალი მცდელობები, რომლებიც სამუდამოდ არ გაიმეორებს მცდელობას. აღრიცხეთ გადაწყვეტილებები და ხელსაწყოს შედეგები, რათა ნახოთ, სად გადადის ის ხრიკებიდან. საერთო უსაფრთხოების სარქველია ესკალაცია: თუ აგენტი არ არის დარწმუნებული ან იმეორებს შეცდომებს, მან უნდა მოითხოვოს დახმარება იმპროვიზაციის ნაცვლად.

რა არის მინიმალური არქიტექტურა ხელოვნური ინტელექტის აგენტის შესაქმნელად?

სულ მცირე, დაგჭირდებათ კონტროლერის ციკლი, რომელიც მოდელს მიაწვდის მიზანს და კონტექსტს, მოითხოვს შემდეგ მოქმედებას, მოთხოვნის შემთხვევაში შეასრულებს ინსტრუმენტს, დაამატებს დაკვირვებას და გაიმეორებს. ასევე დაგჭირდებათ ინსტრუმენტები მკაცრი შეყვანის/გამოყვანის ფორმებით და „დასრულების“ შემოწმებით. თვითმომსახურების ციკლიც კი შეიძლება კარგად იმუშაოს, თუ შეინარჩუნებთ სუფთა მდგომარეობას და დაიცავთ ნაბიჯების ლიმიტს.

როგორ უნდა შევქმნა ხელსაწყოების გამოძახების სისტემა ისე, რომ ის საიმედო იყოს წარმოებაში?

ინსტრუმენტები უნდა იყოს ვიწრო, აკრეფილი, ნებართვებით აღჭურვილი და დამოწმებული — მოერიდეთ ზოგად „ნებისმიერი მოქმედების“ ინსტრუმენტს. უპირატესობა მიანიჭეთ მკაცრ სქემებს (მაგალითად, სტრუქტურირებული გამომავალი მონაცემები/ფუნქციის გამოძახება), რათა აგენტმა ხელით ვერ შეძლოს შეყვანის მონაცემების გამოყენება. ხელსაწყოს დონეზე დაამატეთ დაშვებულთა სიები, სიჩქარის ლიმიტები და მომხმარებლის/ორგანიზაციის ნებართვების შემოწმება. იდემპოტენტობის ნიმუშების გამოყენებით, შექმენით ინსტრუმენტები ისე, რომ მათი ხელახლა გაშვება უსაფრთხო იყოს, როდესაც ეს შესაძლებელია.

რა არის მეხსიერების დამატების საუკეთესო გზა აგენტის გაუარესების გარეშე?

მეხსიერება ორ ნაწილად განიხილეთ: მოკლევადიანი გაშვების მდგომარეობა (ბოლო ნაბიჯები, მიმდინარე გეგმა, შეზღუდვები) და გრძელვადიანი აღდგენა (პარამეტრები, სტაბილური წესები, შესაბამისი დოკუმენტები). შეინარჩუნეთ მოკლევადიანი კომპაქტურობა გაშვების შეჯამებებით და არა სრული ტრანსკრიპტებით. გრძელვადიანი მეხსიერებისთვის, აღდგენა (ჩასაშენებლები + ვექტორული შენახვა/RAG შაბლონები) ჩვეულებრივ ჯობია ყველაფრის კონტექსტში „ჩატენვას“ და მოდელის აღრევას.

რომელი დაგეგმვის სქემა უნდა გამოვიყენო: საკონტროლო სია, ReAct თუ ხელმძღვანელი-მუშაკი?

საკონტროლო სიის დამგეგმავი შესანიშნავია, როდესაც დავალებები პროგნოზირებადია და გსურთ რაიმე მარტივი შესამოწმებელი. ReAct სტილის ციკლები ბრწყინვალეა, როდესაც ხელსაწყოს შედეგები ცვლის თქვენს შემდეგ მოქმედებებს. ხელმძღვანელისა და მუშაკის შაბლონები (მაგალითად, AutoGen სტილის როლების გამიჯვნა) სასარგებლოა, როდესაც დავალებების პარალელიზაცია ან განსხვავებული როლებით სარგებლობა შესაძლებელია (მკვლევარი, პროგრამისტი, ხარისხის უზრუნველყოფის სპეციალისტი). დაგეგმვა-შემდეგ შესრულების მეთოდი ხელახალი დაგეგმვით პრაქტიკული შუალედური ვარიანტია ჯიუტი, ცუდი გეგმების თავიდან ასაცილებლად.

როგორ გავხადო აგენტი უსაფრთხო, თუ მას რეალური ქმედებების განხორციელება შეუძლია?

გამოიყენეთ ყველაზე დაბალი პრივილეგიის მქონე ნებართვები და შეზღუდეთ სარისკო ინსტრუმენტები დამტკიცების ან „მშრალი გაშვების“ რეჟიმების მიღმა. დაამატეთ ბიუჯეტები და ლიმიტები: მაქსიმალური ნაბიჯები, მაქსიმალური ხარჯი და წუთში ხელსაწყოს გამოძახების ლიმიტები. შესვლამდე შეასწორეთ მგრძნობიარე მონაცემები და გამოაცალკევეთ დეველოპერის და წარმოების გარემოები. მოითხოვეთ გაურკვევლობის ფლაგები ან განმარტებითი კითხვები, როდესაც შეყვანილი მონაცემები ბუნდოვანია, იმის ნაცვლად, რომ ნდობამ ჩაანაცვლოს მტკიცებულებები.

როგორ შევამოწმო და შევაფასო ხელოვნური ინტელექტის აგენტი, რათა დროთა განმავლობაში გაუმჯობესდეს?

შექმენით სცენარების ნაკრები წარმატებული ბილიკებით, უკიდურესი შემთხვევებით, ხელსაწყოების წარუმატებლობით, ორაზროვანი მოთხოვნებით და მოთხოვნის ინექციის მცდელობებით (OWASP-ის სტილით). შეაფასეთ შედეგები, როგორიცაა დავალების წარმატება, დასრულების დრო, ხელსაწყოების შეცდომებიდან აღდგენა და მტკიცებულებების გარეშე პრეტენზიები. ყოველთვის, როდესაც შეცვლით ხელსაწყოების სქემებს, მოთხოვნებს, აღდგენას ან მეხსიერების ფორმატირებას, ხელახლა გაუშვით ნაკრები. თუ მისი ტესტირება არ შეგიძლიათ, მისი საიმედოდ გამოყენებაც შეუძლებელია.

როგორ გავააქტიურო აგენტი შეყოვნებისა და ხარჯების გაზრდის გარეშე?

გავრცელებული ნიმუშია უპატრონო კონტროლერი გარე მდგომარეობის საცავით (DB/Redis), მის უკან არსებული ინსტრუმენტების სერვისებით და ძლიერი ჟურნალირებით/მონიტორინგით (ხშირად OpenTelemetry). აკონტროლეთ ხარჯები მონაცემების აღდგენის ქეშირებით, კომპაქტური მდგომარეობის შეჯამებებით, მარშრუტიზაციის/ამოღების უფრო მცირე მოდელებით და „ღრმა აზროვნების“ ყველაზე რთულ ეტაპებამდე შეზღუდვით. გამოიყენეთ რიგები გრძელი ამოცანებისთვის, რათა ვებ მოთხოვნები ღიად არ შეინახოთ. ყოველთვის ჩართეთ „დახურვის“ ღილაკი.

ცნობები

1. სტანდარტებისა და ტექნოლოგიების ეროვნული ინსტიტუტი (NIST) - NIST AI RMF 1.0 (სანდოობა და გამჭვირვალობა) - nvlpubs.nist.gov

2. OpenAI - სტრუქტურირებული შედეგები - platform.openai.com

3. OpenAI - ფუნქციის გამოძახების სახელმძღვანელო - platform.openai.com

4. OpenAI - ტარიფების ლიმიტების სახელმძღვანელო - platform.openai.com

5. OpenAI - მუშაობს API - platform.openai.com

6. OpenAI - ასისტენტების ფუნქციის გამოძახება - platform.openai.com

7. LangChain - აგენტების დოკუმენტაცია (JavaScript) - docs.langchain.com

8. LangChain - ინსტრუმენტების დოკუმენტაცია (Python) - docs.langchain.com

9. LangChain - მეხსიერების მიმოხილვა - docs.langchain.com

10. arXiv - ReAct ნაშრომი (მიზეზი + მოქმედება) - arxiv.org

11. arXiv - RAG ნაშრომი - arxiv.org

12. Amazon Web Services (AWS) Builders' Library - ტაიმ-აუტები, ხელახალი მცდელობები და შეფერხებები რხევის დროს - aws.amazon.com

13. OpenTelemetry - დაკვირვებადობის სახელმძღვანელო - opentelemetry.io

14. Stripe - იდემპოტენტი მოთხოვნები - docs.stripe.com

15. Google Cloud - ხელახალი ცდის სტრატეგია (უკან დახევა + რხევა) - docs.cloud.google.com

16. OWASP - დიდი ენობრივი მოდელის აპლიკაციების ტოპ 10 - owasp.org

17. OWASP - LLM01 სწრაფი ინექცია - genai.owasp.org

18. LlamaIndex - შესავალი RAG-ში - developers.llamaindex.ai

19. Microsoft - სემანტიკური ბირთვი - learn.microsoft.com

20. Microsoft AutoGen - მრავალაგენტიანი ჩარჩო (დოკუმენტაცია) - microsoft.github.io

21. CrewAI - აგენტების კონცეფციები - docs.crewai.com

22. ჰეისტაკი (ღრმა ცხენები) - რეტრივერის დოკუმენტაცია - docs.haystack.deepset.ai

იპოვეთ უახლესი ხელოვნური ინტელექტი ოფიციალურ ხელოვნური ინტელექტის ასისტენტების მაღაზიაში

ჩვენს შესახებ