Skip to main content
Modelos especializados

Mineração de dados (Qwen-Doc-Turbo)

O modelo de mineração de dados extrai informações, modera conteúdo, classifica dados e gera resumos. Ele produz dados estruturados (como JSON) com rapidez e precisão, diferentemente dos modelos de chat de uso geral, que podem retornar formatos inconsistentes ou extrair informações incorretamente. Além disso, este modelo permite gerar apresentações PPT a partir do conteúdo de documentos, com os modos template e creative disponíveis.

Além disso, este modelo permite gerar apresentações PPT a partir do conteúdo de documentos, com os modos template e creative disponíveis.
Este documento aplica-se apenas à região China (Beijing). Para usar o modelo, utilize uma API key da região China (Beijing).

Guia de implementação

O Qwen-Doc-Turbo oferece suporte à extração de informações de arquivos de três maneiras. Para obter mais detalhes sobre limites de tamanho e tipo de arquivo, consulte Limitações.

Recurso

URL do arquivo (Recomendado)

ID do arquivo

Texto simples

Origem do arquivo

URL pública

Arquivo local (upload necessário)

Transmitido como string

Limite de entrada

Até 10 arquivos. Suporta arquivos grandes (entrada máxima de 253 mil tokens)

1 arquivo. Suporta arquivos grandes (entrada máxima de 253 mil tokens)

Até 9.000 tokens

Compatibilidade com SDK

Apenas DashScope

Upload: OpenAI Chamada: OpenAI e DashScope

OpenAI e DashScope

Principais vantagens

Dispensa upload para o Model Studio. Suporta chamadas em lote.

Evita uploads repetidos. Ideal para reutilização.

Dispensa gerenciamento de arquivos.

Pré-requisitos

Passar uma URL de arquivo

Extraia dados estruturados usando URLs de arquivos (até 10 arquivos simultaneamente). Este exemplo utiliza os arquivos Sample Product Manual A e Sample Product Manual B e solicita ao modelo que retorne as informações extraídas no formato JSON.
O método de URL de arquivo suporta apenas o protocolo DashScope. Use o DashScope Python SDK ou chamadas HTTP (como curl). 
import os
import dashscope

# The following is the base_url for the Beijing region.
dashscope.base_http_api_url = 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1'

response = dashscope.Generation.call(
    api_key=os.getenv('DASHSCOPE_API_KEY'), # If you have not set the environment variable, replace this with your API key
    model='qwen-doc-turbo',
    messages=[
    {"role": "system","content": "You are a helpful assistant."},
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "From these two product manuals, extract all product information and organize it into a standard JSON array. Each object must include the following: model (the product model), name (the product name), and price (the price, with currency symbols and commas removed)."
            },
            {
                "type": "doc_url",
                "doc_url": [
                    "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251107/jockge/%E7%A4%BA%E4%BE%8B%E4%BA%A7%E5%93%81%E6%89%8B%E5%86%8CA.docx",
                    "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251107/ztwxzr/%E7%A4%BA%E4%BE%8B%E4%BA%A7%E5%93%81%E6%89%8B%E5%86%8CB.docx"
                ],
                "file_parsing_strategy": "auto"
            }
        ]
    }]
)
try:
    if response.status_code == 200:
        print(response.output.choices[0].message.content)
    else:
        print(f"Request failed, status code: {response.status_code}")
        print(f"Error code: {response.code}")
        print(f"Error message: {response.message}")
        print("For more information, see https://www.alibabacloud.com/help/en/model-studio/developer-reference/error-code")
except Exception as e:
    print(f"An error occurred: {e}")
    print("For more information, see https://www.alibabacloud.com/help/en/model-studio/developer-reference/error-code")

curl --location 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/aigc/text-generation/generation' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer $DASHSCOPE_API_KEY' \
--header 'X-DashScope-SSE: enable' \
--data '{
    "model": "qwen-doc-turbo",
    "input": {
        "messages": [
                {
                    "role": "system",
                    "content": "you are a helpful assistant."
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "text": "From these two product manuals, extract all product information and organize it into a standard JSON array. Each object must include the following: model (the product model), name (the product name), and price (the price, with currency symbols and commas removed)."
                        },
                        {
                            "type": "doc_url",
                            "doc_url": [
                                "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251107/jockge/%E7%A4%BA%E4%BE%8B%E4%BA%A7%E5%93%81%E6%89%8B%E5%86%8CA.docx",
                                "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251107/ztwxzr/%E7%A4%BA%E4%BE%8B%E4%BA%A7%E5%93%81%E6%89%8B%E5%86%8CB.docx"
                            ],
                            "file_parsing_strategy": "auto"
                        }
                    ]
                }
            ]
    }
}'
O modelo retorna os dados extraídos como um array JSON no campo content. Observe que o conteúdo pode estar envolto em marcadores de bloco de código markdown (por exemplo, json\n[...]\n). Remova esses marcadores markdown antes de analisar a resposta com json.loads():
content = response.output.choices[0].message.content
# Strip markdown code block markers if present
if content.startswith("```"):
    # Remove opening ```json or ``` marker
    content = content.split("\n", 1)[1] if "\n" in content else content[3:]
    # Remove closing ``` marker
    if content.endswith("```"):
        content = content[:-3]
    content = content.strip()
data = json.loads(content)

[
  {
    "model": "PRO-100",
    "name": "Smart Printer",
    "price": "8999"
  },
  {
    "model": "PRO-200",
    "name": "Smart Scanner",
    "price": "12999"
  },
  ...
  {
    "model": "SEC-400",
    "name": "Smart Visitor System",
    "price": "9999"
  },
  {
    "model": "SEC-500",
    "name": "Smart Parking Management",
    "price": "22999"
  }
]

Passar um ID de arquivo

Fazer upload de um arquivo

Antes de executar o código, baixe o arquivo Sample Product Manual A e coloque-o no diretório do seu projeto. Faça o upload do arquivo por meio da interface compatível com OpenAI para obter um file-id. Para detalhes da API de upload, consulte a Referência da API.
Python
import os
from pathlib import Path
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),  # If you have not set the environment variable, replace this with your API key
    # The following is the base_url for the Beijing region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",  # Enter the DashScope service base_url
)

file_object = client.files.create(file=Path("Sample Product Manual A.docx"), purpose="file-extract")
# Print the file-id for use in subsequent model calls
print(file_object.id)
Execute o código para obter o file-id do arquivo enviado.

Passar informações e iniciar uma conversa usando um ID de arquivo

Insira o file-id em uma mensagem de sistema (após a mensagem de definição de função). A mensagem do usuário contém sua consulta sobre o arquivo. 
import os
from openai import OpenAI, BadRequestError

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"), # If you have not set the environment variable, replace this with your API key
    # The following is the base_url for the Beijing region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

try:
    completion = client.chat.completions.create(
        model="qwen-doc-turbo",
        messages=[
            {'role': 'system', 'content': 'You are a helpful assistant.'},
            # Replace '{FILE_ID}' with the file-id from your scenario
            {'role': 'system', 'content': 'fileid://{FILE_ID}'},
            {'role': 'user', 'content': 'From this product manual, extract all product information and organize it into a standard JSON array. Each object must include the following: model (the product model), name (the product name), and price (the price, with currency symbols and commas removed).'}
        ],
        # This code example uses streaming output to clearly show the model's output process. For non-streaming output examples, see https://www.alibabacloud.com/help/en/model-studio/user-guide/text-generation
        stream=True,
        stream_options={"include_usage": True}
    )

    full_content = ""
    for chunk in completion:
        if chunk.choices and chunk.choices[0].delta.content:
            full_content += chunk.choices[0].delta.content
            print(chunk.model_dump())

    print(full_content)

except BadRequestError as e:
    print(f"Error message: {e}")
    print("For more information, see https://www.alibabacloud.com/help/en/model-studio/developer-reference/error-code")

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.StreamResponse;
import com.openai.models.chat.completions.*;

public class Main {
    public static void main(String[] args) {
        // Create a client and use the API key from the environment variable
        OpenAIClient client = OpenAIOkHttpClient.builder()
                // If you have not set the environment variable, replace the next line with your Model Studio API key: .apiKey("sk-xxx");
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                // The following is the base_url for the Beijing region.
                .baseUrl("https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1")
                .build();

        ChatCompletionCreateParams chatParams = ChatCompletionCreateParams.builder()
                .addSystemMessage("You are a helpful assistant.")
                // Replace '{FILE_ID}' with the file-id from your scenario
                .addSystemMessage("fileid://{FILE_ID}")
                .addUserMessage("From this product manual, extract all product information and organize it into a standard JSON array. Each object must include the following: model (the product model), name (the product name), and price (the price, with currency symbols and commas removed).")
                .model("qwen-doc-turbo")
                .build();

        try (StreamResponse<ChatCompletionChunk> streamResponse = client.chat().completions().createStreaming(chatParams)) {
            streamResponse.stream().forEach(chunk -> {
                String content = chunk.choices().get(0).delta().content().orElse("");
                if (!content.isEmpty()) {
                    System.out.print(content);
                }
            });
        } catch (Exception e) {
            System.err.println("Error message: " + e.getMessage());
        }
    }
# The following is the base_url for the Beijing region.
}

curl --location 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "Content-Type: application/json" \
--data '{
    "model": "qwen-doc-turbo",
    "messages": [
        {"role": "system","content": "You are a helpful assistant."},
        {"role": "system","content": "fileid://{FILE_ID}"},
        {"role": "user","content": "From this product manual, extract all product information and organize it into a standard JSON array. Each object must include the following: model (the product model), name (the product name), and price (the price, with currency symbols and commas removed)."}
    ],
    "stream": true,
    "stream_options": {
        "include_usage": true
    }
}'

import os
import time
from pathlib import Path
from openai import OpenAI, BadRequestError

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),  # If you have not set the environment variable, replace this with your API key
    # The following is the base_url for the Beijing region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

try:
    # Step 1: Upload the file
    file_object = client.files.create(file=Path("Sample Product Manual A.docx"), purpose="file-extract")
    file_id = file_object.id
    print(f"File uploaded successfully. file-id: {file_id}")

    # Step 2: Wait for the file to finish parsing (optional, may be needed for large files)
    # If the file is still parsing, the API returns an error. You must retry.
    max_retries = 10
    retry_count = 0

    while retry_count < max_retries:
        try:
            # Step 3: Call the model using the file-id
            completion = client.chat.completions.create(
                model="qwen-doc-turbo",
                messages=[
                    {'role': 'system', 'content': 'You are a helpful assistant.'},
                    {'role': 'system', 'content': f'fileid://{file_id}'},
                    {'role': 'user', 'content': 'From this product manual, extract all product information and organize it into a standard JSON array. Each object must include the following: model (the product model), name (the product name), and price (the price, with currency symbols and commas removed).'}
                ],
                stream=True,
                stream_options={"include_usage": True}
            )

            # Step 4: Process the model output
            full_content = ""
            for chunk in completion:
                if chunk.choices and chunk.choices[0].delta.content:
                    full_content += chunk.choices[0].delta.content
                    print(chunk.choices[0].delta.content, end='', flush=True)

            print(f"\n\nFull output:\n{full_content}")
            break

        except BadRequestError as e:
            if "File parsing in progress" in str(e):
                retry_count += 1
                print(f"File is parsing. Retrying after a delay ({retry_count}/{max_retries})...")
                time.sleep(2)  # Wait 2 seconds and retry
            else:
                raise e

    if retry_count >= max_retries:
        print("File parsing timed out. Try again later.")

except BadRequestError as e:
    print(f"Error message: {e}")
    print("For more information, see https://www.alibabacloud.com/help/en/model-studio/developer-reference/error-code")
except Exception as e:
    print(f"An error occurred: {e}")

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.StreamResponse;
import com.openai.models.chat.completions.*;
import com.openai.models.files.*;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        // Create a client
        OpenAIClient client = OpenAIOkHttpClient.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                // The following is the base_url for the Beijing region.
                .baseUrl("https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1")
                .build();

        try {
            // Step 1: Upload the file
            Path filePath = Paths.get("src/main/java/org/example/Sample Product Manual A.docx");
            FileCreateParams fileParams = FileCreateParams.builder()
                    .file(filePath)
                    .purpose(FilePurpose.of("file-extract"))
                    .build();

            FileObject fileObject = client.files().create(fileParams);
            String fileId = fileObject.id();
            System.out.println("File uploaded successfully. file-id: " + fileId);

            // Step 2: Wait for the file to parse and then call the model (max 10 retries)
            int maxRetries = 10;
            int retryCount = 0;
            boolean success = false;

            while (retryCount < maxRetries && !success) {
                try {
                    // Step 3: Call the model using the file-id
                    ChatCompletionCreateParams chatParams = ChatCompletionCreateParams.builder()
                            .addSystemMessage("You are a helpful assistant.")
                            .addSystemMessage("fileid://" + fileId)
                            .addUserMessage("From this product manual, extract all product information and organize it into a standard JSON array. Each object must include the following: model (the product model), name (the product name), and price (the price, with currency symbols and commas removed).")
                            .model("qwen-doc-turbo")
                            .build();

                    // Step 4: Process the model output
                    try (StreamResponse<ChatCompletionChunk> streamResponse =
                            client.chat().completions().createStreaming(chatParams)) {
                        streamResponse.stream().forEach(chunk -> {
                            String content = chunk.choices().get(0).delta().content().orElse("");
                            if (!content.isEmpty()) {
                                System.out.print(content);
                            }
                        });
                        System.out.println();
                        success = true;
                    }

                } catch (Exception e) {
                    if (e.getMessage() != null && e.getMessage().contains("File parsing in progress")) {
                        retryCount++;
                        System.out.println("File is parsing. Retrying after a delay (" + retryCount + "/" + maxRetries + ")...");
                        TimeUnit.SECONDS.sleep(2);  // Wait 2 seconds and retry
                    } else {
                        throw e;
                    }
                }
            }

            if (!success) {
                System.out.println("File parsing timed out. Try again later.");
            }

        } catch (Exception e) {
            System.err.println("Error message: " + e.getMessage());
            e.printStackTrace();
        }
    }
}
O modelo retorna os dados extraídos como um array JSON no campo content. Observe que o conteúdo pode estar envolto em marcadores de bloco de código markdown (por exemplo, json\n[...]\n). Remova esses marcadores markdown antes de analisar a resposta com json.loads():
content = response.output.choices[0].message.content
# Strip markdown code block markers if present
if content.startswith("```"):
    # Remove opening ```json or ``` marker
    content = content.split("\n", 1)[1] if "\n" in content else content[3:]
    # Remove closing ``` marker
    if content.endswith("```"):
        content = content[:-3]
    content = content.strip()
data = json.loads(content)

[
  {
    "model": "PRO-100",
    "name": "Smart Printer",
    "price": "8999"
  },
  {
    "model": "PRO-200",
    "name": "Smart Scanner",
    "price": "12999"
  },
  ...
  {
    "model": "SEC-400",
    "name": "Smart Visitor System",
    "price": "9999"
  },
  {
    "model": "SEC-500",
    "name": "Smart Parking Management",
    "price": "22999"
  }
]

Passar texto simples

É possível transmitir o conteúdo do arquivo diretamente como uma string em vez de usar um file-id. Para evitar confusão, coloque a mensagem de definição de função primeiro no array messages.
Se o conteúdo de texto exceder 9.000 tokens, use uma URL de arquivo ou ID de arquivo (devido aos limites de tamanho do corpo da API). 
import os
from openai import OpenAI, BadRequestError

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"), # If you have not set the environment variable, replace this with your API key
    # The following is the base_url for the Beijing region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

try:
    completion = client.chat.completions.create(
        model="qwen-doc-turbo",
        messages=[
            {'role': 'system', 'content': 'You are a helpful assistant.'},
            {'role': 'system', 'content': 'Smart Office Product Manual Version: V2.0 Release Date: January 2024 Table of Contents 1.1 Product Overview...'},
            {'role': 'user', 'content': 'From this product manual, extract all product information and organize it into a standard JSON array. Each object must include the following: model (the product model), name (the product name), and price (the price, with currency symbols and commas removed).'}
        ],
        # This code example uses streaming output to clearly show the model's output process. For non-streaming output examples, see https://www.alibabacloud.com/help/en/model-studio/user-guide/text-generation
        stream=True,
        stream_options={"include_usage": True}
    )

    full_content = ""
    for chunk in completion:
        if chunk.choices and chunk.choices[0].delta.content:
            full_content += chunk.choices[0].delta.content
            print(chunk.model_dump())

    print(full_content)

except BadRequestError as e:
    print(f"Error message: {e}")
    print("For more information, see https://www.alibabacloud.com/help/en/model-studio/developer-reference/error-code")

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.StreamResponse;
import com.openai.models.chat.completions.*;

public class Main {
    public static void main(String[] args) {
        // Create a client and use the API key from the environment variable
        OpenAIClient client = OpenAIOkHttpClient.builder()
                // If you have not set the environment variable, replace the next line with your Model Studio API key: .apiKey("sk-xxx");
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                // The following is the base_url for the Beijing region.
                .baseUrl("https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1")
                .build();

        ChatCompletionCreateParams chatParams = ChatCompletionCreateParams.builder()
                .addSystemMessage("You are a helpful assistant.")
                .addSystemMessage("Smart Office Product Manual Version: V2.0 Release Date: January 2024 Table of Contents 1.1 Product Overview...")
                .addUserMessage("From this product manual, extract all product information and organize it into a standard JSON array. Each object must include the following: model (the product model), name (the product name), and price (the price, with currency symbols and commas removed).")
                .model("qwen-doc-turbo")
                .build();

        try (StreamResponse<ChatCompletionChunk> streamResponse = client.chat().completions().createStreaming(chatParams)) {
            streamResponse.stream().forEach(chunk -> {
                String content = chunk.choices().get(0).delta().content().orElse("");
                if (!content.isEmpty()) {
                    System.out.print(content);
                }
            });
        } catch (Exception e) {
            System.err.println("Error message: " + e.getMessage());
        }
    }
# The following is the base_url for the Beijing region.
}

curl --location 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "Content-Type: application/json" \
--data '{
    "model": "qwen-doc-turbo",
    "messages": [
        {"role": "system","content": "You are a helpful assistant."},
        {"role": "system","content": "Smart Office Product Manual Version: V2.0 Release Date: January 2024 Table of Contents 1.1 Product Overview..."},
        {"role": "user","content": "From this product manual, extract all product information and organize it into a standard JSON array. Each object must include the following: model (the product model), name (the product name), and price (the price, with currency symbols and commas removed)."}
    ],
    "stream": true,
    "stream_options": {
        "include_usage": true
    }
}'
O modelo retorna os dados extraídos como um array JSON no campo content. Observe que o conteúdo pode estar envolto em marcadores de bloco de código markdown (por exemplo, json\n[...]\n). Remova esses marcadores markdown antes de analisar a resposta com json.loads():
content = response.output.choices[0].message.content
# Strip markdown code block markers if present
if content.startswith("```"):
    # Remove opening ```json or ``` marker
    content = content.split("\n", 1)[1] if "\n" in content else content[3:]
    # Remove closing ``` marker
    if content.endswith("```"):
        content = content[:-3]
    content = content.strip()
data = json.loads(content)

[
  {
    "model": "PRO-100",
    "name": "Smart Printer",
    "price": "8999"
  },
  {
    "model": "PRO-200",
    "name": "Smart Scanner",
    "price": "12999"
  },
  ...
  {
    "model": "SEC-400",
    "name": "Smart Visitor System",
    "price": "9999"
  },
  {
    "model": "SEC-500",
    "name": "Smart Parking Management",
    "price": "22999"
  }
]

Preços do modelo

Modelo

Janela de contexto

Entrada máx.

Saída máx.

Custo de entrada

Custo de saída

Cota gratuita

(Tokens)

(Milhões de tokens)

qwen-doc-turbo

262.144

253.952

32.768

$0,087

$0,144

Sem cota gratuita

Perguntas frequentes

  1. Onde os arquivos são armazenados após o upload pela interface de arquivo compatível com OpenAI? Os arquivos enviados por meio da interface compatível com OpenAI são armazenados gratuitamente no seu bucket do Model Studio. Para consultar e gerenciar arquivos, consulte Interface de arquivo OpenAI.
  2. Ao fazer upload usando o método de URL de arquivo, quais são as diferenças entre as opções do parâmetro file_parsing_strategy? "auto": analisa automaticamente com base no conteúdo. "text_only": analisa apenas texto. "text_and_images": analisa imagens e texto (aumenta o tempo de análise).
  3. Como determinar se um arquivo terminou de ser analisado? Tente iniciar uma conversa com o ID do arquivo. Se o arquivo ainda estiver sendo analisado, a API retorna File parsing in progress, please try again later. -- tente novamente após um atraso. Se a chamada for bem-sucedida, o arquivo está pronto.
  4. O processo de análise após o upload do arquivo gera custos extras? A análise de documentos é gratuita.

Referência da API

Para os parâmetros de entrada e saída do Qwen-Doc-Turbo, consulte a Referência da API compatível com OpenAI ou a Referência da API DashScope.

Códigos de erro

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

Limitações

  • Dependências do SDK:
    • URL de arquivo (doc_url): Suporta apenas o protocolo DashScope. Use o DashScope Python SDK ou chamadas HTTP (como curl).
    • Upload de arquivo (file-id): Use um SDK compatível com OpenAI para upload e gerenciamento.
  • Upload e referência de arquivo:
    • URL de arquivo (doc_url): Até 10 URLs por solicitação. As URLs devem ser acessíveis publicamente.
    • Upload de arquivo (file-id): Máximo de 150 MB por arquivo. Limites da conta: 10.000 arquivos ou 100 GB no total (os arquivos nunca expiram). Cada solicitação referencia apenas um arquivo.
      As solicitações de upload falham quando os limites são atingidos. Exclua arquivos desnecessários para liberar cota. Consulte Compatível com OpenAI - Arquivo para obter detalhes.
    • Formatos suportados: TXT, DOC, DOCX, PDF, XLS, XLSX, MD, PPT, PPTX, JPG, JPEG, PNG, GIF e BMP.
  • Entrada da API:
    • Usando doc_url ou file-id: máximo de 262.144 tokens.
    • Texto simples em mensagens user/system: máximo de 9.000 tokens por mensagem.
  • Saída da API:
    • O comprimento máximo de saída é de 32.768 tokens.
  • Compartilhamento de arquivo:
    • O file-id funciona apenas dentro da conta geradora -- não entre contas ou com API keys de usuários RAM.
  • Limite de taxa: Consulte Limitação de taxa.
Começar
Faturamento
Plano de Tokens
Playground de Modelos
Clientes e Ferramentas de Desenvolvedor
Inferência do Modelo
Ajuste fino
Implantação
Avaliação
Compressão de Modelos
Estatísticas e Monitoramento
Segurança e Conformidade
Melhores Práticas
Suporte
Registro de alterações