Source: https://ailoot.ai/models/da/qwen-qwen2-vl-72b-instruct/
Canonical: https://ailoot.ai/models/da/qwen-qwen2-vl-72b-instruct/
Language: da

# Qwen2 VL 72B Instruct

[Markdown](https://ailoot.ai/models/da/qwen-qwen2-vl-72b-instruct/index.md) · [JSON](https://ailoot.ai/models/da/qwen-qwen2-vl-72b-instruct/facts.json)

## [Qwen2 VL 72B Instruct](https://ailoot.ai/models/da/qwen-qwen2-vl-72b-instruct/)

Qwen2-VL-72B-Instruct kombinerer tekst, billeder og video til visuelle spørgsmål, dokumentlæsning og flersproget tekst i billeder. Producenten beskriver videoforståelse ud over 20 minutter, dynamisk billedopløsning og integrationer med visuelle agenter; svaret er tekst.

- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `Qwen/Qwen2-VL-72B-Instruct`](https://ailoot.ai/models/da/qwen-qwen2-vl-72b-instruct/#method-0)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `Qwen/Qwen2-VL-72B-Instruct`](https://ailoot.ai/models/da/qwen-qwen2-vl-72b-instruct/#method-1)

Om modellen

Denne beskrivelse dækker modellens funktioner. Tilgængelige input, output og indstillinger i Ailoot står nedenfor for den valgte metode.

Qwen2-VL-72B-Instruct er den instruktionstilpassede 72B-version til billeder og sprog bygget omkring Qwen2. Den modtager tekst sammen med billeder eller video og genererer et tekstsvar. Producenten fremhæver forståelse af billeder med forskellige opløsninger og sideforhold, fortolkning af tekst i billeder, ræsonnementer om synlige relationer og besvarelse af spørgsmål om videoer på over 20 minutter.

Billed- og videoevner

Ved en dokumentside skal du bede om det konkrete indhold, du har brug for: en passage, en tabelrække, en formel eller betingelserne knyttet til et udsagn. Hold siden læsbar, og angiv, om resultatet skal gengive ordlyden, sammenfatte den eller forklare betydningen. Et nyttigt dokumentoutput kan bevare den oprindelige afsnitsmærkning ved siden af det udtrukne indhold. Ved et diagram skal du spørge, hvordan de mærkede elementer hænger sammen, og angive den relation, der skal forklares.

Den dokumenterede videobrug omfatter spørgsmål, dialog og skriftligt indhold baseret på den synlige sekvens. Definér den hændelse eller ændring, der skal undersøges: hvornår et objekt dukker op, hvad der sker før et bestemt trin, eller hvordan en demonstreret handling hænger sammen med en skriftlig procedure. Bed om en ordnet hændelsesbeskrivelse eller en sammenligning mellem de synlige trin og den givne procedure. Producentens udsagn om over 20 minutter beskriver forståelse af lange videoer; det er ikke en fast maksimal videovarighed eller en garanti for, at ethvert råklip passer i en uændret inputkonfiguration.

Brug med visuelle agenter

Udgivelsen positionerer også Qwen2-VL til visuelle agenter forbundet med mobilenheder, robotter og andre værktøjer. Meddelelsen beskriver scenarier med funktionskald og kodefortolker, såsom at producere kode ud fra et diagram eller bruge et visuelt spørgsmål til at anmode om et eksternt opslag. Den omgivende applikation leverer værktøjerne, udfører den foreslåede handling og returnerer resultatet. Modellens tekstsvar alene klikker ikke på et betjeningselement, flytter en enhed eller udfører det genererede program.

En praktisk grænsefladeopgave kan give et skærmbillede og brugerens mål og spørge om det synlige betjeningselement, der er relevant for næste trin, og det grundlag, der støtter valget. Hold observation, foreslået handling og faktisk udførelse som separate dele af arbejdsgangen. Det bruger fokus på visuelle agenter og gør det ønskede resultat konkret nok til, at applikationen kan handle på det.

Flersproget tekst i billeder

Producenten beskriver genkendelse af tekst i billeder på engelsk og kinesisk, de fleste europæiske sprog samt sprog som japansk, koreansk, arabisk og vietnamesisk. En flersproget side kan derfor behandles som en visuel læseopgave. Bed først om den oprindelige transskription, når den præcise ordlyd betyder noget, og derefter en oversættelse eller forklaring på det valgte sprog. Bevar mærkninger og tal frem for at blande genkendelse med en uspecificeret omskrivning.

Dynamisk opløsning og positionsinformation

Qwen2-VL kombinerer en billedencoder med Qwen2-sprogmodellen. Naive Dynamic Resolution omsætter forskellige billedstørrelser til forskellige antal visuelle tokens. Multimodal Rotary Position Embedding adskiller positionsinformation, så modellen kan repræsentere tekstens rækkefølge, todimensionelle billeder samt videoens tidslige og rumlige struktur. Disse funktioner forklarer, hvordan samme familie håndterer en side, flere billeder eller en videosekvens.

Modelkortets billedprocessor dokumenterer et standardinterval på 4 til 16.384 visuelle tokens pr. billede. Applikationen kan justere mindste og største pixelantal og bevare sideforholdet eller bede om dimensioner, der afrundes til et multiplum af 28. Eksempelintervallet 256 til 1.280 tokens er en konfigurerbar illustration, ikke en separat universel billedgrænse. Flere billeddetaljer bruger mere beregning og flere visuelle tokens, så bevar de mærkninger, overskrifter og små objekter, som spørgsmålet kræver, når billedet forberedes.

Forberedelse af input og kontekst

Producenten demonstrerer et enkelt billede, flere billeder, video som en billedsekvens eller lokal fil og samtaler i batch. Billedforberedelse omfatter lokale filer, kodede billeddata og billedreferencer. Kortets videoeksempel bruger en valgt billedfrekvens; det fastlægger ikke én påkrævet samplingfrekvens for alle videoer. Angiv rækkefølge og rolle for flere billeder, og giv de oplysninger, der kræves for at fortolke en sekvens, frem for at behandle uvedkommende videobilleder som én scene.

Den udgivne konfiguration sætter maksimale positioner til 32.768. Visuelt materiale og tekstinstruktioner skal planlægges inden for den faktisk konfigurerede kontekst. Kortets genereringseksempel på 128 tokens er kun en eksempelindstilling; det offentliggør ikke en separat maksimal outputkapacitet. 72B-versionen skal beholde sin egen konfiguration frem for at arve indstillingerne til lang kontekst fra Qwen2.5-VL eller en anden Qwen-model.

Væsentlige begrænsninger

Producenten fastslår udtrykkeligt, at Qwen2-VL ikke forstår lyd i videoer. Talt information skal derfor gives separat, hvis spørgsmålet afhænger af den. Billedtræningsdatasættet beskrives som opdateret til og med juni 2023; det er en oplysning om datasættet, ikke et løfte om aktuel visuel viden.

De dokumenterede begrænsninger omfatter også ufuldstændig genkendelse af bestemte personer eller navngiven immateriel ejendom, vanskeligheder med indviklede instruktioner i flere trin, svag optælling i komplekse scener og begrænsninger i tredimensionelle rumlige ræsonnementer. Når opgaven afhænger af en af disse evner, skal du fokusere spørgsmålet på de nødvendige objekter eller relationer og bevare det visuelle grundlag ved siden af svaret. Tydeligt kildemateriale og et defineret output gør resultatet lettere at undersøge uden at erstatte de angivne begrænsninger med en garanti for nøjagtighed.

Praktisk opgave

### Praktisk opgave

Teknisk eksempel på engelsk

```
Read a supplied document transcription

Use this text transcription of page P2, section Limits: 'Store below 25 C. Once opened, use within seven days. Do not freeze.' Return the original wording first, then a plain-English explanation separating the temperature, time and freezing conditions. Preserve P2 as the source label. No image or video is attached.
```

#### Forventet resultat

```
A labelled transcription followed by three source-grounded explanations of the conditions.
```

#### Kontrollér resultatet

```
Below 25 C is not rewritten as at or below 25 C, and the seven-day period starts at opening.
```

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `Qwen/Qwen2-VL-72B-Instruct`

[`Qwen/Qwen2-VL-72B-Instruct`](https://ailoot.ai/models/da/#m=Qwen%2FQwen2-VL-72B-Instruct&route=Ultra&caller=Qwen%2FQwen2-VL-72B-Instruct&fmt=chat)

Alibaba /`Qwen/Qwen2-VL-72B-Instruct`

### Start

Qwen2-VL-72B-Instruct kombinerer tekst, billeder og video til visuelle spørgsmål, dokumentlæsning og flersproget tekst i billeder. Producenten beskriver videoforståelse ud over 20 minutter, dynamisk billedopløsning og integrationer med visuelle agenter; svaret er tekst.

Accepterede input

Tekst

Resultater

Tekst

### Tilgængelig i Ailoot · input og metoder

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

Inputtyper

`text`

Outputtyper

`text`

Outputformat

json eller SSE

| Felt | Type | Krav | Værdier og grænser | Standard |
| --- | --- | --- | --- | --- |
| Felt`model` | Type`string` | KravPåkrævet | Værdier og grænser Qwen/Qwen2-VL-72B-Instruct | Standard— |
| Felt`messages` | Type`message[]` | KravPåkrævet | Værdier og grænser Minimumsantal elementer: 1 | Standard— |
| Felt`messages[].role` | Type`string` | KravPåkrævet | Værdier og grænser Eksempler: system, user, assistant, tool, function Betingelser: Disse roller er eksplicit repræsenteret i kildekodens kompatibilitetstyper; modellens præcise rollesæt er fortsat modelspecifikt. Afhænger af modellen | Standard— |
| Felt`messages[].content` | Type`string\|content_part[]\|null` | KravValgfrit | Værdier og grænser | Standard— |
| Felt`messages[].tool_calls` | Type`tool_call[]` | KravValgfrit | Værdier og grænser | Standard— |
| Felt`messages[].tool_call_id` | Type`string` | KravValgfrit | Værdier og grænser Gælder når: role=tool; brug det faktisk returnerede ID | Standard— |
| Felt`messages[].name` | Type`string` | KravValgfrit | Værdier og grænser | Standard— |
| Felt`messages[].reasoning_content` | Type`string` | KravValgfrit | Værdier og grænser Gælder når: Send det faktisk returnerede ræsonnement tilbage, når modellen bruger det | Standard— |
| Felt`messages[].reasoning_details` | Type`object\|array` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`max_tokens` | Type`integer` | KravValgfrit | Værdier og grænser Minimum: 1 Afhænger af modellen | Standard— |
| Felt`max_completion_tokens` | Type`integer` | KravValgfrit | Værdier og grænser Minimum: 1 Afhænger af modellen | Standard— |
| Felt`stream` | Type`boolean` | KravValgfrit | Værdier og grænser | Standardfalse |
| Felt`stream_options.include_usage` | Type`boolean` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`temperature` | Type`number` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`top_p` | Type`number` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`stop` | Type`string\|string[]` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`tools` | Type`function_tool[]` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`tools[].type` | Type`string` | KravValgfrit | Værdier og grænser function Afhænger af modellen | Standard— |
| Felt`tools[].function.name` | Type`string` | KravPåkrævet | Værdier og grænser Gælder når: funktionsværktøj angivet | Standard— |
| Felt`tools[].function.description` | Type`string` | KravValgfrit | Værdier og grænser | Standard— |
| Felt`tools[].function.parameters` | Type`JSON_schema` | KravValgfrit | Værdier og grænser | Standard— |
| Felt`tool_choice` | Type`string\|object` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`parallel_tool_calls` | Type`boolean` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`response_format` | Type`object` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`reasoning_effort` | Type`string` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`reasoning` | Type`object` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`service_tier` | Type`string` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`instructions` | Type`string` | KravValgfrit | Værdier og grænser Kompatibilitetsfelt | Standard— |
| Felt`functions` | Type`function[]` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`function_call` | Type`string\|object` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`prompt_cache_options` | Type`object` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`modalities` | Type`string[]` | KravValgfrit | Værdier og grænser text | Standard— |
| Felt`provider` | Type`object` | KravValgfrit | Værdier og grænser Betingelser: provider.options afvises på denne Ultra-tekstrute | Standard— |
| Felt`cache_control.ttl` | Type`string` | KravValgfrit | Værdier og grænser Betingelser: 1h afvises på de faktiske placeringer for promptcaching | Standard— |

Kombinationer af inputmaterialer

**Tekst** · UTF8-tekst

`messages[].content`

Metodeparametre og livscyklus

| Parameter | Kontrakt |
| --- | --- |
| Parameter`content_type` | Kontraktapplication/json |
| Parameter`required` | Kontraktmodel, messages |
| Parameter`material_types` | Kontrakttext |
| Parameter`messages` | Kontraktbeskedarray med strukturen role/content |
| Parameter`file_material` | Kontraktfaktisk UTF-8-dokument indsat som bogstavelig tekst; intet fil-ID udledes |
| Parameter`optional_controls` | Kontraktstream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parameter`control_scope` | Kontraktmodelspecifikt; brugerens funktionsværktøjer er forskellige fra hostede værktøjer |
| Parameter`output_modalities` | Kontrakttext |
| Parameter`hosted_operations` | Kontraktfalse |
| Parameter`multimodal_input_binding` | Kontraktnull |

Livscyklus: `synchronous_or_streamed`

Send det præcise model-ID med messages.

Kontekstlængde er ikke et outputloft.

En tekstfil kan levere bogstavelig tekst; billed-, lyd- og filobjektinput kræver en præcis binding.

### Priser

Tarifoplysninger tilføjer ikke anmodningsmuligheder. Understøttede parametre står ved den valgte metode.

Hurtig tilstand

Ikke angivet Når hurtig tilstand er valgt

flex-tilstand

Ikke angivet Når flex-tilstanden er valgt

Maksimal ræsonneringsindsats

Ikke angivet Når default-justeringen anvendes ved maksimal ræsonneringsindsats

#### Ailoot-takster

#### Priser efter konfiguration

| Konfiguration | Takstplan | Beløb |
| --- | --- | --- |
| KonfigurationGrundtakster for tokens | TakstplanGrundtakst | Beløb Input · Inputtokens **$0.00118** / 1K tokens Output · Outputtokens **$0.00118** / 1K tokens Input · Cachelæsning **$0** / 1K tokens Input · Cacheskrivning **$0** / 1K tokens Input · Cacheskrivning, 1 time **—** / 1K tokens |

Ailoot reserverer et estimeret beløb før en anmodning. Efter resultatet afregnes det endelige beløb ud fra det målte forbrug. Ved streaming bruges den endelige forbrugsregistrering til afregningen. [Sådan fungerer reservation og afregning →](https://ailoot.ai/docs/da/billing/reserve/)

### Eksempelanmodninger

#### Ailoot Ultra · OpenAI Chat

curlPython SDKPython-stream

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "Qwen/Qwen2-VL-72B-Instruct", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')

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
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
    if x.get("message",{}).get("content"): print(x["message"]["content"])
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)
result=client.chat.completions.create(model='Qwen/Qwen2-VL-72B-Instruct',messages=[{"role":"user","content":"Explain observations and hypotheses 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(result.to_dict(mode="json"))
```

```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='Qwen/Qwen2-VL-72B-Instruct',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")
```

### Hent og gem resultater

#### Ailoot Ultra · OpenAI Chat

json eller SSE

##### Behold alle færdige resultater

Gem hvert fuldstændigt returneret svar, hver fil og hver indholdsdel.

Bevar hvert valg og dets indhold, værktøjskald og ræsonnement. Saml i SSE deltaer efter valg-/værktøjsindeks, og bevar den endelige afslutningsårsag og forbrugsoplysningerne.

##### Hvis det oprindelige svar skal kontrolleres

Bevar anmodnings-/svar-ID’er og headere. Der leveres ingen generel URL til at hente tekstjob.

Svarfelter

| Felt | Type |
| --- | --- |
| Felt`choices[].index` | Typeinteger |
| Felt`choices[].message.content` | Typestring\|null |
| Felt`choices[].message.tool_calls` | Typetool\_call\[\] |
| Felt`choices[].message.reasoning_content` | Typestring |
| Felt`choices[].message.reasoning_details` | Typeobject\|array |
| Felt`choices[].finish_reason` | Typestring\|null |
| Felt`usage` | Typeobject |

Fejl og næste trin

| Svar | Betingelse | Næste trin |
| --- | --- | --- |
| Svar400 · `invalid_request_error` | BetingelseUgyldige obligatoriske felter, materialerepræsentation eller parameterværdi | Næste trinRet de angivne felter før en ny oprettelsesanmodning. |

### Aliaser

#### Modelaliaser

**Ailoot Ultra** [`Qwen/Qwen2-VL-72B-Instruct`](https://ailoot.ai/models/da/#m=Qwen%2FQwen2-VL-72B-Instruct&route=Ultra&caller=Qwen%2FQwen2-VL-72B-Instruct&fmt=chat)

#### Aliaser for metodestier

Brug metodestierne vist ovenfor.

#### Relaterede kalder-ID’er

[`Qwen/Qwen2-VL-72B-Instruct`](https://ailoot.ai/models/da/#m=Qwen%2FQwen2-VL-72B-Instruct&route=Ultra&caller=Qwen%2FQwen2-VL-72B-Instruct&fmt=chat)

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `Qwen/Qwen2-VL-72B-Instruct`

[`Qwen/Qwen2-VL-72B-Instruct`](https://ailoot.ai/models/da/#m=Qwen%2FQwen2-VL-72B-Instruct&route=Ultra&caller=Qwen%2FQwen2-VL-72B-Instruct&fmt=messages)

Alibaba /`Qwen/Qwen2-VL-72B-Instruct`

### Start

Qwen2-VL-72B-Instruct kombinerer tekst, billeder og video til visuelle spørgsmål, dokumentlæsning og flersproget tekst i billeder. Producenten beskriver videoforståelse ud over 20 minutter, dynamisk billedopløsning og integrationer med visuelle agenter; svaret er tekst.

Accepterede input

Tekst

Resultater

json · sse

### Tilgængelig i Ailoot · input og metoder

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

Inputtyper

`text`

Outputtyper

`json`, `sse`

Outputformat

JSON eller SSE

| Felt | Type | Krav | Værdier og grænser | Standard |
| --- | --- | --- | --- | --- |
| Felt`model` | Type`string` | KravPåkrævet | Værdier og grænser Qwen/Qwen2-VL-72B-Instruct | Standard— |
| Felt`messages` | Type`message[]` | KravPåkrævet | Værdier og grænser | Standard— |
| Felt`messages[].role` | Type`string` | KravPåkrævet | Værdier og grænser user, assistant | Standard— |
| Felt`messages[].content` | Type`string` | KravPåkrævet | Værdier og grænser | Standard— |
| Felt`max_tokens` | Type`integer` | KravPåkrævet | Værdier og grænser | Standard— |
| Felt`stream` | Type`boolean` | KravValgfrit | Værdier og grænser | Standardfalse |

Kombinationer af inputmaterialer

**Tekst** · UTF-8-tekst

`messages[].content som streng`

Metodeparametre og livscyklus

| Parameter | Kontrakt |
| --- | --- |
| Parameter`content_type` | Kontraktapplication/json |
| Parameter`required` | Kontraktmodel, messages, max\_tokens |
| Parameter`optional_controls` | Kontraktstream |
| Parameter`material_types` | Kontrakttext |
| Parameter`text_file_material` | KontraktLæs det faktiske UTF-8-dokument, og indsæt teksten i det angivne input eller beskedens indholdsstreng. |

Livscyklus: `synchronous_or_streamed`

### Priser

Tarifoplysninger tilføjer ikke anmodningsmuligheder. Understøttede parametre står ved den valgte metode.

Hurtig tilstand

Ikke angivet Når hurtig tilstand er valgt

flex-tilstand

Ikke angivet Når flex-tilstanden er valgt

Maksimal ræsonneringsindsats

Ikke angivet Når default-justeringen anvendes ved maksimal ræsonneringsindsats

#### Ailoot-takster

#### Priser efter konfiguration

| Konfiguration | Takstplan | Beløb |
| --- | --- | --- |
| KonfigurationGrundtakster for tokens | TakstplanGrundtakst | Beløb Input · Inputtokens **$0.00118** / 1K tokens Output · Outputtokens **$0.00118** / 1K tokens Input · Cachelæsning **$0** / 1K tokens Input · Cacheskrivning **$0** / 1K tokens Input · Cacheskrivning, 1 time **—** / 1K tokens |

Ailoot reserverer et estimeret beløb før en anmodning. Efter resultatet afregnes det endelige beløb ud fra det målte forbrug. Ved streaming bruges den endelige forbrugsregistrering til afregningen. [Sådan fungerer reservation og afregning →](https://ailoot.ai/docs/da/billing/reserve/)

### Eksempelanmodninger

#### Ailoot Ultra · Anthropic Messages

Komplet minimalt requestbody i JSONcurl · brug dit UTF-8-dokumentPython · gem hele resultatet

```json
{
  "model": "Qwen/Qwen2-VL-72B-Instruct",
  "max_tokens": 128,
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ],
  "stream": false
}
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'Qwen/Qwen2-VL-72B-Instruct', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
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

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```

```python
import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'Qwen/Qwen2-VL-72B-Instruct', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError

api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
    raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
    with urlopen(request, timeout=120) as response:
        raw = response.read()
        Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
    Path('result.json').write_bytes(error.read())
    Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
    raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```

### Hent og gem resultater

#### Ailoot Ultra · Anthropic Messages

JSON eller SSE

##### Behold alle færdige resultater

Gem hvert fuldstændigt returneret svar, hver fil og hver indholdsdel.

Bevar alle indholdsblokke, ræsonnementssignaturer og faktiske værktøjsbrugs-ID’er. Saml alle SSE-blokdeltaer; den første tekstblok er ikke hele outputtet.

##### Hvis det oprindelige svar skal kontrolleres

Bevar anmodnings-/svar-ID’er og headere. Der leveres ingen generel URL til at hente tekstjob.

Svarfelter

| Felt | Type |
| --- | --- |
| Felt`id` | Typestring |
| Felt`model` | Typestring |
| Felt`content[]` | Typetext\|thinking\|tool\_use\|other content block |
| Felt`stop_reason` | Typestring\|null |
| Felt`usage` | Typeobject |

Fejl og næste trin

| Svar | Betingelse | Næste trin |
| --- | --- | --- |
| Svar400 · `invalid_request_error` | BetingelseUgyldige obligatoriske felter, materialerepræsentation eller parameterværdi | Næste trinRet de angivne felter før en ny oprettelsesanmodning. |

### Aliaser

#### Modelaliaser

**Ailoot Ultra** [`Qwen/Qwen2-VL-72B-Instruct`](https://ailoot.ai/models/da/#m=Qwen%2FQwen2-VL-72B-Instruct&route=Ultra&caller=Qwen%2FQwen2-VL-72B-Instruct&fmt=messages)

#### Aliaser for metodestier

Brug metodestierne vist ovenfor.

#### Relaterede kalder-ID’er

[`Qwen/Qwen2-VL-72B-Instruct`](https://ailoot.ai/models/da/#m=Qwen%2FQwen2-VL-72B-Instruct&route=Ultra&caller=Qwen%2FQwen2-VL-72B-Instruct&fmt=messages)

FAQ · Qwen/Qwen2-VL-72B-Instruct

Hvilke input og resultater er tilgængelige?

`POST /v1/chat/completions` · `Qwen/Qwen2-VL-72B-Instruct`: `text` → `text` `POST /v1/messages` · `Qwen/Qwen2-VL-72B-Instruct`: `text` → `json`, `sse`

Hvilke felter bruger anmodningen?

`POST /v1/chat/completions` · `Qwen/Qwen2-VL-72B-Instruct`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `Qwen/Qwen2-VL-72B-Instruct`: `model`, `messages`, `max_tokens`, `stream`

Hvilke grænser gælder?

`POST /v1/chat/completions` · `Qwen/Qwen2-VL-72B-Instruct`: `messages.min_items`: `1`

Tilslut Ailoot til Claude Code, OpenCode, Hermes eller din egen applikation.

## Virksomheden og dens projektportefølje

Virksomheden og dens projektportefølje: millioner af kunder; månedligt salg for milliarder.

## Køb tokens med rabat.

Abonnementsrabat til regelmæssigt arbejde. Rabatkoder giver op til 50% på tokenkøb.

Abonnement

Vælg et abonnement med rabat til dine regelmæssige anmodninger.

Rabatkode på op til 50%

Indtast koden ved købet. Prisen genberegnes efter den aktuelle kampagne.

Udgifter i historikken

Model, tokens og beløb gemmes for hver anmodning.

[Vælg abonnement](https://ailoot.ai/docs/da/billing/subscriptions/) · [Se modelpriser](https://ailoot.ai/models/da/)

## Tilslut API’et til produktet, du sælger.

SaaS, apps og bots efter Ailoots tilbudsvilkår og licensaftale. Anmod om en forhandlerlicens til videresalg.

Kommerciel applikation

Byg generering af tekst, billeder, video og lyd ind i tjenestens betalte funktioner.

Licens til forhandlere

Send projektbeskrivelse og adgangsmodel. Bed om skriftlige vilkår for anvendelse og videresalg.

Dokumenter på websitet

Tilbudsvilkår, licensaftale og politik for behandling af data kan læses før tilslutning.

[Anmod om forhandlerlicens](mailto:support@ailoot.ai) · [Tilbudsvilkår og licensaftale](https://ailoot.ai/legal/offer?lang=da)

## Ailoot · Virksomheden og dens projektportefølje





Ailoot bygger på solid driftserfaring, en stor kundebase, stabil service og løbende kontrol af KPI.





Virksomheden og dens projektportefølje: millioner af kunder; månedligt salg for milliarder.





Ailoot bruger denne driftserfaring til API-adgang til AI-funktioner i kundernes produkter, agenter, applikationer og automatiseringer.
