Arendaja platvorm

Cerebras Inference API

Cerebras ü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 Cerebras Inference API

SDK tugi Ametlik Pythoni pakett: cerebras_cloud_sdk. Ametlik TypeScripti/Node.js-i pakett: @cerebras/cerebras_cloud_sdk. OpenAI-ga ühilduvad Pythoni ja Node.js-i kliendid saab samuti konfigureerida kasutama Cerebrase baas-URL-i. Teised keeled saavad kasutada HTTP-

Päringupiirangud Piirangud sõltuvad mudelist, organisatsioonist, projektist ja paketist ning neid mõõdetakse päringute ja märkide arvu järgi minuti-, tunni- ja päevapõhiste ajavahemike lõikes. Praeguses dokumentatsioonis tuuakse mitme mudeli tasuta taseme näidetena 30 RPM

Platvorm

API ülevaade

Lõppunktid (endpoints)

API ligipääs

Juuraadress (Base URL)


					https://api.cerebras.ai/v1

Peamine API Cerebras Inference API

Hinnad

API Hinnad

Hinnakujundusmudel Tasuta pakett, arendajatele kasutuspõhine tokenitasu ning kohandatud ettevõttehinnad

Praeguste avalike mudeliandmete kohaselt on mudelipõhised sisend- ja väljundtokenite hinnad järgmised: GPT OSS 120B maksab ligikaudu 0,35 USA dollarit miljoni sisendtokeni ja 0,75 USA dollarit miljoni väljundtokeni kohta. Tasuta juurdepääsul on madalamad limiidid; ettevõtetele mõeldud hinnakujundus on kohandatud.

Arendaja töömugavus

SDK info

SDK Ametlik Pythoni pakett: cerebras_cloud_sdk. Ametlik TypeScripti/Node.js-i pakett: @cerebras/cerebras_cloud_sdk. OpenAI-ga ühilduvad Pythoni ja Node.js-i kliendid saab samuti konfigureerida kasutama Cerebrase baas-URL-i. Teised keeled saavad kasutada HTTP-

Kasutusmugavus OpenAI-ga ühilduvate API-dega tuttavate arendajate jaoks on kasutusmugavus kõrge. Platvorm pakub tavapärast REST-liidest, Bearer-autentimist, ametlikke Pythoni ja TypeScripti SDK-sid ning ühilduvust OpenAI kliendiga.

Dokumentatsioon Hea ja tehniliselt põhjalik. Dokumentatsioon hõlmab kiirjuhendit, API dokumentatsiooni, mudeleid, voogedastust, tööriistade kasutamist, struktureeritud väljundeid, päringupiiranguid, projekte, teenusetasemeid, faile ja pakktöötlust. Mõned uuemad funktsioo

Viivitus Cerebras positsioneerib teenuse väga väikese latentsuse ja suure läbilaskevõimega inferentsi jaoks. Praeguses mudelidokumentatsioonis on llama3.1-8b puhul märgitud ligikaudu 2 200 tokenit sekundis ja gpt-oss-120b puhul ligikaudu 3 000 tokenit sekundis. Te

Allikad

Viited arendajale

Dokumentatsioon ↗ API juhend ↗ Liivakast ↗

Featuurid

API võimekused

✓ Voogedastus

✓ Funktsioonide kasutamine

✓ Failide üleslaadimine

✓ Peenhäälestamine

✓ Struktureeritud väljund

✓ Liivakast

Lühikirjeldus

Soovitatav avalik arhitektuur on OpenAI-ga ühilduv Chat Completions API aadressil /v1/chat/completions, millele pääseb ligi ametliku Cerebrase Python- või TypeScripti SDK, otse HTTP või Cerebrase baasaadressiga konfigureeritud ühilduva OpenAI kliendi kaudu. Praegused platvormi võimalused hõlmavad tekstipõhiseid vestluse lõpetamisi, pärandstiilis tekstipõhiseid lõpetamisi, voogedastust, tööriista- ja funktsioonikutseid, rangeid struktureeritud väljundeid, JSON-režiimi, mudelite loendit, kasutuse jälgimist, projektihaldust, päringumäära päiseid, teenusetasemeid ja pakktöötlust. Files API on praegu dokumenteeritud Batch API sisendi jaoks ning saadaval privaatses eelvaates; see ei ole üldotstarbeline otsingu- ega multimodaalsete failide sisestamise API. Peenhäälestatud mudelid on ettevõtetele mõeldud võimalus, mitte üldine iseteenindusfunktsioon. Pildisisendit avalikus jagatud mudelite pakkumises üldiselt ei toetata; praegused avalikud mudemetaandmed näitavad viidatud tootmismudeli puhul, et vision on false. Praeguses avalikus API viites ei ole dokumenteeritud esimese osapoole püsivat Assistants API-t ega majutatud agentide käituskeskkonda. Agentseid rakendusi saab luua mitmekäigulise vestluse, tööriistakutsete, välise oleku ja rakendusepõhise orkestreerimise kombineerimise teel. Mudelite ID-d ja võimaluste saadavus võivad muutuda, seega peaksid rakendused enne juurutamist tutvuma ajakohase mudelikataloogiga. Rakendage ajutiste 429- ja 5xx-vigade jaoks piiratud korduskatseid, järgige päringumäära päiseid ning määrake max_completion_tokens sobivalt, et vältida tarbetut kvoodi prognoosimist.

Näited

API Näited

# Basic request
curl --fail-with-body --silent --show-error \
  https://api.cerebras.ai/v1/chat/completions \
  -H "Authorization: Bearer ${CEREBRAS_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-oss-120b",
    "messages": [
      {"role": "system", "content": "You are a concise technical assistant."},
      {"role": "user", "content": "Explain server-sent events in one paragraph."}
    ],
    "max_completion_tokens": 200
  }' | jq -r '.choices[0].message.content'

# Streaming request
curl --fail-with-body --silent --show-error \
  https://api.cerebras.ai/v1/chat/completions \
  -H "Authorization: Bearer ${CEREBRAS_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-oss-120b",
    "messages": [{"role": "user", "content": "Give three uses for fast inference."}],
    "stream": true,
    "max_completion_tokens": 200
  }'

# Install: pip install --upgrade cerebras_cloud_sdk
import json
import os
import sys
from cerebras.cloud.sdk import Cerebras

api_key = os.environ.get("CEREBRAS_API_KEY")
if not api_key:
    raise RuntimeError("CEREBRAS_API_KEY is not set")

client = Cerebras(api_key=api_key)

try:
    completion = client.chat.completions.create(
        model="gpt-oss-120b",
        messages=[
            {"role": "system", "content": "You are a helpful technical assistant."},
            {"role": "user", "content": "What is a token bucket rate limiter?"}
        ],
        max_completion_tokens=300,
    )
    print(completion.choices[0].message.content)

    stream = client.chat.completions.create(
        model="gpt-oss-120b",
        messages=[
            {"role": "user", "content": "Explain streaming inference briefly."}
        ],
        stream=True,
        max_completion_tokens=200,
    )
    for chunk in stream:
        content = chunk.choices[0].delta.content or ""
        print(content, end="", flush=True)
    print()

    schema = {
        "type": "object",
        "properties": {
            "summary": {"type": "string"},
            "priority": {"type": "string", "enum": ["low", "medium", "high"]}
        },
        "required": ["summary", "priority"],
        "additionalProperties": False,
    }
    structured = client.chat.completions.create(
        model="gpt-oss-120b",
        messages=[
            {"role": "system", "content": "Return a concise classification."},
            {"role": "user", "content": "Classify this issue: API requests are timing out."}
        ],
        response_format={
            "type": "json_schema",
            "json_schema": {"name": "classification", "strict": True, "schema": schema},
        },
        max_completion_tokens=200,
    )
    print(json.loads(structured.choices[0].message.content))
except Exception as exc:
    print(f"Cerebras API error: {exc}", file=sys.stderr)
    raise

// Install: npm install @cerebras/cerebras_cloud_sdk
import Cerebras from "@cerebras/cerebras_cloud_sdk";

const apiKey = process.env.CEREBRAS_API_KEY;
if (!apiKey) throw new Error("CEREBRAS_API_KEY is not set");

const client = new Cerebras({ apiKey });

async function main() {
  try {
    const completion = await client.chat.completions.create({
      model: "gpt-oss-120b",
      messages: [
        { role: "system", content: "You are a helpful technical assistant." },
        { role: "user", content: "Explain why low latency matters for agents." }
      ],
      max_completion_tokens: 250
    });
    console.log(completion.choices[0]?.message?.content ?? "");

    const stream = await client.chat.completions.create({
      model: "gpt-oss-120b",
      messages: [{ role: "user", content: "List three API reliability practices." }],
      stream: true,
      max_completion_tokens: 200
    });
    for await (const chunk of stream) {
      process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
    }
    process.stdout.write("\n");

    const toolCompletion = await client.chat.completions.create({
      model: "gpt-oss-120b",
      messages: [{ role: "user", content: "What is 27 multiplied by 14?" }],
      tools: [{
        type: "function",
        function: {
          name: "calculate",
          description: "Calculate a basic arithmetic expression.",
          strict: true,
          parameters: {
            type: "object",
            properties: { expression: { type: "string" } },
            required: ["expression"],
            additionalProperties: false
          }
        }
      }],
      max_completion_tokens: 200
    });
    console.log(JSON.stringify(toolCompletion.choices[0]?.message ?? {}));
  } catch (error) {
    console.error("Cerebras API error:", error);
    process.exitCode = 1;
  }
}

main();

<?php
$apiKey = getenv('CEREBRAS_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('CEREBRAS_API_KEY is not set');
}

$url = 'https://api.cerebras.ai/v1/chat/completions';
$payload = [
    'model' => 'gpt-oss-120b',
    'messages' => [
        ['role' => 'system', 'content' => 'You are a concise technical assistant.'],
        ['role' => 'user', 'content' => 'Explain how API retries should be bounded.']
    ],
    'max_completion_tokens' => 250
];

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

$body = curl_exec($ch);
if ($body === false) {
    $error = curl_error($ch);
    curl_close($ch);
    throw new RuntimeException('Network 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("Cerebras API HTTP $status: $message");
}

$content = $data['choices'][0]['message']['content'] ?? null;
if ($content === null) {
    throw new RuntimeException('No assistant content in the response');
}
echo $content . PHP_EOL;
?>

Põhimõtted

Andmete kasutus

Cerebrase kehtivate tingimuste kohaselt ei kasutata teenuse sisu mudelite treenimiseks ega peenhäälestuseks. Teenuste osutamiseks, haldamiseks, jälgimiseks ja täiustamiseks võidakse koguda ning töödelda kasutus- ja diagnostikaandmeid vastavalt kohaldatavatele tingimustele ja privaatsuspoliitikale. Ettevõttekliendid peaksid Cerebrasega üle kinnitama kõik täiendavad lepingulised kontrollimehhanismid.

Andmete säilitamine

Cerebrase privaatsuspoliitika sätestab, et selle treeningu-, inferentsi- ja vestlusroboti teenustega seotud sisendeid ja väljundeid ei säilitata ning seotud logid kustutatakse, kui neid pole teenuste osutamiseks enam vaja. Pakettidena üles laaditud failid on eraldi funktsioon ning dokumentatsiooni kohaselt säilitatakse neid vaikimisi seitse päeva; aegumise saab seadistada ühe tunni kuni kolmekümne päeva vahele. Töökoormusepõhiste säilitus- ja vastavusnõuete kohta vaadake kehtivaid ettevõtete lepinguid.

Päringupiirangud

Piirangud sõltuvad mudelist, organisatsioonist, projektist ja paketist ning neid mõõdetakse päringute ja märkide arvu järgi minuti-, tunni- ja päevapõhiste ajavahemike lõikes. Praeguses dokumentatsioonis tuuakse mitme mudeli tasuta taseme näidetena 30 RPM

Arendaja juhend

Cerebras Inference API: algajate arendajate juhend

Cerebras Inference on OpenAI-ga ühilduv arendajatele mõeldud API kiireks hostitud keelemudelite inferentsiks. Selles juhendis käsitletakse juurdepääsu, API-võtmeid, mudeli valimist, vestluse lõpetamisi, voogedastust, tööriistade kutsumist, struktureeritud väljundeid, failide ja pakettide töötlemist, SDK-sid, hinnastamist, päringulimiite ning tootmiskasutusega seotud kaalutlusi.

Cerebras Inference pakub arendajatele tuttavat API-t rakenduste loomiseks, mis genereerivad Cerebrase taristul hostitud mudelite abil teksti. See kasutab autentimiseks API-võtit, toetab ametlikke Pythoni ja TypeScripti SDK-sid ning pakub vestluse lõpetamise päringuid, voogedastust, tööriistade kasutamist, struktureeritud väljundeid, mudelite avastamist, projektihaldust ja kasutuse jälgimist. Saadaval on tasuta juurdepääs, tokenipõhine arveldamine ja ettevõtetele mõeldud kokkulepped, kuid mõned faili- ja pakktöötlusfunktsioonid on endiselt privaatses eelvaates.

Cerebras Inference on OpenAI-ga ühilduv API majutatud keelemudelite kiireks genereerimiseks. Arendajad saavad kasutada Pythoni või TypeScripti SDK-sid, chat completions’i, voogedastust, tööriistade kutsumist, struktureeritud väljundeid, mudelite avastamist, projekte ja kasutuspiiranguid. Juurdepääs hõlmab tasuta testimist, märgipõhist arveldamist ja ettevõtetele mõeldud võimalusi. Failid ja paketttöötlus on eelvaatefunktsioonid, samas kui avalik jagatud API on peamiselt tekstikeskne ning püsivate assistentide ega üldise pildisisendi tuge ei ole dokumenteeritud.

Mis on Cerebras Inference API?

Cerebras Inference on hostitud arendaja-API, mille kaudu saab toetatud keelemudelitele viipasid saata ja genereeritud teksti vastu võtta. Selle peamine liides on OpenAI-ga ühilduv HTTP-API aadressil https://api.cerebras.ai/v1. Peamine lõpp-punkt on /chat/completions, kuhu rakendus saadab sõnumite loendi ja saab vastuseks assistendi vastuse.

Teenus on mõeldud arendajatele, kes loovad rakendusi, programmeerimistööriistu, agente, reaalajas assistente ja muid süsteeme, mis vajavad väikese latentsuse ning suure läbilaskevõimega teksti genereerimist. See ei ole tarbijatele mõeldud vestlusrobotiplatvorm ega paku üldotstarbelist hostitud assistenti püsivate vestluste, sisseehitatud veebiotsingu või natiivse pildigeneratsiooniga.

Mudelite identifikaatorid, hinnad, võimalused ja kasutusest eemaldamise olek võivad muutuda. Enne rakenduse kasutuselevõttu kontrollige Cerebrase praegust mudelikataloogi, mitte ärge tuginege vanemast näitest kopeeritud mudelinimele.

Kellele Cerebras Inference sobib?

Cerebras Inference sobib hästi arendajatele, kes tunnevad juba HTTP või SDK-de kasutamise põhitõdesid ja soovivad kiiret hostitud keelemudeli lõpp-punkti. See on eriti asjakohane interaktiivsete rakenduste puhul, kus vastuse latentsus on oluline, samuti programmeerimisagentide, suure läbilaskevõimega töökoormuste ja OpenAI-ga ühilduvaid päringumustreid vajavate süsteemide jaoks.

See on vähem sobiv valik, kui rakendus sõltub natiivsest pildimõistmisest, pildigeneratsioonist, püsivatest serveripoolsetest assistentidest, veebisirvimisest või ulatuslikust tarbijarakenduste ökosüsteemist. Neid funktsioone ei ole avaliku jagatud inference-teenuse üldiste võimalustena dokumenteeritud.

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

Vajate Cerebrase kontot ja API-võtit. Arendajatele on juurdepääs saadaval Cerebras Cloudi keskkonna kaudu: tasuta kasutusele kehtivad madalamad piirangud ning suurema kasutuse jaoks on saadaval iseteeninduslik kasutuspõhine tasuline juurdepääs. Ettevõttekliendid saavad kokku leppida kohandatud mahu ja toe.

Hoidke võtit keskkonnamuutujas või saladuste halduris, mitte otse lähtekoodis. Cerebrase näidetes kasutatav standardne muutuja on CEREBRAS_API_KEY.

export CEREBRAS_API_KEY="your-api-key"

Päringute autentimiseks kasutatakse bearer-luba. Käsitlege võtit serveripoolse saladusena ning vältige selle avaldamist brauserikoodis, avalikes repositooriumides või kasutajatele levitatavates klientrakendustes.

Valige toetatud mudel

Cerebras pakub mudelikataloogi, kus on loetletud toetatud mudelite ID-d ning võimaluse korral ka teave nende võimekuse, hinna ja oleku kohta. Valige mudel, mis on teie konto ja lõpp-punkti jaoks parajasti saadaval. Allolevates näidetes kasutatakse mudelit gpt-oss-120b, kuid mudelite saadavus võib muutuda.

Mudeli valimisel kontrollige, kas see toetab teie rakenduse vajalikke funktsioone. Ühilduvus võib voogedastuse, tööriistakutsete, struktureeritud väljundite, konteksti piirangute ja muude valikute puhul erineda. Ärge eeldage, et kõik mudelid toetavad kõiki parameetreid.

Tehke esimene päring

Lihtsaim päring on vestluse lõpetamine ehk chat completion. See saadab süsteemijuhise, mis määrab käitumise, ja kasutaja sõnumi, mis sisaldab ülesannet. API tagastab JSON-vastuse, mis sisaldab üht või mitut valikut.

curl --fail-with-body --silent --show-error 
  https://api.cerebras.ai/v1/chat/completions 
  -H "Authorization: Bearer ${CEREBRAS_API_KEY}" 
  -H "Content-Type: application/json" 
  -d '{
    "model": "gpt-oss-120b",
    "messages": [
      {"role": "system", "content": "You are a concise technical assistant."},
      {"role": "user", "content": "Explain server-sent events in one paragraph."}
    ],
    "max_completion_tokens": 200
  }'

Massiiv messages tähistab vestlust. Mitme vooruga vestluse korral saadab rakendus tavaliselt asjakohased varasemad sõnumid uuesti; tavalised chat completion'i päringud ei vaja eraldi serveripoolset vestlusobjekti.

Kasutage ametlikke SDK-sid

Cerebras pakub ametlikku Pythoni paketti nimega cerebras_cloud_sdk ja ametlikku TypeScripti/Node.js-i paketti nimega @cerebras/cerebras_cloud_sdk. Ka otse HTTP-päringute tegemine on praktiline, sest API kasutab tavapärast JSON-vormingut ja bearer-loaga autentimist. Olemasolevaid OpenAI-ga ühilduvaid kliente saab üldjuhul seadistada Cerebrase baasaadressi kasutama, kuid konkreetseid parameetreid ja funktsioonide tuge tuleb siiski eraldi kontrollida.

pip install --upgrade cerebras_cloud_sdk

import os
from cerebras.cloud.sdk import Cerebras

client = Cerebras(api_key=os.environ["CEREBRAS_API_KEY"])

completion = client.chat.completions.create(
    model="gpt-oss-120b",
    messages=[
        {"role": "system", "content": "You are a helpful technical assistant."},
        {"role": "user", "content": "What is a token bucket rate limiter?"}
    ],
    max_completion_tokens=300,
)

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

Mõistke vastuse struktuuri

Edukas chat completion'i vastus sisaldab massiivi choices. Genereeritud assistenditekst asub tavaliselt aadressil choices[0].message.content. Sõltuvalt päringust ja mudelist võib vastus sisaldada ka tööriistakutseid, lõpetamise teavet, mudeli identifikaatoreid ja kasutusandmeid.

Ärge eeldage, et iga vastus sisaldab tavalist teksti. Tööriistakutsega vastus võib paluda rakendusel selle asemel funktsioon välja kutsuda ning voogedastatud vastused edastavad osalisi muudatusi, mitte üht täielikku sõnumit.

Kuidas Cerebras Inference'i hinnastamine toimib?

Cerebras pakub madalamate piirangutega tasuta juurdepääsu, iseteeninduslikku kasutuspõhist tasulist juurdepääsu ja kohandatud ettevõttelahendusi. Iseteenindusliku kasutuse arvestus põhineb mudelipõhistel sisend- ja väljundmärgiste hindadel. Avalikes mudeliandmetes on GPT OSS 120B näitena toodud ligikaudu 0,35 dollarit miljoni sisendmärgise ja 0,75 dollarit miljoni väljundmärgise kohta, kuid enne nende hindade kasutamist eelarves või lepingus tuleb need kehtivast mudelikataloogist ja hinnastusdokumentatsioonist üle kontrollida.

Ettevõttelepingud võivad sisaldada kohandatud mahtu, eelisjärjekorras spetsiaalset mahtu, kohandatud mudelikihte või peenhäälestatud mudeleid, teenusetaseme kohustusi ja spetsiaalset tuge. Tegelikud piirangud ja saadaolevad mudelid võivad sõltuda teie organisatsioonist, projektist, paketist ja mudelist.

Voogedastage vastuseid interaktiivsete rakenduste jaoks

Voogedastus saadab genereerimise ajal osalise väljundi serveri saadetud sündmustena. Seadke stream väärtuseks true ja lisage iga delta tekst liidesesse. Voogedastus on vestlusliideste puhul kasulik, sest kasutajad näevad vastuse algust, ilma et peaksid täieliku vastuse järel ootama.

curl --fail-with-body --silent --show-error 
  https://api.cerebras.ai/v1/chat/completions 
  -H "Authorization: Bearer ${CEREBRAS_API_KEY}" 
  -H "Content-Type: application/json" 
  -d '{
    "model": "gpt-oss-120b",
    "messages": [{"role": "user", "content": "Give three uses for fast inference."}],
    "stream": true,
    "max_completion_tokens": 200
  }'

Kasutus- ja ajastusteave võidakse edastada ainult voo viimases osas. Seetõttu peab voogu töötlev kood arvestama osadega, mis sisaldavad üksnes osalist sisu või metaandmeid.

Looge tööriistu ja funktsioonikutseid

Tööriistakutsed võimaldavad mudelil taotleda toimingut, mille rakendus ise sooritab. Näiteks võib rakendus JSON Schema kaudu avaldada kalkulaatori, andmebaasiotsingu, otsinguteenuse või ärilise toimingu. Mudel otsustab, kas tööriista kutsuda, teie kood käivitab selle ning tulemus saadetakse hilisemas mudelipäringus tagasi.

See on kliendi juhitud tööriistade kasutamine, mitte püsiv hostitud agendikäituskeskkond. Teie rakendus vastutab endiselt autoriseerimise, valideerimise, täitmise, vigade käsitlemise ja välise oleku eest.

const toolCompletion = await client.chat.completions.create({
  model: "gpt-oss-120b",
  messages: [{ role: "user", content: "What is 27 multiplied by 14?" }],
  tools: [{
    type: "function",
    function: {
      name: "calculate",
      description: "Calculate a basic arithmetic expression.",
      strict: true,
      parameters: {
        type: "object",
        properties: { expression: { type: "string" } },
        required: ["expression"],
        additionalProperties: false
      }
    }
  }],
  max_completion_tokens: 200
});

Pärast tööriistakutse saamist valideerige selle argumendid enne toimingu käivitamist. Ärge lubage mudeli genereeritud päringul mööda minna õigustest ja turvakontrollidest, mida teie rakendus rakendaks tavalise kasutajapäringu puhul.

Kasutage struktureeritud väljundeid, kui kood vajab prognoositavat JSON-i

Struktureeritud väljundid võimaldavad esitada JSON Schema ja taotleda sellele vastavat vastust. Kui range režiim on lubatud, piirab mudelit esitatud skeem, juhul kui valitud mudel seda funktsiooni toetab. Rakenduse andmete puhul on see usaldusväärsem kui JSON-i küsimine tavalises proosas.

schema = {
    "type": "object",
    "properties": {
        "summary": {"type": "string"},
        "priority": {"type": "string", "enum": ["low", "medium", "high"]}
    },
    "required": ["summary", "priority"],
    "additionalProperties": False,
}

result = client.chat.completions.create(
    model="gpt-oss-120b",
    messages=[
        {"role": "user", "content": "Classify: API requests are timing out."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "classification",
            "strict": True,
            "schema": schema,
        },
    },
    max_completion_tokens=200,
)

Dokumenteeritud on ka JSON-režiim, kuid kui rakendus vajab kindlaksmääratud skeemi, on struktureeritud väljundid eelistatavad. Enne kummalegi funktsioonile tuginemist kinnitage selle tugi kehtivast mudelikataloogist.

Failid ja pakktöötlus

Files API ja Batch API on dokumenteeritud privaatse eelvaate funktsioonidena asünkroonseks töötlemiseks. Failid laaditakse pakktööde sisendiks üles JSONL-vormingus; need ei ole üldotstarbeline otsingusüsteem ega dokumenteeritud multimodaalsete manuste töövoog.

Dokumenteeritud failipiirang on 200 MB. Faile säilitatakse vaikimisi seitse päeva ning aegumise saab seadistada ühe tunni kuni kolmekümne päeva pikkuseks. Dokumenteeritud privaatses eelvaates ei olnud SDK tugi pakktöödele saadaval, mistõttu võib olla vaja kasutada otse HTTP-päringuid. Enne nende funktsioonide põhjal tootmistöövoo kavandamist kinnitage eelvaate juurdepääs ja praegune käitumine.

Mänguväljak ja arendajatööriistad

Cerebras Cloudi konsool pakub mänguväljakut ja projektihalduse funktsioone. Projektides saab rühmitada API-võtmeid, liikmeid, kasutusanalüütikat ja projektitaseme päringupiiranguid, mis on kasulik arendus-, testimis- ja tootmiskoormuste eraldamiseks.

API pakub ka mudelite avastamist, kasutuse jälgimist, päringupiirangute teavet ja teenusetasemeid. Kui see on organisatsioonis lubatud, on flex liiklus madalama prioriteediga, samal ajal kui priority liiklus saab kõrgema prioriteedi. Saadavus sõltub organisatsioonist ja teenuse praegusest konfiguratsioonist.

Piirangud ja tootmiskasutuse kaalutlused

Piirangud sõltuvad mudelist, organisatsioonist, projektist ja paketist. Need võivad kehtida päringute ja märgiste kvootide suhtes, mida mõõdetakse minuti-, tunni- ja päevaakendes. Dokumentatsioon toob tasuta paketi näidetena mitme mudeli puhul välja 30 päringut minutis ning ligikaudu 60 000–64 000 märgist minutis, kuid täpsed väärtused tuleb asjaomase konto ja mudeli puhul Cerebrase konsoolist üle vaadata.

Vastuse päised näitavad allesjäänud kvooti ja lähtestamisteavet. Vastus 429 näitab päringupiirangu rakendumist. Cerebras soovitab määrata realistliku väärtuse max_completion_tokens, sest märgiste kvoote võidakse hinnata eeldatava maksimaalse tarbimise põhjal.

Hoidke API-võtmeid saladuste halduris või keskkonnamuutujas.
Käsitlege 429-, 5xx-, ajalõpu- ja võrgutõrkeid piiratud eksponentsiaalse viitega.
Järgige päringupiirangute päiseid, selle asemel et pidevalt uuesti proovida.
Jälgige päringu ID-sid, kasutust, latentsust ja hinnangulist maksumust.
Kasutage arenduse, testimise ja tootmise jaoks eraldi projekte.
Enne mudelite ID-de koodi fikseerimist kontrollige mudelikataloogist nende kasutusest eemaldamist.
Valideerige tööriistaargumendid ja struktureeritud vastused enne nende kasutamist rakenduse loogikas.

Privaatsus ja andmekäitlus

Cerebras teatab, et ei säilita oma treeningu-, inference- ja vestlusrobotiteenustega seotud sisendeid ega väljundeid ning kustutab seotud logid, kui neid pole teenuste osutamiseks enam vaja. Teenusetingimuste kohaselt ei kasuta Cerebras teenuse sisu mudelite treenimiseks ega peenhäälestuseks.

Teenuste pakkumiseks, hooldamiseks, jälgimiseks, täiustamiseks, analüüsimiseks ja arendamiseks võidakse siiski koguda kasutus- ja diagnostikaandmeid. Pakktöödena üles laaditud failidele kehtivad eraldi säilitusreeglid. Enne reguleeritud või tundlike andmete saatmist tutvuge kehtiva privaatsuspoliitika, teenusetingimuste ja võimaliku ettevõttelepinguga.

Eelised ja piirangud

Valdkond	Mida oodata
Kiirus	Cerebras positsioneerib teenuse väga väikese latentsuse ja suure läbilaskevõimega inference'i jaoks.
Integratsioon	OpenAI-ga ühilduvad HTTP-mustrid ning ametlikud Pythoni ja TypeScripti SDK-d vähendavad migreerimise vaeva.
Arendajafunktsioonid	Saadaval on chat completion'id, voogedastus, tööriistakutsed, struktureeritud väljundid, mudelite avastamine, projektid ja kasutuse juhtimise funktsioonid.
Failid	Failid ja pakktöötlus on eelvaatefunktsioonid, mis on mõeldud asünkroonseks JSONL-töötluseks, mitte üldotstarbelisteks multimodaalseteks üleslaadimisteks.
Multimodaalsuse tugi	Avalik jagatud pakkumine on peamiselt tekstipõhine; üldist pildisisendi tuge ei ole dokumenteeritud.
Hostitud agendid	Avalikus API-viites ei ole dokumenteeritud esimese osapoole püsivat Assistants API-t ega hostitud agendikäituskeskkonda.

Millal on Cerebras Inference hea või halb valik?

Valige Cerebras Inference, kui väike latentsus, suur läbilaskevõime, OpenAI-ga ühilduv integratsioon, tööriistakutsed või kiired programmeerimis- ja agenditöövood on olulised nõuded. Seda tasub hinnata ka siis, kui soovite arendaja-API-t, mis pakub testimiseks tasuta juurdepääsu ning võimalust minna üle kasutuspõhisele tasule või ettevõtte mahule.

Kui vajate natiivset pildimõistmist, pildigeneratsiooni, veebiotsingut, püsivaid assistendilõimi, tarbijatele mõeldud mobiilirakendusi või küpset hostitud agendikäituskeskkonda, kaaluge muid lahendusi või lisage oma orkestreerimiskiht. Cerebras võib neis süsteemides siiski toimida teksti genereeriva komponendina, kuid puuduvad funktsioonid tuleb pakkuda teie rakendusel või muudel teenustel.

Allikad 20