Arendaja platvorm

AI21 Studio API

AI21 Labs ülevaade arendajatele, mis hõlmab API-juurdepääsu, hinnastust, SDK-tuge, lõppunkte, võimekusi ja platvormi reegleid.

Dokumentatsioon API juhend

API võti Nõutud

Peamine API Jamba Chat Completions API

SDK tugi Ametlikud Pythoni ja TypeScripti SDK-d. Toetatud on ka HTTP-päringute otse kasutamine. SDK-d hõlmavad chat completion’eid, voogedastust, Maestrot, teegifaile ja vestluslikku RAG-funktsionaalsust.

Päringupiirangud Päringulimiidid ja kvoodid sõltuvad kontost, mudelist, paketist ja juurutusest. Viitedokumentatsioon sisaldab juhiseid päringulimiitide kohta, samas kui SDK dokumentatsioon käsitleb korduskatsete seadistamist ja 429-vastuste töötlemist.

Platvorm

API ülevaade

Lõppunktid (endpoints)

API ligipääs

Juuraadress (Base URL)


					https://api.ai21.com/studio/v1

Peamine API Jamba Chat Completions API

Hinnad

API Hinnad

Hinnakujundusmudel Kasutuspõhine tokenipõhine hinnastus koos ettevõtetele mõeldud ja privaatse juurutamise lepingutega

Majutatud juurdepääsu hind sõltub kasutusest, kontost ja mudelist; kehtivad kommertstingimused tuleks üle kontrollida AI21 kontolt või hinnastusdokumentatsioonist. Ettevõtetele mõeldud privaatsed juurutused põhinevad kokkuleppelisel hinnastamisel.

Arendaja töömugavus

SDK info

SDK Ametlikud Pythoni ja TypeScripti SDK-d. Toetatud on ka HTTP-päringute otse kasutamine. SDK-d hõlmavad chat completion’eid, voogedastust, Maestrot, teegifaile ja vestluslikku RAG-funktsionaalsust.

Kasutusmugavus Mõõdukalt lihtne kasutada. REST API järgib tuttavat chat completions’i mustrit ning ametlikud Pythoni ja TypeScripti SDK-d lihtsustavad autentimist, päringute tegemist, voogedastust, Maestro kasutamist ja failitoiminguid.

Dokumentatsioon Hea ja aktiivselt hooldatud. Ajakohane dokumentatsioon hõlmab AI21 Studiot, Jambat, Maestrot, SDK-sid, autentimist, päringulimiite, faile, andmete hankimist, funktsioonikutseid, peenhäälestust, juurutamist ja API-viiteid.

Viivitus Universaalset latentsuse SLA-d ega kindlat latentsusnäitajat ei õnnestunud kinnitada. Jamba vestluse vastuste voogedastus on saadaval ning latentsus sõltub mudelist, viiba pikkusest, väljundi pikkusest, töökoormusest, piirkonnast ja juurutustüübist.

Allikad

Viited arendajale

Dokumentatsioon ↗ API juhend ↗ Liivakast ↗

Featuurid

API võimekused

✓ Voogedastus

✓ Funktsioonide kasutamine

✓ Assistants API

✓ Failide üleslaadimine

✓ Peenhäälestamine

✓ Veebiotsing

✓ Struktureeritud väljund

✓ Liivakast

Lühikirjeldus

Praegune AI21 arendajaliides ühendab AI21 Studios majutatud Jamba API-d kõrgema taseme teenustega. Jamba vestluse lõpuleviimine toetab mitme vooruga sõnumeid, voogedastust ning tööriistade ja funktsioonide kutsumist. Ametlikud Pythoni ja TypeScripti SDK-d toetavad vestluse lõpuleviimist, voogedastust, Maestrot, teegifaile ja vestluslikku RAG-i. AI21 Maestro pakub esimese osapoole agendi- ja orkestreerimisvõimalusi, sealhulgas planeerimist, tööriistu, veebiotsingut, failide otsingut, küsitlusi, nõudeid ja valideeritud väljundit. Failide üleslaadimine on teegi API kaudu saadaval. Jamba mudelite peenhäälestust on dokumenteeritud täieliku peenhäälestuse, LoRA ja QLoRA kaudu, kuid täpne majutatud kättesaadavus sõltub valitud juurutusest ja kontost. AI21 Studio dokumentatsioon loetleb veebiotsingu, failide otsingu, MCP, HTTP-tööriistad ja nendega seotud töövoofunktsioonid. Natiivset pildisisendit ei õnnestunud kasutatud praegusest esimese osapoole API dokumentatsioonist kinnitada. Tavalise Jamba vestluse lõpuleviimise JSON-skeemi jõustamist ei õnnestunud kinnitada; Maestro valideeritud väljund on kõige selgemini dokumenteeritud struktureeritud väljundi võimalus.

Näited

API Näited

set -euo pipefail

: "${AI21_API_KEY:?Set AI21_API_KEY first}"

curl --fail-with-body --silent --show-error \
  --request POST \
  --url "https://api.ai21.com/studio/v1/chat/completions" \
  --header "Authorization: Bearer ${AI21_API_KEY}" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "jamba-mini",
    "messages": [
      {
        "role": "system",
        "content": "You are a concise technical assistant."
      },
      {
        "role": "user",
        "content": "Explain what an API key is in one sentence."
      }
    ],
    "temperature": 0.2,
    "max_tokens": 100
  }' | python3 -c 'import json,sys; data=json.load(sys.stdin); print(data["choices"][0]["message"]["content"])'

# Streaming example
curl --fail-with-body --silent --show-error \
  --request POST \
  --url "https://api.ai21.com/studio/v1/chat/completions" \
  --header "Authorization: Bearer ${AI21_API_KEY}" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "jamba-mini",
    "messages": [{"role": "user", "content": "Write a short explanation of streaming responses."}],
    "stream": true,
    "max_tokens": 120
  }'

# Install: pip install ai21
import json
import os
from ai21 import AI21Client
from ai21.models.chat import ChatMessage

client = AI21Client(api_key=os.environ["AI21_API_KEY"])

messages = [
    ChatMessage(role="system", content="You are a concise technical assistant."),
    ChatMessage(role="user", content="What is an API key?"),
]

try:
    response = client.chat.completions.create(
        model="jamba-mini",
        messages=messages,
        temperature=0.2,
        max_tokens=100,
    )
    print(response.choices[0].message.content)
except Exception as exc:
    print(f"AI21 request failed: {exc}")
    raise

# Streaming
stream = client.chat.completions.create(
    model="jamba-mini",
    messages=[ChatMessage(role="user", content="Write a short explanation of streaming.")],
    stream=True,
)
for chunk in stream:
    content = getattr(chunk.choices[0].delta, "content", None)
    if content:
        print(content, end="", flush=True)
print()

# Portable JSON-output pattern; validate the parsed result in production.
json_response = client.chat.completions.create(
    model="jamba-mini",
    messages=[
        ChatMessage(role="system", content="Return valid JSON only with keys: answer and confidence."),
        ChatMessage(role="user", content="State whether 2+2 equals 4."),
    ],
    temperature=0,
    max_tokens=100,
)
print(json.loads(json_response.choices[0].message.content))

// Install: npm install ai21
import { AI21 } from "ai21";

const client = new AI21({
  apiKey: process.env.AI21_API_KEY,
});

try {
  const response = await client.chat.completions.create({
    model: "jamba-mini",
    messages: [
      { role: "system", content: "You are a concise technical assistant." },
      { role: "user", content: "What is an API key?" },
    ],
    temperature: 0.2,
    max_tokens: 100,
  });

  console.log(response.choices[0]?.message?.content ?? "");
} catch (error) {
  console.error("AI21 request failed:", error);
  process.exitCode = 1;
}

const stream = await client.chat.completions.create({
  model: "jamba-mini",
  messages: [{ role: "user", content: "Write a short explanation of streaming." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}
process.stdout.write("\n");

const jsonResponse = await client.chat.completions.create({
  model: "jamba-mini",
  messages: [
    { role: "system", content: "Return valid JSON only with keys: answer and confidence." },
    { role: "user", content: "State whether 2+2 equals 4." },
  ],
  temperature: 0,
  max_tokens: 100,
});

console.log(JSON.parse(jsonResponse.choices[0].message.content));

<?php
declare(strict_types=1);

$apiKey = getenv('AI21_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set AI21_API_KEY before running this script.');
}

$url = 'https://api.ai21.com/studio/v1/chat/completions';
$payload = [
    'model' => 'jamba-mini',
    'messages' => [
        ['role' => 'system', 'content' => 'You are a concise technical assistant.'],
        ['role' => 'user', 'content' => 'What is an API key?'],
    ],
    'temperature' => 0.2,
    'max_tokens' => 100,
];

$ch = curl_init($url);
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
        'Accept: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode($payload, JSON_THROW_ON_ERROR),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CONNECTTIMEOUT => 10,
    CURLOPT_TIMEOUT => 120,
]);

$body = curl_exec($ch);
if ($body === false) {
    $error = curl_error($ch);
    curl_close($ch);
    throw new RuntimeException('cURL error: ' . $error);
}

$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$data = json_decode($body, true, 512, JSON_THROW_ON_ERROR);
if ($status < 200 || $status >= 300) {
    $message = $data['error']['message'] ?? $body;
    throw new RuntimeException("AI21 HTTP {$status}: {$message}");
}

$content = $data['choices'][0]['message']['content'] ?? null;
if (!is_string($content)) {
    throw new RuntimeException('The response did not contain assistant content.');
}

echo $content . PHP_EOL;

// Portable JSON-output pattern; validate the result in production.
$payload['messages'] = [
    ['role' => 'system', 'content' => 'Return valid JSON only with keys: answer and confidence.'],
    ['role' => 'user', 'content' => 'State whether 2+2 equals 4.'],
];
$payload['temperature'] = 0;
$payload['max_tokens'] = 100;

$ch = curl_init($url);
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
        'Accept: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode($payload, JSON_THROW_ON_ERROR),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 120,
]);
$jsonBody = curl_exec($ch);
if ($jsonBody === false) {
    throw new RuntimeException('JSON request failed: ' . curl_error($ch));
}
$jsonStatus = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($jsonStatus < 200 || $jsonStatus >= 300) {
    throw new RuntimeException("AI21 JSON request failed with HTTP {$jsonStatus}");
}
$jsonData = json_decode($jsonBody, true, 512, JSON_THROW_ON_ERROR);
$structured = json_decode($jsonData['choices'][0]['message']['content'], true, 512, JSON_THROW_ON_ERROR);
print_r($structured);

Põhimõtted

Andmete kasutus

AI21 praegused tingimused reguleerivad kliendiandmeid, väljundeid, teenuse kasutamist ja kontopõhiseid õigusi. Selle kirje koostamisel läbi vaadatud avalik dokumentatsioon ja tingimused ei anna ühtset üldist väidet, mis kehtiks identselt kõigile AI21 Studio pakettidele ja privaatsetele juurutustele seoses sellega, kas API kaudu saadetud sisendeid kasutatakse mudelite treenimiseks. Enne tundlike andmete saatmist peaksid kliendid kinnitama oma kontole, tootele ja lepingule kohaldatavad andmetöötlustingimused.

Andmete säilitamine

Andmete säilitamine sõltub juurutusest ja lepingust. AI21 kirjeldab AI21 Studio, partneri pilve, AI21 hallatava privaatse ning kliendi hallatava privaatse juurutuse võimalusi, sealhulgas VPC- ja kohapealseid lahendusi kvalifitseeruvate ettevõtete kasutusjuhtude jaoks. Läbi vaadatud avalikud materjalid ei sätesta kõigi majutatud API-kontode jaoks ühtset säilitamisperioodi. Säilitamise, kustutamise, andmeresidentsuse ja logimise kontrollid tuleb üle kontrollida kohaldatavast konto- või ettevõttelepingust.

Päringupiirangud

Päringulimiidid ja kvoodid sõltuvad kontost, mudelist, paketist ja juurutusest. Viitedokumentatsioon sisaldab juhiseid päringulimiitide kohta, samas kui SDK dokumentatsioon käsitleb korduskatsete seadistamist ja 429-vastuste töötlemist.

Arendaja juhend

AI21 Studio API juhend: Jamba, Maestro, SDK-d ja arendajatele mõeldud funktsioonid

AI21 Studio on AI21 Labsi praegune arendajaplatvorm majutatud Jamba keelemudelite API-de ja kõrgema taseme teenuste jaoks, nagu failiteegid, vestluspõhine RAG, tööriistakutsed, veebotsing ja Maestro orkestreerimine. Selles juhendis käsitletakse juurdepääsu, autentimist, vestluse lõpetamisi, voogedastust, faile, struktureeritud väljundit, SDK-sid, hinnastust, juurutusvalikuid ja tootmiskeskkonnaga seotud kaalutlusi.

AI21 Studio annab arendajatele REST API ning ametlike Python- ja TypeScripti SDK-de kaudu juurdepääsu AI21 Labsi majutatavatele Jamba mudelitele. Platvorm on mõeldud rakendustele, mis vajavad teksti genereerimist, mitme vooruga vestlusi, voogedastust, tööriistade kasutamist, üles laaditud failidest teabe otsimist või Maestro kaudu agendipõhiseid töövooge. Tegemist on peamiselt tekstile ja dokumentidele keskenduva arendusplatvormiga, mille ärilised tingimused, kvoodid ja mõned juurutusvõimalused võivad kontost ja lepingust sõltuvalt erineda.

AI21 Studio on AI21 Labsi arendajaplatvorm majutatud Jamba vestluspäringute ja kõrgema taseme teenuste jaoks, sealhulgas voogedastus, tööriistade kutsumine, failiteegid, vestluslik RAG, veebiotsing, peenhäälestuse töövood ja Maestro orkestreerimine. Juhendis käsitletakse autentimist, SDK-sid, esimesi päringuid, vastuste töötlemist, struktureeritud väljundi piiranguid, hinnastamist, kasutuspiiranguid, privaatsust, juurutusvõimalusi ning olukordi, kus API sobib või ei sobi kasutamiseks.

Mis on AI21 Studio API?

AI21 Studio on AI21 Labsi praegune majutatud arendusplatvorm. Selle peamine API võimaldab chat completions’i kaudu kasutada Jamba keelemudelite perekonda. Chat completion võtab vastu järjestatud sõnumiloendi, näiteks system, user ja assistant, ning tagastab genereeritud teksti.

Platvorm sisaldab ka tavapärasest tekstigeneerimisest kaugemale ulatuvaid teenuseid. Arendajad saavad dokumente hallatavasse teeki üles laadida, kasutada failiotsingut ja vestluslikku otsinguga täiendatud genereerimist (RAG), määratleda tööriistu, mida rakendus saab käivitada, ning kasutada AI21 Maestrot keerukamate töövoogude planeerimiseks ja orkestreerimiseks.

Peamine majutatud API baasaadress on https://api.ai21.com/studio/v1. AI21 pakub ka arendajakonsooli aadressil https://studio.ai21.com/.

Kellele see mõeldud on?

AI21 Studio sobib arendajatele, kes loovad tekstigeneerimise teenuseid, kirjutamis- ja kokkuvõtete koostamise tööriistu, ettevõtete teadmisteassistente, otsinguga põhjendatud rakendusi ning agendipõhiseid töövooge. See on eriti asjakohane siis, kui organisatsioon vajab selliseid võimalusi nagu hallatav privaatne juurutus, partnerpilve juurutus, VPC-põhine juurutus või ise hallatav juurutus.

See sobib vähem juhul, kui peamine vajadus on laia kasutajaskonnaga tarbijaassistent, natiivne pildi- või heligeneerimine, üldotstarbeline veebisirvimine ilma vastava API-teenuse konfigureerimiseta või suur tarbijatele mõeldud pluginate ja rakenduste ökosüsteem. Natiivset pildisisendit ei õnnestunud selle juhendi koostamisel läbi vaadatud kehtivas API dokumentatsioonis kinnitada.

Juurdepääsu hankimine ja API-võtme loomine

Loo AI21 konto või kasuta olemasolevat kontot, millel on juurdepääs AI21 Studiole.
Loo API-võti vastava AI21 arendaja- või kontoliidese kaudu.
Salvesta võti serveripoolsesse keskkonnamuutujasse, näiteks AI21_API_KEY.
Ära paiguta võtit brauseri JavaScripti, mobiilirakenduse koodi, avalikesse repositooriumidesse ega kliendipoolsesse konfiguratsiooni, mida kasutajad saavad kontrollida.

API-päringud kasutavad bearer-tüüpi autentimist. Tootmiskeskkonnas hoia võtit saladuste halduris või kaitstud juurutuskeskkonnas, vaheta seda vajaduse korral ning väldi võtme kirjutamist rakenduse logidesse.

API ja mudeli valimine

Tavalise tekstigeneerimise või vestlusrakenduse puhul alusta Jamba Chat Completions API-st. Päring sisaldab ajakohast Jamba mudeli identifikaatorit ja sõnumimassiivi. Selle juhendi näidetes kasutatakse jamba-mini; enne juurutamist kontrolli kehtivast AI21 mudelidokumentatsioonist ja oma kontol saadaolevate mudelite seast, millised mudelid on kasutatavad.

Kasuta chat completions’i teenust siis, kui rakendus vajab peamiselt genereeritud teksti, mitme vooruga konteksti, voogedastust või tööriistakutseid. Kasuta teegi- ja otsinguteenuseid siis, kui vastused peavad tuginema üles laaditud dokumentidele. Kasuta Maestrot siis, kui töövoog vajab planeerimist, mitut tööriista, veebiotsingut, failiotsingut, nõudeid, oleku pärimist või valideeritud väljundit.

Need on omavahel seotud võimalused, kuid Maestro on kõrgema taseme orkestreerimisteenus, mitte lihtsalt veel üks chat completion’i võimalus.

Esimese päringu tegemine

Järgmine töötlemata HTTP näide saadab chat completion’i päringu. See kasutab praegust majutatud API mustrit ja hoiab API-võtit serveris.

set -euo pipefail

: "${AI21_API_KEY:?Set AI21_API_KEY first}"

curl --fail-with-body --silent --show-error 
  --request POST 
  --url "https://api.ai21.com/studio/v1/chat/completions" 
  --header "Authorization: Bearer ${AI21_API_KEY}" 
  --header "Content-Type: application/json" 
  --data '{
    "model": "jamba-mini",
    "messages": [
      {
        "role": "system",
        "content": "You are a concise technical assistant."
      },
      {
        "role": "user",
        "content": "Explain what an API key is in one sentence."
      }
    ],
    "temperature": 0.2,
    "max_tokens": 100
  }'

Päring sisaldab kolme olulist osa: mudelit, vestluse sõnumeid ja genereerimisseadeid. temperature mõjutab varieeruvust, samas kui max_tokens seab genereeritud vastuse ülemise pikkusepiiri. Mudelite täpne saadavus ja kontoõigused tuleb üle kontrollida kehtivast AI21 dokumentatsioonist.

Pythoni SDK näide

AI21 ametlik Pythoni pakett installitakse käsuga pip install ai21. Praegune SDK-muster kasutab AI21Client ja chat completion’eid.

import os
from ai21 import AI21Client
from ai21.models.chat import ChatMessage

client = AI21Client(api_key=os.environ["AI21_API_KEY"])

response = client.chat.completions.create(
    model="jamba-mini",
    messages=[
        ChatMessage(
            role="system",
            content="You are a concise technical assistant."
        ),
        ChatMessage(
            role="user",
            content="What is an API key?"
        ),
    ],
    temperature=0.2,
    max_tokens=100,
)

print(response.choices[0].message.content)

Vastuse mõistmine

Edukas chat completion’i vastus sisaldab choices-kogu. Genereeritud assistenditekst on saadaval esimese valiku sõnumi sisus, mida Pythoni SDK-s tähistab response.choices[0].message.content.

Ära eelda, et iga edukas HTTP-vastus tähendab, et mudel koostas täpselt sellise vormingu, mida rakendus vajab. Kontrolli nõutud välju, käsitle tühja või ootamatut sisu ning rakenda rakendusepõhist valideerimist, kui tulemust kasutab mõni teine süsteem.

Struktureeritud andmete puhul võib viip paluda kehtivat JSON-i, kuid tavalise Jamba chat completion’i JSON Schema jõustamist ei õnnestunud esitatud uurimismaterjalide põhjal kinnitada. Maestro valideeritud väljundi ja nõuete funktsioonid on kõige selgemalt dokumenteeritud esimese osapoole struktureeritud väljundi võimalus. Kui küsid tavalisest chat completion’ist JSON-vastust, parsige ja valideerige see oma rakenduses, mitte ära usalda mudeli väljundit pimesi.

Kuidas hinnastamine üldjoontes toimib?

AI21 majutatud mudelite kasutus põhineb kasutuspõhiselt arvestataval hinnastamisel, mis sõltub üldjuhul tokenite tarbimisest. Tegelikud kommertstingimused võivad sõltuda mudelist, kontost, paketist, juurutusest ja lepingust. Ettevõtete ning privaatse juurutuse korral kehtivad läbiräägitavad või kontopõhised tingimused.

API dokumentatsiooni põhjal ei tohiks eeldada ühtset hinda, kvooti ega päringupiirangut. Enne kulude hindamist tutvu kehtiva AI21 konto- ja hinnastamisdokumentatsiooniga. Jälgi sisendi ja väljundi kasutust, vali sobiv mudel, piira ebavajalikku konteksti ning määra võimaluse korral rakenduse eelarved.

Arendajatele kättesaadavad põhivõimalused

Chat completion’id ja vestlused

Jamba chat completion’id toetavad süsteemijuhiseid, kasutaja- ja assistendisõnumeid ning mitme vooruga vestlusi. Rakendus peab ise otsustama, kui palju vestlusajalugu saata ja kuidas hallata konkreetse kasutusjuhtumi konteksti.

Vastuste voogedastus

Voogedastus tagastab genereeritud väljundi järk-järgult, selle asemel et oodata täieliku vastuse valmimist. See võib muuta kasutajaliidese kiiremini reageerivaks ja võimaldab serveril teksti varem edasi saata. See ei kaota vajadust ajalõppude, veakäsitluse ega lõpliku vastuse valideerimise järele.

stream = client.chat.completions.create(
    model="jamba-mini",
    messages=[
        ChatMessage(
            role="user",
            content="Write a short explanation of streaming responses."
        )
    ],
    stream=True,
)

for chunk in stream:
    content = getattr(chunk.choices[0].delta, "content", None)
    if content:
        print(content, end="", flush=True)
print()

Tööriista- ja funktsioonikutsed

Tööriistakutse võimaldab mudelil paluda rakenduse määratletud toimingu tegemist. Tööriista määratlus sisaldab tavaliselt funktsiooni nime, kirjeldust ja JSON-parameetrite skeemi. Mudel ei soorita välist toimingut ise: rakendus saab tööriistakutse, valideerib selle argumendid, käivitab funktsiooni ja saadab tulemuse järgmises vestlussammus tagasi.

See muster sobib kontrollitud juurdepääsuks ärisüsteemidele, kalkulaatoritele, otsinguteenustele, andmebaasidele ja muudele rakenduse funktsioonidele. Käsitle tööriistaargumente ebausaldusväärse sisendina ning rakenda rakenduses autoriseerimist ja valideerimist.

Failid, failiotsing ja vestluslik RAG

AI21 teegi API toetab tööruumi failide üleslaadimist, loendamist, hankimist, uuendamist, allalaadimist ja kustutamist. Üles laaditud sisu saab kasutada failiotsingu või vestlusliku RAG-iga, et vastused põhineksid dokumendikogul ega tugineks ainult mudeli üldistele keelteadmistele.

Maestro dokumentatsioon kirjeldab samuti agendipõhiste töövoogude failiotsingu tööriistu ja failiidentifikaatoreid. Failihaldus on peamiselt teksti- ja dokumendivõimekus; seda ei tohiks segi ajada majutatud Jamba API kinnitatud natiivse pildimõistmisega.

Maestro orkestreerimine

AI21 Maestro on mõeldud kõrgema taseme töövoogude jaoks, mis hõlmavad planeerimist, tööriistu, veebiotsingut, failiotsingut, nõudeid, oleku pärimist ja valideeritud väljundit. Seda tasub kaaluda siis, kui ühtse chat completion’i päringu haldamine on muutunud keeruliseks, sest rakendus vajab mitut koordineeritud sammu.

Peenhäälestus

AI21 kirjeldab Jamba mudelite peenhäälestuse meetodeid, sealhulgas täielikku peenhäälestust, LoRA-t ja QLoRA-t. Täpne saadavus, majutusviis ja kommertstingimused sõltuvad valitud tootest, juurutusest ja kontost, seega ei tohiks eeldada, et kõik meetodid on saadaval igal majutatud kontol.

SDK-d ja arendajatööriistad

AI21 pakub ametlikke Pythoni ja TypeScripti SDK-sid. Need katavad peamised chat completion’i funktsioonid ning toetavad ka selliseid võimalusi nagu voogedastus, Maestro, teegifailid ja vestluslik RAG. Töötlemata HTTP on praktiline valik ametliku SDK-ta keelte puhul või meeskondadele, kes soovivad päringute üle otsest kontrolli.

AI21 Studio konsool pakub arendajatele platvormile sisenemise võimalust ja mänguväljaku-laadset keskkonda selle proovimiseks. Ametlik dokumentatsioon sisaldab API-viiteid, autentimisjuhiseid, SDK-dokumentatsiooni, funktsioonikutsed, failiteeke, failiotsingut, veebiotsingut, peenhäälestust, kasutus- ja kuluteavet ning päringupiirangute juhiseid.

Turvalisem tootmiskeskkonna päringumuster

Tootmiskeskkonna integratsioon peaks sisaldama piiratud kestusega ajalõppe, kontrollitud korduskatseid, olekukoodide käsitlemist, saladusteta päringulogi ja väljundi valideerimist. Pythoni SDK dokumentatsioon kirjeldab konfigureeritavaid ajalõppe ja automaatseid korduskatseid. Rakendused peaksid siiski kasutama piiratud eksponentsiaalset tagasipöördumist ning käsitlema HTTP 429 vastuseid piirkiiruse ületamise märguannetena.

import os
from ai21 import AI21Client
from ai21.models.chat import ChatMessage

client = AI21Client(
    api_key=os.environ["AI21_API_KEY"],
    timeout=60,
    max_retries=2,
)

response = client.chat.completions.create(
    model="jamba-mini",
    messages=[
        ChatMessage(
            role="system",
            content="Return valid JSON only with keys: answer and confidence."
        ),
        ChatMessage(
            role="user",
            content="State whether 2+2 equals 4."
        ),
    ],
    temperature=0,
    max_tokens=100,
)

raw_content = response.choices[0].message.content
print(raw_content)
# Parse and validate raw_content with an application-level JSON validator.

Näide küsib JSON-vastust, kuid ei käsitle mudeli vastust tahtlikult usaldusväärse struktureeritud andmena. Tegelikus teenuses parsige sisu, kontrollige selle skeemi ja väärtusi ning tagastage valideerimise ebaõnnestumisel kontrollitud veateade.

Piirangud ja tootmiskeskkonna kaalutlused

Kvoodid ja päringupiirangud: Piirangud sõltuvad kontost, mudelist, paketist ja juurutusest. Praegused materjalid ei määra kõigile kasutajatele üht universaalset piirangut.
Latentsus: Ühtset latentsusnäitajat ega SLA-d ei õnnestunud kinnitada. Latentsus varieerub olenevalt mudelist, viiba suurusest, väljundi suurusest, töökoormusest, piirkonnast ja juurutuse tüübist. Voogedastus võib parandada tajutavat reageerimiskiirust.
Saadavus: Mudelite nimed, funktsioonid ja kasutusõigused võivad muutuda. Kinnita, et valitud mudel ja teenus on sinu kontol lubatud.
Andmehaldus: Säilitamise, asukoha, kustutamise, logimise ja treenimiseks kasutamise tingimused võivad tootest ja juurutusest sõltuvalt erineda. Enne tundlike andmete saatmist tutvu asjaomase konto- ja ettevõttelepinguga.
Privaatsus: AI21 pakub juurutusvalikuid, sealhulgas AI21 Studio, partnerpilve, AI21 hallatavat privaatset ja ise hallatavat privaatset lahendust. Ettevõttekliendid peaksid täpsed kontrollimehhanismid üle kontrollima, mitte eeldama, et kõigil majutatud ja privaatsetel valikutel on identsed eeskirjad.
Tööriistade turvalisus: Tööriistakutsed võivad käivitada tegelikke toiminguid. Valideeri argumendid, rakenda kasutaja autoriseerimist ja nõua pöördumatute toimingute puhul kinnitust.
Konteksti haldamine: Pikad vestlused ja hangitud dokumendid suurendavad tokenite kasutust ning võivad mõjutada latentsust ja kulu. Vali ülesande jaoks ainult vajalik kontekst.

Eelised ja piirangud

Eelised

Jamba keelemudelite jaoks tuttav chat completion’i liides.
Ametlikud Pythoni ja TypeScripti SDK-d koos otsese REST-juurdepääsuga.
Voogedastus ning tööriista- ja funktsioonikutsed interaktiivsete rakenduste jaoks.
Hallatavad failiteegid, failiotsing ja vestluslik RAG dokumentidele tuginevate töövoogude jaoks.
Maestro planeerimise, orkestreerimise, tööriistade, veebiotsingu, failiotsingu ja valideeritud väljundiga töövoogude jaoks.
Juurutusvalikud, mis ulatuvad tavapärasest jagatud majutatud API-st kaugemale.

Piirangud

Hinnad, kvoodid ja mõned võimalused sõltuvad kontost, mudelist, paketist või lepingust.
Tavalise chat completion’i JSON Schema jõustamist ei õnnestunud kinnitada; rakendusepoolne valideerimine on endiselt vajalik.
Natiivset pildisisendit ei õnnestunud läbi vaadatud kehtivas esimese osapoole API dokumentatsioonis kinnitada.
Platvorm on peamiselt teksti- ja dokumendikeskne, mitte üldotstarbeline multimodaalse meedia genereerimise teenus.
Privaatsed juurutused ja mõned ettevõtetele mõeldud võimalused võivad nõuda müügimeeskonna kaudu või läbirääkimiste teel saadavat juurdepääsu.

Millal on AI21 Studio hea või halb valik?

AI21 Studio on hea valik siis, kui vajad majutatud Jamba tekstigeneerimist, tavapärast chat API-t, voogedastust, tööriistakutseid, dokumentide otsingut või ettevõtetele sobivat võimalust privaatsesse juurutusse liikuda. Seda tasub hinnata ka siis, kui Maestro orkestreerimise ja valideeritud väljundi funktsioonid sobivad loodava töövooga.

See võib olla halb valik juhul, kui rakendus sõltub peamiselt pildi-, video- või heligeneerimisest, kinnitatud natiivsest pildisisendist, universaalsest fikseeritud hinnaga paketist või laiast tarbijaassistentide ökosüsteemist. Enne otsuse tegemist testi oma kontol saadaolevaid mudeleid ja teenuseid, kinnita kehtivad hinnad ja piirangud ning hangi töökoormuse jaoks vajalikud andmetöötlustingimused.

Allikad 21