34-წუთიანი სამუშაო სესია AI აგენტებზე — რა არის სინამდვილეში აგენტი, როგორ მუშაობს ინსტრუმენტების გამოძახება, მსჯელობა → მოქმედება → დაკვირვება ციკლი, დაგეგმვა და მეხსიერება, როდის სჯობს აგენტი უბრალო პრომპტს და ფრეიმვორკები, რომლებიც ამ ყველაფერს ერთად კრავს.
უბრალო პრომპტი ერთი მიმოცვლაა: თქვენ ეკითხებით, მოდელი პასუხობს და საქმე მორჩა. აგენტი იმავე მოდელს ციკლში ახვევს და ინსტრუმენტებს აძლევს — ასე მას შეუძლია მოძებნოს, წაიკითხოს ფაილი, გამოიძახოს API, შეამოწმოს შედეგი და თავად გადაწყვიტოს, რა გააკეთოს შემდეგ, სანამ ამოცანა ნამდვილად არ დასრულდება.
კარგია, როცა მოდელმა უკვე საკმარისი იცის, რომ ერთ ჯერზე უპასუხოს.
კარგია, როცა ამოცანას სჭირდება ინსტრუმენტები, ახალი მონაცემები ან რამდენიმე ნაბიჯი.
თითქოს განსხვავება იმას შორის, კოლეგას სწრაფ კითხვას უსვამთ და ერთ პასუხს იღებთ, თუ ამოცანას გადასცემთ და ანებებთ, გახსნას ფაილები, გაუშვას ძებნები და შეამოწმოს შედეგები, სანამ საქმე არ დასრულდება.
აგენტები ახალი ტიპის მოდელი არ არის — Claude, GPT, Gemini და ღია წონების მოდელები, როგორიცაა Llama, ყველა "ტვინის" როლში გამოდის. აგენტი კი ის შაბლონია, რომელსაც მათ გარშემო აშენებთ.
ეს არის ის ერთადერთი მექანიკა, რომელიც აგენტებს შესაძლებელს ხდის. თქვენ აღწერთ მოდელისთვის ინსტრუმენტების ნაკრებს. როცა მას რომელიმე სჭირდება, ის არაფერს უშვებს — ითხოვს მას სახელით და არგუმენტებით, და ჩერდება. თქვენი კოდი უშვებს ნამდვილ ფუნქციას და შედეგს უკან აბრუნებს. შემდეგ მოდელი განაგრძობს.
get_weather({ city: "Berlin" }) — მაგრამ კოდის შესრულება არ შეუძლია. ფუნქციას თქვენი პროგრამა უშვებს და შედეგს შემდეგ შეტყობინებად აბრუნებს.const getWeather = tool({ description: "Look up the current weather for a city", parameters: { city: z.string() }, // the arg schema execute: async ({ city }) => { return await weatherApi(city) // YOUR code runs here }, }) // the model only ever asks for getWeather — it never runs it
მოდელი ითხოვს getWeather-ს; თქვენი კოდი ასრულებს მას და შედეგს შეტყობინებად აბრუნებს უკან.
მოდელი თითოეული ინსტრუმენტის აღწერას დოკუმენტაციასავით კითხულობს. მკაფიო სახელები და ერთხაზიანი "გამოიყენე მაშინ, როცა…" ტიპის აღწერები წყვეტს, სწორ ინსტრუმენტს აირჩევს თუ შემთხვევით მოსინჯავს.
არგუმენტები სტრუქტურირებული JSON-ის სახით ბრუნდება და თქვენს სქემას უსწორდება. ცუდი შემავალი მონაცემები ადრევე უარყავით — მოდელს არგუმენტის ჰალუცინაცია ისევე ადვილად შეუძლია, როგორც მნიშვნელობის.
ინსტრუმენტის შედეგი საუბარს ახალ შეტყობინებად ემატება. ახლა მოდელი მას "ხედავს" და მსჯელობს, რა ქნას შემდეგ — უპასუხოს თუ სხვა ინსტრუმენტი გამოიძახოს.
თითქოს შეფი, რომელიც შეკვეთას სამზარეულოში გადასძახებს. შეფი წყვეტს, რა არის საჭირო, და ასახელებს მას; სამუშაოს კი მზარეულები აკეთებენ და თეფშს უკან აწვდიან. შეფი ღუმელს არ ეკარება.
როგორც კი მოდელს ინსტრუმენტების გამოძახება შეუძლია, აგენტი მის გარშემო შემოვლებული პატარა ციკლია. მოდელი მსჯელობს მიზანზე, მოქმედებს ინსტრუმენტის გამოძახებით, აკვირდება შედეგს და თავიდან იწყებს — ყოველ ახალ დაკვირვებას საუბარს ამატებს — სანამ არ გადაწყვეტს, რომ მორჩა.
let messages = [{ role: "user", content: goal }] for (let step = 0; step < 10; step++) { // always cap the steps const reply = await model({ messages, tools }) if (!reply.toolCall) return reply.text // no tool → done const result = await run(reply.toolCall) // act messages.push(reply, toolResult(result)) // observe }
ყოველი წრე ერთ დაკვირვებას ამატებს; ციკლი მაშინვე წყდება, როცა მოდელი პასუხობს და ინსტრუმენტს აღარ ითხოვს.
finish() ინსტრუმენტი, რომელიც წარმატების გამოსაცხადებლად უნდა გამოიძახოს, რომ "მორჩა" ცხადი იყოს.ყოველ ჯერზე მოდელი ხედავს უახლეს შედეგს, ამიტომ შეუძლია წარუმატებელი გამოძახების შემდეგ გამოსწორდეს, ძებნა დახვეწოს ან გეგმა შეცვალოს — რასაც ერთი პრომპტი ვერასოდეს გააკეთებს. სწორედ ეს უკუკავშირია მთელი აზრი.
თითქოს ხელოსანი: შეხედე, სცადე რაღაც, შეამოწმე გამოვიდა თუ არა, სცადე შემდეგი — და არა ერთი ვარაუდი დახურული კაპოტით.
ორნაბიჯიანი ამოცანა შიშველ ციკლზეც გადის. ათნაბიჯიანი კი აბნევს გზას, თუ აგენტი არ გეგმავს — არ ყოფს მიზანს დალაგებულ ნაბიჯებად — და თუ არ აქვს მეხსიერება, რომ სასარგებლო ფაქტები წინ გაიყოლოს და ყოველ ჯერზე თავიდან არ გამოიყვანოს.
დაგეგმვა ბუნდოვან მიზანს აქცევს ნაბიჯებად, რომელთა შესრულებაც ციკლს შეუძლია, თქვენ კი — შემოწმება.
მიმდინარე საუბარი — ყველა შეტყობინება, ინსტრუმენტის გამოძახება და შედეგი. ეს არის აგენტის სამუშაო მეხსიერება, ოღონდ სასრული: ბევრი ნაბიჯი და ადრეული დეტალები ან ამოვარდება, ან შეჯამებაში იკარგება.
ფაქტები, წარსული გადაწყვეტილებები ან დოკუმენტები, შენახული ბაზაში, რომელშიც აგენტს ძებნა შეუძლია — ხშირად ვექტორულ ბაზაში. ის მხოლოდ საჭირო ნაწილებს იღებს მაშინ, როცა სჭირდება, იმის ნაცვლად, რომ ყველაფერი ფანჯარაში ეჭიროს.
აგენტი დეტერმინიზმს ავტონომიაზე ცვლის. სწორედ ეს ავტონომია ხდის მას სასარგებლოს ღია დასასრულის მქონე სამუშაოზე — და სწორედ ის ხდის მას არაპროგნოზირებადს, ნელს და ძვირს, როცა ამოცანას ეს არ სჭირდებოდა. ოსტატობა ისაა, იცოდე, რომელ საქმეს ეკუთვნის ციკლი.
ჭერის გარეშე გაჭედილი აგენტი უსასრულოდ ტრიალებს და ტოკენებს წვავს. ნაბიჯების ლიმიტი ზიანს საზღვრავს.
ციკლის ხელით დაწერა შეგიძლიათ — და მარტივი აგენტისთვის ხშირად სწორედ ასე უნდა მოიქცეთ. მაგრამ ფრეიმვორკები წვრილმან საქმეს იბარებენ: ინსტრუმენტების მიერთებას, მდგომარეობას, მეხსიერებას, ხელახალ მცდელობებს, სტრიმინგსა და ტრეისინგს. ოთხი ლიდერობს; რომელი აირჩიოთ, დამოკიდებულია თქვენს სტეკზე და იმაზე, რამდენი კონტროლი გინდათ.
LangChain არის ჯაჭვების, ინსტრუმენტებისა და ინტეგრაციების ფართო ნაკრები (Python და JS). LangGraph კი მისი გრაფზე დაფუძნებული ძრავაა მდგომარეობის მქონე აგენტებისთვის — ცხადი კვანძები, განშტოებები, ციკლები და ადამიანის საკონტროლო წერტილები.
მიწვდით მაშინ, როცა გჭირდებათ რთული, ხანგრძლივად მომუშავე, მდგომარეობის მქონე აგენტები და გინდათ ნაბიჯების გრაფზე ცხადი კონტროლი.
TypeScript SDK LLM-ების პროდუქტებში ჩასაშენებლად: generateText / streamText ინსტრუმენტების გამოძახებითა და ჩაშენებული აგენტის ციკლით, ერთი API ყველა პროვაიდერზე და პირველხარისხოვანი სტრიმინგისა და MCP-ის მხარდაჭერა.
მიწვდით მაშინ, როცა აგენტის ან ჩატის ფუნქციონალს TypeScript / Next.js პროდუქტის ინტერფეისში აწვდით.
Python-ის ფრეიმვორკი რამდენიმე აგენტის ორკესტრირებისთვის, თითოეულს როლი და ამოცანა აქვს — "მკვლევარი", "ავტორი", "რეცენზენტი" — და ერთ მიზანზე მუშაობენ ერთად.
მიწვდით მაშინ, როცა ამოცანა ბუნებრივად ეწერება რამდენიმე სპეციალიზებულ როლში, რომლებიც ერთად მუშაობენ.
Microsoft-ის Python ფრეიმვორკი მრავალაგენტიანი სისტემებისთვის, აგებული აგენტებზე, რომლებიც ერთმანეთს (და ინსტრუმენტებს) ესაუბრებიან ამოცანის გადასაჭრელად, ძლიერი, კვლევის დონის საუბრის შაბლონებით.
მიწვდით მაშინ, როცა მრავალაგენტიანი საუბრის შაბლონებს იკვლევთ ან კვლევითი ტიპის პროტოტიპებს აკეთებთ.
შევკრათ ყველაფერი ერთად: პატარა მხარდაჭერის ტრიაჟის აგენტი. შემოდის მიზანი; მოდელი მსჯელობს, იძახებს ინსტრუმენტებს, აკვირდება შედეგებს და ტრიალებს, სანამ პასუხს ვერ გასცემს — მთელი გზა ჭერით შემოსაზღვრული და ლოგში ჩაწერილი.
ერთი წრე მსჯელობა → მოქმედება → დაკვირვება და შემდეგ საბოლოო პასუხი — მთელი შაბლონი მინიატურაში.
ხუთი სწრაფი კითხვა აგენტებზე, ინსტრუმენტების გამოძახებაზე, ციკლზე, მეხსიერებასა და ინსტრუმენტებზე — მყისიერი უკუკავშირი, ავტორიზაციის გარეშე.
ნავიგაცია ← → ღილაკებით ან სქროლით · ბიბლიოთეკაში დაბრუნება