Alibaba Cloud Model Studio：文本產生

Python

範例程式碼

from openai import OpenAI
from datetime import datetime
import json
import os

client = OpenAI(
    # 若沒有配置環境變數，請用百鍊API Key將下行替換為：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",  # 填寫DashScope SDK的base_url
)

# 定義工具列表，模型在選擇使用哪個工具時會參考工具的name和description
tools = [
    # 工具1 擷取當前時刻的時間
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "當你想知道現在的時間時非常有用。",
            # 因為擷取目前時間無需輸入參數，因此parameters為空白字典
            "parameters": {}
        }
    },  
    # 工具2 擷取指定城市的天氣
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "當你想查詢指定城市的天氣時非常有用。",
            "parameters": {  
                "type": "object",
                "properties": {
                    # 查詢天氣時需要提供位置，因此參數設定為location
                    "location": {
                        "type": "string",
                        "description": "城市或縣區，比如北京市、杭州市、餘杭區等。"
                    }
                }
            },
            "required": [
                "location"
            ]
        }
    }
]

# 類比天氣查詢工具。返回結果樣本：“北京今天是雨天。”
def get_current_weather(location):
    return f"{location}今天是雨天。 "

# 查詢目前時間的工具。返回結果樣本：“目前時間：2024-04-15 17:15:18。“
def get_current_time():
    # 擷取當前日期和時間
    current_datetime = datetime.now()
    # 格式化當前日期和時間
    formatted_time = current_datetime.strftime('%Y-%m-%d %H:%M:%S')
    # 返回格式化後的目前時間
    return f"目前時間：{formatted_time}。"

# 封裝模型響應函數
def get_response(messages):
    completion = client.chat.completions.create(
        model="qwen-plus",
        messages=messages,
        tools=tools
        )
    return completion.model_dump()

def call_with_messages():
    print('\n')
    messages = [
            {
                "content": input('請輸入：'),  # 提問樣本："現在幾點了？" "一個小時後幾點" "北京天氣如何？"
                "role": "user"
            }
    ]
    print("-"*60)
    # 模型的第一輪調用
    i = 1
    first_response = get_response(messages)
    assistant_output = first_response['choices'][0]['message']
    print(f"\n第{i}輪大模型輸出資訊：{first_response}\n")
    if  assistant_output['content'] is None:
        assistant_output['content'] = ""
    messages.append(assistant_output)
    # 如果不需要調用工具，則直接返回最終答案
    if assistant_output['tool_calls'] == None:  # 如果模型判斷無需調用工具，則將assistant的回複直接列印出來，無需進行模型的第二輪調用
        print(f"無需調用工具，我可以直接回複：{assistant_output['content']}")
        return
    # 如果需要調用工具，則進行模型的多輪調用，直到模型判斷無需調用工具
    while assistant_output['tool_calls'] != None:
        # 如果判斷需要調用查詢天氣工具，則執行查詢天氣工具
        if assistant_output['tool_calls'][0]['function']['name'] == 'get_current_weather':
            tool_info = {"name": "get_current_weather", "role":"tool"}
            # 提取位置參數資訊
            location = json.loads(assistant_output['tool_calls'][0]['function']['arguments'])['location']
            tool_info['content'] = get_current_weather(location)
        # 如果判斷需要調用查詢時間工具，則執行查詢時間工具
        elif assistant_output['tool_calls'][0]['function']['name'] == 'get_current_time':
            tool_info = {"name": "get_current_time", "role":"tool"}
            tool_info['content'] = get_current_time()
        print(f"工具輸出資訊：{tool_info['content']}\n")
        print("-"*60)
        messages.append(tool_info)
        assistant_output = get_response(messages)['choices'][0]['message']
        if  assistant_output['content'] is None:
            assistant_output['content'] = ""
        messages.append(assistant_output)
        i += 1
        print(f"第{i}輪大模型輸出資訊：{assistant_output}\n")
    print(f"最終答案：{assistant_output['content']}")

if __name__ == '__main__':
    call_with_messages()

返回結果

當輸入：幾點了？時，程式會進行如下輸出：

以下是發起Function Call流程（模型的第一輪調用）時模型的返回資訊。當輸入“杭州天氣”時，模型會返回tool_calls參數；當輸入“你好”時，模型判斷無需調用工具，模型不會返回tool_calls參數。

{
    'id': 'chatcmpl-e2f045fd-2604-9cdb-bb61-37c805ecd15a',
    'choices': [
        {
            'finish_reason': 'tool_calls',
            'index': 0,
            'logprobs': None,
            'message': {
                'content': '',
                'role': 'assistant',
                'function_call': None,
                'tool_calls': [
                    {
                        'id': 'call_7a33ebc99d5342969f4868',
                        'function': {
                            'arguments': '{
                                "location": "杭州市"
                            }',
                            'name': 'get_current_weather'
                        },
                        'type': 'function',
                        'index': 0
                    }
                ]
            }
        }
    ],
    'created': 1726049697,
    'model': 'qwen-max',
    'object': 'chat.completion',
    'service_tier': None,
    'system_fingerprint': None,
    'usage': {
        'completion_tokens': 18,
        'prompt_tokens': 217,
        'total_tokens': 235
    }
}

{
    'id': 'chatcmpl-5d890637-9211-9bda-b184-961acf3be38d',
    'choices': [
        {
            'finish_reason': 'stop',
            'index': 0,
            'logprobs': None,
            'message': {
                'content': '你好！有什麼可以協助你的嗎？',
                'role': 'assistant',
                'function_call': None,
                'tool_calls': None
            }
        }
    ],
    'created': 1726049765,
    'model': 'qwen-max',
    'object': 'chat.completion',
    'service_tier': None,
    'system_fingerprint': None,
    'usage': {
        'completion_tokens': 7,
        'prompt_tokens': 216,
        'total_tokens': 223
    }
}

HTTP

範例程式碼

import requests
import os
from datetime import datetime
import json

# 定義工具列表，模型在選擇使用哪個工具時會參考工具的name和description
tools = [
    # 工具1 擷取當前時刻的時間
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "當你想知道現在的時間時非常有用。",
            "parameters": {}  # 因為擷取目前時間無需輸入參數，因此parameters為空白字典
        }
    },  
    # 工具2 擷取指定城市的天氣
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "當你想查詢指定城市的天氣時非常有用。",
            "parameters": {  # 查詢天氣時需要提供位置，因此參數設定為location
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "城市或縣區，比如北京市、杭州市、餘杭區等。"
                    }
                }
            },
            "required": [
                "location"
            ]
        }
    }
]

# 類比天氣查詢工具。返回結果樣本：“北京今天是晴天。”
def get_current_weather(location):
    return f"{location}今天是晴天。 "

# 查詢目前時間的工具。返回結果樣本：“目前時間：2024-04-15 17:15:18。“
def get_current_time():
    # 擷取當前日期和時間
    current_datetime = datetime.now()
    # 格式化當前日期和時間
    formatted_time = current_datetime.strftime('%Y-%m-%d %H:%M:%S')
    # 返回格式化後的目前時間
    return f"目前時間：{formatted_time}。"

def get_response(messages):
    # 若沒有配置環境變數，請用百鍊API Key將下行替換為：api_key="sk-xxx",
    api_key = os.getenv("DASHSCOPE_API_KEY")
    url = 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions'
    headers = {'Content-Type': 'application/json',
            'Authorization':f'Bearer {api_key}'}
    body = {
        'model': 'qwen-plus',
        "messages": messages,
        "tools":tools
    }

    response = requests.post(url, headers=headers, json=body)
    return response.json()


def call_with_messages():
    messages = [
            {
                "content": input('請輸入：'),  # 提問樣本："現在幾點了？" "一個小時後幾點" "北京天氣如何？"
                "role": "user"
            }
    ]
    
    # 模型的第一輪調用
    first_response = get_response(messages)
    print(f"\n第一輪調用結果：{first_response}")
    assistant_output = first_response['choices'][0]['message']
    if  assistant_output['content'] is None:
        assistant_output['content'] = ""
    messages.append(assistant_output)
    if 'tool_calls' not in assistant_output:  # 如果模型判斷無需調用工具，則將assistant的回複直接列印出來，無需進行模型的第二輪調用
        print(f"最終答案：{assistant_output['content']}")
        return
    # 如果模型選擇的工具是get_current_weather
    elif assistant_output['tool_calls'][0]['function']['name'] == 'get_current_weather':
        tool_info = {"name": "get_current_weather", "role":"tool"}
        location = json.loads(assistant_output['tool_calls'][0]['function']['arguments'])['location']
        tool_info['content'] = get_current_weather(location)
    # 如果模型選擇的工具是get_current_time
    elif assistant_output['tool_calls'][0]['function']['name'] == 'get_current_time':
        tool_info = {"name": "get_current_time", "role":"tool"}
        tool_info['content'] = get_current_time()
    print(f"工具輸出資訊：{tool_info['content']}")
    messages.append(tool_info)

    # 模型的第二輪調用，對工具的輸出進行總結
    second_response = get_response(messages)
    print(f"第二輪調用結果：{second_response}")
    print(f"最終答案：{second_response['choices'][0]['message']['content']}")

if __name__ == '__main__':
    call_with_messages()

返回結果

當輸入：杭州天氣時，程式會進行如下輸出：

以下是發起Function Call流程（模型的第一輪調用）時模型的返回資訊。當輸入“杭州天氣”時，模型會返回tool_calls參數；當輸入“你好”時，模型判斷無需調用工具，模型不會返回tool_calls參數。

{
    'choices': [
        {
            'message': {
                'content': '',
                'role': 'assistant',
                'tool_calls': [
                    {
                        'function': {
                            'name': 'get_current_weather',
                            'arguments': '{
                                "location": "杭州市"
                            }'
                        },
                        'index': 0,
                        'id': 'call_416cd81b8e7641edb654c4',
                        'type': 'function'
                    }
                ]
            },
            'finish_reason': 'tool_calls',
            'index': 0,
            'logprobs': None
        }
    ],
    'object': 'chat.completion',
    'usage': {
        'prompt_tokens': 217,
        'completion_tokens': 18,
        'total_tokens': 235
    },
    'created': 1726050222,
    'system_fingerprint': None,
    'model': 'qwen-max',
    'id': 'chatcmpl-61e30855-ee69-93ab-98d5-4194c51a9980'
}

{
    'choices': [
        {
            'message': {
                'content': '你好！有什麼可以協助你的嗎？',
                'role': 'assistant'
            },
            'finish_reason': 'stop',
            'index': 0,
            'logprobs': None
        }
    ],
    'object': 'chat.completion',
    'usage': {
        'prompt_tokens': 216,
        'completion_tokens': 7,
        'total_tokens': 223
    },
    'created': 1726050238,
    'system_fingerprint': None,
    'model': 'qwen-max',
    'id': 'chatcmpl-2f2f86d1-bc4e-9494-baca-aac5b0555091'
}

Node.js

範例程式碼

import OpenAI from "openai";
import { format } from 'date-fns';
import readline from 'readline';

function getCurrentWeather(location) {
    return `${location}今天是雨天。`;
}
function getCurrentTime() {
    // 擷取當前日期和時間
    const currentDatetime = new Date();
    // 格式化當前日期和時間
    const formattedTime = format(currentDatetime, 'yyyy-MM-dd HH:mm:ss');
    // 返回格式化後的目前時間
    return `目前時間：${formattedTime}。`;
}
const openai = new OpenAI(
    {
        // 若沒有配置環境變數，請用百鍊API Key將下行替換為：apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
    }
);
const tools = [
// 工具1 擷取當前時刻的時間
{
    "type": "function",
    "function": {
        "name": "getCurrentTime",
        "description": "當你想知道現在的時間時非常有用。",
        // 因為擷取目前時間無需輸入參數，因此parameters為空白
        "parameters": {}  
    }
},  
// 工具2 擷取指定城市的天氣
{
    "type": "function",
    "function": {
        "name": "getCurrentWeather",
        "description": "當你想查詢指定城市的天氣時非常有用。",
        "parameters": {  
            "type": "object",
            "properties": {
                // 查詢天氣時需要提供位置，因此參數設定為location
                "location": {
                    "type": "string",
                    "description": "城市或縣區，比如北京市、杭州市、餘杭區等。"
                }
            },
            "required": ["location"]
        }
    }
}
];
async function getResponse(messages) {
    const response = await openai.chat.completions.create({
        model: "qwen-plus",
        messages: messages,
        tools: tools,
    });
    return response;
}
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
rl.question("user: ", async (question) => {
    const messages = [{"role": "user","content": question}];
    let i = 1;
    const firstResponse = await getResponse(messages);
    let assistantOutput = firstResponse.choices[0].message;    
    console.log(`第${i}輪大模型輸出資訊：${JSON.stringify(assistantOutput)}`);
    if (Object.is(assistantOutput.content,null)){
        assistantOutput.content = "";
    }
    messages.push(assistantOutput);
    if (! ("tool_calls" in assistantOutput)) {
        console.log(`無需調用工具，我可以直接回複：${assistantOutput.content}`);
        rl.close();
    } else{
        while ("tool_calls" in assistantOutput) {
            let toolInfo = {};
            if (assistantOutput.tool_calls[0].function.name == "getCurrentWeather" ) {
                toolInfo = {"role": "tool"};
                let location = JSON.parse(assistantOutput.tool_calls[0].function.arguments)["location"];
                toolInfo["content"] = getCurrentWeather(location);
            } else if (assistantOutput.tool_calls[0].function.name == "getCurrentTime" ) {
                toolInfo = {"role":"tool"};
                toolInfo["content"] = getCurrentTime();
            }
            console.log(`工具輸出資訊：${JSON.stringify(toolInfo)}`);
            console.log("=".repeat(100));
            messages.push(toolInfo);
            assistantOutput = (await getResponse(messages)).choices[0].message;
            if (Object.is(assistantOutput.content,null)){
                assistantOutput.content = "";
            }
            messages.push(assistantOutput);
            i += 1;
            console.log(`第${i}輪大模型輸出資訊：${JSON.stringify(assistantOutput)}`)
    }
    console.log("=".repeat(100));
    console.log(`最終大模型輸出資訊：${JSON.stringify(assistantOutput.content)}`);
    rl.close();
    }});

返回結果

輸入四個直轄市的天氣如何？，輸出結果為：

第1輪大模型輸出資訊：{"content":"","role":"assistant","tool_calls":[{"function":{"name":"getCurrentWeather","arguments":"{\"location\": \"北京市\"}"},"index":0,"id":"call_d2aff21240b24c7291db6d","type":"function"}]}
工具輸出資訊：{"role":"tool","content":"北京市今天是雨天。"}
====================================================================================================
第2輪大模型輸出資訊：{"content":"","role":"assistant","tool_calls":[{"function":{"name":"getCurrentWeather","arguments":"{\"location\": \"天津市\"}"},"index":0,"id":"call_bdcfa937e69b4eae997b5e","type":"function"}]}
工具輸出資訊：{"role":"tool","content":"天津市今天是雨天。"}
====================================================================================================
第3輪大模型輸出資訊：{"content":"","role":"assistant","tool_calls":[{"function":{"name":"getCurrentWeather","arguments":"{\"location\": \"上海市\"}"},"index":0,"id":"call_bbf22d017e8e439e811974","type":"function"}]}
工具輸出資訊：{"role":"tool","content":"上海市今天是雨天。"}
====================================================================================================
第4輪大模型輸出資訊：{"content":"","role":"assistant","tool_calls":[{"function":{"name":"getCurrentWeather","arguments":"{\"location\": \"重慶市\"}"},"index":0,"id":"call_f4f8e149af01492fb60162","type":"function"}]}
工具輸出資訊：{"role":"tool","content":"重慶市今天是雨天。"}
====================================================================================================
第5輪大模型輸出資訊：{"content":"所有四個直轄市（北京市、天津市、上海市、重慶市）今天的天氣都是雨天。別忘了帶傘！","role":"assistant"}
====================================================================================================
最終大模型輸出資訊："所有四個直轄市（北京市、天津市、上海市、重慶市）今天的天氣都是雨天。別忘了帶傘！"

Python

範例程式碼

import os
from dashscope import Generation
from datetime import datetime
import random
import json
import dashscope
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

# 定義工具列表，模型在選擇使用哪個工具時會參考工具的name和description
tools = [
    # 工具1 擷取當前時刻的時間
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "當你想知道現在的時間時非常有用。",
            "parameters": {}  # 因為擷取目前時間無需輸入參數，因此parameters為空白字典
        }
    },
    # 工具2 擷取指定城市的天氣
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "當你想查詢指定城市的天氣時非常有用。",
            "parameters": {
                # 查詢天氣時需要提供位置，因此參數設定為location
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "城市或縣區，比如北京市、杭州市、餘杭區等。"
                    }
                }
            },
            "required": [
                "location"
            ]
        }
    }
]


# 類比天氣查詢工具。返回結果樣本：“北京今天是晴天。”
def get_current_weather(location):
    return f"{location}今天是晴天。 "


# 查詢目前時間的工具。返回結果樣本：“目前時間：2024-04-15 17:15:18。“
def get_current_time():
    # 擷取當前日期和時間
    current_datetime = datetime.now()
    # 格式化當前日期和時間
    formatted_time = current_datetime.strftime('%Y-%m-%d %H:%M:%S')
    # 返回格式化後的目前時間
    return f"目前時間：{formatted_time}。"


# 封裝模型響應函數
def get_response(messages):
    response = Generation.call(
        # 若沒有配置環境變數，請用百鍊API Key將下行替換為：api_key="sk-xxx",
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        model='qwen-plus',
        messages=messages,
        tools=tools,
        seed=random.randint(1, 10000),  # 設定隨機數種子seed，如果沒有設定，則隨機數種子預設為1234
        result_format='message'  # 將輸出設定為message形式
    )
    return response


def call_with_messages():
    print('\n')
    messages = [
            {
                "content": input('請輸入：'),  # 提問樣本："現在幾點了？" "一個小時後幾點" "北京天氣如何？"
                "role": "user"
            }
    ]
   
    # 模型的第一輪調用
    first_response = get_response(messages)
    assistant_output = first_response.output.choices[0].message
    print(f"\n大模型第一輪輸出資訊：{first_response}\n")
    messages.append(assistant_output)
    if 'tool_calls' not in assistant_output:  # 如果模型判斷無需調用工具，則將assistant的回複直接列印出來，無需進行模型的第二輪調用
        print(f"最終答案：{assistant_output.content}")
        return
    # 如果模型選擇的工具是get_current_weather
    elif assistant_output.tool_calls[0]['function']['name'] == 'get_current_weather':
        tool_info = {"name": "get_current_weather", "role":"tool"}
        location = json.loads(assistant_output.tool_calls[0]['function']['arguments'])['location']
        tool_info['content'] = get_current_weather(location)
    # 如果模型選擇的工具是get_current_time
    elif assistant_output.tool_calls[0]['function']['name'] == 'get_current_time':
        tool_info = {"name": "get_current_time", "role":"tool"}
        tool_info['content'] = get_current_time()
    print(f"工具輸出資訊：{tool_info['content']}\n")
    messages.append(tool_info)

    # 模型的第二輪調用，對工具的輸出進行總結
    second_response = get_response(messages)
    print(f"大模型第二輪輸出資訊：{second_response}\n")
    print(f"最終答案：{second_response.output.choices[0].message['content']}")

if __name__ == '__main__':
    call_with_messages()

返回結果

通過運行以上代碼，您可以輸入問題，得到在工具輔助條件下模型的輸出結果。使用過程樣本如下圖所示：

以下是發起Function Call流程（模型的第一輪調用）時模型的返回資訊。當輸入“杭州天氣”時，模型會返回tool_calls參數；當輸入“你好”時，模型判斷無需調用工具，模型不會返回tool_calls參數。

{
  "status_code": 200,
  "request_id": "33cf0a53-ea38-9f47-8fce-b93b55d86573",
  "code": "",
  "message": "",
  "output": {
    "text": null,
    "finish_reason": null,
    "choices": [
      {
        "finish_reason": "tool_calls",
        "message": {
          "role": "assistant",
          "content": "",
          "tool_calls": [
            {
              "function": {
                "name": "get_current_weather",
                "arguments": "{\"location\": \"杭州市\"}"
              },
              "index": 0,
              "id": "call_9f62f52f3a834a8194f634",
              "type": "function"
            }
          ]
        }
      }
    ]
  },
  "usage": {
    "input_tokens": 217,
    "output_tokens": 18,
    "total_tokens": 235
  }
}

{
  "status_code": 200,
  "request_id": "4818ce03-e7c9-96de-a7bc-781649d98465",
  "code": "",
  "message": "",
  "output": {
    "text": null,
    "finish_reason": null,
    "choices": [
      {
        "finish_reason": "stop",
        "message": {
          "role": "assistant",
          "content": "你好！有什麼可以協助你的嗎？"
        }
      }
    ]
  },
  "usage": {
    "input_tokens": 216,
    "output_tokens": 7,
    "total_tokens": 223
  }
}

Java

範例程式碼

// Copyright (c) Alibaba, Inc. and its affiliates.
// version >= 2.12.0

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import com.alibaba.dashscope.aigc.conversation.ConversationParam.ResultFormat;
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationOutput.Choice;
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 com.alibaba.dashscope.tools.FunctionDefinition;
import com.alibaba.dashscope.tools.ToolCallBase;
import com.alibaba.dashscope.tools.ToolCallFunction;
import com.alibaba.dashscope.tools.ToolFunction;
import com.alibaba.dashscope.utils.JsonUtils;
import com.alibaba.dashscope.protocol.Protocol;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.github.victools.jsonschema.generator.Option;
import com.github.victools.jsonschema.generator.OptionPreset;
import com.github.victools.jsonschema.generator.SchemaGenerator;
import com.github.victools.jsonschema.generator.SchemaGeneratorConfig;
import com.github.victools.jsonschema.generator.SchemaGeneratorConfigBuilder;
import com.github.victools.jsonschema.generator.SchemaVersion;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Scanner;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {

    public static class GetWeatherTool {
        private String location;

        public GetWeatherTool(String location) {
            this.location = location;
        }

        public String callWeather() {
            // 假設location是一個JSON字串，例如{"location": "北京"}
            // 需要提取其中的"location"的值
            try {
                // 使用Jackson庫解析JSON
                ObjectMapper objectMapper = new ObjectMapper();
                JsonNode jsonNode = objectMapper.readTree(location);
                String locationName = jsonNode.get("location").asText();
                return locationName + "今天是晴天";
            } catch (Exception e) {
                // 如果解析失敗，返回原始字串
                return location + "今天是晴天";
            }
        }
    }
    public static class GetTimeTool {
        public String getCurrentTime() {
            LocalDateTime now = LocalDateTime.now();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            return "目前時間：" + now.format(formatter) + "。";
        }
    }
    private static ObjectNode generateSchema(Class<?> clazz) {
        SchemaGeneratorConfigBuilder configBuilder =
                new SchemaGeneratorConfigBuilder(SchemaVersion.DRAFT_2020_12, OptionPreset.PLAIN_JSON);
        SchemaGeneratorConfig config = configBuilder.with(Option.EXTRA_OPEN_API_FORMAT_VALUES)
                .without(Option.FLATTENED_ENUMS_FROM_TOSTRING).build();
        SchemaGenerator generator = new SchemaGenerator(config);
        return generator.generateSchema(clazz);
    }
    public static void selectTool()
            throws NoApiKeyException, ApiException, InputRequiredException {
        ObjectNode jsonSchemaWeather = generateSchema(GetWeatherTool.class);
        ObjectNode jsonSchemaTime = generateSchema(GetTimeTool.class);
        FunctionDefinition fdWeather = FunctionDefinition.builder().name("get_current_weather")
                .description("擷取指定地區的天氣")
                .parameters(JsonUtils.parseString(jsonSchemaWeather.toString()).getAsJsonObject()).build();
        FunctionDefinition fdTime = FunctionDefinition.builder().name("get_current_time")
                .description("擷取當前時刻的時間")
                .parameters(JsonUtils.parseString(jsonSchemaTime.toString()).getAsJsonObject()).build();
        Message systemMsg = Message.builder().role(Role.SYSTEM.getValue())
                .content("You are a helpful assistant. When asked a question, use tools wherever possible.")
                .build();
        Scanner scanner = new Scanner(System.in);
        System.out.println("請輸入：");
        String userInput = scanner.nextLine();
        Message userMsg = Message.builder().role(Role.USER.getValue()).content(userInput).build();
        List<Message> messages = new ArrayList<>(Arrays.asList(systemMsg, userMsg));
        GenerationParam param = GenerationParam.builder()
                .model("qwen-plus")
                // 若沒有配置環境變數，請用百鍊API Key將下行替換為：.apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .messages(messages).resultFormat(ResultFormat.MESSAGE)
                .tools(Arrays.asList(
                        ToolFunction.builder().function(fdWeather).build(),
                        ToolFunction.builder().function(fdTime).build()
                )).build();
        Generation gen = new Generation(Protocol.HTTP.getValue(), "https://dashscope-intl.aliyuncs.com/api/v1");
        GenerationResult result = gen.call(param);
        System.out.println("首輪輸出：" + JsonUtils.toJson(result));
        boolean needToolCall = true;
        while (needToolCall) {
            needToolCall = false;
            for (Choice choice : result.getOutput().getChoices()) {
                messages.add(choice.getMessage());
                if (choice.getMessage().getToolCalls() != null) {
                    for (ToolCallBase toolCall : choice.getMessage().getToolCalls()) {
                        if (toolCall.getType().equals("function")) {
                            String functionName = ((ToolCallFunction) toolCall).getFunction().getName();
                            String functionArgument = ((ToolCallFunction) toolCall).getFunction().getArguments();
                            if (functionName.equals("get_current_weather")) {
                                GetWeatherTool weatherTool = new GetWeatherTool(functionArgument);
                                String weather = weatherTool.callWeather();
                                Message toolResultMessage = Message.builder().role("tool")
                                        .content(weather).toolCallId(toolCall.getId()).build();
                                messages.add(toolResultMessage);
                                System.out.println("工具輸出資訊：" + weather);
                            } else if (functionName.equals("get_current_time")) {
                                GetTimeTool timeTool = new GetTimeTool();
                                String time = timeTool.getCurrentTime();
                                Message toolResultMessage = Message.builder().role("tool")
                                        .content(time).toolCallId(toolCall.getId()).build();
                                messages.add(toolResultMessage);
                                System.out.println("工具輸出資訊：" + time);
                            }
                            needToolCall = true;
                        }
                    }
                } else {
                    System.out.println("最終答案：" + choice.getMessage().getContent());
                    return;
                }
            }

            if (needToolCall) {
                param.setMessages(messages);
                result = gen.call(param);
                System.out.println("下一輪輸出：" + JsonUtils.toJson(result));
            }
        }

        System.out.println("最終答案：" + result.getOutput().getChoices().get(0).getMessage().getContent());
    }

    public static void main(String[] args) {
        try {
            selectTool();
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            System.out.println(String.format("Exception: %s", e.getMessage()));
        } catch (Exception e) {
            System.out.println(String.format("Exception: %s", e.getMessage()));
        }
        System.exit(0);
    }
}

返回結果

通過運行以上代碼，您可以輸入問題，得到在工具輔助條件下模型的輸出結果。使用過程樣本如下圖所示：

以下是發起Function Call流程（模型的第一輪調用）時模型的返回資訊。當輸入“杭州天氣”時，模型會返回tool_calls參數；當輸入“你好”時，模型判斷無需調用工具，模型不會返回tool_calls參數。

{
    "requestId": "e2faa5cf-1707-973b-b216-36aa4ef52afc",
    "usage": {
        "input_tokens": 254,
        "output_tokens": 19,
        "total_tokens": 273
    },
    "output": {
        "choices": [
            {
                "finish_reason": "tool_calls",
                "message": {
                    "role": "assistant",
                    "content": "",
                    "tool_calls": [
                        {
                            "type": "function",
                            "id": "",
                            "function": {
                                "name": "get_current_whether",
                                "arguments": "{\"location\": \"杭州\"}"
                            }
                        }
                    ]
                }
            }
        ]
    }
}

{
    "requestId": "f6ca3828-3b5f-99bf-8bae-90b4aa88923f",
    "usage": {
        "input_tokens": 253,
        "output_tokens": 7,
        "total_tokens": 260
    },
    "output": {
        "choices": [
            {
                "finish_reason": "stop",
                "message": {
                    "role": "assistant",
                    "content": "你好！有什麼可以協助你的嗎？"
                }
            }
        ]
    }
}

HTTP

範例程式碼

import requests
import os
from datetime import datetime
import json

# 定義工具列表，模型在選擇使用哪個工具時會參考工具的name和description
tools = [
    # 工具1 擷取當前時刻的時間
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "當你想知道現在的時間時非常有用。",
            "parameters": {}  # 因為擷取目前時間無需輸入參數，因此parameters為空白字典
        }
    },  
    # 工具2 擷取指定城市的天氣
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "當你想查詢指定城市的天氣時非常有用。",
            "parameters": {  # 查詢天氣時需要提供位置，因此參數設定為location
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "城市或縣區，比如北京市、杭州市、餘杭區等。"
                    }
                }
            },
            "required": [
                "location"
            ]
        }
    }
]

# 類比天氣查詢工具。返回結果樣本：“北京今天是晴天。”
def get_current_weather(location):
    return f"{location}今天是晴天。 "

# 查詢目前時間的工具。返回結果樣本：“目前時間：2024-04-15 17:15:18。“
def get_current_time():
    # 擷取當前日期和時間
    current_datetime = datetime.now()
    # 格式化當前日期和時間
    formatted_time = current_datetime.strftime('%Y-%m-%d %H:%M:%S')
    # 返回格式化後的目前時間
    return f"目前時間：{formatted_time}。"

def get_response(messages):
    api_key = os.getenv("DASHSCOPE_API_KEY")
    url = 'https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation'
    headers = {'Content-Type': 'application/json',
            'Authorization':f'Bearer {api_key}'}
    body = {
        'model': 'qwen-plus',
        "input": {

                        "messages": messages
        },
        "parameters": {
            "result_format": "message",
            "tools": tools
        }
    }

    response = requests.post(url, headers=headers, json=body)
    return response.json()

messages = [
    {
        "role": "user",
        "content": "今天天氣怎麼樣？"
    }
]

def call_with_messages():
    messages = [
            {
                "content": input('請輸入：'),  # 提問樣本："現在幾點了？" "一個小時後幾點" "北京天氣如何？"
                "role": "user"
            }
    ]
    
    # 模型的第一輪調用
    first_response = get_response(messages)
    print(f"\n第一輪調用結果：{first_response}")
    assistant_output = first_response['output']['choices'][0]['message']
    messages.append(assistant_output)
    if 'tool_calls' not in assistant_output:  # 如果模型判斷無需調用工具，則將assistant的回複直接列印出來，無需進行模型的第二輪調用
        print(f"最終答案：{assistant_output['content']}")
        return
    # 如果模型選擇的工具是get_current_weather
    elif assistant_output['tool_calls'][0]['function']['name'] == 'get_current_weather':
        tool_info = {"name": "get_current_weather", "role":"tool"}
        location = json.loads(assistant_output['tool_calls'][0]['function']['arguments'])['location']
        tool_info['content'] = get_current_weather(location)
    # 如果模型選擇的工具是get_current_time
    elif assistant_output['tool_calls'][0]['function']['name'] == 'get_current_time':
        tool_info = {"name": "get_current_time", "role":"tool"}
        tool_info['content'] = get_current_time()
    print(f"工具輸出資訊：{tool_info['content']}")
    messages.append(tool_info)

    # 模型的第二輪調用，對工具的輸出進行總結
    second_response = get_response(messages)
    print(f"第二輪調用結果：{second_response}")
    print(f"最終答案：{second_response['output']['choices'][0]['message']['content']}")

if __name__ == '__main__':
    call_with_messages()

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import org.json.JSONArray;
import org.json.JSONObject;

public class Main {
    private static final String userAGENT = "Java-HttpURLConnection/1.0";
    public static void main(String[] args) throws Exception {
        // 使用者輸入問題
        Scanner scanner = new Scanner(System.in);
        System.out.println("請輸入：");
        String UserInput = scanner.nextLine();
        // 初始化messages
        JSONArray messages = new JSONArray();
        // 定義系統資訊system_message
        JSONObject systemMessage = new JSONObject();
        systemMessage.put("role","system");
        systemMessage.put("content","You are a helpful assistant.");
        // 根據使用者的輸入構造user_message
        JSONObject userMessage = new JSONObject();
        userMessage.put("role","user");
        userMessage.put("content",UserInput);
        // 將system_message和user_message依次添加到messages中
        messages.put(systemMessage);
        messages.put(userMessage);
        // 進行模型的第一輪調用，並列印出結果
        JSONObject responseJson = getResponse(messages);
        System.out.println("第一輪調用結果："+responseJson);
        // 擷取助手資訊assistant_message
        JSONObject assistantMessage = responseJson.getJSONObject("output").getJSONArray("choices").getJSONObject(0).getJSONObject("message");
        // 初始化工具資訊tool_message
        JSONObject toolMessage = new JSONObject();

        // 如果assistant_message沒有tool_calls參數，則直接列印出assistant_message中的響應資訊並返回
        if (! assistantMessage.has("tool_calls")){
            System.out.println("最終答案："+assistantMessage.get("content"));
            return;
        }
        // 如果assistant_message有tool_calls參數，說明模型判斷需要調用工具
        else {
            // 將assistant_message添加到messages中
            messages.put(assistantMessage);
            // 如果模型判斷需要調用get_current_weather函數
            if (assistantMessage.getJSONArray("tool_calls").getJSONObject(0).getJSONObject("function").getString("name").equals("get_current_weather")) {
                // 擷取參數arguments資訊，並提取出location參數
                JSONObject argumentsJson = new JSONObject(assistantMessage.getJSONArray("tool_calls").getJSONObject(0).getJSONObject("function").getString("arguments"));
                String location = argumentsJson.getString("location");
                // 運行工具函數，得到工具的輸出，並列印
                String toolOutput = getCurrentWeather(location);
                System.out.println("工具輸出資訊："+toolOutput);
                // 構造tool_message資訊
                toolMessage.put("name","get_current_weather");
                toolMessage.put("role","tool");
                toolMessage.put("content",toolOutput);
            }
            // 如果模型判斷需要調用get_current_time函數
            if (assistantMessage.getJSONArray("tool_calls").getJSONObject(0).getJSONObject("function").getString("name").equals("get_current_time")) {
                // 運行工具函數，得到工具的輸出，並列印
                String toolOutput = getCurrentTime();
                System.out.println("工具輸出資訊："+toolOutput);
                // 構造tool_message資訊
                toolMessage.put("name","get_current_time");
                toolMessage.put("role","tool");
                toolMessage.put("content",toolOutput);
            }
        }
        // 將tool_message添加到messages中
        messages.put(toolMessage);
        // 進行模型的第二輪調用，並列印出結果
        JSONObject secondResponse = getResponse(messages);
        System.out.println("第二輪調用結果："+secondResponse);
        System.out.println("最終答案："+secondResponse.getJSONObject("output").getJSONArray("choices").getJSONObject(0).getJSONObject("message").getString("content"));
    }
    // 定義擷取天氣的函數
    public static String getCurrentWeather(String location) {
        return location+"今天是晴天";
    }
    // 定義擷取目前時間的函數
    public static String getCurrentTime() {
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String currentTime = "目前時間：" + now.format(formatter) + "。";
        return currentTime;
    }
    // 封裝模型響應函數，輸入：messages，輸出：json格式化後的http響應
    public static JSONObject getResponse(JSONArray messages) throws Exception{
        // 初始化工具庫
        JSONArray tools = new JSONArray();
        // 定義工具1：擷取目前時間
        String jsonStringTime = "{\"type\": \"function\", \"function\": {\"name\": \"get_current_time\", \"description\": \"當你想知道現在的時間時非常有用。\", \"parameters\": {}}}";
        JSONObject getCurrentTimeJson = new JSONObject(jsonStringTime);
        // 定義工具2：擷取指定地區天氣
        String jsonString_weather = "{\"type\": \"function\", \"function\": {\"name\": \"get_current_weather\", \"description\": \"當你想查詢指定城市的天氣時非常有用。\", \"parameters\": {\"type\": \"object\", \"properties\": {\"location\": {\"type\": \"string\", \"description\": \"城市或縣區，比如北京市、杭州市、餘杭區等。\"}}}, \"required\": [\"location\"]}}";
        JSONObject getCurrentWeatherJson = new JSONObject(jsonString_weather);
        // 將兩個工具添加到工具庫中
        tools.put(getCurrentTimeJson);
        tools.put(getCurrentWeatherJson);
        String toolsString = tools.toString();
        // 介面調用URL
        String urlStr = "https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation";
        // 通過環境變數擷取DASHSCOPE_API_KEY
        String apiKey = System.getenv("DASHSCOPE_API_KEY");

        URL url = new URL(urlStr);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("POST");
        // 定義要求標頭資訊
        connection.setRequestProperty("Content-Type", "application/json");
        connection.setRequestProperty("Authorization", "Bearer " + apiKey);
        connection.setDoOutput(true);
        // 定義請求體資訊
        String jsonInputString = String.format("{\"model\": \"qwen-max\", \"input\": {\"messages\":%s}, \"parameters\": {\"result_format\": \"message\",\"tools\":%s}}",messages.toString(),toolsString);

        // 擷取http響應response
        try (DataOutputStream wr = new DataOutputStream(connection.getOutputStream())) {
            wr.write(jsonInputString.getBytes(StandardCharsets.UTF_8));
            wr.flush();
        }
        StringBuilder response = new StringBuilder();
        try (BufferedReader in = new BufferedReader(
                new InputStreamReader(connection.getInputStream()))) {
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
        }
        connection.disconnect();
        // 返回json格式化後的response
        return new JSONObject(response.toString());
    }
}

返回結果

當輸入：杭州天氣時，程式會進行如下輸出：

以下是發起Function Call流程（模型的第一輪調用）時模型的返回資訊。當輸入“杭州天氣”時，模型會返回tool_calls參數；當輸入“你好”時，模型判斷無需調用工具，模型不會返回tool_calls參數。

{
    'output': {
        'choices': [
            {
                'finish_reason': 'tool_calls',
                'message': {
                    'role': 'assistant',
                    'tool_calls': [
                        {
                            'function': {
                                'name': 'get_current_weather',
                                'arguments': '{
                                    "location": "杭州市"
                                }'
                            },
                            'index': 0,
                            'id': 'call_240d6341de4c484384849d',
                            'type': 'function'
                        }
                    ],
                    'content': ''
                }
            }
        ]
    },
    'usage': {
        'total_tokens': 235,
        'output_tokens': 18,
        'input_tokens': 217
    },
    'request_id': '235ed6a4-b6c0-9df0-aa0f-3c6dce89f3bd'
}

{
    'output': {
        'choices': [
            {
                'finish_reason': 'stop',
                'message': {
                    'role': 'assistant',
                    'content': '你好！有什麼可以協助你的嗎？'
                }
            }
        ]
    },
    'usage': {
        'total_tokens': 223,
        'output_tokens': 7,
        'input_tokens': 216
    },
    'request_id': '42c42853-3caf-9815-96e8-9c950f4c26a0'
}

Python

範例程式碼

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"), # 如果您沒有配置環境變數，請在此處用您的API Key進行替換
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",  # 填寫DashScope服務的base_url
)
completion = client.chat.completions.create(
    model="qwen-plus",
    messages=[{
        "role": "user",
        "content": "請對“春天來了，大地”這句話進行續寫，來表達春天的美好和作者的喜悅之情"
    },
    {
        "role": "assistant",
        "content": "春天來了，大地",
        "partial": True
    }]
    )
print(completion.choices[0].message.content)

返回結果

披上了一襲翠綠的新裝，萬物複蘇，生機盎然。陽光溫柔地灑在每一寸土地上，彷彿是大自然最溫暖的擁抱。花兒爭先恐後地綻放，紅的、黃的、紫的……如同調色盤上最絢爛的顏色，點綴著這幅春日畫卷。微風輕拂，帶來陣陣花香與泥土的清新氣息，令人心曠神怡。小溪邊，柳樹抽出嫩芽，隨風搖曳生姿；田野裡，農民伯伯開始忙碌起來，播下希望的種子。在這充滿活力與美好的季節裡，我感受到了生命的力量，心中充滿了無限的喜悅與期待。

curl

範例程式碼

curl -X POST https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen-plus",
    "messages": [{
        "role": "user",
        "content": "請對“春天來了，大地”這句話進行續寫，來表達春天的美好和作者的喜悅之情"
    },
    {
        "role": "assistant",
        "content": "春天來了，大地",
        "partial": true
    }]
}'

返回結果

{
    "choices": [
        {
            "message": {
                "role": "assistant",
                "content": "換上了翠綠的新裝，萬物複蘇，生機勃勃。陽光透過輕柔的雲層，灑在剛剛探出頭的小草上，彷彿給它們披上了一層金色的紗衣。花兒們也不甘落後，爭先恐後地綻放著自己的美麗，紅的、黃的、紫的……五彩斑斕，像是大自然精心布置的一幅絢麗畫卷。微風中夾雜著泥土的芬芳與花香，讓人心曠神怡。漫步在這春意盎然的世界裡，我的心情也跟著明媚起來，感受到了生命的力量和希望的美好。"
            },
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 34,
        "completion_tokens": 125,
        "total_tokens": 159
    },
    "created": 1731898325,
    "system_fingerprint": null,
    "model": "qwen-plus",
    "id": "chatcmpl-244c5496-6a84-9380-951d-49d4691f252a"
}

Python

範例程式碼

import os
import dashscope
import dashscope
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

messages = [{
    "role": "user",
    "content": "請對“春天來了，大地”這句話進行續寫，來表達春天的美好和作者的喜悅之情"
},
{
    "role": "assistant",
    "content": "春天來了，大地",
    "partial": True
}]
response = dashscope.Generation.call(
    # 若沒有配置環境變數，請用百鍊API Key將下行替換為：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model='qwen-plus',
    messages=messages,
    result_format='message',  
)

print(response.output.choices[0].message.content)

返回結果

彷彿從漫長的冬眠中蘇醒，披上了一襲翠綠的新裝。萬物複蘇，生機勃勃，小草偷偷地探出了頭，花朵也爭先恐後地綻放著自己的美麗，散發出陣陣芳香。樹木抽出嫩芽，一片片葉子在陽光下閃爍著生命的光澤。河流解凍，潺潺流水聲如同大自然最美妙的樂章，喚醒了沉睡的山川。在這溫暖的季節裡，不僅自然界充滿了活力與希望，人們的心靈也隨之變得輕盈而愉悅，彷彿所有的煩惱都隨著春風飄散而去。我走在這樣的景色之中，心中滿是歡喜與感激，感謝這美好的春日時光，讓生活更加多彩多姿。

curl

範例程式碼

curl -X POST "https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen-plus",
    "input":{
        "messages":[{
            "role": "user",
            "content": "請對“春天來了，大地”這句話進行續寫，來表達春天的美好和作者的喜悅之情"
        },
        {
            "role": "assistant",
            "content": "春天來了，大地",
            "partial": true
        }]
    },
    "parameters": {
        "result_format": "message"
    }
}'

返回結果

{
    "output": {
        "choices": [
            {
                "finish_reason": "stop",
                "message": {
                    "role": "assistant",
                    "content": "換上了嫩綠的新裝，萬物複蘇，生機盎然。陽光透過輕盈的雲層，溫柔地撫摸著每一寸土地，彷彿是大自然最溫暖的擁抱。花朵競相開放，散發出陣陣芬芳，吸引著蜜蜂與蝴蝶前來探訪，它們忙碌的身影在花間穿梭，構成了一幅生動活潑的畫面。小溪解凍，潺潺流水聲如同天籟之音，喚醒了沉睡一冬的小動物們，它們歡快地在林間跳躍、嬉戲。這一切美好景象，讓人心情愉悅，彷彿連空氣中都瀰漫著幸福的味道。我走在這樣的季節裡，心中充滿了對生活的熱愛和對未來無限美好的憧憬。"
                }
            }
        ]
    },
    "usage": {
        "total_tokens": 177,
        "output_tokens": 143,
        "input_tokens": 34
    },
    "request_id": "bb4dab4a-aba1-9786-9857-d0743bab11e8"
}