Arendaja platvorm

Claude API

Claude ü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 Messages API

SDK tugi Ametlikud SDK-d Pythonile, TypeScriptile, C#-ile, Go-le, Javale, PHP-le ja Rubyle; ametlik ant CLI; otsene REST-i ja cURL-i tugi.

Päringupiirangud Organisatsioonipõhised kasutustasemed kehtestavad igakuised kululimiidid ning mudelipõhised RPM-i, sisendtokenite minutis ja väljundtokenite minutis piirangud. Message Batchesi, Files API, veebotsingu ja Managed Agentsi jaoks kehtivad täiendavad piirangud

Platvorm

API ülevaade

Lõppunktid (endpoints)

API ligipääs

Juuraadress (Base URL)


					https://api.anthropic.com

Peamine API Messages API

Hinnad

API Hinnad

Hinnakujundusmudel Kasutuspõhine tokenitasu vastavalt tegelikule tarbimisele, mõne tööriista, vahemällu salvestamise ja teenusetaseme puhul kehtivad eraldi hinnad

Hinnad sõltuvad mudelist ning arvestus toimub sisend- ja väljundtokenite põhjal. Paketttöötlus on üldjuhul tavahinnast 50% soodsam; viipade vahemällu salvestamisel ja veebotsingul kehtivad eraldi hinnareeglid.

Arendaja töömugavus

SDK info

SDK Ametlikud SDK-d Pythonile, TypeScriptile, C#-ile, Go-le, Javale, PHP-le ja Rubyle; ametlik ant CLI; otsene REST-i ja cURL-i tugi.

Kasutusmugavus Kõrge standardsete Messages API integratsioonide puhul; ametlikud SDK-d, Workbench, tüübitud vastused, voogedastuse abifunktsioonid, korduskatsed ja rohked näited vähendavad seadistamise vaeva.

Dokumentatsioon Põhjalik ja üksikasjalik ametlik dokumentatsioon, mis sisaldab API viitelehti, programmeerimiskeeltele kohandatud SDK-juhendeid, funktsioonijuhendeid, migratsioonimärkmeid ja kasutusdokumentatsiooni.

Viivitus Latentsus varieerub sõltuvalt mudelist, töökoormusest, konteksti suurusest, teenusetasemest, piirkonnast ja järjekorra tingimustest. Standardrežiim põhineb parimal jõupingutusel, pakktöötlus on asünkroonne ning sobilike kiire režiimi või prioriteetsete va

Allikad

Viited arendajale

Dokumentatsioon ↗ API juhend ↗ Liivakast ↗

Featuurid

API võimekused

✓ Voogedastus

✓ Funktsioonide kasutamine

✓ Assistants API

✓ Failide üleslaadimine

✓ Veebiotsing

✓ Pildi sisend

✓ Struktureeritud väljund

✓ Liivakast

Lühikirjeldus

Soovitatav otseintegratsioon kasutab Claude API kaudu päringut POST /v1/messages. API toetab olekuta mitmevoorulist sõnumivahetust, süsteemijuhiseid, serveri saadetud sündmustel põhinevat voogedastust, kliendipoolsete tööriistade kasutamist, serveripoolseid tööriistu, sealhulgas veebiotsingut ja veebilehtede laadimist, toetatud mudelite struktureeritud JSON-väljundeid, pildisisendit, PDF- ja dokumenditöötlust, viipade vahemällu salvestamist, sõnumipartiisid, tokenite loendamist ning Files API-t. Claude Managed Agents pakub korduvkasutatavaid versioonitud agente, seansse, keskkondi, tööriistu, oskusi ja MCP-integratsioone, kuid on praegu beetaversioonis ning kasutab beetapäist. Funktsioonide saadavus oleneb mudelist ja platvormist. Otsejuurdepääs Anthropic API-le erineb pilvepõhisest juurdepääsust Amazon Bedrocki, Google Cloudi, Microsoft Foundry ja AWS-i Claude Platformi kaudu.

Näited

API Näited

curl https://api.anthropic.com/v1/messages \
  --header "Authorization: Bearer ${ANTHROPIC_API_KEY}" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-sonnet-5",
    "max_tokens": 1024,
    "system": "You are a concise technical assistant.",
    "messages": [
      {
        "role": "user",
        "content": "Explain how HTTP retries should handle a 429 response."
      }
    ]
  }'

curl https://api.anthropic.com/v1/messages \
  --header "Authorization: Bearer ${ANTHROPIC_API_KEY}" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-sonnet-5",
    "max_tokens": 1024,
    "stream": true,
    "output_config": {
      "format": {
        "type": "json_schema",
        "schema": {
          "type": "object",
          "properties": {
            "answer": {"type": "string"},
            "priority": {"type": "string", "enum": ["low", "medium", "high"]}
          },
          "required": ["answer", "priority"],
          "additionalProperties": false
        }
      }
    },
    "messages": [
      {
        "role": "user",
        "content": "Classify this incident: the API is returning intermittent 429 errors."
      }
    ]
  }' | while IFS= read -r line; do
    case "$line" in
      data:\ {*) printf '%s\n' "$line" ;;
    esac
done

# Install: pip install -U anthropic
import json
import os
import anthropic

client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

try:
    message = client.messages.create(
        model="claude-sonnet-5",
        max_tokens=1024,
        system="You are a concise technical assistant.",
        messages=[
            {"role": "user", "content": "What is an idempotent HTTP request?"},
            {"role": "assistant", "content": "An idempotent request has the same intended effect when repeated."},
            {"role": "user", "content": "Give two API design examples."},
        ],
    )
    text = "\n".join(block.text for block in message.content if block.type == "text")
    print(text)
except anthropic.RateLimitError as exc:
    print(f"Rate limited: {exc}")
except anthropic.APIError as exc:
    print(f"Anthropic API error: {exc}")

print("Request ID:", getattr(message, "_request_id", None))

# Streaming example
with client.messages.stream(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Summarize the benefits of streaming responses."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    print()

# Structured output example
structured = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=512,
    output_config={
        "format": {
            "type": "json_schema",
            "schema": {
                "type": "object",
                "properties": {
                    "summary": {"type": "string"},
                    "severity": {"type": "string", "enum": ["low", "medium", "high"]},
                },
                "required": ["summary", "severity"],
                "additionalProperties": False,
            },
        }
    },
    messages=[{"role": "user", "content": "Classify an API outage that affects 10% of requests."}],
)
json_text = next(block.text for block in structured.content if block.type == "text")
print(json.loads(json_text))

// Install: npm install @anthropic-ai/sdk
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

try {
  const message = await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 1024,
    system: "You are a concise technical assistant.",
    messages: [
      { role: "user", content: "Explain exponential backoff for API clients." },
      { role: "assistant", content: "Exponential backoff increases the delay between retries." },
      { role: "user", content: "Show a simple retry sequence." },
    ],
  });

  const text = message.content
    .filter((block) => block.type === "text")
    .map((block) => block.text)
    .join("\n");
  console.log(text);
} catch (error) {
  if (error instanceof Anthropic.RateLimitError) {
    console.error("Rate limited; retry after the server-provided delay.");
  } else if (error instanceof Anthropic.APIError) {
    console.error(`Anthropic API error: ${error.status} ${error.message}`);
  } else {
    throw error;
  }
}

// Streaming example
const stream = client.messages.stream({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Describe server-sent events in one paragraph." }],
});

stream.on("text", (text) => process.stdout.write(text));
await stream.finalMessage();
process.stdout.write("\n");

// Tool-use example
const toolResponse = await client.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  tools: [
    {
      name: "get_weather",
      description: "Get the current weather for a city.",
      input_schema: {
        type: "object",
        properties: { city: { type: "string" } },
        required: ["city"],
      },
    },
  ],
  messages: [{ role: "user", content: "What is the weather in Boston?" }],
});

for (const block of toolResponse.content) {
  if (block.type === "tool_use") {
    console.log(JSON.stringify({ tool: block.name, input: block.input }));
  }
}

<?php

$apiKey = getenv('ANTHROPIC_API_KEY');
$url = 'https://api.anthropic.com/v1/messages';
$payload = [
    'model' => 'claude-sonnet-5',
    'max_tokens' => 1024,
    'system' => 'You are a concise technical assistant.',
    'messages' => [
        [
            'role' => 'user',
            'content' => 'Explain how to handle transient API failures.'
        ]
    ]
];

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

$raw = curl_exec($ch);
$curlError = curl_error($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($raw === false || $curlError !== '') {
    throw new RuntimeException('Network error: ' . $curlError);
}

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

$text = '';
foreach ($data['content'] ?? [] as $block) {
    if (($block['type'] ?? null) === 'text') {
        $text .= $block['text'];
    }
}

echo $text . PHP_EOL;

// Tool-use request example
$toolPayload = [
    'model' => 'claude-sonnet-5',
    'max_tokens' => 1024,
    'tools' => [[
        'name' => 'get_weather',
        'description' => 'Get the current weather for a city.',
        'input_schema' => [
            'type' => 'object',
            'properties' => ['city' => ['type' => 'string']],
            'required' => ['city']
        ]
    ]],
    'messages' => [[
        'role' => 'user',
        'content' => 'What is the weather in Boston?'
    ]]
];

// Send $toolPayload to the same endpoint, inspect content blocks with type tool_use,
// execute the named function in your application, then send a tool_result message.

Põhimõtted

Andmete kasutus

Anthropicu äriklientidele mõeldud pakkumiste, sealhulgas Anthropic API puhul ei kasutata sisendeid ega väljundeid vaikimisi mudelite treenimiseks. Anthropic võib materjali kasutada juhul, kui klient annab selleks sõnaselgelt nõusoleku, saadab tagasisidet või veateateid või osaleb kohaldatavas arendus- või täiustusprogrammis. Är an thropic kommertskliendid säilitavad oma sisendite ja väljundite õigused vastavalt kohaldatavatele äritingimustele.

Andmete säilitamine

Anthropic märgib, et Anthropic API standardsete sisendite ja väljundite koopiad kustutatakse selle taustsüsteemidest automaatselt 30 päeva jooksul pärast nende vastuvõtmist või genereerimist, välja arvatud õiguslike, kasutuspoliitikast tulenevate, turvalisuse ja lepinguliste erandite korral. Nõuetele vastavad kliendid võivad kokku leppida Zero Data Retentioni (ZDR) kasutamises, kuid ZDR-i sobivus sõltub funktsioonist. Files API kaudu üles laaditud failid säilivad kuni nende kustutamiseni või valikulise aegumiseni, on seotud konkreetse tööruumiga ning nende elutsükkel toimib eraldi.

Päringupiirangud

Organisatsioonipõhised kasutustasemed kehtestavad igakuised kululimiidid ning mudelipõhised RPM-i, sisendtokenite minutis ja väljundtokenite minutis piirangud. Message Batchesi, Files API, veebotsingu ja Managed Agentsi jaoks kehtivad täiendavad piirangud

Arendaja juhend

Anthropic Claude API: algaja juhend arendajaplatvormi kasutamiseks

Anthropicu Claude API on kasutuspõhise hinnastusega arendajaplatvorm, mis põhineb Messages API-l. See võimaldab rakendustel kasutada Claude’i mudeleid teksti genereerimiseks, multimodaalsete sisendite töötlemiseks, struktureeritud JSON-vastuste loomiseks, voogedastuseks, tööriistade kutsumiseks, failide analüüsimiseks, veebiotsinguks, koodi käivitamiseks, MCP-ühenduseks ja agenditöövoogudeks ametlike SDK-de või HTTPS-päringute kaudu.

Anthropicu Claude’i platvorm võimaldab arendajatel lisada Claude’i mudelite võimalused rakendustesse ja teenustesse. Soovitatav lähtekoht on Messages API, mis võtab vastu mudeli, juhised, vestlussõnumid ning valikulised tööriistad või failid ja tagastab seejärel tüübistatud sisublokid. Selles juhendis selgitatakse, kuidas saada juurdepääs, saata esimene päring, mõista vastuseid, hinnata kasutust, kasutada voogedastust ja tööriistu ning hinnata platvormi tootmiskasutusega seotud kompromisse.

Anthropicu Claude’i platvorm pakub Messages API kaudu otse kasutuspõhist juurdepääsu Claude’ile ning toetab SDK-sid, voogedastust, tööriistu, struktureeritud JSON-vormingut, faile, multimodaalset sisendit, veebiotsingut, MCP-d ja agendipõhiseid töövooge.

Mis on Claude API ja millal seda kasutada

Claude API on Anthropicu arendajatele mõeldud otseühendus, mille kaudu saab oma rakendusest Claude'i mudelitele päringuid saata. Peamine lõpp-punkt on Messages API aadressil https://api.anthropic.com/v1/messages. Päring võib sisaldada süsteemijuhiseid, kasutaja ja assistendi sõnumite jada, valikulisi pilte või dokumente ning tööriistu, mille käivitamist võib Claude teie rakenduselt paluda.

API on olekuta: vestlusajaloo säilitamise ja asjakohaste sõnumite iga päringuga saatmise eest vastutab teie rakendus. See muudab API sobivaks vestlusrakendustele, dokumendianalüüsile, kodeerimisassistentidele, struktureeritud andmete eraldamisele, klienditeeninduse töövoogudele ja agentidele, mis kutsuvad väliseid süsteeme.

Kasutage otse-API-t siis, kui soovite juhtida rakenduse loogikat, andmesalvestust, tööriistade käivitamist, autentimist ja juurutamist. Anthropic pakub ka kõrgema taseme võimalusi, näiteks Claude Agent SDK-d ja Claude Managed Agentsi, rakendustele, mis vajavad rohkem hallatud agentide käitamist.

Kellele see mõeldud on?

Platvorm on suunatud arendajatele, kes loovad tootmisteenuseid või prototüüpe, millel on vaja juurdepääsu Claude'i mudelitele. Algajad saavad alustada ühe HTTPS-päringu või ametliku SDK-ga. Kesktaseme arendajad saavad lisada voogedastuse, valideeritud struktureeritud väljundi, taaskasutatavad failid, kliendipoolsed tööriistad, serveripoolsed tööriistad, viipade vahemällu salvestamise, paketttöötluse või MCP-ühenduse.

Juurdepääsu ja mandaadi hankimine

Looge Claude Console'i konto.
Looge Anthropic API-võti.
Salvestage võti keskkonnamuutujasse ANTHROPIC_API_KEY, mitte otse lähtekoodi.
Installige ametlik SDK või saatke API-le HTTPS-päringuid.

Otsepäringud autentitakse päisega x-api-key ja peavad sisaldama päist anthropic-version. SDK-d loevad ANTHROPIC_API_KEY tavaliselt automaatselt. Hoidke võtit serveris või muus kaitstud käituskeskkonnas; ärge avaldage seda brauserikoodis ega avalikes repositooriumides.

API ja mudeli valimine

Uute otseintegratsioonide puhul kasutage vanemate Claude'i lõpetamisstiilis lõpp-punktide asemel Messages API-t. Valige Anthropicu praegusest mudelikataloogist aktiivne mudelitunnus. Mudelite saadavus, võimalused, hinnad ja kasutuselt kõrvaldamise kuupäevad võivad muutuda, seega vältige aegunud mudeli kõvakodeerimist ja vaadake Anthropicu mudelite elutsükli dokumentatsiooni regulaarselt üle.

Mudeli valik mõjutab kulu, vastuse kiirust, konteksti käsitlemist ja saadaolevaid funktsioone. Esitatud uurimismaterjal ei määra üht universaalselt sobivat mudelit ega fikseeritud hinda, seega peaksid rakendused võrdlema aktiivseid mudeleid oma töökoormuse ja eelarvega.

Esimese päringu tegemine

Järgmises töötlemata HTTP-näites kasutatakse kohatäitena mudelitunnust. Asendage active-model-id Anthropicu praegusest kataloogist pärit aktiivse mudeliga.

curl https://api.anthropic.com/v1/messages 
  --header "x-api-key: ${ANTHROPIC_API_KEY}" 
  --header "anthropic-version: 2023-06-01" 
  --header "content-type: application/json" 
  --data '{
    "model": "active-model-id",
    "max_tokens": 512,
    "system": "You are a concise technical assistant.",
    "messages": [
      {
        "role": "user",
        "content": "Explain exponential backoff in three sentences."
      }
    ]
  }'

Päringus määratakse mudel, väljundmärgendite limiit, valikuline süsteemijuhis ja sõnumite massiiv. API-võti loetakse keskkonnast, mis vähendab selle kogemata lähtekoodihoidlasse lisamise riski.

Sama päring Pythoni SDK-ga

Anthropic pakub ametlikke SDK-sid Pythonile, TypeScriptile, C#-ile, Gole, Javale, PHP-le ja Rubyle. Selles näites kasutatakse praegust Pythoni kliendi mustrit.

pip install anthropic

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

response = client.messages.create(
    model="active-model-id",
    max_tokens=512,
    system="You are a concise technical assistant.",
    messages=[
        {"role": "user", "content": "Explain exponential backoff in three sentences."}
    ],
)

print("n".join(
    block.text for block in response.content if block.type == "text"
))

Vastuse mõistmine

Messages API vastus ei ole lihtsalt tavaline tekstistring. See sisaldab sisublokke ja igal plokil on tüüp. Tekstivastused kasutavad tekstiplokke, tööriistapäringud tööriistakasutuse plokke ning muud võimalused võivad luua teist tüüpi plokke. Kood peaks ploki tüüpi kontrollima ja teksti sihipäraselt eraldama.

Lihtsa tekstivastuse puhul valivad rakendused tavaliselt plokid, kus block.type == "text". Tööriistu kasutavad rakendused otsivad selle asemel tööriistakasutuse plokki, käivitavad soovitud funktsiooni ja saadavad tulemuse järgmises kasutaja sõnumis Claude'ile tagasi. Selline sisublokkide ülesehitus võimaldab ühes vastuses esitada mitut tüüpi väljundit.

Kuidas hinnastamine üldjoontes toimib

Claude API hinnastamine põhineb kasutusel. Tasu sõltub üldjuhul valitud mudeli sisend- ja väljundmärgendite hindadest, kusjuures eri mudelitel on erinevad hinnad. Märgend on mudeli töödeldava teksti ühik; täpne arv sõltub sisust ja märgendamisest.

Lisahinnareeglid võivad kehtida viipade vahemällu kirjutamise ja vahemälust lugemise, pika konteksti kasutamise, paketttöötluse ja serveripoolsete tööriistade korral. Message Batches API pakub sobivate töökoormuste puhul soodushinnaga asünkroonset töötlust. Veebiotsing ja muud serveripoolsed tööriistad võivad samuti kaasa tuua funktsioonipõhiseid lisatasusid.

Kuna mudelite hinnad muutuvad ja uurimismaterjal ei esita üht praegust hinda, vaadake kulude hindamisel Anthropicu hinnalehte. Tootmiskeskkonnas registreerige märgendikasutus, mudeli valik, tööriistade tegevus ja päringute maht, et rakenduse tasandi kulu saaks jälgida.

Olulised võimalused

Vastuste voogedastus

Voogedastus saadab vastuse sündmusi nende loomise ajal, selle asemel et oodata kogu sõnumi valmimist. See on kasulik vestlusliidestes ja pikkade vastuste puhul, sest rakendus saab teksti järk-järgult kuvada ning lühendada aega, mille järel kasutaja esimest väljundit näeb.

with client.messages.stream(
    model="active-model-id",
    max_tokens=512,
    messages=[
        {"role": "user", "content": "Explain server-sent events briefly."}
    ],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
print()

HTTP-tasandil kasutab voogedastus serveri saadetud sündmusi. Voogedastusklient peaks töötlema sündmuste tüüpe, mitte eeldama, et iga sündmus sisaldab kuvatavat teksti.

Tööriistade ja funktsioonide kutsumine

Tööriistakasutus võimaldab Claude'il paluda teie rakendusel funktsiooni käivitada. Teie määrate tööriista nime, kirjelduse ja JSON-sisendskeemi. Kood teeb toimingu, näiteks pärib andmebaasi või kutsub ilmateenust, ja saadab tulemuse Claude'ile tagasi. Anthropic toetab ka rangeid tööriistaskeeme tööriistade sisendite valideerimiseks.

tools = [
    {
        "name": "get_weather",
        "description": "Return current weather for a city.",
        "input_schema": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
            "additionalProperties": False,
        },
        "strict": True,
    }
]

response = client.messages.create(
    model="active-model-id",
    max_tokens=512,
    tools=tools,
    messages=[
        {"role": "user", "content": "What is the weather in Boston?"}
    ],
)

for block in response.content:
    if block.type == "tool_use":
        print(block.name, block.input)

Rakendus peab enne soovitud tööriista käivitamist valideerima autoriseerimise, argumendid ja kõrvalmõjud. Mudel ei saa automaatselt luba teie süsteemidele juurde pääseda; teie rakendus otsustab, kas ja kuidas iga soovitud toiming käivitatakse.

Struktureeritud JSON-väljundid

Struktureeritud väljundid võimaldavad rakendusel küsida JSON-teksti, mis järgib etteantud JSON-skeemi. See on kasulik eraldamise, klassifitseerimise ja järgnevate töövoogude puhul, mis vajavad ettearvatavaid välju. Struktureeritud väljund erineb tavalisest JSON-i küsimisest, sest päringus määratakse valideerimiseks skeem.

response = client.messages.create(
    model="active-model-id",
    max_tokens=512,
    output_config={
        "format": {
            "type": "json_schema",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "priority": {"type": "string"}
                },
                "required": ["name", "priority"],
                "additionalProperties": False
            }
        }
    },
    messages=[
        {"role": "user", "content": "Extract: Alex Kim has high priority."}
    ],
)

json_text = next(
    block.text for block in response.content if block.type == "text"
)

Parsimise ja valideerimisega tuleb tagastatud tekst oma rakenduses lõpule jõuda enne selle kasutamist. Range tööriistakasutus valideerib tööriistade sisendid struktureeritud vastuse väljundist eraldi.

Failid, dokumendid ja pildid

Nägemisvõimega Claude'i mudelid saavad vastu võtta pilte toetatud base64-andmete, URL-ide või failiviidete kaudu. Dokumente ja PDF-faile saab samuti edastada otse või Files API kaudu. Files API toetab taaskasutatavate failide üleslaadimist, loendamist, hankimist, allalaadimist ja kustutamist.

Faili aegumiseks saab määrata 3 600 kuni 7 776 000 sekundit ehk 90 päeva. Pärast aegumist ei saa faili sisu enam API kaudu hankida, kuigi metaandmed võivad jääda loetavaks kuni 30 päevaks. Aegumist ei tohiks käsitada kohese ja garanteeritud kustutamise juhtimisvahendina; kustutage tundlikud failid sõnaselgelt, kui neid enam vaja ei ole.

Serveripoolsed tööriistad ja agendifunktsioonid

Sõltuvalt mudelist, kontost, tööriista versioonist ja väljalaskeolekust pakub Anthropic serveripoolseid tööriistu, nagu veebiotsing, veebiandmete hankimine, koodi käitamine, tööriistaotsing, mälu, arvuti kasutamine, brauseri kasutamine ja MCP-ühendus. Platvorm sisaldab ka Claude Agent SDK funktsioone ja Claude Managed Agentsi kõrgema taseme agenditöövoogude jaoks.

Need funktsioonid võivad vähendada rakenduse ehitatava taristu mahtu, kuid toovad kaasa täiendavaid õigusi, kulusid, latentsust ja töökorralduslikke kaalutlusi. Enne funktsioonile ülesehitamist kontrollige selle saadavust ja kehtivaid tingimusi konkreetse konto ja mudeli puhul.

Mänguväljak ja arendajatööriistad

Claude Console pakub kohta API-võtmete loomiseks ja päringutega katsetamiseks. Anthropicu ametlikud SDK-d pakuvad Pythoni, TypeScripti, C#-i, Go, Java, PHP ja Ruby jaoks tüübistatud või vastava keele tavadega kliente, voogedastust, korduskatseid ja veahaldust.

Esimese prototüübi jaoks piisab tavaliselt Console'ist ja lühikesest SDK-skriptist. Tootmiskeskkonnas kasutage keskkonnapõhiseid saladusi, struktureeritud logimist, päringute ja kulude jälgimist, korduskatsete käsitlemist ning tööriistade ja skeemide käitumise teste.

Piirangud ja tootmiskeskkonna kaalutlused

Päringumäärade piiranguid mõõdetakse päringutes minutis, sisendmärgendites minutis ja väljundmärgendites minutis. Piirangud sõltuvad mudelist ja organisatsiooni tasemest. Esitatud dokumentatsiooni kohaselt võivad mitme aktiivse mudeliklassi praegused maksimumid ulatuda 1 000 päringuni minutis, 2 000 000 sisendmärgendini minutis ja 400 000 väljundmärgendini minutis, kuid need näitajad ei ole universaalsed garantiid.

Päringu piiramisel võib 429-vastus sisaldada retry-after ja päringumäära päiseid. Tootmiskliendid peaksid järgima serveri edastatud viivitust, kasutama eksponentsiaalset tagasipöördumist ja jälgima allesjäänud päringute ning märgendite mahtu. Managed Agentsil ja Files API-l on eraldi piirangud.

Latentsus sõltub mudelist, viiba suurusest, väljundi pikkusest, arutlusseadetest, tööriistadest ja teenusetasemest. Voogedastus võib lühendada esimese nähtava väljundini kuluvat aega. Tööriistatsüklid lisavad samuti võrgu edasi-tagasi päringuid ning neil peaksid olema selged ajalõpud, tõrgete käsitlemine ja korduvate kutsungite piirangud.

Privaatsus ja andmekäitlus

Anthropicuga seotud ärilised tingimused sätestavad, et Anthropic ei pruugi oma kommertsteenuste klientide sisul mudelite treenimiseks kasutada. Organisatsioonid peaksid siiski enne tundliku teabe saatmist üle vaatama kehtivad ärilised tingimused, teenusepõhised tingimused, privaatsusdokumentatsiooni, toetatud piirkondade nõuded, säilitusseaded ning võimalikud ettevõtetele mõeldud või null-andmesäilitusega lepingud.

Eelised ja piirangud

Valdkond	Mida arvestada
API ülesehitus	Messages API pakub ühtset alust teksti, multimodaalse sisendi, tööriistade, voogedastuse ja struktureeritud väljundi jaoks.
Arendajakogemus	Ametlikud SDK-d, Console, voogedastuse tugi, korduskatsed ja tüübistatud sisublokid toetavad nii prototüüpe kui ka tootmisteenuseid.
Agenditöövood	Tööriistakasutus, MCP, serveripoolsed tööriistad, Agent SDK ja Managed Agents toetavad üha keerukamaid töövooge.
Kulud	Kasutus põhineb märgenditel, sõltub mudelist ja võib vahemällu salvestamise, partiide, pika konteksti või serveripoolsete tööriistade tõttu suureneda.
Käitamine	Rakendused peavad haldama vestlusajalugu, tööriistade käivitamist, korduskatseid, päringumäärade piiranguid, saladusi, seiret ja mudelite elutsükli muutusi.
Peenhäälestus	Otseplatvorm ei paku praegu üldotstarbelist avalikku peenhäälestuse API-t, seega tuginevad arendajad üldjuhul viipadele, otsingule, tööriistadele, vahemällu salvestamisele, struktureeritud väljunditele ja mudelivalikule.

Millal on Claude API hea või halb valik

API sobib hästi siis, kui rakendus vajab Claude'i juhiste järgimist, pika konteksti töötlemist, arutlemist, kodeerimisabi, dokumendianalüüsi, multimodaalset sisendit, struktureeritud eraldamist, tööriistakasutust või agentide orkestreerimist. See on praktiline valik ka siis, kui meeskond soovib päringu elutsükli üle otsest kontrolli, mitte ainult valmis vestlusliidest.

See võib olla halb valik, kui töökoormus vajab üldotstarbelist avalikku peenhäälestuse API-t, kasutusest sõltumatuid fikseeritud ja etteaimatavaid kulusid, valitud mudelis või kontol puuduvaid võimalusi või täielikult hallatud agendisüsteemi ilma rakendusepoolse tööriistade ja turbehalduseta. Enne lahenduse lõplikku kavandamist kontrollige mudeli saadavust, hindu, päringumäärade piiranguid, säilitustingimusi ja vajalikke serveripoolseid tööriistu.

Usaldusväärse esimese rakenduse jaoks alustage ühe Messages API päringuga, eraldage sisublokid selgesõnaliselt, lisage korduskatsed ja kasutuse jälgimine ning võtke voogedastus, tööriistad, failid või struktureeritud väljund kasutusele alles siis, kui rakendus neid vajab.

Allikad 18