Source: https://ailoot.ai/models/sk/nvidia-riva-translate-4b-instruct-v1-1/
Canonical: https://ailoot.ai/models/sk/nvidia-riva-translate-4b-instruct-v1-1/
Language: sk

# Riva Translate 4B Instruct v1.1

[Markdown](https://ailoot.ai/models/sk/nvidia-riva-translate-4b-instruct-v1-1/index.md) · [JSON](https://ailoot.ai/models/sk/nvidia-riva-translate-4b-instruct-v1-1/facts.json)

## [Riva Translate 4B Instruct v1.1](https://ailoot.ai/models/sk/nvidia-riva-translate-4b-instruct-v1-1/)

Riva-Translate-4B-Instruct-v1.1 od NVIDIA prekladá vety a dokumenty medzi angličtinou a 11 ďalšími jazykmi a regionálnymi variantmi vrátane ruštiny. Podporuje príklady prekladu v požiadavke a kontext až 8K tokenov.

- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `nvidia/riva-translate-4b-instruct-v1.1`](https://ailoot.ai/models/sk/nvidia-riva-translate-4b-instruct-v1-1/#method-0)

O modeli

Tento opis pokrýva možnosti modelu. Dostupné vstupy, výstupy a voľby v Ailoot sú uvedené nižšie pre vybranú metódu.

Riva-Translate-4B-Instruct-v1.1 je špecializovaný model NVIDIA na písomný preklad. Pracuje s jednotlivými vetami aj dokumentmi: prijíma text a vracia text vo zvolenom jazyku. Takýto formát je vhodný pre prekladateľov, marketérov a vývojárov, ktorí pripravujú viacjazyčné materiály.

#### Jazyky a regionálne varianty

Model podporuje 12 jazykov a variantov: angličtinu, nemčinu, európsku a latinskoamerickú španielčinu, francúzštinu, brazílsku portugalčinu, ruštinu, čínštinu so zjednodušeným a tradičným písmom, japončinu, kórejčinu a arabčinu. Pre španielčinu a čínštinu možno samostatne určiť potrebný variant, pričom portugalčina je v tejto verzii zastúpená brazílskym variantom.

Smery prekladu sú usporiadané okolo angličtiny: z angličtiny do uvedených jazykov a späť. Pre ruský text je k dispozícii preklad do angličtiny, pre anglický text do ruštiny. Regionálny variant je súčasťou voľby smeru, preto je vhodné uvádzať ho spolu s jazykom.

#### Ako sa zadáva preklad

V požiadavke sa oddeľuje smer prekladu od samotného materiálu. Systémová správa označuje jazykový pár, používateľská obsahuje zdrojový text. Napríklad `en-ru` zadáva preklad z angličtiny do ruštiny a `ru-en` z ruštiny do angličtiny. Pre európsku španielčinu je k dispozícii `en-es-es`, pre latinskoamerickú `en-es-us`; pre brazílsku portugalčinu `en-pt-br`.

V rámci požiadavky možno odovzdať niekoľko príkladov prekladu. Šablóna dialógu podporuje striedanie používateľského textu a odpovede s prekladom. To umožňuje ukázať dvojicu zdrojového a preloženého textu pred ďalším materiálom. NVIDIA odporúča používať prekladovú šablónu, na ktorej bol model dotrénovaný: výslovne určuje zdrojový a cieľový jazyk.

#### Kontext a konštrukcia

Model obsahuje približne štyri miliardy parametrov a je vytvorený ako Transformer s dekóderom. Základný model vznikol kompresiou a destiláciou a následne prešiel ďalším tréningom na texte, tréningom na príkladoch a optimalizáciou podľa preferencií. Kontext je až 8K tokenov.

#### Čo ovplyvňuje preklad

Kvalita závisí od témy, podmienok úlohy, šumu v zdrojovom texte a dostupného kontextu. V odpovedi sa môžu vyskytnúť gramatické chyby a významové nepresnosti. Spresnenie požiadavky môže pomôcť získať vhodnejší preklad.

Praktická úloha

### Praktická úloha

Technický príklad v angličtine

```
Translate a collection notice into Russian

Translation direction: English to Russian, en-ru. Translate this notice: 'Your repaired kettle is ready for collection at the service desk. Please bring receipt R-204. We will keep it until Friday at 18:00.' Preserve the receipt identifier and the collection deadline. Return only the translated notice.
```

#### Očakávaný výsledok

```
A Russian translation preserving the service-desk location, R-204 and Friday 18:00 deadline.
```

#### Overenie výsledku

```
The translation must not turn the collection deadline into the repair completion time.
```

**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `nvidia/riva-translate-4b-instruct-v1.1`

[`nvidia/riva-translate-4b-instruct-v1.1`](https://ailoot.ai/models/sk/#m=nvidia%2Friva-translate-4b-instruct-v1.1&route=Core&caller=nvidia%2Friva-translate-4b-instruct-v1.1&fmt=chat)

NVIDIA /`nvidia/riva-translate-4b-instruct-v1.1`

### Úvod

Riva-Translate-4B-Instruct-v1.1 od NVIDIA prekladá vety a dokumenty medzi angličtinou a 11 ďalšími jazykmi a regionálnymi variantmi vrátane ruštiny. Podporuje príklady prekladu v požiadavke a kontext až 8K tokenov.

Povolené vstupy

Text

Výsledky

Text

### Dostupné v Ailoot · vstupy a metódy

**Ailoot · OpenAI Chat** `POST /v1/chat/completions`

Vstup

`text`

Výstup

`text`

Kontext

4 096 tokens

Maximálny výstup

1 024 tokens

Výstupný formát

json alebo SSE

| Pole | Typ | Požiadavka | Hodnoty a limity | Predvolené |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožiadavkaPovinné | Hodnoty a limity nvidia/riva-translate-4b-instruct-v1.1 | Predvolené— |
| Pole`messages` | Typ`message[]` | PožiadavkaPovinné | Hodnoty a limity Minimálny počet položiek: 1 | Predvolené— |
| Pole`messages[].role` | Typ`string` | PožiadavkaPovinné | Hodnoty a limity Príklady: system, user, assistant, tool, function Podmienky: Tieto roly sú výslovne zastúpené typmi kompatibility v zdrojovom kóde; presný súbor rolí zostáva závislý od modelu. Závisí od modelu | Predvolené— |
| Pole`messages[].content` | Typ`string\|content_part[]\|null` | PožiadavkaVoliteľné | Hodnoty a limity | Predvolené— |
| Pole`messages[].tool_calls` | Typ`tool_call[]` | PožiadavkaVoliteľné | Hodnoty a limity | Predvolené— |
| Pole`messages[].tool_call_id` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Platí, keď: role=tool; použite skutočne vrátené ID | Predvolené— |
| Pole`messages[].name` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity | Predvolené— |
| Pole`messages[].reasoning_content` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Platí, keď: Posielajte späť skutočne vrátené uvažovanie, ak ho tento model používa | Predvolené— |
| Pole`messages[].reasoning_details` | Typ`object\|array` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`max_tokens` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Minimum: 1 Závisí od modelu | Predvolené— |
| Pole`max_completion_tokens` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Minimum: 1 Závisí od modelu | Predvolené— |
| Pole`stream` | Typ`boolean` | PožiadavkaVoliteľné | Hodnoty a limity | Predvolenéfalse |
| Pole`stream_options.include_usage` | Typ`boolean` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`temperature` | Typ`number` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`top_p` | Typ`number` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`stop` | Typ`string\|string[]` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`tools` | Typ`function_tool[]` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`tools[].type` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`tools[].function.name` | Typ`string` | PožiadavkaPovinné | Hodnoty a limity Platí, keď: poskytnutý nástroj typu funkcia | Predvolené— |
| Pole`tools[].function.description` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity | Predvolené— |
| Pole`tools[].function.parameters` | Typ`JSON_schema` | PožiadavkaVoliteľné | Hodnoty a limity | Predvolené— |
| Pole`tool_choice` | Typ`string\|object` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`response_format` | Typ`object` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`reasoning_effort` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`reasoning` | Typ`object` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`service_tier` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`instructions` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Pole kompatibility | Predvolené— |
| Pole`functions` | Typ`function[]` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`function_call` | Typ`string\|object` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`prompt_cache_options` | Typ`object` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |

Kombinácie vstupných podkladov

**Text** · Text UTF8

`messages[].content`

Parametre a životný cyklus metódy

| Parameter | Špecifikácia |
| --- | --- |
| Parameter`material_types` | Špecifikáciatext |
| Parameter`required` | Špecifikáciamodel, messages |
| Parameter`optional_controls` | Špecifikácianull |
| Parameter`content_type` | Špecifikáciaapplication/json |
| Parameter`text_file_material` | Špecifikáciaskutočný obsah UTF-8 vložený ako text; ID súborov a URLs potrebujú samostatnú presne určenú podporu |

Životný cyklus: `exact retained published method`

Štruktúry metód a ID sú presné; možnosti dodávateľa sa posudzujú oddelene od prijatia požiadavky.

### Cenník

#### Sadzby metód Ailoot

Vstup

0,0001 USD */ 1K*

Výstup

0,0002 USD */ 1K*

Čítanie cache

0,0001 USD */ 1K*

Zápis do cache

0,0001 USD */ 1K*

Zápis do cache, 5 min

0,0001 USD */ 1K tokens*

Ailoot pred požiadavkou rezervuje odhadovanú sumu. Po získaní výsledku vyúčtuje konečný poplatok podľa nameraného využitia. Pri streamovaní sa vyúčtovanie riadi konečným záznamom využitia. [Ako funguje rezervácia a vyúčtovanie →](https://ailoot.ai/docs/sk/billing/reserve/)

### Príklady požiadaviek

#### Ailoot · OpenAI Chat

Príklad textuPython SDKNode.js SDKStreamovanie v jazyku Python

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "nvidia/riva-translate-4b-instruct-v1.1", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```

```python
from openai import OpenAI
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.chat.completions.create(
    model="nvidia/riva-translate-4b-instruct-v1.1",
    messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(resp.to_dict(mode="json"))
```

```js
import OpenAI from "openai";

if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
  model: "nvidia/riva-translate-4b-instruct-v1.1",
  messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";

function saveResult(data, stem = "result") {
  writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
  console.log(JSON.stringify(data, null, 2));
  const saveBlob = (encoded, suffix, label) => {
    const raw = Buffer.from(encoded, "base64");
    const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
    const file = `${stem}-${label}.${ext}`;
    writeFileSync(file, raw); console.log("Saved", file);
  };
  for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
  for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
  for (const [i, item] of (data.output || []).entries()) {
    console.log("Output", i, JSON.stringify(item));
    if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
  }
  for (const [ci, candidate] of (data.candidates || []).entries()) {
    for (const [pi, part] of (candidate.content?.parts || []).entries()) {
      console.log("Candidate/part", ci, pi, JSON.stringify(part));
      const blob = part.inlineData || part.inline_data;
      if (blob?.data) {
        const mime = blob.mimeType || blob.mime_type;
        const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
        saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
      }
    }
  }
}

saveResult(resp);
```

```python
from openai import OpenAI
import os
from pathlib import Path

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

with client.chat.completions.stream(model='nvidia/riva-translate-4b-instruct-v1.1',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
    with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
        for event in stream:
            payload=event.to_dict(mode="json")
            log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
            print(json.dumps(payload,ensure_ascii=False))
    final=stream.get_final_completion()
    save_result(final.to_dict(mode="json"),"stream-result")
```

### Prijať a uložiť výsledky

#### Ailoot · OpenAI Chat

json alebo SSE

##### Uchovať všetky dokončené výsledky

Uložte každú úplnú vrátenú odpoveď, súbor a časť obsahu.

Zachovajte každý variant odpovede a jeho obsah, volania nástrojov a uvažovanie. V SSE zostavujte čiastkové zmeny podľa indexu variantu/nástroja a zachovajte konečný dôvod ukončenia aj údaje o spotrebe.

##### Ak treba overiť pôvodnú odpoveď

Zachovajte ID požiadaviek/odpovedí aj hlavičky. Všeobecná URL na načítanie textovej úlohy nie je poskytnutá.

Polia odpovede

| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |

Chyby a ďalšie kroky

| Odpoveď | Podmienka | Ďalší krok |
| --- | --- | --- |
| Odpoveď400 · `invalid_request_error` | PodmienkaNeplatné povinné polia, reprezentácia materiálu alebo hodnota parametra | Ďalší krokPred novou požiadavkou na vytvorenie opravte uvedené polia. |

### Aliasy

#### Aliasy modelov

**Ailoot** [`nvidia/riva-translate-4b-instruct-v1.1`](https://ailoot.ai/models/sk/#m=nvidia%2Friva-translate-4b-instruct-v1.1&route=Core&caller=nvidia%2Friva-translate-4b-instruct-v1.1&fmt=chat)

#### Aliasy ciest metód

Použite cesty metód uvedené vyššie.

#### Súvisiace ID na volanie

[`nvidia/riva-translate-4b-instruct-v1.1`](https://ailoot.ai/models/sk/#m=nvidia%2Friva-translate-4b-instruct-v1.1&route=Core&caller=nvidia%2Friva-translate-4b-instruct-v1.1&fmt=chat)

FAQ · nvidia/riva-translate-4b-instruct-v1.1

Aké vstupy a výsledky sú dostupné?

`POST /v1/chat/completions` · `nvidia/riva-translate-4b-instruct-v1.1`: `text` → `text`

Aké polia používa požiadavka?

`POST /v1/chat/completions` · `nvidia/riva-translate-4b-instruct-v1.1`: `model`, `messages`, `stream`

Aké limity platia?

`POST /v1/chat/completions` · `nvidia/riva-translate-4b-instruct-v1.1`: `ctx`: `4096`; `max_out`: `1024`; `messages.min_items`: `1`

Pripojte Ailoot k Claude Code, OpenCode, Hermes alebo vlastnej aplikácii.

## Spoločnosť a jej portfólio projektov

Spoločnosť a jej portfólio projektov: milióny zákazníkov; mesačné tržby v miliardách.

## Nakupujte tokeny so zľavou.

Zľava predplatného na pravidelnú prácu. Promo kódy až 50% na nákup tokenov.

Predplatné

Na pravidelné požiadavky vyberte tarifu so zľavou.

Promo kód až 50%

Pri nákupe zadajte kód. Cena sa prepočíta podľa prebiehajúcej akcie.

Výdavky v histórii

Pri každej požiadavke sa uloží model, tokeny a suma.

[Vybrať predplatné](https://ailoot.ai/docs/sk/billing/subscriptions/) · [Zobraziť ceny modelov](https://ailoot.ai/models/sk/)

## Pripojte API k produktu, ktorý predávate.

SaaS, aplikácie a boti podľa ponuky a licenčnej zmluvy Ailoot. Na ďalší predaj požiadajte o licenciu predajcu.

Komerčná aplikácia

Začleňte generovanie textu, obrázkov, videa a zvuku do platených funkcií svojej služby.

Licencia pre predajcu

Pošlite popis projektu a spôsob poskytovania prístupu. Vyžiadajte písomné podmienky použitia a ďalšieho predaja.

Dokumenty na webe

Ponuka, licenčná zmluva a zásady spracovania dát sú dostupné pred pripojením.

[Požiadať o licenciu predajcu](mailto:support@ailoot.ai) · [Ponuka a licenčná zmluva](https://ailoot.ai/legal/offer?lang=sk)

## Ailoot · Spoločnosť a jej portfólio projektov





Ailoot stavia na dlhodobých prevádzkových skúsenostiach, širokej klientskej základni, stabilných službách a priebežnom sledovaní KPI.





Spoločnosť a jej portfólio projektov: milióny zákazníkov; mesačné tržby v miliardách.





Ailoot využíva tieto prevádzkové skúsenosti na poskytovanie prístupu cez API k funkciám AI v produktoch zákazníkov, agentoch, aplikáciách a automatizáciách.