ბიბლიოთეკა
00/07 · ~34 წთ
GUIDEDECK · AI ინფრასტრუქტურის ქირაობა გაშვების ნაცვლად

მართული AI
პლატფორმები — იყიდეთ
მოსაწყენი ნაწილები.

34-წუთიანი სამუშაო სესია სერვისებზე, რომლებიც მოდელებს უმასპინძლებენ, და მათ გარშემო არსებულ ინფრასტრუქტურაზე — AWS Bedrock, Google Vertex AI, Azure AI Foundry, მოდელების გეითვეები, აგენტების რანტაიმები — და გულახდილი არჩევანი ჰოსტირებულ API-სა და მოდელს შორის, რომელსაც თავად უშვებთ.

~34 წთდამწყები → საშუალოღრუბელი და AI
გადაახვიეთ
01 · აშენება თუ ყიდვა 4 წთ

ახლა უკვე იქირავებთ
თითქმის მთელ AI სტეკს.

ხუთი წლის წინ „AI-ის გამოყენება“ ნიშნავდა GPU-ების ყიდვას, CUDA-სთან ჭიდილს და ადამიანების აყვანას, რომ მოდელის სერვერი ღამის 3 საათზეც ცოცხალი ყოფილიყო. დღეს გუნდების უმეტესობა API-ს იძახებს და უშვებს. მართული AI პლატფორმა სწორედ ის სერვისია, რაც ამას შესაძლებელს ხდის — და პირველი ნამდვილი გადაწყვეტილება ისაა, სტეკის რა ნაწილის ფლობა გინდათ სინამდვილეში.

მართული AI პლატფორმა — ღრუბლოვანი სერვისი, რომელიც მოდელებს უმასპინძლებს და მათ გარშემო არსებულ ინფრასტრუქტურასაც (ავთენტიფიკაცია, ავტომასშტაბირება, ლოგირება, უსაფრთხოების ფილტრები, ბილინგი) მარტივ API-ს მიღმა მალავს. თქვენ ქირაობთ შესაძლებლობას — „შეაჯამე ეს“, „დააკლასიფიცირე ის“ — იმის ნაცვლად, რომ მისი მომცემი აპარატურა და პროგრამული უზრუნველყოფა თავად გამართოთ. აპლიკაცია, რომელსაც ზემოდან დაადგამთ, აღწერილია დეკში აპლიკაციების შექმნა LLM-ებით; ქვემოთ არსებული ღრუბლები კი — ღრუბლის საფუძვლებში.

რას გხსნით „მართული“ მხრებიდან

  • GPU-ები & სიმძლავრე — არაა ფლოტი, რომელიც უნდა იყიდოთ, დაატალღოთ ან ხტუნვადი ტრაფიკისთვის დაამასშტაბიროთ.
  • სერვინგი & ხელმისაწვდომობა — დატვირთვის ბალანსირება, პარტიებად დამუშავება და გადართვა ვენდორის თავის ტკივილია.
  • წვდომა მოდელებზე — წამყვანი მოდელები, რომელთა წვრთნასაც ვერასდროს შეძლებდით, ერთი API-გამოძახების მოშორებით.
  • დანარჩენი — უსაფრთხოების ფილტრები, შეფასებები, RAG-კონექტორები, გამოყენების აღრიცხვა, SOC-2 ქაღალდები.
თქვენი აპი + პრომპტები
თქვენი აპი + პრომპტები
სერვინგი / API
პლატფორმა
(ყველაფერი ქვემოთ)
მასშტაბირება + პარტია
მოდელის წონები
GPU ფლოტი
დრაივერები + ops
თვითმართული
მართული

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

როდის იმარჯვებს უფრო მარტივი ვარიანტი — და ის ხშირად იმარჯვებს

  • პროდუქტების უმეტესობამ უბრალოდ ჰოსტირებული API უნდა გამოიძახოს. თუ GPU-ზე არ ხართ მიბმული და მონაცემებს არ ამუშავებთ, რომელთა გატანაც კანონით არ შეგიძლიათ, ყიდვა უფრო სწრაფია, დასაწყისში უფრო იაფი და პეიჯერს სხვა ატარებს.
  • თვითჰოსტინგზე გადადით, როცა არითმეტიკა ან წესები ამას მოითხოვს — ძალიან დიდი, სტაბილური მოცულობა, სადაც ტოკენზე ღირებულება დომინირებს, მკაცრი მოთხოვნები მონაცემების ადგილმდებარეობაზე, ქსელისგან იზოლირებული გარემო ან მოდელის ღრმა მორგება.
  • დეკის დანარჩენი ნაწილი არის რუკა შუალედური ტერიტორიისა „ერთ API-გამოძახებასა“ და „საკუთარი GPU-ების გაშვებას“ შორის.
02 · საბაზისო მოდელების პლატფორმები 6 წთ

დიდი სამეული:
Bedrock · Vertex AI · Foundry.

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

საბაზისო მოდელების პლატფორმა — მართული სერვისი, რომელიც ბევრ წინასწარ დაწვრთნილ მოდელს ერთი უნიფიცირებული API-ით აჩენს, პლუს საერთო ფუნქციონალი: მოძიება (RAG), უსაფრთხოების ბარიერები, შეფასება და გამოძახებაზე აღრიცხვა. თქვენ სერვერს არ ირჩევთ; ირჩევთ modelId-ს და ტექსტს აგზავნით. პლატფორმა მარშრუტიზაციას, მასშტაბირებასა და ანგარიშს იღებს თავზე.

პლატფორმა კომუტატორია: თქვენი აპი ერთ API-ზე ლაპარაკობს; modelId-ს მიღმა მდგარი მოდელი კი გადაწერის გარეშე იცვლება.

წაიკითხეთ სქემა

  • ერთი კონტრაქტი. ერთი და იგივე ფორმის მოთხოვნა, რომელი მოდელიც არ უნდა პასუხობდეს — ეს ზუსტად აბსტრაქციის იდეაა დეკიდან OOP & დიზაინი, ვენდორებზე გადატანილი.
  • საერთო სერვისები — RAG, დამცავი ბარიერები, შეფასებები და აუდიტის ლოგები პლატფორმის შრეზე ზის და არა თქვენს კოდში.
  • მიბმა დანარჩენში ცხოვრობს. modelId-ის შეცვლა მარტივია; ცოდნის ბაზის ან დამცავი ბარიერის ამოხსნა კი ის ღირებულებაა, რაც გაკავებთ.
import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime"
const client = new BedrockRuntimeClient({})

const out = await client.send(new ConverseCommand({
  modelId: MODEL,         // swap providers — same call
  messages: [{ role: "user",
               content: [{ text: "Summarize Q3" }] }],
}))
console.log(out.output?.message?.content?.[0]?.text)

Bedrock-ის Converse API მოთხოვნას ანორმალიზებს — შეცვალეთ MODEL და კოდის დანარჩენი ნაწილი ხელუხლებელი რჩება.

ინსტრუმენტების ლანდშაფტი

AWS Bedrock — მოდელების მარკეტპლეისი AWS-ის მომხმარებლებისთვის

სერვერლეს წვდომა Anthropic-ის (Claude), Meta-ს, Mistral-ის, Cohere-ის, AI21-ის, Stability-ის და Amazon-ის საკუთარი Nova-სა და Titan-ის მოდელებზე — პლუს Knowledge Bases (RAG), Guardrails, მოდელის შეფასება და Bedrock Agents, ყველაფერი IAM-ის მიღმა.

ClaudeLlamaMistralNova / TitanGuardrails
  • დადებითი — ყველაზე ფართო მესამე მხარის კატალოგი (Claude-ის ჩათვლით) მშობლიური AWS IAM-ით, VPC-ითა და ბილინგით; არაფერი გადის თქვენი AWS-ანგარიშის საზღვრებს გარეთ.
  • უარყოფითი — მოდელების ხელმისაწვდომობა რეგიონების მიხედვით განსხვავდება და API უფრო სიტყვამრავალია, ვიდრე ჩვეულებრივი OpenAI-სტილის კლიენტი.
  • აირჩიეთ, როცა — უკვე AWS-ზე მუშაობთ და გინდათ, რომ მართვაც და მონაცემებიც მის შიგნით დარჩეს.

Google Vertex AI — მოდელები პლუს სრული ML-პლატფორმა

Google Cloud-ის ერთიანი AI-ზედაპირი. Model Garden Gemini-ს მესამე მხარის მოდელებთან (Claude, Llama, Mistral) ერთად აჩენს წინ, და იგივე პლატფორმა ასევე აკეთებს საკუთარ წვრთნას, პაიპლაინებსა და Agent Builder-ის სტეკს — უფრო მეტ სიგანეს, ვიდრე სუფთა მოდელის გეითვეი.

GeminiClaudeLlamaModel Garden+ წვრთნა
  • დადებითი — Gemini-ის გრძელი კონტექსტი და მულტიმოდალურობა პირველი კლასის მოქალაქეებია, მოდელების სერვინგი კი ნამდვილი ML-ინსტრუმენტების გვერდით ზის (იხილეთ ნაწილი 3).
  • უარყოფითი — ზედაპირი დიდია და კონსოლი შეიძლება გაბნეულად მოგეჩვენოთ; მყარად Google Cloud-ზე ხართ.
  • აირჩიეთ, როცა — Gemini გინდათ, ან მოდელებს ერთსა და იმავე ადგილას გამოიძახებთ და დაწვრთნით კიდეც.

Azure AI Foundry — OpenAI-ის სახლი Azure-ზე

Microsoft-ის პლატფორმა (ადრე Azure AI Studio) კორპორაციულ წვდომას აძლევს OpenAI-ის GPT-მოდელებზე Azure OpenAI-ის გავლით, პლუს მოდელების კატალოგს (Llama, Mistral და სხვები), აგენტების სერვისს, prompt flow-ს, შეფასებებსა და Content Safety-ს — ყველაფერი Azure-ის იდენტობისა და შესაბამისობის ქვეშ.

GPTLlamaMistralContent SafetyAgent Service
  • დადებითი — კორპორაციული გზა GPT-მოდელებამდე Azure-ის შესაბამისობის ისტორიითა და მჭიდრო ინტეგრაციით Microsoft 365-სა და Entra-სთან.
  • უარყოფითი — Bedrock-ზე ნაკლები არა-OpenAI წამყვანი ვარიანტი; კვოტებისა და დეპლოიმენტების მართვა ნაბიჯებს ამატებს.
  • აირჩიეთ, როცა — Microsoft-ის მომხმარებელი ხართ ან სპეციალურად GPT გჭირდებათ კორპორაციული კონტროლის ქვეშ.
03 · საკუთარის წვრთნა 5 წთ

როცა მოდელის გამოძახება
საკმარისი აღარაა.

ზოგჯერ მოდელი, რომელიც გჭირდებათ, ჯერ არ არსებობს — თაღლითობის დეტექტორი თქვენს ტრანზაქციებზე, მოთხოვნის პროგნოზირება, კლასიფიკატორი თქვენი დარგის ჟარგონზე. ამისთვის სრული ML-პლატფორმა გინდათ: SageMaker AWS-ზე, Vertex AI Google-ზე. ისინი მთელ სასიცოცხლო ციკლს მართავს და არა მხოლოდ ინფერენსს.

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

პლატფორმა ყველა ეტაპსა და უკუკავშირის ციკლს მართავს — როცა ცოცხალი სიზუსტე იკლებს, მოდელს ხელახლა წვრთნით და ხელახლა უშვებთ.

რას გაძლევთ SageMaker & Vertex AI

  • მართული წვრთნა — აწიეთ GPU-კლასტერი ერთი სამუშაოსთვის, გადაიხადეთ საათებში, ჩამოშალეთ ავტომატურად.
  • რეესტრი & ვერსიონირება — ყოველი მოდელი აღრიცხულია, ამაღლებადი და უკან დასაბრუნებელი.
  • მიწოდების რეჟიმები — რეალურ დროში, სერვერლესი, ასინქრონული და პარტიული ენდპოინტები ერთი და იმავე რეესტრიდან.
  • ფიჩერების საცავები & პაიპლაინები — გამეორებადი შესატანები და გადაწვრთნის ავტომატური გაშვებები.
წვრთნა + სერვინგი თავად
// you own data, training, eval, serving
const est = new XGBoost({ instanceType: "ml.m5", ... })
await est.fit(trainData)       // managed job
const model = await est.register()     // versioned
await model.deploy(endpoint)      // real-time
// worth it for tabular / domain-specific tasks
საბაზისო მოდელის გამოძახება
// no training, no servers — instant
const out = await client.send(new ConverseCommand({
  modelId: MODEL,
  messages: msgs,
}))
// great for language, summary, extraction,
// classification with a good prompt

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

04 · ერთი API, ბევრი პროვაიდერი 4 წთ

გეითვეი ყოველი
მოდელის ვენდორის წინ.

ღრუბლოვანი პლატფორმები ერთ ღრუბელზე გაბამთ. მოდელის გეითვეი უფრო თხელი, პროვაიდერისგან ნეიტრალური შრეა: ერთი ენდპოინტი, რომელიც თანაბრად მიმართავს OpenAI-ზე, Anthropic-ზე, Google-ზე და ღია მოდელებზე — სარეზერვო გადართვით, ხარჯის აღრიცხვითა და ერთი API-გასაღებით ყველასთვის.

მოდელის გეითვეი — პროქსი, რომელიც ერთ თანმიმდევრულ API-ს აჩენს და ყოველ მოთხოვნას იმ პროვაიდერს გადასცემს, რომელსაც დაასახელებთ, და ამას ამატებს პროვაიდერებს შორის მარშრუტიზაციას, ავტომატურ სარეზერვო გადართვას, ქეშირებას და ერთიან ბილინგსა და დაკვირვებადობას. ეს არის ადაპტერის შაბლონი სერვისის სახით — თქვენი კოდი გეითვეის ელაპარაკება; გეითვეი კი ყველას.

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

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

  • მდგრადობა — პროვაიდერის გათიშვა ან 429 სარეზერვოზე გადადის და არ გაგათიშავთ.
  • მოქნილობა — ახალი მოდელის A/B-ტესტი ერთი სტრიქონის შეცვლით; ახალი SDK არ არის საჭირო, ახალი გასაღებიც არა.
  • ერთი ანგარიში, ერთი დაფა — ხარჯი, შეყოვნება და ტოკენების ხარჯვა ყველა პროვაიდერზე ერთ ადგილას.
  • ხაფანგი — ამატებთ ნახტომს (ცოტა შეყოვნებას) და თქვენს ტრაფიკს შუამავალს ანდობთ.
import { generateText } from "ai"

const { text } = await generateText({
  model: "anthropic/claude-...",  // creator/model slug
  prompt,
})
// change "openai/gpt-..." → new provider, same code
// the gateway resolves auth, routing + failover

პროვაიდერებს შორის მხოლოდ creator/model სლაგი იცვლება — დანარჩენს გეითვეი აგვარებს.

Vercel AI Gateway

ჩაშენებული AI SDK-ში

  • დადებითი — პირველი კლასის მოქალაქე Vercel AI SDK-ში; მოდელებს სლაგით ცვლით და ხარჯის ლიმიტებს, ქეშირებასა და დაკვირვებადობას თითქმის შეწებების გარეშე იღებთ.
  • უარყოფითი — საუკეთესოა Vercel / AI SDK-ის ეკოსისტემის შიგნით; ნაკლებად მიმზიდველია, თუ თქვენი სტეკი სხვაგან ცხოვრობს.
  • აირჩიეთ, როცა — AI SDK-ზე აშენებთ და მარშრუტიზაცია და სარეზერვო გადართვა უფასოდ გინდათ.
OpenRouter

ყველაზე ფართო კატალოგი

  • დადებითი — ასობით მოდელი ერთი OpenAI-სთან თავსებადი API-ისა და ერთი ანგარიშის მიღმა, ფასსა და შეყოვნებაზე დაყრდნობილი მარშრუტიზაციითა და მარტივი სარეზერვო გადართვებით.
  • უარყოფითი — მესამე მხარე თქვენი მოთხოვნის გზაზე ზის; შეამოწმეთ მონაცემების დამუშავება და ტოკენებზე დანამატი.
  • აირჩიეთ, როცა — მოდელების მაქსიმალური არჩევანი და პროვაიდერისგან ნეიტრალური მარშრუტიზაცია სწრაფად გინდათ.

გირჩევნიათ გეითვეის თვითჰოსტინგი? LiteLLM პოპულარული ღია კოდის პროქსია, რომელიც პროვაიდერებზე იმავე OpenAI-სთან თავსებად API-ზე ლაპარაკობს — იგივე იდეა, ოღონდ თქვენ უშვებთ.

05 · ჰოსტინგი თუ ლოკალი / ღია 6 წთ

ჰოსტირებული წამყვანი მოდელები თუ
ღია მოდელები, რომლებსაც თავად უშვებთ.

ამ სივრცის ყველაზე მკვეთრი კომპრომისი: გამოიძახოთ საკუთრებაში არსებული მოდელი (Claude, GPT, Gemini) ქსელით, თუ გაუშვათ ღიაწონებიანი მოდელი (Llama, Mistral) აპარატურაზე, რომელსაც აკონტროლებთ. ორივე ლეგიტიმურია. გულახდილი პასუხი დამოკიდებულია ხარჯის ფორმაზე, მონაცემების წესებზე და იმაზე, რამდენ ოპერაციულ ტვირთს აიტანთ.

ღიაწონებიანი მოდელი — მოდელი, რომლის დაწვრთნილი პარამეტრებიც გამოქვეყნებულია, ასე რომ ნებისმიერს შეუძლია ჩამოტვირთოს და საკუთარ აპარატურაზე გაუშვას (Llama, Mistral, Gemma, Qwen). ეს იგივე არაა, რაც „ღია კოდი“ — წესებს მაინც ლიცენზია აწესებს და წვრთნის მონაცემები ჩვეულებრივ არ ქვეყნდება. საპირისპიროა ჰოსტირებული საკუთრებაში არსებული მოდელი, რომლამდეც მხოლოდ ვენდორის API-ით მიდიხართ.
თქვენი საზღვარი
თქვენი საზღვარი
მონაცემი რჩება
აპი
აპი
თქვენი GPU
ფიქსირებული $/სთ
ვენდორის ღრუბელი
$ ტოკენზე
ჰოსტინგი
ლოკალური / ღია
მონაცემი გადის

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

ხუთი გულახდილი კომპრომისი

  • ხარჯის ფორმა — ჰოსტინგი ტოკენზე იხდევინებს (იაფია დასაწყისში, იზრდება გამოყენებასთან ერთად); ლოკალური GPU-ს ფიქსირებული ხარჯია (იაფია მხოლოდ მაღალ, სტაბილურ მოცულობაზე).
  • პრივატულობა / ადგილმდებარეობა — ლოკალური ყოველ ბაიტს თქვენი ქსელის შიგნით ტოვებს; გადამწყვეტია რეგულირებული ან ქსელისგან იზოლირებული მონაცემებისთვის.
  • კონტროლი — ლოკალურზე ვერსიებს აფიქსირებთ და თავისუფლად აკეთებთ ფაინთიუნინგს; ჰოსტირებული მოდელები კი შეიძლება თქვენს ქვეშ შეიცვალოს ან მოიხსნას.
  • ხარისხი — წამყვანი ჰოსტირებული მოდელები ჯერ კიდევ ლიდერობენ ყველაზე რთულ ამოცანებში, თუმცა ღიების ჩამორჩენა თანდათან იკლებს.
  • ოპერაციული ტვირთი — ჰოსტინგზე თითქმის ნულია; ლოკალურზე GPU-ები, სერვინგი, მასშტაბირება და განახლებები უკვე თქვენი საქმეა.
vLLM — ლოკალური, ნამდვილი ტრაფიკი
# high-throughput serving on real GPUs vllm serve mistralai/Mistral-... # or a Llama ckpt # PagedAttention + continuous batching # OpenAI-compatible server at :8000/v1 # fast at scale — but you size + run the cluster
Ollama — ლოკალური, მარტივად
# one binary, great for a laptop or a dev box ollama pull mistral # weights download once ollama run mistral # chat in the terminal # OpenAI-compatible API at :11434/v1 # simple — but single-box, modest throughput
Ollama

მოდელი წუთებში

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

ღია მოდელების მიწოდება მასშტაბში

  • დადებითი — მაღალი გამტარუნარიანობა და დაბალი შეყოვნება PagedAttention-ისა და უწყვეტი პარტიების წყალობით; თვითჰოსტინგის მუშა ცხენი.
  • უარყოფითი — GPU-ების ზომა, ავტომასშტაბირება და ხელმისაწვდომობა თქვენზეა — ნამდვილი MLOps-სამუშაო.
  • აირჩიეთ, როცა — სტაბილური მოცულობა გაქვთ და გაქვთ მიზეზი (ხარჯი ან მონაცემები), რომ ინფერენსი შიგნით დაიტოვოთ.

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

06 · აგენტის პლატფორმები 5 წთ

ერთი გამოძახებიდან
ციკლამდე, რომელიც ინსტრუმენტებს იყენებს.

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

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

ციკლი რანტაიმს ეკუთვნის — ის იძახებს ინსტრუმენტებს, მეხსიერებას ატარებს და მოდელს ხელახლა ეკითხება, სანამ მიზანი არ მიიღწევა.

რისგან გიხსნით რანტაიმი

  • ციკლი — ინსტრუმენტების გამოძახებების პარსინგი, მათი შესრულება, შედეგების უკან მიწოდება, გაჩერების მომენტის გადაწყვეტა.
  • მდგომარეობა — მრავალნაბიჯიანი სესიები და მეხსიერება, რომელიც ნაბიჯებსა და მოთხოვნებს გადაურჩება.
  • უსაფრთხო შესრულება — იზოლირებული ინსტრუმენტები, ტაიმაუტები და დამცავი ბარიერები იმაზე, რისი გაკეთებაც აგენტს შეუძლია.
  • დეპლოი & მასშტაბირება — მართული ადგილი აგენტის სამასპინძლოდ, ტრეისინგით იმ შემთხვევისთვის, როცა საქმე გვერდზე გადაუხვევს.
G
Google · Vertex AI Agent Builder
აგენტების აგება, დეპლოი და ჰოსტინგი Google Cloud-ზე.
+

Vertex AI Agent Builder Google-ის მართული აგენტური სტეკია. აგებთ ღია კოდის Agent Development Kit-ით (ADK), შემდეგ კი დეპლოით მართულ რანტაიმზე (Agent Engine), რომელიც სესიებს, მასშტაბირებასა და ტრეისინგს უვლის — აგენტები, რომლებიც Gemini-სა და თქვენს ინსტრუმენტებს ეყრდნობა.

  • ADK — ღია კოდის ფრეიმვორკი აგენტების, ინსტრუმენტებისა და მრავალაგენტიანი ვორქფლოუების კოდში აღსაწერად.
  • Agent Engine — მართული რანტაიმი, რომელიც ამ აგენტებს ამასპინძლებს და თქვენ ნაცვლად მასშტაბირებს.
A
A2A · Agent2Agent პროტოკოლი
ღია სტანდარტი აგენტებისთვის, რომ ერთმანეთს ელაპარაკონ.
+

A2A (Agent2Agent) ღია პროტოკოლია — ახლა უკვე Linux Foundation-ის ქვეშ — რომლითაც სხვადასხვა გუნდის ან ვენდორის მიერ აგებული აგენტები ერთმანეთს აღმოაჩენენ და თანამშრომლობენ. ეს თავსებადობის შრეა: სადაც MCP ასტანდარტებს, როგორ მიდის აგენტი ინსტრუმენტებამდე, A2A ასტანდარტებს, როგორ მიდის აგენტი სხვა აგენტებამდე.

B
AWS · Bedrock Agents
Bedrock-ის მოდელების ორკესტრირება თქვენი ინსტრუმენტებითა და მონაცემებით.
+

Bedrock Agents საბაზისო მოდელს აერთებს ქმედებების ჯგუფებთან (თქვენი ფუნქციები, ჩვეულებრივ AWS Lambda) და Knowledge Bases-თან (მართული RAG), ასე რომ მოდელს ნამდვილი ნაბიჯების გადადგმა და პასუხების თქვენს მონაცემებზე დაფუძნება შეუძლია — ყველაფერი AWS-ის IAM-ისა და ლოგირების შიგნით. AWS ასევე გთავაზობთ AgentCore-ს, უფრო ახალ მართულ რანტაიმს აგენტების დასადეპლოებლად (მათ შორის სხვა ფრეიმვორკებით აგებულების), მეხსიერებით, იდენტობითა და დაკვირვებადობით.

?
როდის პლატფორმა და როდის საკუთარი კოდი
მარტივი ვარიანტი უფრო ხშირად იმარჯვებს, ვიდრე გგონიათ.
+

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

07 · არჩევანი და შეჯამება 4 წთ

ოთხი ბერკეტი წყვეტს,
სად იმუშავებს თქვენი AI.

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

ხარჯი

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

მონაცემთა ადგილი

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

შეყოვნება

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

მიბმა

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

უხეში გზაა და არა კანონი: მონაცემების წესები და მოცულობა ჰოსტინგის ნაგულისხმევი გზიდან გწევთ; ბევრი პროვაიდერის საჭიროება კი გეითვეის ამატებს.

  • ნაგულისხმევად აიღეთ ჰოსტირებული API იმ ღრუბელზე, რომელსაც უკვე იყენებთ — ეს ყველაზე იაფი გზაა იმის შესასწავლად, რა გჭირდებათ სინამდვილეში.
  • დაამატეთ გეითვეი იმ წუთს, როცა სარეზერვო გადართვა ან პროვაიდერების შედარება მოგინდებათ.
  • სრულ ML-პლატფორმაზე მხოლოდ მაშინ გადადით, როცა არცერთი მზა მოდელი არ ჯდება — შემდეგ კი MLOps თქვენი სახლია.
  • ღია მოდელების თვითჰოსტინგი მაშინ, როცა ხარჯი მასშტაბზე ან მონაცემების ადგილმდებარეობა ოპერაციულ ტვირთს ამართლებს — და არა ადრე.
1იყიდეთ მოსაწყენი ნაწილები. იქირავეთ სერვინგი, მასშტაბირება და უსაფრთხოება, რომ ძალა პროდუქტზე დახარჯოთ.
2დაპროგრამეთ API-ზე და არა ვენდორზე. მოდელებს შორის მხოლოდ ერთი modelId ან სლაგი უნდა იცვლებოდეს.
3ჯერ ჰოსტინგი, თვითჰოსტინგი კი გააზრებულად. ღია მოდელები ოპერაციულ ტვირთს მხოლოდ სტაბილურ მასშტაბზე ან მკაცრი მონაცემთა წესების ქვეშ იმართლებს.
4მიბმა დანარჩენში იმალება. უყურეთ ცოდნის ბაზებს, დამცავ ბარიერებსა და აგენტების რანტაიმებს — სწორედ მათი მიტოვებაა ძვირი.
5იმარჯვებს უმარტივესი, რაც მუშაობს. გეითვეი, პლატფორმა, აგენტის რანტაიმი — თითოეული მხოლოდ მაშინ დაამატეთ, როცა ტკივილი ნამდვილია.
ცოდნის შემოწმება

დაგამახსოვრდათ?

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

შეაფასეთ ეს დასტა
იყავით პირველი

ნავიგაცია ← → ღილაკებით ან სქროლით · უკან ბიბლიოთეკაში