Source: https://ailoot.ai/models/sl/gemini-pro-agent/
Canonical: https://ailoot.ai/models/sl/gemini-pro-agent/
Language: sl

# Gemini Pro Agent

[Markdown](https://ailoot.ai/models/sl/gemini-pro-agent/index.md) · [JSON](https://ailoot.ai/models/sl/gemini-pro-agent/facts.json)

## [Gemini Pro Agent](https://ailoot.ai/models/sl/gemini-pro-agent/)

Multimodalni model družbe Google za zahtevne programske naloge, analizo obsežnega gradiva in natančno večstopenjsko delo z orodji.

- [**Ailoot · Anthropic Messages** `POST /v1/messages` `gemini-pro-agent`](https://ailoot.ai/models/sl/gemini-pro-agent/#method-0)
- [**Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent` `gemini-pro-agent`](https://ailoot.ai/models/sl/gemini-pro-agent/#method-1)

O modelu

Ta opis zajema zmožnosti modela. Vhodi, izhodi in možnosti, ki so na voljo v Ailoot, so spodaj navedeni za izbrano metodo.

Gemini 3.1 Pro Preview je namenjen delu z zahtevnim gradivom in nalogam, ki zahtevajo več zaporednih odločitev. Google izpostavlja programsko inženirstvo, uporabo orodij in skladnost odgovorov o dejstvih. Model pomaga analizirati obsežne podatkovne zbirke, celotne programske repozitorije in naloge, pri katerih je besedilo povezano z vizualnim ali zvočnim gradivom.

#### Katere vrste gradiva model razume

Googlove značilnosti navajajo **besedilo, slike, video, zvok in PDF**. V trenutnem katalogu Ailoot API sta za besedilne načine dostopa na vhodu navedena **besedilo in slike**, na izhodu pa besedilo. Video, zvok in PDF niso vključeni v ta nabor vhodov. Dolg kontekst sprejme do **1 048 576 vhodnih tokenov**, besedilni odgovor pa do **65 536 izhodnih tokenov**. Razumevanje slik in zvoka ne pomeni njihovega ustvarjanja: izhod te različice ostaja besedilen.

#### Sklepanje in delo po korakih

Thinking omogoča nameniti dodatno intenzivnost notranjemu sklepanju. V načinu osnovnega modela, ki ga opisuje Google, je običajna raven `high`; na voljo so `low`, `medium` in `high`. Te vrednosti opisujejo Googlov osnovni model; način in razpoložljivost upravljanja prek Ailoot API sta odvisna od izbranega načina dostopa in različice modela. Glavni scenariji vključujejo zahtevno programiranje, razvoj algoritmov, strateško načrtovanje in postopno izboljševanje rešitve. To je posebno koristno, kadar je treba upoštevati več medsebojno povezanih zahtev in se vračati k vmesnim rezultatom.

Zmožnosti modela vključujejo klice funkcij, izvajanje kode in strukturirane odgovore. Podprti so predpomnjenje konteksta, utemeljevanje z iskanjem, Google Maps in uporaba vsebine spletnih naslovov; predvidena je paketna obdelava. Takšen nabor omogoča oblikovanje procesa, v katerem model analizira podatke, izbere naslednje orodje in oblikuje rezultat. Dejanska razpoložljivost vsakega orodja je odvisna od načina dela z modelom.

#### Različica in značilnosti

Kartica se nanaša na predhodno različico `gemini-3.1-pro-preview`. Njena osnova je Gemini 3 Pro. Proizvajalec ločeno označuje različico `gemini-3.1-pro-preview-customtools`, usmerjeno v procese z ukazno lupino in uporabniškimi orodji. Njene prednostne izbire orodij in vedenjske značilnosti niso lastnosti običajne različice Preview.

Za model ostajajo splošne omejitve osnovne linije: odgovori lahko vsebujejo izmišljene podatke, posamezne zahteve pa se izvajajo počasi ali končajo s časovno prekoračitvijo. Večstopenjsko sklepanje, velik kontekst in dostop do podatkov pomagajo pri zahtevni nalogi, vendar vsake ustvarjene ugotovitve ne spremenijo v preverjeno dejstvo.

Praktična naloga

### Praktična naloga

Tehnični primer v angleščini

```
Design a dependency-aware work order

Plan execution for these tasks: A has no dependency; B depends on A; C depends on A; D depends on both B and C. At most two tasks may run together, and each takes one hour. Give the earliest valid schedule, a general scheduling algorithm and a test that catches starting D before C finishes.
```

#### Pričakovani rezultat

```
A time-slot schedule, algorithm pseudocode and a dependency-violation test case.
```

#### Preverjanje rezultata

```
Check that the proposed schedule respects both dependencies and the two-task concurrency limit.
```

**Ailoot · Anthropic Messages** `POST /v1/messages` `gemini-pro-agent`

[`gemini-pro-agent`](https://ailoot.ai/models/sl/#m=gemini-pro-agent&route=Core&caller=gemini-pro-agent&fmt=messages)

Google /`gemini-pro-agent`

### Začetek

Multimodalni model družbe Google za zahtevne programske naloge, analizo obsežnega gradiva in natančno večstopenjsko delo z orodji.

Dovoljeni vhodi

Besedilo · Slike

Rezultati

Besedilo

### Na voljo v Ailoot · vhodi in metode

**Ailoot · Anthropic Messages** `POST /v1/messages`

Vhod

`text`, `image`

Izhod

`text`

Kontekst

1.048.576 tokens

Največji izhod

65.536 tokens

Izhodni format

json ali SSE

| Polje | Vrsta | Zahteva | Vrednosti in omejitve | Privzeto |
| --- | --- | --- | --- | --- |
| Polje`model` | Vrsta`string` | ZahtevaObvezno | Vrednosti in omejitve gemini-pro-agent | Privzeto— |
| Polje`messages` | Vrsta`message[]` | ZahtevaObvezno | Vrednosti in omejitve Najmanjše število elementov: 1 | Privzeto— |
| Polje`messages[].role` | Vrsta`string` | ZahtevaObvezno | Vrednosti in omejitve user, assistant | Privzeto— |
| Polje`messages[].content` | Vrsta`string\|content_block[]` | ZahtevaObvezno | Vrednosti in omejitve | Privzeto— |
| Polje`system` | Vrsta`string\|content_block[]` | ZahtevaIzbirno | Vrednosti in omejitve | Privzeto— |
| Polje`max_tokens` | Vrsta`integer` | ZahtevaObvezno | Vrednosti in omejitve Najmanj: 1 Omejitev velja za: natančna zgornja meja izbranega modela/kartice | Privzeto— |
| Polje`stream` | Vrsta`boolean` | ZahtevaIzbirno | Vrednosti in omejitve | Privzetofalse |
| Polje`temperature` | Vrsta`number` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`top_p` | Vrsta`number` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`stop_sequences` | Vrsta`string[]` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`tools` | Vrsta`tool[]` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`tools[].name` | Vrsta`string` | ZahtevaIzbirno | Vrednosti in omejitve Velja, ko: podano je orodje | Privzeto— |
| Polje`tools[].description` | Vrsta`string` | ZahtevaIzbirno | Vrednosti in omejitve | Privzeto— |
| Polje`tools[].input_schema` | Vrsta`JSON_schema` | ZahtevaIzbirno | Vrednosti in omejitve | Privzeto— |
| Polje`tool_choice` | Vrsta`object` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`thinking.type` | Vrsta`string` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`thinking.budget_tokens` | Vrsta`integer` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`output_config.effort` | Vrsta`string` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`metadata` | Vrsta`object` | ZahtevaIzbirno | Vrednosti in omejitve | Privzeto— |
| Polje`cache_control` | Vrsta`object` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |

Kombinacije vhodnih gradiv

**Besedilo** · Besedilo UTF8

`messages[].content ali blok type=text`

**Besedilo + slika**

`{type:image,source:{type:base64,media_type,data}} ali vir vrste type=url`

Parametri in življenjski cikel metode

| Parameter | Specifikacija |
| --- | --- |
| Parameter`material_types` | Specifikacijatext, image |
| Parameter`required` | Specifikacijamodel, messages, max\_tokens |
| Parameter`optional_controls` | Specifikacijanull |
| Parameter`content_type` | Specifikacijaapplication/json |
| Parameter`text_file_material` | Specifikacijadejanska vsebina UTF-8 je vstavljena kot besedilo; ID datotek in URLs potrebujejo ločeno, natančno določeno podporo |

Življenjski cikel: `exact retained published method`

Strukture metod in ID so natančno določeni; zmožnost ponudnika je ločena od sprejema zahteve.

### Cenik

#### Cene metod Ailoot

Vhod

0,002 $ */ 1K*

Izhod

0,012 $ */ 1K*

Branje predpomnilnika

0,0002 $ */ 1K*

#### Cene glede na dolžino zahteve · Anthropic Messages

| Velikost zahteve, žetoni | Vhod | Izhod | Branje predpomnilnika | Zapis v predpomnilnik | Predpomnilnik 5 min | Predpomnilnik 1 ura |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost zahteve, žetoni(0; 200.000\] | Vhod0,002 $ | Izhod0,012 $ | Branje predpomnilnika0,0002 $ | Zapis v predpomnilnikOsnovna: — | Predpomnilnik 5 minOsnovna: — | Predpomnilnik 1 uraOsnovna: — |
| Velikost zahteve, žetoni(200.000; ∞) | Vhod0,004 $ | Izhod0,018 $ | Branje predpomnilnika0,0004 $ | Zapis v predpomnilnikOsnovna: — | Predpomnilnik 5 minOsnovna: — | Predpomnilnik 1 uraOsnovna: — |

Cene v USD na 1K žetonov. Če cena ni nastavljena, se prevzame osnovna cena te metode; «—» pomeni, da osnovna cena ni nastavljena.

Ailoot pred zahtevo rezervira ocenjeni znesek. Po rezultatu obračuna končni strošek na podlagi izmerjene porabe. Obračun pretakanja uporablja končni zapis porabe. [Kako delujeta rezervacija in obračun →](https://ailoot.ai/docs/sl/billing/reserve/)

### Primeri zahtev

#### Ailoot · Anthropic Messages

Primer besedilaVhod, slikaPython SDKNode.js SDKTok 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": "gemini-pro-agent", "max_tokens": 1024, "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/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -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
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gemini-pro-agent", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
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/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -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
import anthropic
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
    model="gemini-pro-agent",
    max_tokens=1024,
    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(msg.to_dict(mode="json"))
```

```js
import Anthropic from "@anthropic-ai/sdk";

if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
  model: "gemini-pro-agent",
  max_tokens: 1024,
  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(msg);
```

```python
import anthropic,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=anthropic.Anthropic(base_url="https://api.ailoot.ai",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.messages.stream(model='gemini-pro-agent',max_tokens=1024,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_message()
    save_result(final.to_dict(mode="json"),"stream-result")
```

### Prejmi in shrani rezultate

#### Ailoot · Anthropic Messages

json ali SSE

##### Ohrani vse dokončane rezultate

Shranite vsak v celoti vrnjen odgovor, datoteko in del vsebine.

Ohranite vse vsebinske bloke, podpise sklepanja in dejanske ID uporabe orodij. Sestavite vse delne spremembe blokov SSE; prvi besedilni blok ni celoten izhod.

##### Če je treba preveriti izvirni odgovor

Ohranite ID zahtev/odgovorov in glave. Splošni URL za pridobivanje besedilne naloge ni podan.

Polja odgovora

| Polje | Vrsta |
| --- | --- |
| Polje`id` | Vrstastring |
| Polje`model` | Vrstastring |
| Polje`content[]` | Vrstatext\|thinking\|tool\_use\|other content block |
| Polje`stop_reason` | Vrstastring\|null |
| Polje`usage` | Vrstaobject |

Napake in naslednji koraki

| Odgovor | Pogoj | Naslednji korak |
| --- | --- | --- |
| Odgovor400 · `invalid_request_error` | PogojNeveljavna obvezna polja, predstavitev gradiva ali vrednost parametra | Naslednji korakPred novo zahtevo za ustvarjanje popravite navedena polja. |

### Druga imena

#### Druga imena modelov

**Ailoot** [`gemini-pro-agent`](https://ailoot.ai/models/sl/#m=gemini-pro-agent&route=Core&caller=gemini-pro-agent&fmt=messages)

#### Druga imena poti metod

Uporabite zgoraj navedene poti metod.

#### Povezani ID-ji za klic

[`gemini-pro-agent`](https://ailoot.ai/models/sl/#m=gemini-pro-agent&route=Core&caller=gemini-pro-agent&fmt=messages)

**Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent` `gemini-pro-agent`

[`gemini-pro-agent`](https://ailoot.ai/models/sl/#m=gemini-pro-agent&route=Core&caller=gemini-pro-agent&fmt=gemini)

Google /`gemini-pro-agent`

### Začetek

Multimodalni model družbe Google za zahtevne programske naloge, analizo obsežnega gradiva in natančno večstopenjsko delo z orodji.

Dovoljeni vhodi

Besedilo · Slike

Rezultati

Besedilo

### Na voljo v Ailoot · vhodi in metode

**Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent`

Vhod

`text`, `image`

Izhod

`text`

Kontekst

1.048.576 tokens

Največji izhod

65.536 tokens

Izhodni format

json ali podprti pretočni izhod

| Polje | Vrsta | Zahteva | Vrednosti in omejitve | Privzeto |
| --- | --- | --- | --- | --- |
| Polje`path.model` | Vrsta`string` | ZahtevaObvezno | Vrednosti in omejitve gemini-pro-agent | Privzeto— |
| Polje`contents` | Vrsta`content[]` | ZahtevaObvezno | Vrednosti in omejitve Najmanjše število elementov: 1 | Privzeto— |
| Polje`contents[].role` | Vrsta`string` | ZahtevaIzbirno | Vrednosti in omejitve user, model | Privzeto— |
| Polje`contents[].parts` | Vrsta`part[]` | ZahtevaObvezno | Vrednosti in omejitve | Privzeto— |
| Polje`systemInstruction` | Vrsta`content` | ZahtevaIzbirno | Vrednosti in omejitve | Privzeto— |
| Polje`generationConfig.maxOutputTokens` | Vrsta`integer` | ZahtevaIzbirno | Vrednosti in omejitve Najmanj: 1 Odvisno od modela | Privzeto— |
| Polje`generationConfig.temperature` | Vrsta`number` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`generationConfig.topP` | Vrsta`number` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`generationConfig.topK` | Vrsta`integer` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`generationConfig.stopSequences` | Vrsta`string[]` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`generationConfig.thinkingConfig.includeThoughts` | Vrsta`boolean` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`generationConfig.thinkingConfig.thinkingBudget` | Vrsta`integer` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`tools[].functionDeclarations` | Vrsta`function_declaration[]` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`toolConfig.functionCallingConfig.mode` | Vrsta`string` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`safetySettings` | Vrsta`object[]` | ZahtevaIzbirno | Vrednosti in omejitve Odvisno od modela | Privzeto— |
| Polje`sessionId` | Vrsta`string` | ZahtevaIzbirno | Vrednosti in omejitve | Privzeto— |

Kombinacije vhodnih gradiv

**Besedilo** · Besedilo UTF8

`contents[].parts[].text`

**Besedilo + slika**

`parts[].inlineData={mimeType,data}`

Parametri in življenjski cikel metode

| Parameter | Specifikacija |
| --- | --- |
| Parameter`material_types` | Specifikacijatext, image |
| Parameter`required` | Specifikacijacontents |
| Parameter`optional_controls` | Specifikacijanull |
| Parameter`content_type` | Specifikacijaapplication/json |
| Parameter`text_file_material` | Specifikacijadejanska vsebina UTF-8 je vstavljena kot besedilo; ID datotek in URLs potrebujejo ločeno, natančno določeno podporo |

Življenjski cikel: `exact retained published method`

Strukture metod in ID so natančno določeni; zmožnost ponudnika je ločena od sprejema zahteve.

### Cenik

#### Cene metod Ailoot

Vhod

0,002 $ */ 1K*

Izhod

0,012 $ */ 1K*

Branje predpomnilnika

0,0002 $ */ 1K*

#### Cene glede na dolžino zahteve · Gemini generateContent

| Velikost zahteve, žetoni | Vhod | Izhod | Branje predpomnilnika | Zapis v predpomnilnik | Predpomnilnik 5 min | Predpomnilnik 1 ura |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost zahteve, žetoni(0; 200.000\] | Vhod0,002 $ | Izhod0,012 $ | Branje predpomnilnika0,0002 $ | Zapis v predpomnilnikOsnovna: — | Predpomnilnik 5 minOsnovna: — | Predpomnilnik 1 uraOsnovna: — |
| Velikost zahteve, žetoni(200.000; ∞) | Vhod0,004 $ | Izhod0,018 $ | Branje predpomnilnika0,0004 $ | Zapis v predpomnilnikOsnovna: — | Predpomnilnik 5 minOsnovna: — | Predpomnilnik 1 uraOsnovna: — |

Cene v USD na 1K žetonov. Če cena ni nastavljena, se prevzame osnovna cena te metode; «—» pomeni, da osnovna cena ni nastavljena.

Ailoot pred zahtevo rezervira ocenjeni znesek. Po rezultatu obračuna končni strošek na podlagi izmerjene porabe. Obračun pretakanja uporablja končni zapis porabe. [Kako delujeta rezervacija in obračun →](https://ailoot.ai/docs/sl/billing/reserve/)

### Primeri zahtev

#### Ailoot · Gemini generateContent

Primer besedilaVhod, slikaPython SDKNode.js SDKTok 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('{"contents": []}')
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["contents"]=[{"role":"user","parts":[{"text":"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/v1beta/models/gemini-pro-agent:generateContent \
  -H "x-goog-api-key: $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"contents": [{"role": "user", "parts": [{"text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["contents"][0]["parts"].append({"inlineData":{"mimeType":mime,"data":b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1beta/models/gemini-pro-agent:generateContent \
  -H "x-goog-api-key: $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```

```python
from google import genai
from google.genai import types
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = genai.Client(
    api_key=os.environ["AILOOT_API_KEY"],
    http_options=types.HttpOptions(base_url="https://api.ailoot.ai"),
)
resp = client.models.generate_content(model="gemini-pro-agent", contents="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_json_dict())
```

```js
import { GoogleGenAI } from "@google/genai";

if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const ai = new GoogleGenAI({ apiKey: process.env.AILOOT_API_KEY, httpOptions: { baseUrl: "https://api.ailoot.ai" } });
const resp = await ai.models.generateContent({ model: "gemini-pro-agent", contents: "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 google import genai
from google.genai import types
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=genai.Client(api_key=os.environ["AILOOT_API_KEY"],http_options=types.HttpOptions(base_url="https://api.ailoot.ai"))
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))

count=0
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
    for chunk in client.models.generate_content_stream(model='gemini-pro-agent',contents="Explain observations and hypotheses in three sentences."):
        payload=chunk.to_json_dict()
        log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
        save_result(payload,"stream-chunk-"+str(count))
        count+=1
```

### Prejmi in shrani rezultate

#### Ailoot · Gemini generateContent

json ali podprti pretočni izhod

##### Ohrani vse dokončane rezultate

Shranite vsak v celoti vrnjen odgovor, datoteko in del vsebine.

Ohranite vse kandidate in dele, vključno s klici funkcij, podpisi sklepanja in podatki o porabi; dele toka sestavite po vrsti.

##### Če je treba preveriti izvirni odgovor

Ohranite ID zahtev/odgovorov in glave. Splošni URL za pridobivanje besedilne naloge ni podan.

Polja odgovora

| Polje | Vrsta |
| --- | --- |
| Polje`responseId` | Vrstastring |
| Polje`modelVersion` | Vrstastring |
| Polje`candidates[].content.parts[]` | Vrstatext\|inlineData\|functionCall\|other part |
| Polje`candidates[].finishReason` | Vrstastring |
| Polje`usageMetadata` | Vrstaobject |

Napake in naslednji koraki

| Odgovor | Pogoj | Naslednji korak |
| --- | --- | --- |
| Odgovor400 · `invalid_request_error` | PogojNeveljavna obvezna polja, predstavitev gradiva ali vrednost parametra | Naslednji korakPred novo zahtevo za ustvarjanje popravite navedena polja. |

### Druga imena

#### Druga imena modelov

**Ailoot** [`gemini-pro-agent`](https://ailoot.ai/models/sl/#m=gemini-pro-agent&route=Core&caller=gemini-pro-agent&fmt=gemini)

#### Druga imena poti metod

Uporabite zgoraj navedene poti metod.

#### Povezani ID-ji za klic

[`gemini-pro-agent`](https://ailoot.ai/models/sl/#m=gemini-pro-agent&route=Core&caller=gemini-pro-agent&fmt=gemini)

FAQ · Gemini Pro Agent

Kateri vhodi in rezultati so na voljo?

`POST /v1/messages` · `gemini-pro-agent`: `text`, `image` → `text` `POST /v1beta/models/{model}:generateContent` · `gemini-pro-agent`: `text`, `image` → `text`

Katera polja uporablja zahteva?

`POST /v1/messages` · `gemini-pro-agent`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1beta/models/{model}:generateContent` · `gemini-pro-agent`: `contents`, `systemInstruction`, `sessionId`

Katere omejitve veljajo?

`POST /v1/messages` · `gemini-pro-agent`: `ctx`: `1048576`; `max_out`: `65536`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1beta/models/{model}:generateContent` · `gemini-pro-agent`: `ctx`: `1048576`; `max_out`: `65536`; `contents.min_items`: `1`

Ailoot povežite s Claude Code, OpenCode, Hermes ali svojo aplikacijo.

## Podjetje in njegov portfelj projektov

Podjetje in njegov portfelj projektov: milijoni strank; mesečna prodaja v milijardah.

## Žetone kupujte s popustom.

Naročniški popust za redno delo. Promocijske kode prinesejo do 50% popusta na nakup žetonov.

Naročnina

Za redne zahteve izberite paket s popustom.

Promocijska koda do 50%

Kodo vnesite ob nakupu. Cena se preračuna po veljavni akciji.

Poraba v zgodovini

Za vsako zahtevo se shranijo model, žetoni in znesek.

[Izberite naročnino](https://ailoot.ai/docs/sl/billing/subscriptions/) · [Oglejte si cene modelov](https://ailoot.ai/models/sl/)

## API povežite z izdelkom, ki ga prodajate.

SaaS, aplikacije in boti po ponudbi in licenčni pogodbi Ailoot. Za nadaljnjo prodajo zaprosite za preprodajno licenco.

Komercialna aplikacija

Ustvarjanje besedila, slik, videa in zvoka vključite v plačljive funkcije svoje storitve.

Licenca za preprodajalca

Pošljite opis projekta in shemo dostopa. Zahtevajte pisne pogoje uporabe in nadaljnje prodaje.

Dokumenti na strani

Ponudba, licenčna pogodba in politika obdelave podatkov so dostopne pred povezavo.

[Zaprosite za preprodajno licenco](mailto:support@ailoot.ai) · [Ponudba in licenčna pogodba](https://ailoot.ai/legal/offer?lang=sl)

## Ailoot · Podjetje in njegov portfelj projektov





Ailoot temelji na pridobljenih operativnih izkušnjah, široki bazi strank, stabilni storitvi in stalnem spremljanju KPI.





Podjetje in njegov portfelj projektov: milijoni strank; mesečna prodaja v milijardah.





Ailoot te operativne izkušnje uporablja za dostop prek API do funkcij umetne inteligence v izdelkih strank, agentih, aplikacijah in avtomatizacijah.