Alibaba Cloud Model Studio:Function calling

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

client = OpenAI(
    # If you use a model in the China (Singapore) region, you must use an API key from that region. Get it here: https://bailian.console.alibabacloud.com/?tab=model#/api-key
    # If you have not configured an environment variable, replace the next line with: api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # If you use a model in the China (Singapore) region, replace the base_url with: https://dashscope.aliyuncs.com/compatible-mode/v1
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",  
)
# Simulate a user question.
USER_QUESTION = "What's the weather like in Singapore?"
# Define the tool list.
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Useful for when you want to query the weather in a specific city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "A city or district, such as Singapore, London, or Shanghai.",
                    }
                },
                "required": ["location"],
            },
        },
    },
]


# Simulate a weather query tool.
def get_current_weather(arguments):
    weather_conditions = ["Sunny", "Cloudy", "Rainy"]
    random_weather = random.choice(weather_conditions)
    location = arguments["location"]
    return f"Today {location} is {random_weather}."


# Encapsulate the model response function.
def get_response(messages):
    completion = client.chat.completions.create(
        model="qwen-plus",
        messages=messages,
        tools=tools,
    )
    return completion


messages = [{"role": "user", "content": USER_QUESTION}]
response = get_response(messages)
assistant_output = response.choices[0].message
if assistant_output.content is None:
    assistant_output.content = ""
messages.append(assistant_output)
# If no tool call is needed, output the content directly.
if assistant_output.tool_calls is None:
    print(f"No tool call needed for weather query. Replying directly: {assistant_output.content}")
else:
    # Enter the tool calling loop.
    while assistant_output.tool_calls is not None:
        tool_call = assistant_output.tool_calls[0]
        tool_call_id = tool_call.id
        func_name = tool_call.function.name
        arguments = json.loads(tool_call.function.arguments)
        print(f"Calling tool [{func_name}] with arguments: {arguments}")
        # Run the tool.
        tool_result = get_current_weather(arguments)
        # Construct the tool return message.
        tool_message = {
            "role": "tool",
            "tool_call_id": tool_call_id,
            "content": tool_result,  # Keep the original tool output.
        }
        print(f"Tool returned: {tool_message['content']}")
        messages.append(tool_message)
        # Call the model again to get a summarized natural language response.
        response = get_response(messages)
        assistant_output = response.choices[0].message
        if assistant_output.content is None:
            assistant_output.content = ""
        messages.append(assistant_output)
    print(f"Final assistant response: {assistant_output.content}")

import OpenAI from 'openai';  
  
// Initialize the client.  
const openai = new OpenAI({  
  apiKey: process.env.DASHSCOPE_API_KEY,  
  // If you use a model in the China (Singapore) region, replace the baseURL with: https://dashscope.aliyuncs.com/compatible-mode/v1
  baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",  
});  
  
// Define the tool list.  
const tools = [  
  {  
    type: "function",  
    function: {  
      name: "get_current_weather",  
      description: "Useful for when you want to query the weather in a specific city.",  
      parameters: {  
        type: "object",  
        properties: {  
          location: {  
            type: "string",  
            description: "A city or district, such as Singapore, London, or Shanghai.",  
          },  
        },  
        required: ["location"],  
      },  
    },  
  },  
];  
  
// Simulate a weather query tool.  
const getCurrentWeather = (args) => {  
  const weatherConditions = ["Sunny", "Cloudy", "Rainy"];  
  const randomWeather = weatherConditions[Math.floor(Math.random() * weatherConditions.length)];  
  const location = args.location;  
  return `Today ${location} is ${randomWeather}.`;  
};  
  
// Encapsulate the model response function.  
const getResponse = async (messages) => {  
  const response = await openai.chat.completions.create({  
    model: "qwen-plus",  
    messages: messages,  
    tools: tools,  
  });  
  return response;  
};  

const main = async () => {  
  const input = "What's the weather like in Singapore?";

  let messages = [  
    {  
      role: "user",  
      content: input,  
    }  
  ];  
  let response = await getResponse(messages);  
  let assistantOutput = response.choices[0].message;  
  // Ensure content is not null.  
  if (!assistantOutput.content) assistantOutput.content = "";  
  messages.push(assistantOutput);  
  // Determine if a tool call is needed.  
  if (!assistantOutput.tool_calls) {  
    console.log(`No tool call needed for weather query. Replying directly: ${assistantOutput.content}`);  
  } else {  
    // Enter the tool calling loop.  
    while (assistantOutput.tool_calls) {  
      const toolCall = assistantOutput.tool_calls[0];  
      const toolCallId = toolCall.id;  
      const funcName = toolCall.function.name;  
      const funcArgs = JSON.parse(toolCall.function.arguments);  
      console.log(`Calling tool [${funcName}] with arguments:`, funcArgs);  
      // Run the tool.  
      const toolResult = getCurrentWeather(funcArgs);  
      // Construct the tool return message.  
      const toolMessage = {  
        role: "tool",  
        tool_call_id: toolCallId,  
        content: toolResult,  
      };  
      console.log(`Tool returned: ${toolMessage.content}`);  
      messages.push(toolMessage);  
      // Call the model again to get a natural language summary.  
      response = await getResponse(messages);  
      assistantOutput = response.choices[0].message;  
      if (!assistantOutput.content) assistantOutput.content = "";  
      messages.push(assistantOutput);  
    }  
    console.log(`Final assistant response: ${assistantOutput.content}`);  
  }  
};  
  
// Start the program.  
main().catch(console.error);

import os
from dashscope import Generation
import dashscope
import json
import random
# If you use a model in the China (Singapore) region, replace the base_http_api_url with: https://dashscope.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

# 1. Define the tool list.
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Useful for when you want to query the weather in a specific city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "A city or district, such as Singapore, London, or Shanghai.",
                    }
                },
                "required": ["location"],
            },
        },
    }
]

# 2. Simulate a weather query tool.
def get_current_weather(arguments):
    weather_conditions = ["Sunny", "Cloudy", "Rainy"]
    random_weather = random.choice(weather_conditions)
    location = arguments["location"]
    return f"Today {location} is {random_weather}."

# 3. Encapsulate the model response function.
def get_response(messages):
    response = Generation.call(
        # If you have not configured an environment variable, replace the next line with: api_key="sk-xxx"
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        model="qwen-plus",
        messages=messages,
        tools=tools,
        result_format="message",
    )
    return response

# 4. Initialize the conversation history.
messages = [
    {
        "role": "user",
        "content": "What's the weather like in Singapore?"
    }
]

# 5. Make the first model call.
response = get_response(messages)
assistant_output = response.output.choices[0].message
messages.append(assistant_output)

# 6. Determine if a tool call is needed.
if "tool_calls" not in assistant_output or not assistant_output["tool_calls"]:
    print(f"No tool call needed. Replying directly: {assistant_output['content']}")
else:
    # 7. Enter the tool calling loop.
    # Loop condition: as long as the latest model response contains a tool call request.
    while "tool_calls" in assistant_output and assistant_output["tool_calls"]:
        tool_call = assistant_output["tool_calls"][0]
        # Parse the tool call information.
        func_name = tool_call["function"]["name"]
        arguments = json.loads(tool_call["function"]["arguments"])
        tool_call_id = tool_call.get("id")  # Get the tool_call_id.
        print(f"Calling tool [{func_name}] with arguments: {arguments}")
        # Run the corresponding tool function.
        tool_result = get_current_weather(arguments)
        # Construct the tool return message.
        tool_message = {
            "role": "tool",
            "content": tool_result,
            "tool_call_id": tool_call_id
        }
        print(f"Tool returned: {tool_message['content']}")
        messages.append(tool_message)
        # Call the model again to get a response based on the tool result.
        response = get_response(messages)
        assistant_output = response.output.choices[0].message
        messages.append(assistant_output)
    # 8. Output the final natural language response.
    print(f"Final assistant response: {assistant_output['content']}")

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.protocol.Protocol;
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.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

public class Main {

    /**
     * Define the local implementation of the tool.
     * @param arguments A JSON string from the model that contains the required parameters for the tool.
     * @return A string with the result of the tool execution.
     */
    public static String getCurrentWeather(String arguments) {
        try {
            // The parameters provided by the model are in JSON format and need to be parsed manually.
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode argsNode = objectMapper.readTree(arguments);
            String location = argsNode.get("location").asText();

            // Use a random result to simulate a real API call or business logic.
            List<String> weatherConditions = Arrays.asList("Sunny", "Cloudy", "Rainy");
            String randomWeather = weatherConditions.get(new Random().nextInt(weatherConditions.size()));

            return "Today " + location + " is " + randomWeather + ".";
        } catch (Exception e) {
            // Handle exceptions to ensure program robustness.
            return "Could not parse location parameter.";
        }
    }

    public static void main(String[] args) {
        try {
            // Describe (register) our tool with the model.
            String weatherParamsSchema =
                    "{\"type\":\"object\",\"properties\":{\"location\":{\"type\":\"string\",\"description\":\"A city or district, such as Singapore, London, or Shanghai.\"}},\"required\":[\"location\"]}";

            FunctionDefinition weatherFunction = FunctionDefinition.builder()
                    .name("get_current_weather") // A unique identifier for the tool, which must correspond to the local implementation.
                    .description("Useful for when you want to query the weather in a specific city.") // A clear description helps the model decide when to use the tool.
                    .parameters(JsonUtils.parseString(weatherParamsSchema).getAsJsonObject())
                    .build();
            // If you use a model in the China (Singapore) region, replace the URL with: https://dashscope.aliyuncs.com/api/v1        
            Generation gen = new Generation(Protocol.HTTP.getValue(), "https://dashscope-intl.aliyuncs.com/api/v1");
            String userInput = "What's the weather like in Singapore?";

            List<Message> messages = new ArrayList<>();
            messages.add(Message.builder().role(Role.USER.getValue()).content(userInput).build());

            // Make the first model call. Send the user's request and our defined tool list to the model.
            GenerationParam param = GenerationParam.builder()
                    .model("qwen-plus") // Specify the model to call.
                    .apiKey(System.getenv("DASHSCOPE_API_KEY")) // Get the API key from an environment variable.
                    .messages(messages) // Pass the current conversation history.
                    .tools(Arrays.asList(ToolFunction.builder().function(weatherFunction).build())) // Pass the list of available tools.
                    .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                    .build();

            GenerationResult result = gen.call(param);
            Message assistantOutput = result.getOutput().getChoices().get(0).getMessage();
            messages.add(assistantOutput); // Add the model's first response to the conversation history.

            // Check the model's response to see if it requested a tool call.
            if (assistantOutput.getToolCalls() == null || assistantOutput.getToolCalls().isEmpty()) {
                // Scenario A: The model did not call a tool and answered directly.
                System.out.println("No tool call needed for weather query. Replying directly: " + assistantOutput.getContent());
            } else {
                // Scenario B: The model decided to call a tool.
                // Use a while loop to handle scenarios where the model calls tools multiple times in a row.
                while (assistantOutput.getToolCalls() != null && !assistantOutput.getToolCalls().isEmpty()) {
                    ToolCallBase toolCall = assistantOutput.getToolCalls().get(0);

                    // Parse the specific tool call information (function name, parameters) from the model's response.
                    ToolCallFunction functionCall = (ToolCallFunction) toolCall;
                    String funcName = functionCall.getFunction().getName();
                    String arguments = functionCall.getFunction().getArguments();
                    System.out.println("Calling tool [" + funcName + "] with arguments: " + arguments);

                    // Run the corresponding local Java method based on the tool name.
                    String toolResult = getCurrentWeather(arguments);

                    // Construct a message with the role "tool" that contains the tool's execution result.
                    Message toolMessage = Message.builder()
                            .role("tool")
                            .toolCallId(toolCall.getId())
                            .content(toolResult)
                            .build();
                    System.out.println("Tool returned: " + toolMessage.getContent());
                    messages.add(toolMessage); // Add the tool's return result to the conversation history.

                    // Call the model again.
                    param.setMessages(messages);
                    result = gen.call(param);
                    assistantOutput = result.getOutput().getChoices().get(0).getMessage();
                    messages.add(assistantOutput);
                }

                // Print the final, summarized response generated by the model.
                System.out.println("Final assistant response: " + assistantOutput.getContent());
            }

        } catch (NoApiKeyException | InputRequiredException e) {
            System.err.println("Error: " + e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}