BRASILTradução de apoio para consulta. Código e identificadores técnicos preservados. Consultar referência original ↗
Modo parcial
Continue a partir de um prefixo
Ele garante que a saída do modelo se conecte perfeitamente com o prefixo.
Como funciona
Para usar o Modo Parcial, configure o messages Array. Na última mensagem do array, definir o role para assistant e fornecer o prefixo no content Campo. Você também deve definir o "partial": true parâmetro nessa mensagem. O messages O formato é o seguinte:
[
{
"role": "user",
"content": "Complete this Fibonacci function. Do not add anything else."
},
{
"role": "assistant",
"content": "def calculate_fibonacci(n):\n if n <= 1:\n return n\n else:\n",
"partial": true
}
]
O modelo começa a gerar texto a partir do prefixo especificado.
Modelos apoiados.
- Qwen-Max Série
- Qwen-Plus Série (modo não pensante)
- Qwen-Flash Série (modo não pensante)
- Qwen-Coder Série
- Qwen-Math Série - Qwen-Math série, Qwen2.5-Math Série
- DeepSeek Série (SiliconFlow implantação) - fluxo de silício /deepseek-v3.2 (modo não pensante), fluxo de silício/deepseek-v3.1-terminus (modo não pensante), fluxo de silício/deepseek-v3-0324
- DeepSeek Série (implantação de Vanchin) - Vanchin/deepseek-v3.2-think, Vanchin/deepseek-r1, Vanchin/deepseek-v3
- Qwen-VL Série - qwen3-vl-plus e qwen3.6-flash são apenas o modo de não pensar.
- Kimi Série (implantação de IA de Moonshot) kimi/kimi-k3, kimi/kimi-k2.6, kimi/kimi-k2.5
- Qwen Série de código aberto - Qwen3.6 e Qwen3.5 Modelos MoE/dense suportam o modo de pensar; Qwen3.6-35B-A3B, Qwen3.5-35B-A3B, Qwen3, e Qwen3-VL Modelos de código aberto são apenas modos não pensantes.
Para IDs de modelos e versões de instantâneos, veja [Modelos de geração de texto] (/developer-guides/getting-started/text-generation-models).
O modo de pensar não suporta a continuação do prefixo. Use o modo não pensante para todos os modelos que o suportam, ou escolha uma série de modelos que só opera em modo não pensante.
Começando.
Pré-requisitos
[Pegue uma chave API] (/api-reference/preparation/api-keyE o define como uma variável de ambiente./api-reference/preparation/export-api-key-env). Para usar o SDK, [instale-o] (/api-reference/preparation/install-sdk). Se você está em um sub-espaço de trabalho, certifique-se de que o super administrador tenha [acesso concedido ao seu espaço de trabalho] (/developer-guides/administration/workspace).
O DashScope Java SDK não é suportado.
Código de amostra.
O exemplo a seguir mostra como completar uma função Python.
OpenAI compatible
```python Python
import os
from openai import OpenAI
# 1. Initialize the client
client = OpenAI(
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
)
# 2. Define the code prefix to complete
prefix = """def calculate_fibonacci(n):
if n <= 1:
return n
else:
"""
# 3. Make a Partial Mode request
# Note: The last message in the messages array must have role "assistant" and include "partial": True
completion = client.chat.completions.create(
model="qwen3.8-max",
messages=[
{"role": "user", "content": "Complete this Fibonacci function. Do not add anything else."},
{"role": "assistant", "content": prefix, "partial": True},
],
)
# 4. Manually join the prefix and the model's generated content
generated_code = completion.choices[0].message.content
complete_code = prefix + generated_code
print(complete_code)
```
```javascript Node.js
import OpenAI from "openai";
const openai = new OpenAI({
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1"
});
// Define the code prefix to complete
const prefix = `def calculate_fibonacci(n):
if n <= 1:
return n
else:
`;
const completion = await openai.chat.completions.create({
model: "qwen3.8-max", // Use a code model
messages: [
{ role: "user", content: "Complete this Fibonacci function. Do not add anything else." },
{ role: "assistant", content: prefix, partial: true }
],
});
// Manually join the prefix and the model's generated content
const generatedCode = completion.choices[0].message.content;
const completeCode = prefix + generatedCode;
console.log(completeCode);
```
```bash curl
curl -X POST https://maas.qwencloudapi.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen3.8-max",
"messages": [
{
"role": "user",
"content": "Complete this Fibonacci function. Do not add anything else."
},
{
"role": "assistant",
"content": "def calculate_fibonacci(n):\n if n <= 1:\n return n\n else:\n",
"partial": true
}
]
}'
```
? Responder ?
A saída pode variar de acordo com o modelo. Qualquer implementação Fibonacci válida é aceitável.
```plaintext
def calculate_fibonacci(n):
if n <= 1:
return n
else:
return calculate_fibonacci(n-1) + calculate_fibonacci(n-2)
```
Resposta completa do JSON
```json
{
"choices": [
{
"message": {
"content": " return calculate_fibonacci(n-1) + calculate_fibonacci(n-2)",
"role": "assistant"
},
"finish_reason": "stop",
"index": 0,
"logprobs": null
}
],
"object": "chat.completion",
"usage": {
"prompt_tokens": 48,
"completion_tokens": 19,
"total_tokens": 67,
"prompt_tokens_details": {
"cache_type": "implicit",
"cached_tokens": 0
}
},
"created": 1756800231,
"system_fingerprint": null,
"model": "qwen3.8-max",
"id": "chatcmpl-d103b1cf-4bda-942f-92d6-d7ecabfeeccb"
}
```
DashScope
```python Python
import os
import dashscope
dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'
# Define the code prefix to be completed
prefix = """def calculate_fibonacci(n):
if n <= 1:
return n
else:
"""
messages = [
{
"role": "user",
"content": "Complete this Fibonacci function. Do not add any other content."
},
{
"role": "assistant",
"content": prefix,
"partial": True
}
]
response = dashscope.Generation.call(
api_key=os.getenv("DASHSCOPE_API_KEY"),
model='qwen3.8-max', # Use a code model
messages=messages,
result_format='message',
)
# Manually concatenate the prefix and the content generated by the model
generated_code = response.output.choices[0].message.content
complete_code = prefix + generated_code
print(complete_code)
```
```bash curl
curl -X POST "https://maas.qwencloudapi.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen3.8-max",
"input":{
"messages":[
{
"role": "user",
"content": "Complete this Fibonacci function. Do not add anything else."
},
{
"role": "assistant",
"content": "def calculate_fibonacci(n):\n if n <= 1:\n return n\n else:\n",
"partial": true
}
]
},
"parameters": {
"result_format": "message"
}
}'
```
? Responder ?
A saída pode variar de acordo com o modelo. Qualquer implementação Fibonacci válida é aceitável.
```plaintext
def calculate_fibonacci(n):
if n <= 1:
return n
else:
return calculate_fibonacci(n-1) + calculate_fibonacci(n-2)
```
Resposta completa do JSON
```json
{
"output": {
"choices": [
{
"message": {
"content": " return calculate_fibonacci(n-1) + calculate_fibonacci(n-2)",
"role": "assistant"
},
"finish_reason": "stop"
}
]
},
"usage": {
"total_tokens": 67,
"output_tokens": 19,
"input_tokens": 48,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"request_id": "c61c62e5-cf97-90bc-a4ee-50e5e117b93f"
}
```
Use casos.
Passe imagens ou vídeos
Qwen-VL Modelos suportam o Modo Parcial para pedidos que incluem dados de imagem ou vídeo. Isso é útil para cenários como gerar descrições de produtos, criar conteúdo de mídia social, escrever artigos de notícias e escrever textos criativos.
OpenAI compatible
```python Python
import os
from openai import OpenAI
client = OpenAI(
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://maas.qwencloudapi.com/compatible-mode/v1"
)
completion = client.chat.completions.create(
model="qwen3-vl-plus",
messages=[
{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {
"url": "https://img.alicdn.com/imgextra/i3/O1CN01zFX2Bs1Q0f9pESgPC_!!6000000001914-2-tps-450-450.png"
},
},
{"type": "text", "text": "I want to post this on social media. Help me write a caption."},
],
},
{
"role": "assistant",
"content": "Today I discovered a hidden-gem café",
"partial": True,
},
],
)
print(completion.choices[0].message.content)
```
```javascript Node.js
import OpenAI from "openai";
const openai = new OpenAI({
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1"
});
async function main() {
const response = await openai.chat.completions.create({
model: "qwen3-vl-plus",
messages: [
{
role: "user",
content: [
{
type: "image_url",
image_url: {
"url": "https://img.alicdn.com/imgextra/i3/O1CN01zFX2Bs1Q0f9pESgPC_!!6000000001914-2-tps-450-450.png"
}
},
{
type: "text",
text: "I want to post this on social media. Help me write a caption."
}
]
},
{
role: "assistant",
content: "Today I discovered a hidden-gem café",
"partial": true
}
]
});
console.log(response.choices[0].message.content);
}
main();
```
```bash curl
curl -X POST 'https://maas.qwencloudapi.com/compatible-mode/v1/chat/completions' \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
"model": "qwen3-vl-plus",
"messages": [
{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {
"url": "https://img.alicdn.com/imgextra/i3/O1CN01zFX2Bs1Q0f9pESgPC_!!6000000001914-2-tps-450-450.png"
}
},
{
"type": "text",
"text": "I want to post this on social media. Help me write a caption."
}
]
},
{
"role": "assistant",
"content": "Today I discovered a hidden-gem café",
"partial": true
}
]
}'
```
? Responder ?
```plaintext
— the tiramisu here is pure bliss! Every bite delivers perfect harmony between coffee and cream. Pure joy! #FoodShare #Tiramisu #CoffeeTime
Hope you like this caption! Let me know if you need any changes.
```
Resposta completa do JSON
```json
{
"choices": [
{
"message": {
"content": "— the tiramisu here is pure bliss! Every bite delivers perfect harmony between coffee and cream. Pure joy! #FoodShare #Tiramisu #CoffeeTime\n\nHope you like this caption! Let me know if you need any changes.",
"role": "assistant"
},
"finish_reason": "stop",
"index": 0,
"logprobs": null
}
],
"object": "chat.completion",
"usage": {
"prompt_tokens": 282,
"completion_tokens": 56,
"total_tokens": 338,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"created": 1756802933,
"system_fingerprint": null,
"model": "qwen3-vl-plus",
"id": "chatcmpl-5780cbb7-ebae-9c63-b098-f8cc49e321f0"
}
```
DashScope
```python Python
import os
import dashscope
dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'
messages = [
{
"role": "user",
"content": [
{
"image": "https://img.alicdn.com/imgextra/i3/O1CN01zFX2Bs1Q0f9pESgPC_!!6000000001914-2-tps-450-450.png"
},
{"text": "I want to post this on social media. Help me write a caption."},
],
},
{"role": "assistant", "content": "Today I discovered a hidden-gem café", "partial": True},
]
response = dashscope.MultiModalConversation.call(
api_key=os.getenv("DASHSCOPE_API_KEY"),
model="qwen3-vl-plus",
messages=messages
)
print(response.output.choices[0].message.content[0]["text"])
```
```bash curl
curl -X POST https://maas.qwencloudapi.com/api/v1/services/aigc/multimodal-generation/generation \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
"model": "qwen3-vl-plus",
"input":{
"messages":[
{"role": "user",
"content": [
{"image": "https://img.alicdn.com/imgextra/i3/O1CN01zFX2Bs1Q0f9pESgPC_!!6000000001914-2-tps-450-450.png"},
{"text": "I want to post this on social media. Help me write a caption."}]
},
{"role": "assistant",
"content": "Today I discovered a hidden-gem café",
"partial": true
}
]
}
}'
```
? Responder ?
```plaintext
— the tiramisu here is pure bliss! Every bite delivers perfect harmony between coffee and cream. Pure joy! #FoodShare #Tiramisu #CoffeeTime
Hope you like this caption! Let me know if you need any changes.
```
Resposta completa do JSON
```json
{
"output": {
"choices": [
{
"message": {
"content": [
{
"text": "— the tiramisu here is pure bliss! Every bite delivers perfect harmony between coffee and cream. Pure joy! #FoodShare #Tiramisu #CoffeeTime\n\nHope you like this caption! Let me know if you need any changes."
}
],
"role": "assistant"
},
"finish_reason": "stop"
}
]
},
"usage": {
"total_tokens": 339,
"input_tokens_details": {
"image_tokens": 258,
"text_tokens": 24
},
"output_tokens": 57,
"input_tokens": 282,
"output_tokens_details": {
"text_tokens": 57
},
"image_tokens": 258
},
"request_id": "c741328c-23dc-9286-bfa7-626a4092ca09"
}
```
Continue a partir de saída incompleta
Se o valor do max_tokens O parâmetro é muito pequeno, o Modelo de Língua Grande (MLM) pode retornar conteúdo incompleto. Você pode usar o Modo Parcial para continuar gerando a partir desse ponto e garantir que a saída seja completa semanticamente.
OpenAI compatible
```python Python
import os
from openai import OpenAI
client = OpenAI(
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
)
def chat_completion(messages,max_tokens=None):
response = client.chat.completions.create(
model="qwen3.7-plus",
messages=messages,
max_tokens=max_tokens
)
print(f"### Reason generation stopped: {response.choices[0].finish_reason}")
return response.choices[0].message.content
# Example usage
messages = [{"role": "user", "content": "Write a short sci-fi story"}]
# First call with max_tokens set to 40
first_content = chat_completion(messages, max_tokens=40)
print(first_content)
# Add the first response as an assistant message and set partial=True
messages.append({"role": "assistant", "content": first_content, "partial": True})
# Second call
second_content = chat_completion(messages)
print("### Complete content:")
print(first_content+second_content)
```
```javascript Node.js
import OpenAI from "openai";
const openai = new OpenAI({
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1"
});
async function chatCompletion(messages, maxTokens = null) {
const completion = await openai.chat.completions.create({
model: "qwen3.7-plus",
messages: messages,
max_tokens: maxTokens
});
console.log(`### Reason generation stopped: ${completion.choices[0].finish_reason}`);
return completion.choices[0].message.content;
}
// Example usage
async function main() {
let messages = [{"role": "user", "content": "Write a short sci-fi story"}];
try {
// First call with max_tokens set to 40
const firstContent = await chatCompletion(messages, 40);
console.log(firstContent);
// Add the first response as an assistant message and set partial=true
messages.push({"role": "assistant", "content": firstContent, "partial": true});
// Second call
const secondContent = await chatCompletion(messages);
console.log("### Complete content:");
console.log(firstContent + secondContent);
} catch (error) {
console.error('Execution error:', error);
}
}
// Run the example
main();
```
? Responder ?
A `length` A razão indica que o `max_tokens` O limite foi alcançado. A `stop` A razão indica que o modelo terminou gerando texto naturalmente ou encontrou uma palavra de parada definida no `stop` parâmetro.
```plaintext
### Reason generation stopped: length
**"The End of Memory"**
In the distant future, Earth is no longer fit for human life. The atmosphere is polluted, oceans are dry, and cities lie in ruins. Humans migrated to a habitable planet named "Eden," with blue skies, fresh air, and endless resources.
However, Eden is not a true paradise. It holds no human history, no past, and no memory.
...
**"If we forget who we are, are we still human?"**
— End —
```
DashScope
```python
import os
import dashscope
dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'
# Use MultiModalConversation for qwen3.7-plus and qwen3.5-plus.
# For text-only models such as qwen-plus and qwen3.7-max, use dashscope.Generation.call instead.
def chat_completion(messages, max_tokens=None):
response = dashscope.MultiModalConversation.call(
api_key=os.getenv("DASHSCOPE_API_KEY"),
model='qwen3.7-plus',
messages=messages,
max_tokens=max_tokens,
)
print(f"### Reason generation stopped: {response.output.choices[0].finish_reason}")
return response.output.choices[0].message.content[0]["text"]
# Example usage
messages = [{"role": "user", "content": [{"text": "Write a short sci-fi story"}]}]
# First call with max_tokens set to 40
first_content = chat_completion(messages, max_tokens=40)
print(first_content)
# Add the first response as an assistant message and set partial=True
messages.append({"role": "assistant", "content": first_content, "partial": True})
# Second call
second_content = chat_completion(messages)
print("### Complete content:")
print(first_content + second_content)
```
? Responder ?
```plaintext
### Reason generation stopped: length
Title: **"Origami Time"**
---
In 2179, humanity finally mastered time travel. But this technology did not rely on massive machines or complex energy fields. It relied on paper.
A single sheet of paper.
It was called "Origami Time," made from an unknown alien material. Scientists could not explain how it worked. They only knew that drawing a scene on the paper and folding it in a specific way opened a door to the past or future.
...
"You are not the key to time. You are just a reminder that our future is always in our hands."
Then I tore it into pieces.
---
**(End)**
```
Contagem
Você está faturado por ambos os tokens de entrada e de saída. O prefixo é contado como parte dos símbolos de entrada.
Códigos de erro.
Se uma ligação falhar, veja [Mensagens de erro] (/api-reference/preparation/error-messages).