Large model-based interaction method, interaction device and vehicle

Abstract

The application provides a large model-based interaction method, an interaction device and a vehicle. The method relates to the field of vehicles and is applied to a vehicle enterprise platform. The vehicle enterprise platform is loaded with a large model. The method comprises the following steps: obtaining input content of a user, analyzing the input content to obtain N tasks, wherein N is an integer greater than 0; determining a target task chain from a plurality of task chains associated with the large model according to the N tasks; processing the N tasks based on the target task chain to generate target output content corresponding to the input content. The method can improve the intelligent degree of large model interaction in a vehicle business scene.

Description

Technical Field

[0001] This application relates to the field of vehicles, and more specifically, to a large-model-based interaction method, interaction device, and vehicle in the field of vehicles. Background Technology

[0002] By applying large-scale models to automotive enterprise business scenarios, the level of intelligence and business innovation capabilities of automotive enterprises can be improved.

[0003] However, existing technologies for large-scale model interaction cannot meet the demands of complex business logic in the automotive field, nor can they link the underlying model capabilities with business processes, resulting in a low level of intelligence for large-scale models in automotive business scenarios. Therefore, improving the intelligence level of large-scale model interaction in automotive business scenarios is a technical problem that needs to be solved. Summary of the Invention

[0004] This application provides an interaction method, interaction device, and vehicle based on a large model, which can improve the intelligence level of large model interaction in automotive business scenarios.

[0005] Firstly, a large-model-based interaction method is provided, which is applied to automotive enterprise platforms that are equipped with large models. This method includes:

[0006] Obtain user input, parse the input to obtain N tasks, where N is an integer greater than 0;

[0007] Based on N tasks, determine the target task chain from multiple task chains associated with the large model;

[0008] Based on the target task chain, N tasks are processed to generate the target output content corresponding to the input content.

[0009] In the embodiments of this application, user input is parsed, and a target task chain associated with the large model is matched with N tasks obtained from the parsing. The N tasks are then processed according to the target task chain to generate the target output. Compared to existing technologies that require users to input prompts multiple times when handling complex tasks (tasks with multiple processing flows), allowing the model to process them sequentially according to the complex task flow, this solution can determine the target task chain from pre-configured task chains based on user input and automatically execute the N tasks corresponding to the input. This enables the large model to handle scenarios requiring multi-round interactions and multi-task collaboration, ensuring that the large model can handle complex business in the vehicle domain, thereby improving the intelligence level of model interaction.

[0010] In conjunction with the first aspect, in some implementations of the first aspect, the large model is associated with M agents, each of the M agents has different processing capabilities, and the target task chain is associated with Q target agents among the M agents, where M≥Q>1, and M and Q are integers;

[0011] Based on N tasks, determine the target task chain from multiple task chains associated with the large model, including: based on N tasks, determine Q target agents from M agents associated with the large model; and determine the task chains corresponding to the Q target agents as the target task chain.

[0012] Processing N tasks based on a target task chain includes: processing N tasks based on Q target agents associated with the target task chain.

[0013] In the embodiments of this application, the target task chain is associated with Q agents out of M agents; the M agents are agents associated with a large model, and each agent has different processing capabilities; therefore, each agent can handle different tasks. The process of determining the target task chain based on N tasks is the same as determining Q target agents based on N tasks, and then determining the task chain corresponding to the Q agents as the target task chain, ensuring that the N tasks can be processed sequentially by each target agent in the target task chain, thereby obtaining the target output content corresponding to the input content.

[0014] Combining the first aspect and the above implementation methods, in some implementation methods of the first aspect, the target task chain is determined from multiple task chains associated with the large model based on N tasks, including:

[0015] Perform keyword matching or semantic matching on N tasks to determine the similarity between the N tasks and each task chain in multiple task chains;

[0016] The task chain with the highest similarity among multiple task chains is identified as the target task chain.

[0017] In the embodiments of this application, keyword matching or semantic matching is performed on the N tasks corresponding to the input content to determine the similarity between the N tasks and each pre-configured task chain. The task chain with the highest similarity (i.e., matching degree) is determined as the target task chain. Since the agent in the task chain with the highest similarity to the N tasks can better handle the N tasks corresponding to the input content, the task chain with the highest similarity is determined as the target task chain, ensuring that the target task chain matches the input content.

[0018] In conjunction with the first aspect and the above implementation methods, some implementation methods of the first aspect also include:

[0019] Embed interfaces for calling external databases and external query tools of large models in multiple task chains;

[0020] Process N tasks based on the target task chain, including:

[0021] If any of the N tasks include tasks that call external databases and / or external query tools, the external databases and / or external query tools are called through the interfaces embedded in the target task chain.

[0022] In the embodiments of this application, by embedding interfaces for calling external databases and external query tools in the task chain, if N tasks include tasks that call external databases and / or external query tools, the external databases and external query tools can be called directly according to the interface, thereby improving the processing capacity of the task chain (i.e. the processing capacity of the large model), enabling the large model to combine with external databases and external query tools to generate the target output content corresponding to the input content more efficiently.

[0023] In combination with the first aspect and the above implementation methods, some implementation methods of the first aspect further include:

[0024] Record the execution status of each task node in the target task chain. The execution status includes executed status, unexecuted status, and execution failed status.

[0025] If the execution status of the first task node in the target task chain is in the execution failure state, re-execute the task associated with the first task node.

[0026] In the embodiments of this application, each of the N tasks is a task node. If there is a first task node in the target task chain that fails to execute, the tasks associated with the first task node are re-executed. Compared to re-executing the entire target task chain when execution fails, this solution can re-execute the task at the failed task node, avoiding repeated execution of tasks that have not failed, improving the execution efficiency of the target task chain, and thus improving the generation efficiency of the target output content.

[0027] Combining the first aspect and the above implementation methods, in some implementations of the first aspect, when processing N tasks based on the target task chain, the method further includes:

[0028] The display interface shows the execution order of the target task chain, the time consumed by each task node, and the execution status of each task node. The display interface is the client display interface of the car manufacturer's platform.

[0029] In the embodiments of this application, the execution order of the target task chain, the time consumption of each task node, and the execution status of each task node are displayed on the client's display interface. This ensures that users can quickly understand the generation process of the target output content on the display interface of the car manufacturer's platform, which facilitates business personnel and R&D teams to monitor the processing process corresponding to the target task chain, thereby improving the controllability of the large model on the car manufacturer's platform.

[0030] In combination with the first aspect and the above implementation methods, some implementation methods of the first aspect further include:

[0031] The different processing capabilities of the large model are encapsulated to obtain M agents, each of which has different processing capabilities.

[0032] Identify at least two agents from the M agents corresponding to different services;

[0033] By sorting at least two agents, multiple task chains associated with a large model can be obtained.

[0034] In the embodiments of this application, the different processing capabilities of the large model are encapsulated to obtain M intelligent agents. Since each of the M intelligent agents has different processing capabilities, each intelligent agent can handle different tasks. Based on the business of the car manufacturer's platform (e.g., vehicle status inquiry, fault consultation, service appointment, etc.), at least two intelligent agents are sorted to obtain multiple task chains associated with the large model; ensuring that the business in the car manufacturer's platform can be processed through the task chains.

[0035] Combining the first aspect and the above implementation methods, in some implementations of the first aspect, at least two agents are sorted to obtain multiple task chains associated with the large model, including:

[0036] Determine the input and output content of each agent in at least two agents;

[0037] Based on the data format of the input and output content of each agent, at least two agents are sorted to obtain multiple task chains associated with the large model;

[0038] Among at least two agents, the data format of the output data of the preceding agent is the same as the data format of the input content of the following agent in two adjacent agents.

[0039] In the embodiments of this application, the data format of the output data of the preceding agent in two adjacent agents is the same as the data format of the input content of the following agent. Following this principle, at least two agents are sorted according to the data formats of their input and output content to obtain multiple task chains associated with a large model. Different task chains correspond to different businesses within the automotive enterprise platform. This ensures that task chains can be pre-arranged according to the automotive enterprise's business, so that when user input is detected, the corresponding target task chain can be directly matched based on the user's input.

[0040] Secondly, an interactive device based on a large model is provided. This device is applied to a vehicle manufacturer's platform, which carries the large model. The device includes:

[0041] The acquisition module is used to acquire user input, parse the input to obtain N tasks, where N is an integer greater than 0;

[0042] The processing module is used to determine the target task chain from multiple task chains associated with the large model based on N tasks; and to process the N tasks based on the target task chain to generate the target output content corresponding to the input content.

[0043] In conjunction with the second aspect, in some implementations of the second aspect, the processing module is specifically used to: determine Q target agents from the M agents associated with the large model based on N tasks; determine the task chains corresponding to the Q target agents as target task chains; and process the N tasks based on the Q target agents associated with the target task chains.

[0044] Combining the second aspect and the above implementation methods, in some implementation methods of the second aspect, the processing module is specifically used to: perform keyword matching or semantic matching on N tasks to determine the similarity between the N tasks and each task chain in multiple task chains; and determine the task chain with the highest similarity among the multiple task chains as the target task chain.

[0045] In conjunction with the second aspect and the above implementation methods, in some implementation methods of the second aspect, the processing module is also used to: embed interfaces for calling external databases and external query tools of a large model in multiple task chains; if N tasks include tasks that call external databases and / or external query tools, call the external databases and / or external query tools through the interfaces embedded in the target task chain.

[0046] In conjunction with the second aspect and the above implementation methods, in some implementation methods of the second aspect, the processing module is also used to: record the execution status of each task node in the target task chain, including the executed status, the unexecuted status, and the execution failure status; if the execution status of the first agent in the target task chain is the execution failure status, re-execute the task associated with the first agent.

[0047] In conjunction with the second aspect and the above implementation methods, in some implementation methods of the second aspect, the processing module is also used to: display the execution order of the target task chain, the time consumed by each task node, and the execution status of each task node in the display interface.

[0048] In conjunction with the second aspect and the above implementation methods, in some implementation methods of the second aspect, the processing module is also used to: encapsulate the different processing capabilities of the large model to obtain M intelligent agents, wherein each of the M intelligent agents has different processing capabilities; determine at least two intelligent agents among the M intelligent agents corresponding to different services; and sort the at least two intelligent agents to obtain multiple task chains associated with the large model.

[0049] Combining the second aspect and the above implementation methods, in some implementation methods of the second aspect, the processing module is specifically used to: determine the input content and output content of each of the at least two intelligent agents;

[0050] Based on the data format of the input and output content of each agent, at least two agents are arranged to obtain multiple task chains associated with the large model;

[0051] Among at least two agents, the data format of the output data of the preceding agent is the same as the data format of the input content of the following agent in two adjacent agents.

[0052] Thirdly, a vehicle is provided, including a memory and a processor, the memory for storing executable program code, and the processor for calling and running the executable program code from the memory, causing the vehicle to perform the methods of the first aspect or any possible implementation thereof.

[0053] Fourthly, a computer program product is provided, comprising: computer program code, which, when run on a computer, causes the computer to perform the methods described in the first aspect or any possible implementation thereof.

[0054] Fifthly, a computer-readable storage medium is provided that stores a computer program, which, when executed, implements the method described in the first aspect or any possible implementation thereof. Attached Figure Description

[0055] Figure 1 This is a schematic flowchart illustrating an interaction method based on a large model provided in an embodiment of this application;

[0056] Figure 2 This is a schematic diagram illustrating the process of encapsulating and invoking an intelligent agent according to an embodiment of this application;

[0057] Figure 3 This is a schematic flowchart illustrating another interaction method based on a large model provided in an embodiment of this application;

[0058] Figure 4 This is a schematic diagram of the structure of an interactive device based on a large model provided in an embodiment of this application;

[0059] Figure 5 This is a schematic diagram of the structure of a vehicle provided in an embodiment of this application. Detailed Implementation

[0060] The technical solutions in this application will be clearly and thoroughly described below with reference to the accompanying drawings. In the description of the embodiments of this application, unless otherwise stated, " / " means "or," for example, A / B can mean A or B. "And / or" in the text is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, and B existing alone. Furthermore, in the description of the embodiments of this application, "multiple" refers to two or more than two.

[0061] Hereinafter, the terms "first" and "second" are used for descriptive purposes only and should not be construed as implying or suggesting relative importance or implicitly indicating the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of that feature.

[0062] Because the interaction methods of large models in automotive platforms in the current technology can only handle single responses to a single question (for example, when a user asks "What should I do if the fuel consumption is too high?", the model directly gives the answer), large models cannot cope with scenarios that require multiple rounds of interaction and multi-task collaboration. Therefore, it is difficult to complete relatively complex systematic tasks in the vehicle field (including but not limited to: vehicle maintenance suggestions, owner interaction analysis and maintenance process planning, etc.).

[0063] Furthermore, for more complex systemic tasks, the model needs to switch between different data sources and tasks, and single-round interactions are insufficient to achieve seamless integration and coherence between multiple tasks. For example, for vehicle repair recommendations, it is necessary to first collect vehicle fault codes and vehicle age information, and then perform step-by-step analysis based on the collected information; a single question-and-answer session (i.e., a single-round interaction) is insufficient to complete the information and logical deduction. For maintenance process planning, it is necessary to integrate variable information such as user time, parts inventory, and maintenance store location; a single-round interaction cannot cover all the required variables. For owner interaction analysis, after the owner inquires about a problem, tasks such as intent recognition, vehicle status retrieval, comprehensive analysis, and response generation need to be performed sequentially. Clearly, the single-round interaction of existing models cannot achieve automatic integration between multiple tasks.

[0064] In view of this, this application provides an interaction method, interaction device and vehicle based on a large model. The method can parse the input content of the user in the vehicle enterprise platform, match the target task chain associated with the large model according to the N tasks obtained by parsing, and process the N tasks according to the target task chain to generate target output content. This enables the large model to cope with scenarios that require multi-round interaction and multi-task collaboration, and ensures that the large model can handle complex business in the vehicle field, thereby improving the intelligence level of model interaction.

[0065] The following is combined Figure 1 The flowchart in this paper provides a detailed explanation of the interaction method based on a large model provided in this application.

[0066] Figure 1 This is a schematic flowchart illustrating an interaction method based on a large model provided in an embodiment of this application.

[0067] For example, Figure 1 The method 100 shown can be executed by the car manufacturer's platform or by the server side of the car manufacturer's platform. The car manufacturer's platform refers to a comprehensive technology platform built by the car manufacturer based on artificial intelligence big model technology, which has multi-dimensional intelligent processing capabilities and can serve all stages of the entire life cycle of the car.

[0068] It's important to note that a vehicle manufacturer's platform comprises a client and a server. The client refers to the device or software that the user directly interacts with, used to receive user input and display information (for a vehicle manufacturer's platform, the client can be an application within the vehicle's infotainment system). The server refers to the computer or program that provides services to the client, used for data storage, logical processing, and resource scheduling. The large-scale model is hosted on the vehicle manufacturer's platform's server (also known as the platform's cloud server). The user inputs content into the client application, which packages this input into a request and sends it to the server via an Application Programming Interface (API). The server's large-scale model then processes the request, and the server sends the resulting content back to the client application for display.

[0069] like Figure 1 As shown, the interaction method 100 based on the large model includes S110 to S130, which are described in detail below.

[0070] S110: Obtain user input and parse the input to obtain N tasks.

[0071] For example, the user's input is the content entered by the user in the client application of the car manufacturer's platform (e.g., the application of the in-vehicle system). The client packages the user's input into a request and sends it to the server through the application programming interface (API), so that the server can obtain the user's input. By parsing and decomposing the user's input, N tasks corresponding to the input are obtained, where N is an integer greater than 0. The process of parsing the input to obtain N tasks can be understood as recognizing the intent of the input and breaking down the intent into multiple step-by-step actions.

[0072] In one implementation, the user's input is preprocessed; the user's intent is matched based on a preset dictionary and grammar rules; and the matched intent is decomposed into N executable actions (i.e., decomposed into N tasks). The preprocessing includes data cleaning and feature extraction of the user's input.

[0073] For example, during data cleaning, if the user input is speech, it is converted into standardized text. If the user input is text, the corresponding text is standardized (e.g., standardization includes removing punctuation, correcting typos, and replacing synonyms). For instance, if the user input is "Find me a nearby charging station," the data cleaning process transforms this into "charging station." During feature extraction, a deep learning model is used to extract keywords from the user input, such as "navigation" and "temperature." Alternatively, a keyword lexicon for the vehicle domain can be pre-defined, and the user input can be checked to see if it matches any keywords in the lexicon. If a match is found, the matched keyword is identified as the keyword in the user input.

[0074] For example, user intent can be matched based on a preset dictionary and grammar rules. For instance, "navigate to address A" can be identified as "route planning intent"; "low battery" can be identified as "in-vehicle charging port query intent" or "in-vehicle wireless charging intent".

[0075] For example, if a user inputs "My vehicle has fault A, how should I maintain it?", the input is transformed into a "maintenance process planning" intent. This intent is then broken down into multiple tasks, including scheduling a repair, checking vehicle fault codes, finding nearby repair shops, selecting a time, and confirming the appointment. By sequentially executing these tasks, the output corresponding to the user's input can be obtained.

[0076] For example, a car manufacturer platform (i.e., a car manufacturer's large model capability platform) refers to a comprehensive technology platform built by a car manufacturer based on artificial intelligence large model technology, which has multi-dimensional intelligent processing capabilities and can serve all stages of the entire life cycle of a car.

[0077] The application scenarios for automotive platforms include, but are not limited to: intelligent cockpit interaction, autonomous driving assistance, and vehicle networking and services. Specifically, intelligent cockpit interaction refers to using natural language processing to achieve voice assistants, contextualized dialogue, and understanding of user intent, thereby accurately executing vehicle control commands and providing personalized services to users. Autonomous driving assistance refers to combining technologies such as computer vision and reinforcement learning to improve perception and planning capabilities in complex road conditions. Vehicle networking and services refer to providing services such as in-vehicle entertainment, intelligent navigation, intelligent question answering, remote vehicle control, and after-sales prediction based on user profiles and scenario analysis.

[0078] S120: Based on N tasks, determine the target task chain from multiple task chains associated with the large model.

[0079] The large model is associated with multiple task chains, which are pre-designed for different business scenarios of the automotive platform. This allows the system to directly determine the target task chain from among the pre-designed task chains when user input is detected. The process of determining the multiple task chains associated with the large model is explained in detail below.

[0080] Specifically, the different processing capabilities of the large model are encapsulated to obtain M intelligent agents, each of which has different processing capabilities; at least two intelligent agents are identified from the M intelligent agents corresponding to different services; and the at least two intelligent agents are sorted to obtain multiple task chains associated with the large model.

[0081] For example, the different processing capabilities of a large model are encapsulated to obtain reusable task units (i.e., agents). Encapsulation refers to hiding the complex implementation details within the system and exposing only a unified interface that conforms to industry or protocol standards, facilitating external calls and thus improving modularity and maintainability. The automotive platform provides a standard definition for each agent, including input parameters, output parameters, the agent's calling model, and the agent's prompt template and access control data. For instance, the large model may include a "vehicle recommendation agent," defined as receiving basic user information and purchase intent, calling the large model to generate recommendation text, and returning structured suggestions with confidence levels. By encapsulating the large model, each agent can be reused, scheduled, and managed as a separate module.

[0082] It should be noted that the prompt word template is used to automatically convert user input into appropriate prompt words and automatically populate variables before inputting them into the large model. Users do not need to manually configure prompt words, thereby improving the quality of prompt words and ensuring the output effect of the large model.

[0083] For example, the different processing capabilities of the large model are encapsulated to obtain M intelligent agents, each with different processing capabilities. Different businesses within the automotive platform are pre-splitted, with each business divided into at least two executable actions (or at least two tasks). Based on these at least two executable actions, at least two intelligent agents corresponding to each business are determined. These at least two intelligent agents are then sorted to obtain the task chains corresponding to each business. Multiple task chains corresponding to multiple pre-designed businesses are then identified as multiple task chains associated with the large model.

[0084] For example, if the user inputs "There is an abnormal noise in the brakes, how to deal with it", the corresponding prompt can be: "Fault clue: User description: {abnormal noise in the brakes}; Data characteristics: {Brake pressure fluctuation frequency 20Hz, brake pad thickness 3mm}; Output repair solution, and indicate whether immediate action is required."

[0085] In the embodiments of this application, the different processing capabilities of the large model are encapsulated to obtain M intelligent agents. Since each of the M intelligent agents has different processing capabilities, each intelligent agent can handle different tasks. Based on the business of the car manufacturer's platform (e.g., vehicle status inquiry, fault consultation, service appointment, etc.), at least two intelligent agents are sorted to obtain multiple task chains associated with the large model; ensuring that the business in the car manufacturer's platform can be processed through the task chains.

[0086] Optionally, the input and output content of each of the at least two agents are determined; based on the data format of the input and output content of each agent, the at least two agents are sorted to obtain multiple task chains associated with the large model; wherein, among the at least two agents, the data format of the output data of the preceding agent in two adjacent agents is the same as the data format of the input content of the following agent.

[0087] For example, in a task chain between two adjacent agents, the output of the preceding agent serves as the input of the following agent; therefore, the data format of the output of the preceding agent needs to be the same as the data format of the input of the following agent to ensure smooth data transmission throughout the chain. For instance, the task chain includes an intent recognition agent and a vehicle status query agent. The intent recognition agent outputs: the user intent is to query the vehicle status. The vehicle status query agent needs to input: the user intent and the vehicle's identifier code. The user intent comes from the output of the intent recognition agent, and the vehicle's identifier code comes from the contextual input information.

[0088] It is understandable that the data format of the output data of the preceding agent in two adjacent agents is the same as the data format of the input content of the following agent. Following this principle, at least two agents are sorted according to the data formats of their input and output content to obtain multiple task chains associated with the large model. Different task chains correspond to different businesses within the automotive enterprise platform, ensuring that task chains can be pre-arranged according to the automotive enterprise's business. This allows the system to directly match the corresponding target task chain based on the user's input content when it is detected.

[0089] For example, breaking down the business processes within a car manufacturer's platform yields the following intelligent agents: Agent 1 {Input A; Output C}; Agent 2 {Input B; Output A}; Agent 3 {Input C; Output D}. Based on the input and output data of each agent, the task chain corresponding to this business process is determined as: {Agent 2, Agent 1, Agent 3}. The processing flow of this chain is as follows: Agent 2, based on input B, outputs content A; Agent 2 inputs content A into Agent 1, and Agent 1 outputs content C; Agent 1 inputs content C into Agent 3, and Agent 3 outputs content D, which is the final output content.

[0090] It should be noted that the above are examples of intelligent agents obtained from business decomposition, as well as the inputs and outputs of each intelligent agent. They are only used to describe the process of sorting the task chain based on the inputs and outputs of the intelligent agents. This application does not limit the specific task chain arrangement process.

[0091] Optionally, when different businesses in the car manufacturer's platform are pre-divided into at least two tasks, the intelligent agents corresponding to the tasks are sorted according to the order in which the tasks are executed, resulting in task chains corresponding to different businesses. For example, the vehicle condition query business may be divided into multiple tasks, including intent recognition, vehicle status retrieval, and response generation; then, according to the order in which the tasks are divided, the task chain corresponding to the vehicle condition query business is determined as {intent recognition intelligent agent, vehicle status retrieval intelligent agent, response generation intelligent agent}.

[0092] It should be noted that the above embodiments illustrate the process of determining multiple task chains associated with a large model. After determining multiple task chains, based on the task corresponding to the user input content, the task chain corresponding to the input content can be directly determined from the multiple task chains (i.e., the task chain is reused). The process of determining the target task chain from multiple task chains is further explained below.

[0093] In one implementation, keyword matching or semantic matching is performed on N tasks to determine the similarity between the N tasks and each task chain in multiple task chains; the task chain with the highest similarity among the multiple task chains is determined as the target task chain.

[0094] For example, the keyword matching process includes: establishing a correspondence between preset keywords and intelligent agents, and storing the preset keywords corresponding to the intelligent agents; extracting keywords from N tasks, and comparing the keywords with the preset keywords corresponding to the intelligent agents in the task chain to determine the similarity between the keywords of the N tasks and the preset keywords of the intelligent agents in the task chain; and determining the task chain with the highest similarity as the target task chain.

[0095] For example, the semantic matching process includes: converting the task corresponding to the input content into a semantic vector; calculating the similarity between the semantic vector and the semantic vector of the agent in each task chain, which is the similarity between N tasks and each task chain in multiple task chains; and determining the task chain with the highest similarity as the target task chain.

[0096] In the embodiments of this application, keyword matching or semantic matching is performed on the N tasks corresponding to the input content to determine the similarity between the N tasks and each pre-configured task chain. The task chain with the highest similarity (i.e., matching degree) is determined as the target task chain. Since the agent in the task chain with the highest similarity to the N tasks can better handle the N tasks corresponding to the input content, the task chain with the highest similarity is determined as the target task chain, ensuring that the target task chain matches the input content.

[0097] In one implementation, a large model is associated with M agents, each of which has different processing capabilities. A target task chain is associated with Q target agents among the M agents, where M ≥ Q > 1, and M and Q are integers.

[0098] Based on N tasks, determine the target task chain from multiple task chains associated with the large model, including: determining Q target agents from M agents associated with the large model based on N tasks; determining the task chains corresponding to the Q target agents as the target task chain; and processing the N tasks based on the target task chain, including: processing the N tasks based on the Q target agents associated with the target task chain.

[0099] Understandably, the correspondence between tasks and target agents can be one-to-one, one-to-many, or many-to-one, depending on the processing requirements of the tasks. Specifically, if one of N tasks requires processing by multiple target agents, the correspondence between tasks and target agents is one-to-many. If multiple tasks among the N tasks require processing by one agent, the correspondence between tasks and target agents is many-to-one. If different tasks among the N tasks require processing by different target agents, the correspondence between tasks and target agents is one-to-one.

[0100] For example, among the N tasks are: converting fuel consumption data into a line graph, converting fault statistics into a pie chart, and converting driving behavior data into a heatmap. The M agents associated with the large model include a data visualization agent (used to convert different data into graphs / tables for data visualization). This data visualization agent performs the above three tasks, resulting in a many-to-one correspondence between tasks and target agents. Among the N tasks is a driving plan recommendation task, which requires identifying the user's driving style and generating a driving method by combining vehicle parameters and driving style. This driving plan recommendation task requires a behavior analysis agent (used to identify the user's driving style) and a driving plan generation agent (used to generate a driving plan by combining vehicle parameters and driving style), resulting in a one-to-many correspondence between tasks and target agents.

[0101] In the embodiments of this application, the target task chain is associated with Q agents out of M agents; the M agents are agents associated with a large model, and each agent has different processing capabilities; therefore, each agent can handle different tasks. The process of determining the target task chain based on N tasks is the process of determining Q target agents based on N tasks, and then determining the task chain corresponding to the Q agents as the target task chain. This ensures that the N tasks can be processed sequentially by each target agent in the target task chain, thereby obtaining the target output content corresponding to the input content.

[0102] S130: Process N tasks based on the target task chain to generate the target output content corresponding to the input content.

[0103] For example, the large model is called sequentially according to each agent in the target task chain to process N tasks and obtain the output content corresponding to the input content.

[0104] Understandably, an intelligent agent is an encapsulation of the capabilities of a large model, used to organize, guide, and manage the use of the model. The intelligent agent cannot replace the large model, but rather calls upon the large model to implement the reasoning process and obtain the output content.

[0105] In one implementation, the method further includes: embedding interfaces for calling external databases and external query tools of a large model in multiple task chains; if N tasks include tasks that call external databases and / or external query tools, calling external databases and / or external query tools through the interfaces embedded in the target task chain.

[0106] The external databases and query tools include the real-time vehicle status query interface of the Telematics Service Provider (TSP) platform, the vehicle maintenance history database, and customer service knowledge query tools.

[0107] For example, in vehicle-related business scenarios, it may be necessary to combine external data sources and query tools to generate content. For instance, a fault query agent needs to obtain the vehicle's real-time status through interfaces with external databases and query tools to perform fault queries based on that real-time status. A maintenance planning agent needs to call external data sources and query tool interfaces to retrieve the vehicle's historical maintenance information from a maintenance history database, thereby combining this historical information to perform maintenance planning.

[0108] In the embodiments of this application, by embedding an interface for calling external databases and external query tools in the task chain, if N tasks include tasks that call external databases and / or external query tools, the external databases and external query tools can be called according to the interface, thereby improving the processing capacity of the task chain (i.e. the processing capacity of the large model), so that the large model can combine external databases and external query tools to generate the target output content corresponding to the input content more efficiently.

[0109] In some specific embodiments, the method further includes: recording the execution status of each task node in the target task chain, including executed status, unexecuted status and execution failure status; if the execution status of the first task node in the target task chain is execution failure status, re-execute the task associated with the first task node.

[0110] For example, each of the N tasks is a task node. If the first task node in the target task chain fails, the tasks associated with that first task node are re-executed. Compared to re-executing the entire target task chain when an execution fails, this solution can re-execute the task at the failed task node, avoiding the repeated execution of successful tasks, improving the execution efficiency of the target task chain, and thus improving the generation efficiency of the target output content.

[0111] For example, the target task chain might be {intent recognition agent; vehicle status query agent; response generation agent}. When generating the target response, each agent in the target task chain sequentially calls the larger model to execute its corresponding task. If, during task execution, the vehicle status query agent experiences an abnormal interruption in the task chain while querying vehicle status, an error occurs, and after repair, execution restarts from the node querying vehicle status, instead of starting from the intent recognition node.

[0112] Optionally, when processing N tasks based on the target task chain, the method further includes: displaying the execution order of the target task chain, the time consumed by each task node, and the execution status of each task node in the display interface, wherein the display interface is the client display interface of the vehicle enterprise platform (i.e., the display interface of the client application).

[0113] For example, when processing N tasks through various agents in the target task chain, the execution order of the target task chain, the time consumed by each task node, and the execution status of each task node are displayed on the interface. This ensures that users can quickly understand the generation process of the target output content on the display interface, facilitating business personnel and R&D teams to monitor the processing process corresponding to the target task chain, thereby improving the controllability of the large model in the automotive platform.

[0114] In the above embodiments, the user's input on the vehicle manufacturer's platform is parsed, and the N tasks obtained from the parsing are matched with a target task chain associated with the large model. The N tasks are then processed according to the target task chain to generate the target output. Compared to existing technologies that require users to input prompts multiple times when handling complex tasks (complex tasks refer to tasks with multiple processing flows), this solution can determine the target task chain from a pre-configured set of task chains based on the user's input and automatically execute the N tasks corresponding to the input. This allows the large model to handle scenarios requiring multi-round interactions and multi-task collaboration, ensuring that the large model can handle complex business in the vehicle domain, thereby improving the intelligence level of model interaction.

[0115] Figure 2 The method 200 shown is a schematic diagram of the method for encapsulating and calling an intelligent agent provided in the embodiments of this application.

[0116] For example, such as Figure 2 As shown, the capabilities of the large model are decomposed, and S201 is executed to encapsulate the agents. By encapsulating the agents into reusable task units, each agent (such as recommendation, recognition, response, etc.) provides an external calling interface as an independent task unit, which facilitates the subsequent orchestration, calling and management of the agents.

[0117] For example, the agent is encapsulated, and steps S202 to S205 are executed, including defining the agent's input and output, configuring the agent's prompt word template, configuring the agent's ability to call the model, and orchestrating through an agent flow orchestration engine. Defining the agent's input and output includes defining the agent's input data, the data format of the input data, and the data format of the output parameters. By configuring the agent's prompt word template, when input content is detected, it is converted into standard prompt words according to the prompt word template, thereby ensuring the output result. Configuring the agent's ability to call the model can be understood as defining the tasks that the agent can perform, which are achieved by the agent calling the capabilities of the larger model. The agent is orchestrated through an agent flow orchestration engine. During agent orchestration, steps S206 (Organizing Agents) and S207 (Setting Flow Control Logic) are executed. Orchestrending agents refers to allowing developers to connect multiple agents in an orderly manner to form a task chain (e.g., ...). Figure 2 The diagram shows agent 1 connected to agent 2, and agent 2 connected to agent n. The flow control logic can be set to include sequential logic (i.e., executing the agent's task nodes in order), conditional logic (i.e., executing the next task node when a specific condition is met), or loop logic (i.e., repeatedly executing task nodes in the task chain when a condition is met).

[0118] For example, the encapsulation and orchestration of the intelligent agent are implemented through S201 to S207, and the invocation of the intelligent agent is implemented through S208 to S209, including calling external tools through the interface and generating output content through the task execution engine.

[0119] For example, interfaces for embedding external tools in the task chain include: real-time vehicle status query interface, vehicle insurance damage assessment system, vehicle maintenance history database, and customer service knowledge query tool. Each agent can be configured with invocation methods, authentication mechanisms, and parameter mapping relationships to ensure seamless collaboration between the platform and external tools during execution. The return results from external tools can serve as input for agents in subsequent task nodes, forming a closed-loop chain. For instance, a fault diagnosis agent can read vehicle fault codes through the interface of an external tool and automatically trigger an agent to generate repair suggestions based on the fault codes.

[0120] For example, a unified task execution engine is built into the vehicle manufacturer's platform. This engine is used to schedule, run, and manage task flows composed of multiple intelligent agents. The engine supports full-process monitoring of the task chain, recording the execution time, request / response logs, context variable changes, and error states of each task node. If a task is abnormally interrupted during execution, the engine can automatically restore the interrupted state and resume execution. It also supports execution timeout control and custom alarm mechanisms (e.g., alerting the user when a task node's execution time reaches a preset duration), ensuring the stable operation of the task chain.

[0121] Optionally, the output content can be displayed after the task execution engine generates it. All intelligent agents on the platform support structured returns, such as JSON format or key-value fields, facilitating secondary processing and display by client applications (e.g., applications in in-vehicle systems, work order systems). The platform also integrates a task flow visualization tool, displaying the task execution path, time consumption at each node, call status, and output preview in real time, facilitating joint debugging and monitoring by business personnel and R&D teams. It also supports exporting the task flow as a graphical report, helping teams analyze results, optimize models, and reproduce problems, thereby improving the engineering feasibility and transparency of large models in automotive companies.

[0122] For example, in combination Figure 2 The flowchart below illustrates this process: For instance, after a car owner enters a question into the vehicle's infotainment application, the client application sends the question to the server, initiating the entire orchestration process. First, the intent recognition agent determines that the owner is inquiring about a fault. Then, the preliminary fault classification agent infers that the problem may be related to a powertrain malfunction. The process engine orchestrates the following steps: retrieving vehicle operating data (such as engine status and acceleration sensor data), retrieving the vehicle's recent maintenance history (whether there are any overdue or abnormal maintenance procedures), and calling the fault knowledge base retrieval plugin to search for similar acceleration weakness fault cases. After summarizing the retrieved data, the comprehensive analysis agent determines the possible causes. The diagnostic suggestion generation agent (or response generation agent) outputs structured suggestions, such as: "Preliminary judgment: severe carbon buildup in the throttle body; recommended to visit a repair shop for cleaning." The task execution engine ensures monitoring and log tracking throughout the process. Finally, the structured results are output to the application and presented to the car owner.

[0123] Figure 3 This is a schematic flowchart illustrating another interaction method based on a large model provided in the embodiments of this application. Figure 3 The method 300 shown can be executed on the vehicle manufacturer's platform, or it can be executed on the server side of the vehicle manufacturer's platform.

[0124] like Figure 3As shown, the interaction method 300 based on the large model includes S301 to S311, and S301 to S311 are described in detail below.

[0125] S301 encapsulates the different processing capabilities of a large model to obtain M intelligent agents.

[0126] For example, encapsulation refers to hiding the complex implementation details inside a system and exposing only a unified interface that conforms to industry or protocol standards, making it easy for external users to call. In a model with M intelligent agents, each agent corresponds to a different processing capability of the larger model, and each agent can perform different processing tasks.

[0127] Optionally, when encapsulating a large model to obtain an agent, a standard definition is provided for each agent. The definition of an agent includes data such as input parameters, output parameters, agent calling model, agent prompt word template, and permission control.

[0128] S302, Based on different services, determine at least two intelligent agents among the M intelligent agents corresponding to different services.

[0129] For example, based on different business scenarios of the car manufacturer's platform, each business is divided into at least two executable actions (or at least two tasks), and at least two intelligent agents corresponding to different businesses among M intelligent agents are obtained based on these at least two executable actions.

[0130] S303, sort at least two agents to obtain multiple task chains associated with a large model.

[0131] For example, different businesses within the automotive platform can be pre-divided into at least two tasks. Then, the corresponding agents are sorted according to the order of task execution to obtain task chains for different businesses. Alternatively, based on the data format of the input and output content of each agent, at least two agents can be sorted to obtain multiple task chains associated with a larger model; wherein, among at least two agents, the data format of the output data of the preceding agent in adjacent agents is the same as the data format of the input content of the following agent.

[0132] S304, Has user input been detected? If so, proceed to S305.

[0133] For example, determine whether user input has been detected; if input is detected, parse the input to obtain N tasks. Optionally, if no user input is detected, do not execute the subsequent steps.

[0134] S305 parses the input content to obtain N tasks.

[0135] For example, when user input is detected, intent recognition is performed on the input, and the recognized intent is broken down into multiple tasks to be executed step by step.

[0136] For example, the user's input is preprocessed; the user's intent is matched based on a preset dictionary and grammar rules, and the matched intent is decomposed into N executable actions (i.e., decomposed into N tasks). The preprocessing includes data cleaning and feature extraction of the user's input.

[0137] Alternatively, the implementation methods of S304 to S305 can be found in [reference needed]. Figure 1 The relevant description of S110 will not be repeated here.

[0138] S306: Perform keyword matching or semantic matching on N tasks to obtain the similarity between the N tasks and multiple task chains.

[0139] For example, a correspondence between preset keywords and intelligent agents is established, and the preset keywords corresponding to the intelligent agents are stored; keywords are extracted for N tasks, and the similarity between the keywords of the N tasks and the preset keywords of the intelligent agents in the task chain is determined by comparing the keywords with the preset keywords of the intelligent agents in the task chain.

[0140] For example, the task corresponding to the input content is converted into a semantic vector; the similarity between the semantic vector and the semantic vector of the agent in each task chain is calculated, and this similarity is the similarity between N tasks and each task chain in multiple task chains.

[0141] S307, identify the task chain with the highest similarity among multiple task chains as the target task chain.

[0142] For example, determining the task chain with the highest similarity among multiple task chains as the target task chain includes: determining the task chain with the highest similarity between the keywords in the task chain and the keywords of N tasks as the target task chain; or, determining the task chain with the highest similarity between the semantic vector in the task chain and the semantic vector of N tasks as the target task chain.

[0143] S308 calls the large model sequentially according to the execution order of each agent in the target task chain.

[0144] For example, the large model is called sequentially according to the execution order of each agent in the target task chain; wherein, the output of the preceding agent of two adjacent agents in the task chain is used as the input of the following agent, thereby realizing the binding of context variables during the processing of the target task chain to ensure the transmission of context information flow.

[0145] S309, Does the target task chain contain any failed task nodes? If yes, proceed to S311; otherwise, proceed to S310.

[0146] For example, determine whether there are any failed task nodes in the target task chain; if there are failed task nodes, re-execute the task corresponding to that task node; if there are no failed task nodes, output the target output content obtained after executing the target task chain.

[0147] S310 outputs the target output content obtained after executing the target task chain.

[0148] For example, if there are no failed task nodes, the target output content obtained after executing the target task chain is output; the target output content supports structured return, such as JSON format or key-value fields, which is convenient for upper-layer applications (e.g., applications in the vehicle system, work order system) to process and display.

[0149] S311, Re-execute the task corresponding to this task node.

[0150] For example, if there is a task node that fails to execute, the task corresponding to that task node is re-executed to avoid repeatedly executing tasks that have not failed, thereby improving the execution efficiency of the target task chain and thus improving the generation efficiency of the target output content.

[0151] In the embodiments of this application, the capabilities of a large model are encapsulated to obtain standardized intelligent agent units. This enables the large model's capabilities to be visualized, reusable, and iterative in the form of intelligent agents, thereby lowering the barrier to business access. When a new business needs to be integrated, the encapsulated intelligent agent units can be directly invoked for orchestration, eliminating the need to retrain the model for the new business. By orchestrating the intelligent agents' processes, the model is no longer just a static "question-answering interface," but a collection of intelligent agents capable of performing multi-step logical reasoning, tool invocation, and information integration. This more efficiently enables model interaction in multi-step automotive business scenarios such as owner interaction, after-sales service, and risk assessment. Furthermore, the collaborative processing of the intelligent agent execution process with external system databases or tools (e.g., TSP platforms, in-vehicle data platforms) improves the model's interaction efficiency and quality.

[0152] The above text combined Figures 1 to 3 The interaction method based on a large model provided in the embodiments of this application is described in detail below; the following will be combined with Figure 4 and Figure 5 The apparatus embodiments of this application are described in detail below. It should be understood that the apparatus in the embodiments of this application can perform the various methods described in the foregoing embodiments of this application, that is, the specific working processes of the various products described below can be referred to the corresponding processes in the foregoing method embodiments.

[0153] Figure 4This is a schematic diagram of the structure of an interactive device based on a large model provided in an embodiment of this application.

[0154] For example, such as Figure 4 As shown, the interactive device 400 based on the large model includes:

[0155] The acquisition module 410 is used to acquire the input content from the user, parse the input content to obtain N tasks, where N is an integer greater than 0;

[0156] The processing module 420 is used to determine a target task chain from multiple task chains associated with the large model based on the N tasks; and to process the N tasks based on the target task chain to generate target output content corresponding to the input content.

[0157] Optionally, as an embodiment, the processing module 420 is specifically used to: determine Q target agents from M agents associated with the large model based on N tasks; determine the task chains corresponding to the Q target agents as target task chains; and process the N tasks based on the Q target agents associated with the target task chains.

[0158] Optionally, as an embodiment, the processing module 420 is specifically used to: perform keyword matching or semantic matching on N tasks to determine the similarity between the N tasks and each task chain in multiple task chains; and determine the task chain with the highest similarity among the multiple task chains as the target task chain.

[0159] Optionally, as an embodiment, the processing module 420 is further configured to: embed interfaces for calling external databases and external query tools of a large model in multiple task chains; if N tasks include tasks that call external databases and / or external query tools, call the external databases and / or external query tools through the interfaces embedded in the target task chain.

[0160] Optionally, as an embodiment, the processing module 420 is further configured to: record the execution status of each task node in the target task chain, including executed status, unexecuted status and execution failure status; if the execution status of the first agent in the target task chain is execution failure status, re-execute the task associated with the first agent.

[0161] Optionally, as an embodiment, the processing module 420 is further configured to: display the execution order of the target task chain, the time consumed by each task node, and the execution status of each task node in the display interface, wherein the display interface is the client display interface of the vehicle manufacturer platform.

[0162] Optionally, as an embodiment, the processing module 420 is further configured to: encapsulate the different processing capabilities of the large model to obtain M intelligent agents, wherein each of the M intelligent agents has different processing capabilities; determine at least two intelligent agents among the M intelligent agents corresponding to different services; and sort the at least two intelligent agents to obtain multiple task chains associated with the large model.

[0163] Optionally, as an embodiment, the processing module 420 is specifically used to: determine the input content and output content of each of the at least two intelligent agents; based on the data format of the input content and output content of each intelligent agent, arrange the at least two intelligent agents to obtain multiple task chains associated with the large model; wherein, among the at least two intelligent agents, the data format of the output data of the preceding intelligent agent in two adjacent intelligent agents is the same as the data format of the input content of the following intelligent agent.

[0164] It should be noted that the aforementioned interactive device based on a large model is embodied in the form of functional units. The term "module" here can be implemented in software and / or hardware, without specific limitations.

[0165] For example, a "module" can be a software program, hardware circuit, or a combination of both that implements the above functions. Hardware circuits may include application-specific integrated circuits (ASICs), electronic circuits, processors (e.g., shared processors, proprietary processors, or group processors) and memory for executing one or more software or firmware programs, combined logic circuits, and / or other suitable components that support the described functions.

[0166] Therefore, the units of the various examples described in the embodiments of this application can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0167] Figure 5 This is a schematic diagram of the structure of a vehicle provided in an embodiment of this application.

[0168] For example, vehicle 500 includes processor 510, memory 520 and executable program code 530.

[0169] For example, vehicle 500 includes one or more processors 510 that can support the implementation of the large-model-based interaction method in the method embodiments of vehicle 500. Processor 510 can be a general-purpose processor or a special-purpose processor. For example, processor 510 can be a central processing unit (CPU), a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or other programmable logic devices, such as discrete gates, transistor logic devices, or discrete hardware components.

[0170] For example, processor 510 can be used to control vehicle 500, execute software programs, and process data from the software programs. Vehicle 500 may also include a communication unit for receiving and transmitting signals.

[0171] For example, the vehicle 500 may include one or more memories 520 storing executable program code 530, which can be run by the processor 510 to generate instructions, causing the processor 510 to execute the large model-based interaction method described in the above method embodiments according to the instructions.

[0172] Optionally, the memory 520 may also store data. Optionally, the processor 510 may also read data stored in the memory 520, which may be stored at the same memory address as the executable program code 530, or the data may be stored at a different memory address than the executable program code 530.

[0173] For example, the processor 510 and memory 520 can be configured separately or integrated together, for example, integrated on the system on chip (SOC) of the terminal device.

[0174] For example, the memory 520 can be used to store related programs of the interaction method based on the large model provided in the embodiments of this application. The processor 520 can be used to call the executable program code 530 stored in the memory 520 when controlling the vehicle to execute the interaction method based on the large model of this application. For example, the user's input content is obtained, and the input content is parsed to obtain N tasks, where N is an integer greater than 0. According to the N tasks, a target task chain is determined from multiple task chains associated with the large model. The N tasks are processed based on the target task chain to generate the target output content corresponding to the input content.

[0175] This application also provides a computer-readable storage medium having a computer program stored thereon that, when executed by a processor, implements the steps of the large-model-based interaction method of any of the foregoing embodiments.

[0176] The computer-readable storage medium may include, but is not limited to, any type of disk, including floppy disks, optical disks, Digital Video Discs (DVDs), Compact Disc Read-Only Memory (CD-ROM), microdrives, and magneto-optical disks, read-only memory (ROM), random access memory (RAM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), dynamic random access memory (DRAM), video random access memory (VRAM), flash memory devices, magnetic cards or optical cards, nanosystems (including molecular memory ICs), or any type of medium or device suitable for storing instructions and / or data.

[0177] This application also provides a computer program product that, when run on a computer, causes the computer to perform the aforementioned related steps to implement a large-model-based interaction method as described in the above embodiments.

[0178] In addition, the vehicle provided in the embodiments of this application may specifically be a chip, component or module. The vehicle may include a connected processor and a memory. The memory is used to store instructions. When the vehicle is running, the processor may call and execute the instructions to enable the chip to execute an interaction method based on a large model in the above embodiments.

[0179] The vehicle, computer-readable storage medium, computer program product or chip provided in this application are all used to execute the corresponding large model-based interaction method provided above. Therefore, the beneficial effects that can be achieved can be referred to the beneficial effects of the corresponding large model-based interaction method provided above, and will not be repeated here.

[0180] Through the above description of the embodiments, those skilled in the art will understand that, for the sake of convenience and brevity, only the division of the above functional modules is used as an example. In actual applications, the above functions can be assigned to different functional modules as needed, that is, the internal structure of the device can be divided into different functional modules to complete all or part of the functions described above.

[0181] In the embodiments provided in this application, it should be understood that the disclosed apparatus and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another device, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between devices or units may be electrical, mechanical, or other forms.

[0182] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. An interaction method based on a large model, characterized in that, The method is applied to a vehicle manufacturer platform, which carries a large model, and the method includes: Obtain user input, parse the input to obtain N tasks, where N is an integer greater than 0; Identify the multiple task chains associated with the large model; Based on the N tasks, determine the target task chain from the multiple task chains associated with the large model; Based on the target task chain, the N tasks are processed to generate the target output content corresponding to the input content; The determination of the multiple task chains associated with the large model includes: The different processing capabilities of the large model are encapsulated to obtain M intelligent agents, wherein each of the M intelligent agents has different processing capabilities. Each business within the different services of the vehicle enterprise platform is divided into at least two executable actions; based on the at least two executable actions, at least two intelligent agents from the M intelligent agents corresponding to different services are determined; Determine the input and output content of each of the at least two intelligent agents; Based on the data format of the input and output content of each agent, the at least two agents are sorted to obtain multiple task chains associated with the large model; wherein, among the at least two agents, the data format of the output data of the preceding agent in two adjacent agents is the same as the data format of the input content of the following agent.

2. The method according to claim 1, characterized in that, The target task chain is associated with Q target agents out of the M agents, where M ≥ Q > 1, and M and Q are integers; The step of determining the target task chain from multiple task chains associated with the large model based on the N tasks includes: Based on the N tasks, determine the Q target agents from the M agents associated with the large model; The task chains corresponding to the Q target agents are determined as the target task chains; The processing of the N tasks based on the target task chain includes: The Q target agents associated with the target task chain process the N tasks.

3. The method according to claim 1, characterized in that, The step of determining the target task chain from multiple task chains associated with the large model based on the N tasks includes: Perform keyword matching or semantic matching on the N tasks to determine the similarity between the N tasks and each task chain in the multiple task chains; The task chain with the highest similarity among the multiple task chains is determined as the target task chain.

4. The method according to claim 1, characterized in that, Also includes: The interfaces for calling external databases and external query tools of the large model are embedded in the multiple task chains; The processing of the N tasks based on the target task chain includes: If any of the N tasks includes a task that calls the external database and / or the external query tool, the external database and / or the external query tool shall be called through the interface embedded in the target task chain.

5. The method according to any one of claims 1 to 4, characterized in that, The method further includes: Record the execution status of each task node in the target task chain, including executed status, unexecuted status, and execution failed status; If the execution status of the first task node in the target task chain is the execution failure status, the task associated with the first task node is re-executed.

6. The method according to any one of claims 1 to 4, characterized in that, When processing the N tasks based on the target task chain, the method further includes: The display interface shows the execution order of the target task chain, the time consumed by each task node, and the execution status of each task node. The display interface is the client display interface of the car manufacturer's platform.

7. An interactive device based on a large model, characterized in that, The device is applied to a vehicle manufacturer's platform, which carries a large model, and the device includes: The acquisition module is used to acquire user input content, parse the input content to obtain N tasks, where N is an integer greater than 0; The processing module is used to determine multiple task chains associated with the large model; determine a target task chain from the multiple task chains associated with the large model based on the N tasks; process the N tasks based on the target task chain to generate target output content corresponding to the input content; The processing module is specifically used for: encapsulating the different processing capabilities of the large model to obtain M intelligent agents, wherein each of the M intelligent agents has different processing capabilities; splitting each business in the different businesses of the car enterprise platform into at least two executable actions; determining at least two intelligent agents from the M intelligent agents corresponding to different businesses based on the at least two executable actions; determining the input and output content of each of the at least two intelligent agents; sorting the at least two intelligent agents based on the data format of the input and output content of each intelligent agent to obtain multiple task chains associated with the large model; wherein, in the at least two intelligent agents, the data format of the output data of the preceding intelligent agent is the same as the data format of the input content of the following intelligent agent in two adjacent intelligent agents.

8. A vehicle, characterized in that, The vehicles include: Memory, used to store executable program code; A processor for calling and running the executable program code from the memory, causing the vehicle to perform the method as described in any one of claims 1 to 6.

Images