Todos os produtos
Search
Central de documentação

Alibaba Cloud Model Studio:API de embedding multimodal

Última atualização: Jun 30, 2026

Os modelos de embedding multimodal convertem texto, imagens e vídeos em embeddings em um espaço semântico compartilhado para permitir recuperação entre modalidades, classificação de conteúdo e busca por similaridade.

Capacidades principais

  • Recuperação entre modalidades: Execute buscas semânticas em diferentes tipos de conteúdo, como texto para imagem, imagem para vídeo ou imagem para imagem.

  • Similaridade semântica: Meça a similaridade semântica entre diferentes tipos de conteúdo em um espaço de embedding unificado.

  • Classificação e agrupamento de conteúdo: Agrupe, rotule e organize conteúdos com base em embeddings semânticos.

Recurso principal : Os embeddings de todas as modalidades (texto, imagens e vídeo) compartilham o mesmo espaço semântico, permitindo correspondência e comparação direta entre modalidades por métodos como similaridade de cosseno. Consulte embedding de texto e multimodal para obter detalhes sobre seleção e uso de modelos.
Importante

Este serviço de modelo está disponível apenas na região China (Beijing). Para chamar o serviço, use uma chave de API dessa região.

Tipos de embedding

O modelo de embedding multimodal oferece dois métodos para gerar embeddings:

  • Embedding multimodal independente: Gera um embedding separado para cada entrada, como texto, imagem, vídeo ou múltiplas imagens, dentro de contents. Por exemplo, uma entrada com uma string de texto e uma imagem retorna dois embeddings independentes. Essa abordagem é ideal para comparar itens individuais, como em buscas de imagem para imagem ou texto para imagem.

  • Embedding multimodal fundido: Combina todas as entradas em contents em um único embedding para obter uma representação semântica unificada entre modalidades. Indicado para cenários que exigem compreensão holística do conteúdo multimodal, como a fusão da imagem de um produto com sua descrição textual em uma representação única para recuperação. Para qwen3-vl-embedding, ative a fusão definindo enable_fusion=true. O embedding fundido aceita as seguintes combinações:

    • Fusão de texto e imagem

    • Fusão de texto e vídeo

    • Fusão de múltiplas imagens com texto (passando várias entradas image)

    • Fusão de imagens, vídeo e texto

qwen2.5-vl-embedding suporta apenas embeddings fundidos, não aceitando embeddings independentes. tongyi-embedding-vision-plus e tongyi-embedding-vision-flash suportam somente embeddings independentes.

Para apresentações de modelos, orientações de seleção e instruções de uso, consulte Embedding de texto e multimodal.

Visão geral dos modelos

China (Beijing)

Modelo

Dimensões do embedding

Limite de comprimento de texto

Limite de tamanho de imagem

Limite de tamanho de vídeo

Preço (por 1.000 tokens)

Cota gratuita (Nota)

qwen3-vl-embedding

2560 (padrão), 2048, 1536, 1024, 768, 512, 256

32.000 tokens

Até 10 MB por imagem

Até 50 MB por arquivo de vídeo

Imagem/Vídeo: CNY 0,0018

Texto: CNY 0,0007

1 milhão de tokens

Esta cota gratuita expira 90 dias após a ativação do Model Studio.

qwen2.5-vl-embedding

2048, 1024 (padrão), 768, 512

Até 5 MB por imagem

tongyi-embedding-vision-plus-2026-03-06

1152 (padrão), 1024, 512, 256, 128, 64

1.024 tokens

Recomendado: até 5 MB por imagem; máximo: 10 MB. Suporta até 64 imagens.

Até 50 MB por arquivo de vídeo

A codificação do vídeo deve ser H.264 ou H.265.

CNY 0,0005

tongyi-embedding-vision-flash-2026-03-06

768 (padrão), 512, 256, 128, 64

CNY 0,00015

tongyi-embedding-vision-plus

1152

Até 3 MB por imagem. Suporta até 8 imagens.

Até 10 MB por arquivo de vídeo

CNY 0,0005

tongyi-embedding-vision-flash

768

CNY 0,00015

multimodal-embedding-v1

1.024

512 tokens

Até 3 MB por imagem

Até 10 MB por arquivo de vídeo

Imagem/Vídeo: CNY 0,0009

Texto: CNY 0,0007

Singapore

Modelo

Dimensões do embedding

Limite de comprimento de texto

Limite de tamanho de imagem

Limite de tamanho de vídeo

Preço (por 1.000 tokens)

Singapore

Modelo

Dimensões do embedding

Limite de comprimento de texto

Limite de tamanho de imagem

Limite de tamanho de vídeo

Preço (por 1 milhão de tokens)

Cota gratuita (Nota)

tongyi-embedding-vision-plus

1152

1.024 tokens

Até 3 MB por imagem. Suporta até 8 imagens.

Até 10 MB por arquivo de vídeo

Imagem/Vídeo: $0,09

Texto: $0,09

1 milhão de tokens

Esta cota gratuita expira 90 dias após a ativação do Model Studio.

tongyi-embedding-vision-flash

768

Imagem/Vídeo: $0,03

Texto: $0,09

China (Beijing)

Modelo

Dimensões do embedding

Limite de comprimento de texto

Limite de tamanho de imagem

Limite de tamanho de vídeo

Preço (por 1 milhão de tokens)

qwen3-vl-embedding

2560 (padrão), 2048, 1536, 1024, 768, 512, 256

32.000 tokens

Até 1 imagem com tamanho máximo de 5 MB

Até 50 MB por arquivo de vídeo

Imagem/Vídeo: $0,258

Texto: $0,1

multimodal-embedding-v1

1024

512 tokens

Até 8 imagens, com tamanho máximo de 3 MB cada.

Até 10 MB por arquivo de vídeo

Teste gratuito

Formatos de entrada e limites de uso

Modelo multimodal fundido

Modelo

Texto

Imagem

Vídeo

Limite da requisição

qwen3-vl-embedding

Suporta 33 idiomas principais, como chinês, inglês, japonês, coreano, francês e alemão.

Todos os idiomas suportados

Chinês, japonês, coreano, indonésio, vietnamita, tailandês, inglês, francês, alemão, russo, português, espanhol, italiano, sueco, dinamarquês, tcheco, norueguês, holandês, finlandês, turco, polonês, suaíli, romeno, sérvio, grego, cazaque, uzbeque, cebuano, árabe, urdu, persa, hindi/devanágari e hebraico.

JPEG, PNG, WEBP, BMP, TIFF, ICO, DIB, ICNS e SGI (URL ou Base64 suportados)

MP4, AVI e MOV (somente URL)

O número total de elementos de conteúdo em uma única requisição não pode exceder 20. A quantidade de imagens não pode ultrapassar 5. Imagens, texto e vídeos compartilham esse limite.

Modelo multimodal independente

Modelo

Texto

Imagem

Vídeo

Limite da requisição

tongyi-embedding-vision-plus

Chinês/Inglês

JPG, PNG e BMP (URL ou Base64 suportados)

MP4, MPEG, AVI, MOV, MPG, WEBM, FLV e MKV (somente URL)

Não há limite para o número de elementos de conteúdo. O total de tokens de entrada não deve exceder o limite de tokens.

tongyi-embedding-vision-flash

multimodal-embedding-v1

O número total de elementos de conteúdo em uma única requisição não pode exceder 20. Uma requisição pode conter no máximo 1 imagem, 1 vídeo e 20 entradas de texto. Esses itens compartilham o limite total.

Todos os modelos aceitam entradas de texto, imagem e vídeo, individualmente ou combinadas. Os modelos tongyi-embedding-vision-plus , tongyi-embedding-vision-flash também suportam multi_images para sequências de imagens.

Capacidades dos modelos

Modelo

Dimensão padrão

Tipo de vetor

Entradas suportadas

Descrição

qwen3-vl-embedding

2560

Independente / Fundido

texto, imagem, vídeo, múltiplas imagens

O modo de fusão, ativado pelo parâmetro enable_fusion, combina entradas multimodais em um único vetor.

tongyi-embedding-vision-plus

1152

Somente independente

Suporta sequências multi_images (até 8 imagens).

tongyi-embedding-vision-flash

768

multimodal-embedding-v1

1024

texto, imagem, vídeo

A dimensão do vetor é fixa em 1.024 e não pode ser configurada.

Pré-requisitos

Obtenha uma chave de API e exporte a chave de API como variável de ambiente. Se você usar um SDK para fazer chamadas, instale o DashScope SDK.

Chamada HTTP

POST https://dashscope.aliyuncs.com/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding

Requisição

Embedding multimodal independente

O exemplo abaixo usa o modelo tongyi-embedding-vision-plus para gerar um embedding independente para cada entrada. Substitua o nome do modelo por outro compatível. O tipo multi_images é suportado apenas por tongyi-embedding-vision-plus e tongyi-embedding-vision-flash. O modelo qwen3-vl-embedding também aceita um modo de embedding fundido, ativado ao definir enable_fusion=true. Para mais detalhes, consulte a aba "Embedding multimodal fundido".
curl --silent --location --request POST 'https://dashscope.aliyuncs.com/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding' \
        --header "Authorization: Bearer $DASHSCOPE_API_KEY" \
        --header 'Content-Type: application/json' \
        --data '{
            "model": "tongyi-embedding-vision-plus",
            "input": {
                "contents": [ 
                    {"text": "Multimodal embedding model"},
                    {"image": "https://img.alicdn.com/imgextra/i3/O1CN01rdstgY1uiZWt8gqSL_!!6000000006071-0-tps-1970-356.jpg"},
                    {"video": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250107/lbcemt/new+video.mp4"},
                    {"multi_images": [
                        "https://img.alicdn.com/imgextra/i2/O1CN019eO00F1HDdlU4Syj5_!!6000000000724-2-tps-2476-1158.png",
                        "https://img.alicdn.com/imgextra/i2/O1CN01dSYhpw1nSoamp31CD_!!6000000005089-2-tps-1765-1639.png"
                        ]
                      }
                ]
            }
        }'

Embedding multimodal fundido

O modelo qwen3-vl-embedding suporta geração de embedding fundido. Defina enable_fusion=true para combinar todas as entradas em um único embedding. Isso permite diversas combinações, como texto e imagem, texto e vídeo, múltiplas imagens e texto, ou uma mistura de imagem, vídeo e texto. O exemplo a seguir mostra a fusão de múltiplas imagens, um vídeo e texto.
curl --location 'https://dashscope.aliyuncs.com/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding' \
        --header "Authorization: Bearer $DASHSCOPE_API_KEY" \
        --header 'Content-Type: application/json' \
        --data '{
            "model": "qwen3-vl-embedding",
            "input": {
                "contents": [
                    {"text": "Product description text"},
                    {"image": "https://dashscope.oss-cn-beijing.aliyuncs.com/images/256_1.png"},
                    {"image": "https://img.alicdn.com/imgextra/i3/O1CN01rdstgY1uiZWt8gqSL_!!6000000006071-0-tps-1970-356.jpg"},
                    {"video": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250107/lbcemt/new+video.mp4"}
                ]
            },
            "parameters": {
                "enable_fusion": true
            }
        }'

Cabeçalhos da requisição

Content-Type string (Obrigatório)

O tipo de conteúdo da requisição. Deve ser application/json.

Authorization string (Obrigatório)

Autentica a requisição com uma chave de API do Model Studio. Exemplo: Bearer sk-xxxx.

Corpo da requisição

model string(obrigatório)

Nome do modelo. Selecione um modelo na Visão geral dos modelos.

input object (obrigatório)

Conteúdo de entrada.

Propriedades

contents array(obrigatório)

Itens de conteúdo a serem processados. Cada item é um dicionário ou string que especifica o tipo e o valor do conteúdo no formato {"modality_type": "input_string_or_image/video_url"}. Os tipos de modalidade suportados são text, image, video e multi_images.

O modelo qwen3-vl-embedding suporta geração de embeddings fundidos e independentes. Para gerar um embedding fundido, adicione o campo booleano enable_fusion e defina-o como true. O modelo qwen2.5-vl-embedding aceita apenas embeddings fundidos.
  • Texto: A chave é text e o valor é uma string. Também é possível passar a string diretamente sem um dicionário.

  • Imagem: Use a chave image. O valor pode ser uma URL pública ou um Data URI codificado em Base64. O formato Base64 é data:image/{format};base64,{data}, onde {format} é o formato da imagem, como jpeg ou png, e {data} é a string codificada em Base64.

  • Múltiplas imagens: Este tipo é suportado apenas pelos modelos tongyi-embedding-vision-plus, tongyi-embedding-vision-flash. A chave é multi_images e o valor é uma lista de imagens. Cada item da lista deve seguir o formato descrito acima.

  • Vídeo: A chave é video. O valor deve ser uma URL publicamente acessível.

parameters object (opcional)

Parâmetros de processamento de embedding. Para chamadas HTTP, envolva esses parâmetros no objeto parameters. Em chamadas via SDK, use-os diretamente.

Propriedades

output_type string (opcional)

Formato da representação do embedding de saída. Atualmente, apenas dense é suportado.

dimension integer (opcional)

Dimensão do embedding de saída. Os valores suportados variam conforme o modelo:

  • qwen3-vl-embedding: Suporta 2560, 2048, 1536, 1024, 768, 512 e 256. O padrão é 2560.

  • tongyi-embedding-vision-plus: Não suporta este parâmetro. Retorna um embedding fixo de 1152 dimensões.

  • tongyi-embedding-vision-flash: Não suporta este parâmetro. Retorna um embedding fixo de 768 dimensões.

  • multimodal-embedding-v1: Não suporta este parâmetro. Retorna um embedding fixo de 1024 dimensões.

fps float (opcional)

Taxa de amostragem de quadros de vídeo. Um valor menor extrai menos quadros. O intervalo válido é [0, 1], sendo o padrão 1,0.

instruct string (opcional)

Descrição personalizada da tarefa para ajudar o modelo a entender a intenção da consulta. Recomenda-se o uso de instruções em inglês, que podem melhorar o desempenho em 1% a 5%.

enable_fusion bool (opcional)

Especifique se um embedding fundido deve ser gerado. Este parâmetro é suportado apenas pelo modelo qwen3-vl-embedding. Quando definido como true, todo o conteúdo multimodal no array contents é fundido em um único embedding. O valor padrão é false, que gera um embedding independente para cada modalidade. Embeddings fundidos aceitam combinações como texto e imagem, texto e vídeo, múltiplas imagens e texto (passando vários itens de imagem) e uma mistura de imagem, vídeo e texto. Essa opção é adequada para cenários de recuperação que exigem compreensão abrangente do conteúdo multimodal.

Resposta

Resposta bem-sucedida

{
    "output": {
        "embeddings": [
            {
                "index": 0,
                "embedding": [
                    -0.026611328125,
                    -0.016571044921875,
                    -0.02227783203125,
                    ...
                ],
                "type": "text"
            },
            {
                "index": 1,
                "embedding": [
                    0.051544189453125,
                    0.007717132568359375,
                    0.026611328125,
                    ...
                ],
                "type": "image"
            },
            {
                "index": 2,
                "embedding": [
                    -0.0217437744140625,
                    -0.016448974609375,
                    0.040679931640625,
                    ...
                ],
                "type": "video"
            }
        ]
    },
    "usage": {
        "input_tokens": 10,
        "input_tokens_details": {
            "image_tokens": 896,
            "text_tokens": 7
        },
        "output_tokens": 3,
        "total_tokens": 906
    },
    "request_id": "1fff9502-a6c5-9472-9ee1-73930fdd04c5"
}
Nota

O campo usage varia conforme o modelo. Veja as descrições abaixo:

  • Modelos da série tongyi-embedding-vision-*: Retornam input_tokens (soma de tokens de texto e imagem), input_tokens_details (incluindo image_tokens e text_tokens), output_tokens e total_tokens. O exemplo de resposta acima refere-se a este tipo de modelo.

  • qwen3-vl-embedding: Retorna apenas input_tokens (somente tokens de texto, incluindo tokens de modelo do sistema), image_tokens e total_tokens (= input_tokens + image_tokens). Não retorna input_tokens_details nem output_tokens. Exemplo:

{
    "usage": {
        "input_tokens": 43,
        "image_tokens": 1247,
        "total_tokens": 1290
    }
}
Nota
  • qwen2.5-vl-embedding: Retorna apenas input_tokens e image_tokens. Não retorna total_tokens, input_tokens_details ou output_tokens.

  • multimodal-embedding-v1: Retorna input_tokens, image_tokens, image_count e duration. Não retorna total_tokens, input_tokens_details ou output_tokens.

Resposta de erro

{
    "code":"InvalidApiKey",
    "message":"Invalid API-key provided.",
    "request_id":"fb53c4ec-1c12-4fc4-a580-cdb7c3261fc1"
}

output object

Saída da tarefa.

Propriedades

embeddings array

Lista dos embeddings resultantes, onde cada objeto corresponde a um elemento de entrada.

Propriedades

index int

Índice do resultado na lista de entrada.

embedding array

A dimensão do array de embeddings gerado depende do modelo e do parâmetro dimension.

type string

Tipo de entrada para este resultado. text, image, video e multi_images correspondem a entradas de texto, imagem, vídeo e múltiplas imagens, respectivamente. Tipos especiais incluem: fusion é o tipo retornado pelo modelo qwen3-vl-embedding no modo de embedding fundido; vl é o tipo retornado pelo modelo qwen3-vl-embedding no modo de embedding independente.

request_id string

Identificador único da requisição para rastreamento e solução de problemas.

code string

Código de erro. Retornado apenas para requisições com falha. Consulte Códigos de erro.

message string

Mensagem de erro detalhada. Retornada apenas para requisições com falha. Consulte Códigos de erro.

usage object

Estatísticas sobre o uso de tokens.

Propriedades

input_tokens int

Número de tokens no conteúdo de entrada da requisição atual. Para os modelos qwen3-vl-embedding e qwen2.5-vl-embedding, este valor inclui apenas tokens de texto (incluindo tokens de modelo do sistema) e não abrange tokens de imagem ou vídeo. Nos modelos da série tongyi-embedding-vision-*, este valor representa o total de tokens de texto, imagem e vídeo.

input_tokens_details object

Detalhamento dos tokens de entrada. Este campo é retornado apenas pelos modelos da série tongyi-embedding-vision-*. Não é retornado pelos modelos qwen3-vl-embedding, qwen2.5-vl-embedding ou multimodal-embedding-v1.

Propriedades

image_tokens int

Número de tokens referentes às imagens ou vídeos de entrada.

text_tokens int

Número de tokens referentes ao texto de entrada.

output_tokens int

Número de tokens na saída da requisição atual. Este campo é retornado apenas pelos modelos da série tongyi-embedding-vision-*.

total_tokens int

Total de tokens de entrada e saída. Este campo é retornado pelos modelos qwen3-vl-embedding e tongyi-embedding-vision-*, mas não por qwen2.5-vl-embedding ou multimodal-embedding-v1. Para o modelo qwen3-vl-embedding, total_tokens = input_tokens + image_tokens.

image_tokens int

Número de tokens das imagens ou vídeos de entrada na requisição atual. O sistema amostra quadros dos vídeos de entrada, com o número máximo controlado pela configuração do sistema, e calcula os tokens com base no resultado processado. Este campo é retornado como campo de nível superior apenas pelos modelos qwen3-vl-embedding, qwen2.5-vl-embedding e multimodal-embedding-v1. Nos modelos da série tongyi-embedding-vision-*, a contagem de tokens de imagem está incluída em input_tokens_details.image_tokens.

image_count int

Número de imagens na entrada da requisição atual. Este campo é retornado apenas pelo modelo multimodal-embedding-v1.

duration int

Duração do vídeo de entrada em segundos. Este campo é retornado apenas pelo modelo multimodal-embedding-v1.

Uso do SDK

O parâmetro input do SDK mapeia para input.contents no corpo da requisição HTTP, mas suas estruturas são diferentes .

Exemplos de código

Image embedding

Image URL

import dashscope
import json
from http import HTTPStatus
# Replace with your image URL.
image = "https://dashscope.oss-cn-beijing.aliyuncs.com/images/256_1.png"
input = [{'image': image}]
# Call the model API.
resp = dashscope.MultiModalEmbedding.call(
    model="tongyi-embedding-vision-plus",
    input=input
)

if resp.status_code == HTTPStatus.OK:
    result = {
        "status_code": resp.status_code,
        "request_id": getattr(resp, "request_id", ""),
        "code": getattr(resp, "code", ""),
        "message": getattr(resp, "message", ""),
        "output": resp.output,
        "usage": resp.usage
    }
    print(json.dumps(result, ensure_ascii=False, indent=4))

Local image

Para gerar um embedding a partir de uma imagem local, converta a imagem para uma string Base64:

import dashscope
import base64
import json
from http import HTTPStatus
# Read the image and convert it to Base64. Replace xxx.png with your image file.
image_path = "xxx.png"
with open(image_path, "rb") as image_file:
    # Read the file and convert it to Base64.
    base64_image = base64.b64encode(image_file.read()).decode('utf-8')
# Set the image format.
image_format = "png"  # Change this to your image's format (e.g., jpg, bmp).
image_data = f"data:image/{image_format};base64,{base64_image}"
# Input data
input = [{'image': image_data}]

# Call the model API.
resp = dashscope.MultiModalEmbedding.call(
    model="tongyi-embedding-vision-plus",
    input=input
)
if resp.status_code == HTTPStatus.OK:
    result = {
        "status_code": resp.status_code,
        "request_id": getattr(resp, "request_id", ""),
        "code": getattr(resp, "code", ""),
        "message": getattr(resp, "message", ""),
        "output": resp.output,
        "usage": resp.usage
    }
    print(json.dumps(result, ensure_ascii=False, indent=4))

Video embedding

Atualmente, o modelo aceita entrada de vídeo apenas via URL. Arquivos de vídeo locais não são suportados.
import dashscope
import json
from http import HTTPStatus
# Replace with your video URL.
video = "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250107/lbcemt/new+video.mp4"
input = [{'video': video}]
# Call the model API.
resp = dashscope.MultiModalEmbedding.call(
    model="tongyi-embedding-vision-plus",
    input=input
)

if resp.status_code == HTTPStatus.OK:
    result = {
        "status_code": resp.status_code,
        "request_id": getattr(resp, "request_id", ""),
        "code": getattr(resp, "code", ""),
        "message": getattr(resp, "message", ""),
        "output": resp.output,
        "usage": resp.usage
    }
    print(json.dumps(result, ensure_ascii=False, indent=4))
    

Text embedding

import dashscope
import json
from http import HTTPStatus

text = "General multimodal representation model example"
input = [{'text': text}]
# Call the model API.
resp = dashscope.MultiModalEmbedding.call(
    model="tongyi-embedding-vision-plus",
    input=input
)

if resp.status_code == HTTPStatus.OK:
    result = {
        "status_code": resp.status_code,
        "request_id": getattr(resp, "request_id", ""),
        "code": getattr(resp, "code", ""),
        "message": getattr(resp, "message", ""),
        "output": resp.output,
        "usage": resp.usage
    }
    print(json.dumps(result, ensure_ascii=False, indent=4))

Fused embedding

import dashscope
import json
import os
from http import HTTPStatus

# Fuses text, image, and video into a single fused embedding.
# Ideal for use cases like cross-modal retrieval and image search.
text = "This is a test text for generating a multimodal fused embedding."
image = "https://dashscope.oss-cn-beijing.aliyuncs.com/images/256_1.png"
video = "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250107/lbcemt/new+video.mp4"

# Input includes text, image, and video. Set enable_fusion=True to generate a fused embedding.
input_data = [
    {"text": text},
    {"image": image},
    {"video": video}
]

resp = dashscope.MultiModalEmbedding.call(
    # If the environment variable is not set, provide your Model Studio API key, e.g., api_key="sk-xxx".
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model="qwen3-vl-embedding",
    input=input_data,
    enable_fusion=True,
    # Optional: Specify the embedding dimension. Valid values: 2560, 2048, 1536, 1024, 768, 512, and 256. Default: 2560.
    # parameters={"dimension": 1024}
)

print(json.dumps(resp, ensure_ascii=False, indent=4))

Multi-image fused embedding

Use qwen3-vl-embedding para fundir múltiplas imagens e texto em um único embedding. Para fundir várias imagens, passe múltiplos itens image. Essa abordagem é ideal para recuperação semântica usando imagens de produtos em vários ângulos acompanhadas de uma descrição textual.

import dashscope
import json
import os
from http import HTTPStatus

# Fuses multiple product images and a description into a single embedding.
# Ideal for comprehensive semantic retrieval using multi-angle product images and a text description.
text = "White sports shoes, lightweight and breathable, suitable for running and daily wear."
image1 = "https://dashscope.oss-cn-beijing.aliyuncs.com/images/256_1.png"
image2 = "https://img.alicdn.com/imgextra/i3/O1CN01rdstgY1uiZWt8gqSL_!!6000000006071-0-tps-1970-356.jpg"

# Pass multiple image items and set enable_fusion=True to fuse all inputs into a single embedding.
input_data = [
    {"text": text},
    {"image": image1},
    {"image": image2}
]

resp = dashscope.MultiModalEmbedding.call(
    # If the environment variable is not set, provide your Model Studio API key, e.g., api_key="sk-xxx".
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model="qwen3-vl-embedding",
    input=input_data,
    enable_fusion=True
)

print(json.dumps(resp, ensure_ascii=False, indent=4))

2026-03-06 snapshot version

Este exemplo demonstra o uso do modelo tongyi-embedding-vision-plus-2026-03-06 e seus parâmetros res_level (resolução) e max_video_frames (quadros de vídeo). Construído sobre a base Qwen3, este modelo suporta mais de 30 idiomas e gera tanto embeddings independentes quanto fundidos.
import dashscope
import json
import os
from http import HTTPStatus

# Demonstrates using the res_level (resolution) and max_video_frames (video frames) parameters.
image = "https://dashscope.oss-cn-beijing.aliyuncs.com/images/256_1.png"
video = "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250107/lbcemt/new+video.mp4"
text = "This is a visual multimodal representation model."

input_data = [
    {"text": text},
    {"image": image},
    {"video": video}
]

resp = dashscope.MultiModalEmbedding.call(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model="tongyi-embedding-vision-plus-2026-03-06",
    input=input_data,
    dimension=1152,      # Valid values: 1152, 1024, 512, 256, 128, 64
    res_level=1,         # Resolution level: 0, 1, 2, or 3. The default is 1.
    max_video_frames=64  # Maximum number of sampled video frames. Default: 8. Maximum: 64.
)

if resp.status_code == HTTPStatus.OK:
    result = {
        "status_code": resp.status_code,
        "request_id": getattr(resp, "request_id", ""),
        "output": resp.output,
        "usage": resp.usage
    }
    print(json.dumps(result, ensure_ascii=False, indent=4))

Para gerar um embedding fundido com a versão 2026-03-06, coloque texto, imagem e vídeo no mesmo objeto de conteúdo. O modelo funde todas as entradas em um único embedding do tipo fused.

import dashscope
import json
import os
from http import HTTPStatus

# To create a fused embedding, place text and image in the same content object.
# The model fuses all inputs into a single embedding of type `fused`.
text = "White sports shoes, lightweight and breathable, suitable for running and daily wear."
image = "https://dashscope.oss-cn-beijing.aliyuncs.com/images/256_1.png"

input_data = [
    {"text": text, "image": image}
]

resp = dashscope.MultiModalEmbedding.call(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model="tongyi-embedding-vision-plus-2026-03-06",
    input=input_data,
    dimension=1152
)

if resp.status_code == HTTPStatus.OK:
    result = {
        "status_code": resp.status_code,
        "request_id": getattr(resp, "request_id", ""),
        "output": resp.output,
        "usage": resp.usage
    }
    print(json.dumps(result, ensure_ascii=False, indent=4))

Exemplo de saída

{
    "status_code": 200,
    "request_id": "40532987-ba72-42aa-a178-bb58b52fb7f3",
    "code": "",
    "message": "",
    "output": {
        "embeddings": [
            {
                "index": 0,
                "embedding": [
                    -0.009490966796875,
                    -0.024871826171875,
                    -0.031280517578125,
                    ...
                ],
                "type": "text"
            }
        ]
    },
    "usage": {
        "input_tokens": 10,
        "input_tokens_details": {
            "image_tokens": 0,
            "text_tokens": 10
        },
        "output_tokens": 1,
        "total_tokens": 11
    }
}

Códigos de erro

Se a chamada do modelo falhar e retornar uma mensagem de erro, consulte Códigos de erro para resolver o problema.