Structured output

from openai import OpenAI
import os

client = OpenAI(
    # If you haven't configured an environment variable, replace the next line with: api_key="sk-xxx"
    # API keys differ by region. Get an API key: https://help.aliyun.com/en/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # This is the Beijing region base_url. If you use Singapore region models, replace base_url with: https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="qwen-flash",
    messages=[
        {
            "role": "system",
            "content": "Extract the user's name and age, and return them in JSON format"
        },
        {
            "role": "user",
            "content": "Hi everyone, my name is Alex Brown, I'm 34 years old, my email is alexbrown@example.com, and I enjoy playing basketball and traveling", 
        },
    ],
    response_format={"type": "json_object"}
)

json_string = completion.choices[0].message.content
print(json_string)

Response

{
  "Name": "Alex Brown",
  "Age": 34
}

import OpenAI from "openai";

const openai = new OpenAI({
    // If you haven't configured an environment variable, replace the next line with: apiKey: "sk-xxx"
    // API keys differ by region. Get an API key: https://help.aliyun.com/en/model-studio/get-api-key
    apiKey: process.env.DASHSCOPE_API_KEY,
    // This is the Beijing region base_url. If you use Singapore region models, replace base_url with: https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1
    baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
});

const completion = await openai.chat.completions.create({
    model: "qwen-flash",
    messages: [
        {
            role: "system",
            content: "Extract the user's name and age, and return them in JSON format"
        },
        {
            role: "user",
            content: "Hi everyone, my name is Alex Brown, I'm 34 years old, my email is alexbrown@example.com, and I enjoy playing basketball and traveling"
        }
    ],
    response_format: {
        type: "json_object"
    }
});

const jsonString = completion.choices[0].message.content;
console.log(jsonString);

Response

{
  "name": "Alex Brown",
  "age": 34
}

# ======= Important notes =======
# API keys differ by region. Get an API key: https://help.aliyun.com/en/model-studio/get-api-key
# This is the Beijing region base_url. If you use Singapore region models, replace base_url with: https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions
# === Delete this comment before running ===
curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen-plus",
    "messages": [
        {
            "role": "system",
            "content": "Extract the user'\''s name and age, and return them in JSON format"
        },
        {
            "role": "user", 
            "content": "Hi everyone, my name is Alex Brown, I'\''m 34 years old, my email is alexbrown@example.com"
        }
    ],
    "response_format": {
        "type": "json_object"
    }
}'

Response

{
    "choices": [
        {
            "message": {
                "role": "assistant",
                "content": "{\"name\":\"Alex Brown\",\"age\":\"34 years old\"}"
            },
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 207,
        "completion_tokens": 20,
        "total_tokens": 227,
        "prompt_tokens_details": {
            "cached_tokens": 0
        }
    },
    "created": 1756455080,
    "system_fingerprint": null,
    "model": "qwen-plus",
    "id": "chatcmpl-624b665b-fb93-99e7-9ebd-bb6d86d314d2"
}

import os
import dashscope

# If you use Singapore region models, uncomment the following line
# dashscope.base_http_api_url = "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1"
messages=[
    {
        "role": "system",
        "content": "Extract the user's name and age, and return them in JSON format"
    },
    {
        "role": "user",
        "content": "Hi everyone, my name is Alex Brown, I'm 34 years old, my email is alexbrown@example.com, and I enjoy playing basketball and traveling", 
    },
]
response = dashscope.Generation.call(
    # If you haven't configured an environment variable, replace the next line with: api_key="sk-xxx" (Alibaba Cloud Model Studio API key),
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="qwen-flash", 
    messages=messages,
    result_format='message',
    response_format={'type': 'json_object'}
    )
json_string = response.output.choices[0].message.content
print(json_string)

Response

{
  "name": "Alex Brown",
  "age": 34
}

Response

{
  "name": "Alex Brown",
  "age": 34
}

# ======= Important notes =======
# API keys differ by region. Get an API key: https://help.aliyun.com/en/model-studio/get-api-key
# This is the Beijing region URL. If you use Singapore region models, replace the URL with: https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/aigc/text-generation/generation
# === Delete this comment before running ===
curl -X POST https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen-flash",
    "input": {
        "messages": [
            {
                "role": "system",
                "content": "Extract the user'\''s name and age, and return them in JSON format"
            },
            {
                "role": "user", 
                "content": "Hi everyone, my name is Alex Brown, I'\''m 34 years old, my email is alexbrown@example.com, and I enjoy playing basketball and traveling"
            }
        ]
    },
    "parameters": {
        "result_format": "message",
        "response_format": {
            "type": "json_object"
        }
    }
}'

Response

{
  "name": "Alex Brown",
  "age": 34
}

import OpenAI from "openai";

const openai = new OpenAI({
  // If you haven't configured an environment variable, replace the next line with: apiKey: "sk-xxx" (Model Studio API key)
  // API keys differ by region. Get an API key: https://help.aliyun.com/en/model-studio/get-api-key
  apiKey: process.env.DASHSCOPE_API_KEY,
  // This is the Beijing region base_url. If you use Singapore region models, replace base_url with: https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1
  baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
});

async function main() {
  const response = await openai.chat.completions.create({
    model: "qwen3-vl-plus",
    messages: [{
        role: "system",
        content: [{
          type: "text",
          text: "You are a helpful assistant."
        }]
      },
      {
        role: "user",
        content: [{
            type: "image_url",
            image_url: {
              "url": "http://duguang-labelling.oss-cn-shanghai.aliyuncs.com/demo_ocr/receipt_zh_demo.jpg"
            }
          },
          {
            type: "text",
            text: "Extract ticket (array type, including travel_date, trains, seat_num, arrival_site, price) and invoice information (array type, including invoice_code and invoice_number) from the image. Output a JSON containing both ticket and invoice arrays"
          }
        ]
      }
    ],
    response_format: {type: "json_object"}
  });
  console.log(response.choices[0].message.content);
}

main()

Response

{
  "ticket": [
    {
      "travel_date": "2013-06-29",
      "trains": "stream",
      "seat_num": "371",
      "arrival_site": "Development Zone",
      "price": "8.00"
    }
  ],
  "invoice": [
    {
      "invoice_code": "221021325353",
      "invoice_number": "10283819"
    }
  ]
}

Sample code

from openai import OpenAI
import os

# Initialize the OpenAI client
client = OpenAI(
    # If you haven't configured an environment variable, replace with: api_key="sk-xxx" (Alibaba Cloud Model Studio API key)
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

messages=[
    {
        "role": "system",
        "content": "Extract the user's name and age, and return them in JSON format"
    },
    {
        "role": "user",
        "content": "Hi everyone, my name is Alex Brown, I'm 34 years old, my email is alexbrown@example.com, and I enjoy playing basketball and traveling", 
    },
]

completion = client.chat.completions.create(
    model="kimi-k2-thinking",
    messages=messages,
    extra_body={"enable_thinking": True},
    stream=True,
    stream_options={
        "include_usage": True
    },
    response_format={"type": "json_object"}
)

reasoning_content = ""  # Full reasoning process
answer_content = ""  # Full response
is_answering = False  # Whether the response phase has started
print("\n" + "=" * 20 + "Reasoning process" + "=" * 20 + "\n")

for chunk in completion:
    if not chunk.choices:
        print("\nUsage:")
        print(chunk.usage)
        continue

    delta = chunk.choices[0].delta

    # Collect only reasoning content
    if hasattr(delta, "reasoning_content") and delta.reasoning_content is not None:
        if not is_answering:
            print(delta.reasoning_content, end="", flush=True)
        reasoning_content += delta.reasoning_content

    # Received content, start responding
    if hasattr(delta, "content") and delta.content:
        if not is_answering:
            print("\n" + "=" * 20 + "Full response" + "=" * 20 + "\n")
            is_answering = True
        print(delta.content, end="", flush=True)
        answer_content += delta.content

Response

==================== Reasoning Process ====================

The user requests that you extract the name and age information and return it in JSON format.

From the text, you can see:
- Name: Alex Brown
- Age: 34
- Mailbox: alexbrown@example.com (but the user requests only the name and age)
- Hobbies: playing basketball and traveling (but the user requests only the name and age)

Per the requirements, you need to extract only the name and age information and return it in JSON format.

The JSON format should be:
{
  "name": "Alex Brown",
  "age": 34
}

Or using Chinese keys:
{
  "姓名": "刘五",
  "年龄": 34
}

Because the user's request is in Chinese, using Chinese keys may be more appropriate. However, using English keys for JSON is a common practice. In this case, English keys are used because the instruction is technical and follows standard JSON conventions.

Final output:
{
  "name": "Alex Brown",
  "age": 34
}
==================== Complete Response ====================

{"name":"Alex Brown","age":34}
Usage:
CompletionUsage(completion_tokens=203, prompt_tokens=48, total_tokens=251, completion_tokens_details=CompletionTokensDetails(accepted_prediction_tokens=None, audio_tokens=None, reasoning_tokens=190, rejected_prediction_tokens=None), prompt_tokens_details=None)

Sample code

import OpenAI from "openai";
import process from 'process';

// Initialize the OpenAI client
const openai = new OpenAI({
    apiKey: process.env.DASHSCOPE_API_KEY, // Read from the environment variable
    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1'
});

let reasoningContent = '';
let answerContent = '';
let isAnswering = false;

async function main() {
    try {
        const messages = [
            {
                "role": "system",
                "content": "Extract the user's name and age information and return it in JSON format"
            },
            {
                "role": "user",
                "content": "Hello everyone, my name is Alex Brown, I am 34 years old, my email address is alexbrown@example.com, and I enjoy playing basketball and traveling", 
            },
        ];
        const stream = await openai.chat.completions.create({
            model: 'glm-4.5',
            messages,
            stream: true,
            enable_thinking: true,
            response_format: {type: 'json_object'},
        });
        console.log('\n' + '='.repeat(20) + 'Reasoning Process' + '='.repeat(20) + '\n');

        for await (const chunk of stream) {
            if (!chunk.choices?.length) {
                console.log('\nUsage:');
                console.log(chunk.usage);
                continue;
            }

            const delta = chunk.choices[0].delta;
            
            // Collect only reasoning content
            if (delta.reasoning_content !== undefined && delta.reasoning_content !== null) {
                if (!isAnswering) {
                    process.stdout.write(delta.reasoning_content);
                }
                reasoningContent += delta.reasoning_content;
            }

            // When content is received, start generating the response
            if (delta.content !== undefined && delta.content) {
                if (!isAnswering) {
                    console.log('\n' + '='.repeat(20) + 'Complete Response' + '='.repeat(20) + '\n');
                    isAnswering = true;
                }
                process.stdout.write(delta.content);
                answerContent += delta.content;
            }
        }
    } catch (error) {
        console.error('Error:', error);
    }
}

main();

Response

====================Reasoning process====================

The user requests extracting name and age information and returning it in JSON format.

From the text:
- Name: Alex Brown
- Age: 34
- Email: alexbrown@example.com (but the user only requested name and age)
- Hobbies: playing basketball and traveling (but the user only requested name and age)

According to the request, only extract name and age information and return it in JSON format.

The JSON format should be:
{
  "name": "Alex Brown",
  "age": 34
}

Or using English keys:
{
  "name": "Alex Brown",
  "age": 34
}

Although the user's instruction was in Chinese, using English keys for JSON is standard practice. Therefore, I will use English keys for the JSON output.

Final output:
{
  "name": "Alex Brown",
  "age": 34
}
====================Full response====================

{"name":"Alex Brown","age":34}
Usage:
CompletionUsage(completion_tokens=203, prompt_tokens=48, total_tokens=251, completion_tokens_details=CompletionTokensDetails(accepted_prediction_tokens=None, audio_tokens=None, reasoning_tokens=190, rejected_prediction_tokens=None), prompt_tokens_details=None)

Sample code

curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "glm-4.5",
    "messages": [
    {
            "role": "system",
            "content": "Extract the user'\''s name and age, and return them in JSON format"
        },
        {
            "role": "user", 
            "content": "Hi everyone, my name is Alex Brown, I'\''m 34 years old, my email is alexbrown@example.com, and I enjoy playing basketball and traveling"
        }
    ],
    "stream": true,
    "stream_options": {
        "include_usage": true
    },
    "enable_thinking": true,
    "response_format": {
        "type": "json_object"
    }
}'

Sample code

import os
from dashscope import Generation
import dashscope 

messages = [
    {
        "role": "system",
        "content": "Extract the user's name and age, and return them in JSON format"
    },
    {"role": "user", "content": "Hi everyone, my name is Alex Brown, I'm 34 years old, my email is alexbrown@example.com, and I enjoy playing basketball and traveling"}
]

completion = Generation.call(
    # If you haven't configured an environment variable, replace the next line with: api_key = "sk-xxx" (Alibaba Cloud Model Studio API key),
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model="glm-4.5",
    messages=messages,
    result_format="message",
    enable_thinking=True,
    response_format={"type": "json_object"},
    stream=True,
    incremental_output=True
)

# Define full reasoning process
reasoning_content = ""
# Define full response
answer_content = ""
# Determine if reasoning has ended and response has started
is_answering = False

print("=" * 20 + "Reasoning process" + "=" * 20)

for chunk in completion:
    # Ignore if both reasoning and response are empty
    if (
        chunk.output.choices[0].message.content == ""
        and chunk.output.choices[0].message.reasoning_content == ""
    ):
        pass
    else:
        # If currently in reasoning process
        if (
            chunk.output.choices[0].message.reasoning_content != ""
            and chunk.output.choices[0].message.content == ""
        ):
            print(chunk.output.choices[0].message.reasoning_content, end="", flush=True)
            reasoning_content += chunk.output.choices[0].message.reasoning_content
        # If currently in response
        elif chunk.output.choices[0].message.content != "":
            if not is_answering:
                print("\n" + "=" * 20 + "Full response" + "=" * 20)
                is_answering = True
            print(chunk.output.choices[0].message.content, end="", flush=True)
            answer_content += chunk.output.choices[0].message.content

Response

====================Thinking Process====================
1.  **Identify the user's goal:** The user wants me to extract specific information (name and age) from their sentence and return it in a specific format (JSON).
...
7.  **Final Review:**
    *   Does the JSON contain the name "Alex Brown"? Yes.
    *   Does the JSON contain the age 34? Yes.
    *   Is the format valid JSON? Yes.
    *   Does it directly answer the user's request? Yes.

This process is simple because it is a direct information extraction task. The key is to parse the Chinese sentence to find patterns ("My name is...", "... years old this year"), and then correctly format the extracted data as required.
====================Complete Response====================
{  "Name": "Alex Brown",
  "Age": 34
}

Sample code

// DashScope SDK version >= 2.19.4
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import io.reactivex.Flowable;
import java.lang.System;
import java.util.Arrays;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.dashscope.common.ResponseFormat;

public class Main {
    private static final Logger logger = LoggerFactory.getLogger(Main.class);
    private static StringBuilder reasoningContent = new StringBuilder();
    private static StringBuilder finalContent = new StringBuilder();
    private static boolean isFirstPrint = true;

    private static void handleGenerationResult(GenerationResult message) {
        String reasoning = message.getOutput().getChoices().get(0).getMessage().getReasoningContent();
        String content = message.getOutput().getChoices().get(0).getMessage().getContent();

        if (!reasoning.isEmpty()) {
            reasoningContent.append(reasoning);
            if (isFirstPrint) {
                System.out.println("====================Reasoning process====================");
                isFirstPrint = false;
            }
            System.out.print(reasoning);
        }

        if (!content.isEmpty()) {
            finalContent.append(content);
            if (!isFirstPrint) {
                System.out.println("\n====================Full response====================");
                isFirstPrint = true;
            }
            System.out.print(content);
        }
    }
    private static GenerationParam buildGenerationParam(List<Message> msgs) {
        ResponseFormat jsonMode = ResponseFormat.builder().type("json_object").build();
        return GenerationParam.builder()
                // If you haven't configured an environment variable, replace the next line with: .apiKey("sk-xxx") (Alibaba Cloud Model Studio API key)
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .model("glm-4.5")
                .enableThinking(true)
                .incrementalOutput(true)
                .resultFormat("message")
                .messages(msgs)
                .responseFormat(jsonMode)
                .build();
    }
    public static void streamCallWithMessage(Generation gen, List<Message> msgs)
            throws NoApiKeyException, ApiException, InputRequiredException {
        GenerationParam param = buildGenerationParam(msgs);
        Flowable<GenerationResult> result = gen.streamCall(param);
        result.blockingForEach(message -> handleGenerationResult(message));
    }

    public static void main(String[] args) {
        try {
            Generation gen = new Generation();
            Message systemMsg = Message.builder().role(Role.SYSTEM.getValue()).content("Extract the user's name and age, and return them in JSON format").build();
            Message userMsg = Message.builder().role(Role.USER.getValue()).content("Hi everyone, my name is Alex Brown, I'm 34 years old, my email is alexbrown@example.com, and I enjoy playing basketball and traveling").build();
            List<Message> msgs = Arrays.asList(systemMsg, userMsg);
            streamCallWithMessage(gen, msgs);
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            logger.error("An exception occurred: {}", e.getMessage());
        }
    }
}

Response

====================Reasoning process====================
1.  **Identify the user's goal:** The user wants me to extract specific information (name and age) from their sentence and return it in a specific format (JSON).
...
7.  **Final review:**
    *   Does the JSON contain the name "Alex Brown"? Yes.
    *   Does the JSON contain the age 34? Yes.
    *   Is the format valid JSON? Yes.
    *   Does it directly answer the user's request? Yes.

This process is straightforward because it's a direct information extraction task. The key is parsing the Chinese sentence to find patterns ("My name is...", "I'm ... years old") and then formatting the extracted data correctly as requested.
====================Full response====================
{  "name": "Alex Brown",
  "age": 34
}

Sample code

curl -X POST "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-H "X-DashScope-SSE: enable" \
-d '{
    "model": "glm-4.5",
    "input":{
        "messages":[      
            {
                "role": "system",
                "content": "Extract the user'\''s name and age, and return them in JSON format"
            },
            {
                "role": "user",
                "content": "Hi everyone, my name is Alex Brown, I'\''m 34 years old, my email is alexbrown@example.com, and I enjoy playing basketball and traveling"
            }
        ]
    },
    "parameters":{
        "enable_thinking": true,
        "incremental_output": true,
        "result_format": "message",
        "response_format": {
            "type": "json_object"
        }
    }
}'

from openai import OpenAI
import os
import json
import textwrap  # Used to handle the indentation of multi-line strings and improve code readability.

# Predefine example responses to show the model the expected output format.
# Example 1: A complete response that contains all fields.
example1_response = json.dumps(
    {
        "info": {"name": "John Doe", "age": "25 years old", "email": "johndoe@example.com"},
        "hobby": ["singing"]
    },
    ensure_ascii=False
)
# Example 2: A response that contains multiple hobbies.
example2_response = json.dumps(
    {
        "info": {"name": "Jane Smith", "age": "30 years old", "email": "janesmith@example.com"},
        "hobby": ["dancing", "swimming"]
    },
    ensure_ascii=False
)
# Example 3: A response that does not contain the hobby field (hobby is optional).
example3_response = json.dumps(
    {
        "info": {"name": "Alex Ray", "age": "28 years old", "email": "alexray@example.com"}
    },
    ensure_ascii=False
)
# Example 4: Another response that does not contain the hobby field.
example4_response = json.dumps(
    {
        "info": {"name": "Sam Wilson", "age": "35 years old", "email": "samwilson@example.com"}
    },
    ensure_ascii=False
)

# Initialize the OpenAI client.
client = OpenAI(
    # If you have not configured the environment variable, replace the following line with: api_key="sk-xxx"
    # API keys vary by region. To obtain an API key, see https://help.aliyun.com/en/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # The following is the base_url for the Beijing region. If you use a model in the Singapore region, replace the base_url with: https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# The dedent function removes common leading whitespace from every line in a string. 
# This lets you indent strings in your code for better readability without including the indentation in the runtime string.
system_prompt = textwrap.dedent(f"""\
    Please extract personal information from the user input and output it in the specified JSON Schema format.

    [Output Format Requirements]
    The output must strictly follow the JSON structure below:
    {{
      "info": {{
        "name": "String, required. The user's name.",
        "age": "String, required. The format must be '<number> years old', for example, '25 years old'.",
        "email": "String, required. A standard email format, for example, 'user@example.com'."
      }},
      "hobby": ["Array of strings, optional. Contains all of the user's hobbies. If no hobbies are mentioned, do not include this field in the output."]
    }}

    [Field Extraction Rules]
    1. name: Identify the user's name from the text. This field is required.
    2. age: Identify the age and convert it to the '<number> years old' format. This field is required.
    3. email: Identify the email address and keep its original format. This field is required.
    4. hobby: Identify the user's hobbies and output them as an array of strings. If no hobbies are mentioned, completely omit the hobby field.

    [Reference Examples]
    Example 1 (with hobbies):
    Q: My name is John Doe, I am 25 years old, my email is johndoe@example.com, and my hobby is singing.
    A: {example1_response}

    Example 2 (with multiple hobbies):
    Q: My name is Jane Smith, I am 30 years old, and I like dancing and swimming.
    A: {example2_response}

    Example 3 (without hobbies):
    Q: My name is Alex Ray, I am 28 years old, and my email is alexray@example.com.
    A: {example3_response}

    Example 4 (without hobbies):
    Q: I am Sam Wilson, 35 years old, email samwilson@example.com.
    A: {example4_response}

    Please strictly follow the format and rules above to extract information and output the JSON. If the user does not mention any hobbies, do not include the hobby field in the output.\
""")

# Call the model API to perform information extraction.
completion = client.chat.completions.create(
    model="qwen-plus",
    messages=[
        {
            "role": "system",
            "content": system_prompt
        },
        {
            "role": "user",
            "content": "Hello everyone, my name is Chris Lee, I am 34 years old, my email is chrislee@example.com, and I enjoy playing basketball and traveling.", 
        },
    ],
    response_format={"type": "json_object"},  # Specify the response format as JSON.
)

# Extract and print the JSON result generated by the model.
json_string = completion.choices[0].message.content
print(json_string)

Response

{
  "info": {
    "name": "Alex Brown",
    "age": "34 years old",
    "email": "alexbrown@example.com"
  },
  "hobby": ["Basketball", "Traveling"]  
}

import OpenAI from "openai";

// Predefined example responses (to demonstrate the expected output format to the model)
// Example 1: Complete response containing all fields
const example1Response = JSON.stringify({
    info: { name: "Alice", age: "25 years old", email: "alice@example.com" },
    hobby: ["singing"]
}, null, 2);

// Example 2: Response containing multiple hobbies
const example2Response = JSON.stringify({
    info: { name: "Bob", age: "30 years old", email: "bob@example.com" },
    hobby: ["dancing", "swimming"]
}, null, 2);

// Example 3: Response without the hobby field (hobby is optional)
const example3Response = JSON.stringify({
    info: { name: "Dave", age: "28 years old", email: "dave@example.com" }
}, null, 2);

// Example 4: Another response without the hobby field
const example4Response = JSON.stringify({
    info: { name: "Sun Qi", age: "35 years old", email: "sunqi@example.com" }
}, null, 2);

// Initialize the OpenAI client configuration
const openai = new OpenAI({
    // If environment variables are not configured, replace the following line with your Model Studio API key: apiKey: "sk-xxx"
    // API keys vary by region. To obtain an API key, see https://help.aliyun.com/en/model-studio/get-api-key
    apiKey: process.env.DASHSCOPE_API_KEY,
    // The following is the base URL for the Beijing region. If you use a model in the Singapore region, replace the base URL with: https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1
    baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
});

// Create a chat completion request using a structured prompt to improve output accuracy
const completion = await openai.chat.completions.create({
    model: "qwen-plus",
    messages: [
        {
            role: "system",
            content: `Extract personal information from the user input and output it in the specified JSON Schema format:

Output format requirements
The output must strictly follow this JSON structure:
{
  "info": {
    "name": "String type, required field, user's name",
    "age": "String type, required field, formatted as 'number + years old', for example, '25 years old'",
    "email": "String type, required field, standard email format, for example, 'user@example.com'"
  },
  "hobby": ["String array type, optional field, contains all user hobbies; omit this field entirely if hobbies are not mentioned"]
}

Field extraction rules
1. name: Identify the user's name from the text; this field is required
2. age: Identify the age information and convert it to the 'number + years old' format; this field is required
3. email: Identify the email address and retain its original format; this field is required
4. hobby: Identify the user's hobbies and output them as a string array; omit the hobby field entirely if no hobbies are mentioned

Reference examples
Example 1 (with hobbies):
Q: My name is Alice, I am 25 years old, my email is alice@example.com, and my hobby is singing
A: ${example1Response}

Example 2 (with multiple hobbies):
Q: My name is Bob, I am 30 years old, my email is bob@example.com, and I enjoy dancing and swimming
A: ${example2Response}

Example 3 (without hobbies):
Q: My name is Dave, I am 28 years old, and my email is dave@example.com
A: ${example3Response}

Example 4 (without hobbies):
Q: I am Sun Qi, 35 years old, and my email is sunqi@example.com
A: ${example4Response}

Strictly follow the above format and rules to extract information and output JSON. If the user does not mention hobbies, do not include the hobby field in the output.`
        },
        {
            role: "user",
            content: "Hello everyone, my name is Alex Brown, I am 34 years old, my email is alexbrown@example.com, and I enjoy playing basketball and traveling"
        }
    ],
    response_format: {
        type: "json_object"
    }
});

// Extract and print the JSON result generated by the model
const jsonString = completion.choices[0].message.content;
console.log(jsonString);

Response

{
  "info": {
    "name": "Alex Brown",
    "age": "34 years old",
    "email": "alexbrown@example.com"
  },
  "hobby": [
    "playing basketball",
    "traveling"
  ]
}

import os
import json
import dashscope

# If you use a model in the Singapore region, uncomment the following line.
# dashscope.base_http_api_url = "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1"

# Predefined sample responses (to show the model the expected output format).
example1_response = json.dumps(
    {
        "info": {"name": "Alice", "age": "25 years old", "email": "alice@example.com"},
        "hobby": ["singing"]
    },
    ensure_ascii=False
)
example2_response = json.dumps(
    {
        "info": {"name": "Bob", "age": "30 years old", "email": "bob@example.com"},
        "hobby": ["dancing", "swimming"]
    },
    ensure_ascii=False
)
example3_response = json.dumps(
    {
        "info": {"name": "Charlie", "age": "40 years old", "email": "charlie@example.com"},
        "hobby": ["Rap", "basketball"]
    },
    ensure_ascii=False
)

messages=[
        {
            "role": "system",
            "content": f"""Please extract personal information from the user input and output it in the specified JSON Schema format:

[Output Format Requirements]
The output must strictly follow the JSON structure below:
{{
  "info": {{
    "name": "String type, required field, user's name",
    "age": "String type, required field, format is 'number years old', for example, '25 years old'",
    "email": "String type, required field, standard email format, for example, 'user@example.com'"
  }},
  "hobby": ["String array type, optional field, contains all of the user's hobbies. If not mentioned, this field should be completely omitted from the output."]
}}

[Field Extraction Rules]
1. name: Identify the user's name from the text. This is a required field.
2. age: Identify the age information and convert it to the 'number years old' format. This is a required field.
3. email: Identify the email address and keep its original format. This is a required field.
4. hobby: Identify the user's hobbies and output them as a string array. If no hobbies are mentioned, omit the hobby field entirely.

[Reference Examples]
Example 1 (includes a hobby):
Q: My name is Alice, I am 25 years old, my email is alice@example.com, and my hobby is singing.
A: {example1_response}

Example 2 (includes multiple hobbies):
Q: My name is Bob, I am 30 years old, my email is bob@example.com, and I like dancing and swimming.
A: {example2_response}

Example 3 (includes multiple hobbies):
Q: My email is charlie@example.com, I am 40 years old, my name is Charlie, and I can rap and play basketball.
A: {example3_response}

Please strictly follow the format and rules above to extract information and output it in JSON format. If the user does not mention any hobbies, do not include the hobby field in the output."""
        },
        {
            "role": "user",
            "content": "Hello everyone, my name is Alex Brown, I am 34 years old, my email is alexbrown@example.com, and I enjoy playing basketball and traveling.", 
        },
    ]
response = dashscope.Generation.call(
    # If you have not configured the environment variable, replace the following line with your Alibaba Cloud Model Studio API key: api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="qwen-plus", 
    messages=messages,
    result_format='message',
    response_format={'type': 'json_object'}
    )
json_string = response.output.choices[0].message.content
print(json_string)

Response

{
  "info": {
    "name": "Alex Brown",
    "age": "34 years old",
    "email": "alexbrown@example.com"
  },
  "hobby": [
    "playing basketball",
    "traveling"
  ]
}

Response

{
  "info": {
    "name": "Alex Brown",
    "age": "34 years old",
    "email": "alexbrown@example.com"
  },
  "hobby": [
    "Playing basketball",
    "Traveling"
  ]
}