Interface parameter extraction method and device based on slot filling and medium

Abstract

The invention discloses an interface parameter extraction method and device based on slot filling and a medium, and relates to large model application. The method comprises the steps that semantic analysis is conducted on natural language query through a pre-trained large language model, an intermediate parameter set containing intention types and slot filling parameters is generated, and accurate conversion from natural language parameters to structured interface specifications is achieved through multi-stage standardization processing; based on a dynamic matching mechanism of parameters and interface metadata, an interface calling chain including parallel calling, transaction compensation and data conversion nodes is constructed, and a multi-source aggregation data set is generated through cross-interface data verification and space-time alignment processing; and finally, in combination with dynamic template selection and semantic generation rules, outputting a multi-modal interaction report fusing the structured visual component and natural language interpretation.

Description

Technical Field

[0001] The present application relates to the field of large model application technology, and in particular to a method, device and medium for extracting interface parameters based on slot filling. Background Art

[0002] In the process of digital transformation, enterprises have accumulated a large number of data interface (API) resources, but the existing technical system is difficult to fully realize their value. Traditional data service systems generally use fixed charts or tables to display data of preset dimensions, requiring users to clarify the details of data requirements in advance. This one-way data delivery model leads to a serious lack of interactive flexibility. When users put forward dynamic analysis requirements such as "the top 10 products with the highest sales in the East China region in the past three months", they can neither obtain them directly through existing charts nor lack automated tools to convert natural language into executable interface call instructions. Existing API management systems usually solidify interface functions, and different dimensional analyses of the same data source require repeated development of interfaces, resulting in low utilization of enterprise interface resources and a large amount of potential data combination value not being tapped.

[0003] At present, some systems try to introduce natural language processing technology to improve the interactive experience, but they mainly rely on rule engines based on regular expressions or template matching. When faced with expressions with implicit time logic such as "last quarter" and "year-on-year", such technologies often require manual preset of complex rule bases, and are difficult to adapt to the professional terminology systems of different industries. In the parameter mapping link, existing solutions mostly use static dictionary matching, which results in the inability to accurately associate business synonyms such as "Eastern Region" and "East China Region" with standard interface parameters, and frequently triggers manual confirmation processes. The more prominent contradiction is that when user needs involve collaborative calls to multiple interfaces (such as first calling the regional sales interface to obtain basic data, and then linking the product library interface to parse product details), the existing technology lacks automated orchestration capabilities, and developers are still required to manually write interface series logic, making it difficult for the demand response cycle to meet the requirements of real-time enterprise decision-making.

[0004] The above technical bottlenecks have caused enterprises to fall into a double dilemma at the data service level: on the one hand, it is difficult for business personnel to bypass technical barriers to freely explore the value of data, and a large number of potential analysis needs are suppressed; on the other hand, the technical team is tired of dealing with trivial interface development needs and cannot focus on core system optimization. Especially in the market environment where new formats are rapidly iterating, the rigid technical architecture of traditional solutions has significantly restricted the ability of enterprises to activate data assets. There is an urgent need for an interface parameter extraction solution that can understand dynamic needs and automatically adapt interface resources to open up the "last mile" from natural language to data services. Summary of the invention

[0005] The embodiments of the present application provide a method, device, and medium for extracting interface parameters based on slot filling to solve the following technical problem: how to implement an interface parameter extraction solution that can understand dynamic requirements and automatically adapt interface resources.

[0006] In a first aspect, the embodiments of the present application provide a method for extracting interface parameters based on slot filling, characterized in that the method includes: receiving a natural language query input by a user, and performing semantic parsing on the natural language query through a pre-trained large language model to generate a corresponding intermediate parameter set; wherein, the intermediate parameter set includes intent type information and slot filling parameters; performing multi-level normalization processing on the slot filling parameters to generate standardized API parameters compatible with the target API interface; matching the target API interface metadata according to the standardized API parameters and the intent type information, and dynamically constructing an API call chain including interface dependencies according to the target API interface metadata; executing the API call chain to obtain original response data, and performing interface specification verification on the original response data to generate a multi-interface return data set; performing cross-interface aggregation calculation on the multi-interface return data set, and generating structured data and natural language description text based on the aggregation result, so as to return a result report to the user based on the structured data and the natural language description text.

[0007] In an implementation manner of the present application, the slot filling parameters include: entity parameters and time parameters; performing multi-level normalization processing on the slot filling parameters to generate standardized API parameters compatible with the target API interface specifically includes: converting unstructured text in the entity parameters into an interface-specified data format; performing interface adaptation processing on the time parameters to generate machine-parsable time interval parameters; performing interface constraint verification on the converted slot filling parameters to generate standardized API parameters.

[0008] In an implementation manner of the present application, matching the target API interface metadata according to the standardized API parameters and the intent type information specifically includes: based on the key name set of the standardized API parameters, screening out a candidate interface pool with compatible input parameters from the interface registration center, and performing business scenario filtering on the candidate interface pool according to the intent type information to obtain a candidate interface set; determining the metadata of each candidate interface in the candidate interface set, and matching the input parameter constraint conditions included in the metadata with the value range of the standardized API parameters to determine the target API interface metadata.

[0009] In an implementation manner of the present application, an API call chain including interface dependency relationships is dynamically constructed according to target API interface metadata, which specifically includes: parsing input-output dependency declarations in the target API interface metadata to construct a directed acyclic graph of interface dependency relationships; generating a set of interface call policies according to the data characteristics of standardized API parameters and the directed acyclic graph of interface dependency relationships, and setting node operation requirement marks for the call policies in the set of interface call policies; wherein, the set of interface call policies includes: parallel policy, transaction policy, circuit breaker policy; injecting data conversion nodes at corresponding positions in the directed acyclic graph of interface dependency relationships based on the node operation requirement marks; generating an executable API call chain description file.

[0010] In an implementation manner of the present application, the API call chain is executed to obtain original response data, and interface specification verification is performed on the original response data to generate a multi-interface return data set, which specifically includes: real-time monitoring of the response status codes of each node in the interface call chain, and triggering an automatic retry mechanism based on the exponential backoff algorithm for non-successful responses; performing multi-dimensional verification on the successful response data, including verifying the consistency of the data format with the output mode declared in the interface metadata, detecting whether the numerical fields exceed the value range defined in the interface document, and verifying the data primary key association relationship and temporal continuity between associated interfaces; generating exception marks for the verified-failed data and triggering a processing flow, including at least one of calling a data cleaning pipeline for format repair, automatically cropping out-of-bounds values to the legal range, and initiating a compensating secondary call to the associated interface.

[0011] In an implementation manner of the present application, cross-interface aggregation calculation is performed on the multi-interface return data set, which specifically includes: performing time zone unification processing on time series data from different interfaces, detecting the time zone identifiers of the time stamps returned by each interface and aligning the time axes according to the target time zone when there are differences; performing unit standardization processing on numerical fields, parsing the measurement unit declarations in the interface metadata and converting heterogeneous unit data according to the International System of Units; establishing cross-interface data association relationships, performing table join operations through primary key fields and performing similarity matching on the feature vectors extracted from unstructured data; performing multi-dimensional analysis according to a preset aggregation strategy, including sliding window statistics based on the time dimension and multi-metric association analysis based on business entities.

[0012] In one implementation of the present application, structured data and natural language description text are generated based on the aggregation result, specifically including: selecting an adapted data display template from the template library according to the user intent type, where the template includes preset statistical dimensions and visualization form configuration parameters; performing outlier detection on the aggregation result and generating a data evaluation report including data coverage metrics and quality scores; extracting key metrics and their change trend features from the aggregation result, dynamically selecting text generation rules including time comparison templates, distribution feature templates, and association analysis templates, injecting structured metric values into the templates to generate readable text, and automatically adding interpretation annotations based on data confidence.

[0013] In one implementation of the present application, a result report is returned to the user based on the structured data and natural language description text, specifically including: converting the structured data into an interactive visualization component, automatically selecting a bar chart, line chart, or heat map for dynamic rendering according to the data dimension characteristics, and generating a drill-down data table view that supports field sorting and conditional filtering; constructing a multimodal report document, embedding an interactive data snapshot in the natural language description and associating the original response data traceability path, and adding confidence labels based on data coverage and interface reliability calculations to key conclusions; providing a parameter dynamic adjustment control, refreshing the analysis result in real time in response to user operations, and displaying detailed verification logs and data repair traces when the user clicks on a data anomaly marker.

[0014] In a second aspect, an interface parameter extraction device based on slot filling provided by an embodiment of the present application includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and when the instructions are executed by the at least one processor, the at least one processor is enabled to execute a method for extracting interface parameters based on slot filling as described in any one of the above.

[0015] In a third aspect, a non-volatile computer storage medium for extracting interface parameters based on slot filling provided by an embodiment of the present application stores computer-executable instructions, and when the computer-executable instructions are executed, a method for extracting interface parameters based on slot filling as described in any one of the above is implemented.

[0016] The method, device, and medium for extracting interface parameters based on slot filling provided by an embodiment of the present application have the following beneficial effects:

[0017] 1. Efficient mapping between natural language interaction and API calls:

[0018] Through the collaborative work of the slot filling engine and the large language model, the accurate conversion of unstructured natural language to structured interface parameters is achieved. The slot filling process handles explicit parameter extraction, and the large language model analyzes implicit semantic requirements. The dual mechanism effectively solves the contradiction between the ambiguity of user expressions and the accuracy of interface parameters, significantly reducing the need for manual parameter configuration intervention.

[0019] 2. Intelligent adaptation ability for heterogeneous interfaces: The multi-level standardization processing mechanism automatically completes data type conversion, time zone adaptation, and unit unification, overcoming the technical obstacles of different parameter formats for multi-source interfaces. The interface constraint verification module ensures the compliance of parameter value ranges, avoids call failures caused by out-of-bounds parameters, and improves interface compatibility in complex system environments.

[0020] 3. Reliability guarantee for dynamic interface composition: The call chain generated based on the interface dependency graph realizes fault tolerance control for distributed calls through transaction compensation strategies and circuit breaker mechanisms. The combination of exception retry logic and data consistency verification ensures business continuity in scenarios of multi-interface collaboration, significantly reducing system-level risks caused by single-point failures.

[0021] 4. In-depth processing of multi-source data fusion: The spatio-temporal alignment algorithm eliminates the time-axis deviation of cross-interface data, and the feature vector matching technology establishes semantic associations between unstructured data. Multi-dimensional aggregation analysis reveals the internal laws of data, solves the insight limitations caused by data silos in traditional methods, and improves decision-making support capabilities in complex business scenarios.

[0022] 5. Paradigm upgrade of the human-computer interaction experience: The dual output mode of structured data and natural language description meets the requirements of machine processability and human readability at the same time. Interactive visualization components support dynamic data exploration, and multi-modal reports automatically associate the original data traceability path, realizing the interpretability and verifiability of technical analysis results. Brief Description of the Drawings

[0023] The drawings described herein are used to provide a further understanding of the present application and form a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation of the present application. In the drawings:

[0024] Figure 1 It is a flowchart of a method for extracting interface parameters based on slot filling provided by an embodiment of the present application;

[0025] Figure 2 It is a schematic internal structure diagram of a device for extracting interface parameters based on slot filling provided by an embodiment of the present application. Detailed Embodiments

[0026] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below in conjunction with specific embodiments of this application and the corresponding drawings. Apparently, the described embodiments are only a part of the embodiments of this application, rather than all of them. All other embodiments obtained by those of ordinary skill in the art based on the embodiments in this application without creative efforts belong to the scope of protection of this application.

[0027] An interface parameter extraction method, device, and medium based on slot filling are provided in an embodiment of this application to solve the following technical problem: how to implement an interface parameter extraction solution that can understand dynamic requirements and automatically adapt interface resources.

[0028] The technical solutions proposed in the embodiments of this application will be described in detail below with reference to the drawings.

[0029] Figure 1 It is a flowchart of an interface parameter extraction method based on slot filling provided in an embodiment of this application. As Figure 1 shown, an interface parameter extraction method based on slot filling provided in an embodiment of this application specifically includes the following steps:

[0030] Step 101: Receive a natural language query input by a user, and perform semantic parsing on the natural language query through a pre-trained large language model to generate a corresponding intermediate parameter set.

[0031] In this embodiment, the natural language query refers to an unstructured business requirement description input by the user through voice or text. For example, in a supply chain management scenario, the user may input "Please summarize the inventory data of all distributors in East China whose sales exceeded 5 million last quarter". The natural language query contains explicit parameters (such as "East China", "last quarter", "5 million") and implicit semantics (such as "summarize" corresponding to a data aggregation operation, and "inventory data" referring to a specific business entity).

[0032] It should be noted that the intermediate parameter set in this embodiment includes intent type information and slot filling parameters.

[0033] The generation of the intermediate parameter set is achieved through the collaborative work of the slot filling engine and the large language model parsing module. Specifically, the slot filling engine adopts a hybrid model based on regular expressions and named entity recognition to extract explicit parameters from the query text. For example, "East China region" is recognized through a predefined "regional keyword library", and "last quarter" is converted into a machine-readable time interval (such as 2023Q3) using a time expression parser. Meanwhile, the unmatched text fragments are input into the large language model fine-tuned with interface knowledge, and the model realizes semantic parsing through the following paths: First, an intent classifier trained based on the interface document corpus determines the type of user requirements (such as "data aggregation", "trend analysis"); Second, an implicit parameter is generated through a parameter inference module (such as mapping "inventory data" to the interface parameter inventory_data_flag = true); Finally, an intermediate parameter set containing the intent type label and slot filling parameters is output.

[0034] Exemplarily, when the user inputs "Compare the monthly sales trends of Product A in North China and South China", the slot filling engine extracts the explicit parameters product_id = A, region = [North China, South China], while the large language model parses out the implicit parameters analysis_type = trend_comparison, time_granularity = monthly. It should be noted that the fine-tuning process of the large language model includes two stages: In the first stage, a knowledge graph is constructed through interface metadata (parameter definitions, value range constraints) to enable the model to understand the logical relationships between parameters; In the second stage, the parameter combination inference ability is trained through simulated user query corpora to ensure that the generated parameter set complies with the interface call specification.

[0035] Step 102: Perform multi-level standardization processing on the slot filling parameters to generate standardized API parameters compatible with the target API interface.

[0036] In an embodiment of the present application, the slot filling parameters include: entity parameters and time parameters; performing multi-level standardization processing on the slot filling parameters to generate standardized API parameters compatible with the target API interface specifically includes: converting the unstructured text in the entity parameters into the data format specified by the interface; performing interface adaptation processing on the time parameters to generate machine-parsable time interval parameters; performing interface constraint verification on the converted slot filling parameters to generate standardized API parameters.

[0037] In this embodiment, the multi-level standardization processing aims to solve the problems of format, value range, and semantic deviation between natural language parameters and interface specifications. The specific implementation includes the following hierarchical processing:

[0038] Format Standardization: Convert unstructured text into the data format specified by the interface. For example, the user input "5 million" needs to be converted into the numerical value 5000000 or the unit string "5,000,000" according to the interface requirements. For time parameters, the time expression parser converts "last month" into the ISO standard format 2023-09-01T00:00:00 / 2023-09-30T23:59:59 and adapts to the time zone requirements of the interface (such as uniformly converting to the UTC+8 time zone).

[0039] Value Range Adaptation: Perform legality verification and adjustment on parameter values according to the parameter constraint rules in the interface metadata. For example, when the interface stipulates that the region parameter only accepts provincial administrative region codes, convert the user input "North China" into the list of supported codes by the interface [110000, 130000,...]. For enumerated parameters, use a fuzzy matching algorithm to select the closest item from the candidate values (such as mapping the user input "sales amount" to the sales_amount field defined by the interface).

[0040] Semantic Disambiguation: Eliminate parameter ambiguity through context correlation analysis. For example, when the user query contains "KPI data of Department A", according to the business entity relationship in the interface metadata, determine that "Department A" corresponds to the interface parameter department_id = 001, and "KPI data" is mapped to the specific indicator set kpi_type = [revenue, profit_margin].

[0041] Exemplarily, in the customer service scenario, when the user inputs "Query the last 3 complaint records of customer number 12345", the slot filling parameter customer_id = 12345 generates customer_id = "CUST-12345" after format standardization to match the interface coding rule; the time parameter "the last 3 times" is converted into the query condition of taking the first 3 records in reverse order by time sort = desc&limit = 3. It should be noted that during the standardization process, if a parameter conflict is detected (such as a numerical value exceeding the interface defined range), an exception handling process will be triggered to return a clarification request to the user or automatically perform a rationalization correction.

[0042] Step 103: Match the target API interface metadata according to the standardized API parameter and intent type information, and dynamically construct an API call chain containing interface dependencies according to the target API interface metadata.

[0043] In one embodiment of the present application, according to the standardized API parameters and intent type information, the target API interface metadata is matched, specifically including: based on the set of key names of the standardized API parameters, filtering out a candidate interface pool with compatible input parameters from the interface registration center, and performing business scenario filtering on the candidate interface pool according to the intent type information to obtain a candidate interface set; determining the metadata of each candidate interface in the candidate interface set, and matching the input parameter constraint conditions included in the metadata with the value range of the standardized API parameters to determine the target API interface metadata.

[0044] In one embodiment of the present application, according to the target API interface metadata, an API call chain including interface dependency relationships is dynamically constructed, specifically including: parsing the input-output dependency declarations in the target API interface metadata to construct a directed acyclic graph of interface dependency relationships; generating a set of interface call policies according to the data characteristics of the standardized API parameters and the directed acyclic graph of interface dependency relationships, and setting node operation requirement tags for the call policies in the set of interface call policies; where the set of interface call policies includes: parallel policy, transaction policy, circuit breaker policy; injecting data conversion nodes at the corresponding positions in the directed acyclic graph of interface dependency relationships based on the node operation requirement tags; generating an executable API call chain description file.

[0045] In this embodiment, the target API interface metadata refers to the technical specification description pre-registered in the interface management center, including the input and output parameter definitions, dependency relationship declarations, and business scenario tags of the interface. It should be noted that the structured storage of interface metadata is the key basis for realizing intelligent matching, and it describes the call constraint conditions of the interface through JSON Schema or OpenAPI specifications, such as the data type, value range, and mandatory identification of parameters.

[0046] The specific implementation process is as follows: First, a candidate interface pool is filtered from the interface registration center based on the set of key names of the standardized API parameters (such as product_id, region_code). It can be understood that the key name matching here adopts a fuzzy mapping strategy. For example, the user parameter area is mapped to the region_code field defined in the interface, even if their names are not exactly the same. Exemplarily, when the standardized parameters include start_time and end_time, the system will filter out all interfaces that declare support for time range queries, such as "Order Query Interface v2" and "Logistics Track Interface v3".

[0047] Secondly, perform business scenario filtering on the candidate interface pool according to the intent type information. It should be noted that the intent type information is parsed and generated by the large language model in step 101, such as business labels like "data aggregation" and "real-time monitoring". Exemplarily, if the user's intent is "predict the inventory turnover rate for the next week", the system will preferentially select interfaces that support prediction algorithms and whose output fields contain turnover_rate, while excluding interfaces that only provide historical data queries.

[0048] In the metadata matching phase, the system will verify the compatibility between the standardized parameters and the interface input constraints. Specifically, for numerical parameters (such as sales_target), check whether its value falls within the min_value and max_value ranges defined by the interface; for enumeration parameters (such as region_code), verify whether its value is in the enumeration list allowed by the interface. Exemplarily, when the interface requires region_code to be a 6-digit administrative division code and the parameter provided by the user is "East China Region", the system will trigger an address coding conversion service to convert the semantic description into a standard code (such as "East China Region" being mapped to 310000).

[0049] When dynamically constructing the API call chain, it is necessary to parse the dependency declarations in the interface metadata. It can be understood that there are two types of dependencies: Data dependency: The input parameters of interface B depend on the output fields of interface A (such as "logistics track query" depending on the order_id returned by "order query"); Business dependency: Interface calls need to meet a specific order to conform to the business process (such as the "payment interface" needs to be called after the "inventory lock interface").

[0050] In this embodiment, the system constructs a directed acyclic graph (DAG) of interface dependencies by parsing the depends_on field in the interface metadata. Exemplarily, in the e-commerce refund scenario, the call chain needs to execute the "order status query → logistics receipt verification → refund approval → payment callback" interfaces in sequence. The system will automatically generate a DAG containing these four nodes and inject data transfer nodes according to the dependencies (such as mapping the order_status field of the "order status query" to the status parameter of the "refund approval" interface).

[0051] In terms of call policy settings, the system generates optimization policies based on interface response time prediction and parameter passing complexity: Parallel policy: Enable parallel calls for independent interfaces (such as querying the inventory of multiple warehouses simultaneously) to shorten the overall response time; Transaction policy: Inject transaction compensation logic into interface groups with business atomicity requirements (such as "deduct inventory" and "generate outbound order") to ensure automatic rollback in case of partial call failures; Circuit breaker policy: Monitor the interface response success rate in real time and automatically switch to a backup interface or return a degraded result when the error rate exceeds the threshold.

[0052] It should be noted that the dynamic injection of data conversion nodes is the core mechanism to ensure parameter compatibility between interfaces. Exemplarily, when the timestamp returned by interface A is in the Unix timestamp format and interface B requires start_time to be in the ISO 8601 format, the system will insert a format conversion function in the call chain to achieve the automatic conversion of timestamp → 2023-10-01T00:00:00Z.

[0053] Step 104, Execute the API call chain to obtain the original response data, and perform interface specification verification on the original response data to generate a multi-interface return data set.

[0054] In an embodiment of the present application, executing the API call chain to obtain the original response data, and performing interface specification verification on the original response data to generate a multi-interface return data set specifically includes: Real-time monitoring of the response status codes of each node in the interface call chain, triggering an automatic retry mechanism based on the exponential backoff algorithm for non-successful responses; Performing multi-dimensional verification on the successful response data, including verifying the consistency between the data format and the output mode declared in the interface metadata, detecting whether the numerical fields exceed the value range defined in the interface document, and verifying the data primary key association relationship and temporal continuity between associated interfaces; Generating exception marks for the verified failed data and triggering a processing flow, including at least one of calling a data cleaning pipeline for format repair, automatically cropping out-of-bounds values to the legal range, and initiating a compensating secondary call to the associated interface.

[0055] In this embodiment, the implementation focus is on ensuring data integrity and consistency, specifically including the following operations:

[0056] Response verification: Perform multi-dimensional verification on the interface return data. For example, check whether the JSON structure conforms to the Schema defined in the interface document, whether the numerical fields are within the declared range (such as the value of the temperature field is between -50 and 100), and whether the timestamp format is unified (such as the ISO 8601 standard). For the data of associated interfaces, verify the primary key consistency (such as the order ID remains consistent in all related interfaces).

[0057] Exception handling: When data anomalies are detected, an adaptive repair mechanism is triggered. For example, if the timestamp returned by an interface lacks time zone information, the system automatically supplements the default time zone based on the call chain context; if a numeric field exceeds the range, it is truncated according to the threshold defined by the interface (e.g., correcting 150 to the maximum value of 100 and recording an alarm log).

[0058] Data integration: The data returned by multiple interfaces is associated according to business entities. For example, a Join operation is performed on the user_id returned by the "User Basic Information Interface" and the owner_id of the "Order Record Interface" to construct a complete user profile dataset. For unstructured data (such as customer service work order text), semantic association is achieved through feature vector similarity matching.

[0059] Exemplarily, in a medical data analysis scenario, after calling the "Patient Medical Record Interface" and the "Inspection Report Interface", the system associates the data through the patient ID and verifies whether the inspection index values meet the medical standard range (such as whether the hemoglobin value is within a reasonable range). It should be noted that the verification rule library supports dynamic updates, and custom verification logic can be added according to business requirements.

[0060] Step 105: Perform cross-interface aggregation calculation on the dataset returned by multiple interfaces, generate structured data and natural language description text based on the aggregation result, and return a result report to the user based on the structured data and natural language description text.

[0061] In an embodiment of the present application, performing cross-interface aggregation calculation on the dataset returned by multiple interfaces specifically includes: performing time zone unification processing on time series data from different interfaces, detecting the time zone identifiers of the timestamps returned by each interface and aligning the time axes according to the target time zone when there are differences; performing unit standardization processing on numeric fields, parsing the measurement unit declarations in the interface metadata and converting heterogeneous unit data to the International System of Units; establishing cross-interface data association relationships, performing table join operations through primary key fields and extracting feature vectors for unstructured data to perform similarity matching; performing multi-dimensional analysis according to a preset aggregation strategy, including sliding window statistics based on the time dimension and multi-index association analysis based on business entities.

[0062] In one embodiment of the present application, structured data and natural language description text are generated based on the aggregation result, which specifically includes: selecting an adapted data display template from the template library according to the user intention type, where the template includes preset statistical dimensions and visualization form configuration parameters; performing outlier detection on the aggregation result and generating a data evaluation report including data coverage metrics and quality scores; extracting key metrics and their changing trend features from the aggregation result, dynamically selecting text generation rules including time comparison templates, distribution feature templates, and association analysis templates, injecting structured metric values into the templates to generate readable text, and automatically adding interpretation annotations based on data confidence.

[0063] In this embodiment, the technical implementation covers two levels: data aggregation and multimodal output.

[0064] Aggregation calculation: Perform multidimensional analysis according to the user intention type. For example, for the "sales trend analysis" intention, perform a sliding window statistics on the sales amount by time dimension (such as calculating the week-on-week growth); for the "customer segmentation" intention, use a clustering algorithm to group customer behavior data. In cross-system data integration, the unit unification module converts heterogeneous data into standard measurement units (such as converting "pounds" to "kilograms").

[0065] Result generation: The structured data output adopts dynamic template rendering technology. For example, select a line chart template suitable for time-series data and automatically mark key data points (such as peaks and valleys). The natural language description generation module generates readable text based on preset grammar rules and dataset features (such as "The sales amount in the East China region in the third quarter increased by 12% quarter-on-quarter, and the main contribution came from Product Line A").

[0066] Exemplarily, in the energy management scenario, the aggregation calculation module performs an association analysis on multi-source data from smart meters and environmental sensors, generates a conclusion text such as "The peak air-conditioning energy consumption in Office Area A on high-temperature days increased by 20% compared to the baseline value", and attaches an energy consumption curve graph divided by hours. It should be noted that the confidence annotation module will add credibility labels to the conclusion according to data coverage and interface reliability (such as "High confidence: data coverage reaches 95%").

[0067] In one embodiment of the present application, a result report is returned to the user based on structured data and natural language description text, specifically including: converting structured data into interactive visualization components, automatically selecting bar charts, line charts or heat maps for dynamic rendering according to data dimension characteristics, and generating drill-down data table views that support field sorting and conditional filtering; constructing a multimodal report document, embedding interactive data snapshots in natural language descriptions and associating the original response data traceability path, adding confidence labels based on data coverage and interface reliability calculations for key conclusions; providing parameter dynamic adjustment controls, refreshing analysis results in real time in response to user operations, and displaying detailed verification logs and data repair trajectories when users click on data anomaly marks.

[0068] This step realizes the visualization and interactive exploration of technical achievements: Multimodal report construction: Integrate structured data (charts, tables) with natural language descriptions into interactive documents. For example, clicking on the "peak sales" keyword in natural language can highlight the corresponding data point; the table supports column sorting and conditional filtering (such as only showing products with a growth rate greater than 10%). Dynamic interactive function: Provide parameter adjustment controls to achieve real-time analysis. For example, users can adjust the time range through the slider, and the system automatically refreshes the associated charts and description text. The data traceability function allows users to drill down to the original interface response layer by layer to ensure the verifiability of the results.

[0069] For example, in the supply chain risk warning scenario, the report shows "Supplier X's delivery delay risk level: high", and users can click on the risk label to view specific delay records, related orders, and a list of recommended alternative suppliers. It should be noted that the interaction logic is implemented through the collaboration of the front-end framework (such as React) and the back-end data service (such as GraphQL) to ensure responsiveness in high-concurrency scenarios.

[0070] The above is an embodiment of the method proposed in this application. Based on the same inventive concept, the embodiment of this application also provides an interface parameter extraction device based on slot filling, and its structure is as follows: Figure 2 shown.

[0071] Figure 2 The internal structure diagram of an interface parameter extraction device based on slot filling provided in an embodiment of the present application is shown in FIG. Figure 2 As shown, the device includes:

[0072] at least one processor 201;

[0073] and, a memory 202 communicatively connected to the at least one processor;

[0074] Among them, the memory 202 stores instructions executable by at least one processor. The instructions are executed by at least one processor 201 so that at least one processor 201 can:

[0075] Receive a natural language query input by a user, and perform semantic parsing on the natural language query through a pre-trained large language model to generate a corresponding set of intermediate parameters; wherein, the set of intermediate parameters includes intent type information and slot filling parameters;

[0076] Perform multi-level normalization processing on the slot filling parameters to generate standardized API parameters compatible with the target API interface;

[0077] Match the target API interface metadata according to the standardized API parameters and the intent type information, and dynamically construct an API call chain including interface dependency relationships according to the target API interface metadata;

[0078] Execute the API call chain to obtain the original response data, and perform interface specification verification on the original response data to generate a multi-interface return data set;

[0079] Perform cross-interface aggregation calculation on the multi-interface return data set, and generate structured data and natural language description text based on the aggregation result, so as to return a result report to the user based on the structured data and the natural language description text.

[0080] Some embodiments of the present application provide a non-volatile computer storage medium corresponding to Figure 1 for interface parameter extraction based on slot filling, storing computer-executable instructions, and the computer-executable instructions are set as:

[0081] Receive a natural language query input by a user, and perform semantic parsing on the natural language query through a pre-trained large language model to generate a corresponding set of intermediate parameters; wherein, the set of intermediate parameters includes intent type information and slot filling parameters;

[0082] Perform multi-level normalization processing on the slot filling parameters to generate standardized API parameters compatible with the target API interface;

[0083] Match the target API interface metadata according to the standardized API parameters and the intent type information, and dynamically construct an API call chain including interface dependency relationships according to the target API interface metadata;

[0084] Execute the API call chain to obtain the original response data, and perform interface specification verification on the original response data to generate a multi-interface return data set;

[0085] Perform cross - interface aggregation calculations on the data sets returned by multiple interfaces, and generate structured data and natural - language description texts based on the aggregation results, so as to return a result report to the user based on the structured data and natural - language description texts.

[0086] Each embodiment in this application is described in a progressive manner. For the same or similar parts among the embodiments, reference can be made to each other. Each embodiment focuses on the differences from other embodiments. In particular, for the embodiments of Internet of Things devices and media, since they are basically similar to the method embodiments, the description is relatively simple, and reference can be made to the relevant parts of the method embodiments for the related content.

[0087] The systems and media provided by the embodiments of this application correspond one - to - one with the methods. Therefore, the systems and media also have beneficial technical effects similar to those of their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the systems and media will not be elaborated here.

[0088] Those skilled in the art should understand that the embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware aspects. Moreover, this application can take the form of a computer program product implemented on one or more computer - usable storage media (including but not limited to disk storage, CD - ROM, optical storage, etc.) containing computer - usable program code.

[0089] This application is described with reference to the flowcharts and / or block diagrams of methods, devices (systems), and computer program products according to the embodiments of this application. It should be understood that each flow and / or block in the flowchart and / or block diagram, as well as the combination of flows and / or blocks in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to the processors of general - purpose computers, special - purpose computers, embedded processors, or other programmable data - processing devices to generate a machine, so that the instructions executed by the processors of the computer or other programmable data - processing devices generate means for implementing the functions specified in Figure 1 one flow or multiple flows and / or blocks Figure 1 one block or multiple blocks.

[0090] These computer program instructions can also be stored in a computer - readable memory that can direct a computer or other programmable data - processing device to work in a specific manner, so that the instructions stored in the computer - readable memory generate a manufactured article including instruction means, and the instruction means implements the functions specified in Figure 1 one flow or multiple flows and / or blocks Figure 1 one block or multiple blocks.

[0091] These computer program instructions can also be loaded onto a computer or other programmable data processing device, so that a series of operation steps are executed on the computer or other programmable device to generate a computer-implemented process, and thus the instructions executed on the computer or other programmable device provide for implementing the steps of the function specified in one process Figure 1 one process or multiple processes and / or blocks Figure 1 steps of the function specified in one block or multiple blocks.

[0092] In a typical configuration, a computing device includes one or more processors (CPUs), an input / output interface, a network interface, and memory.

[0093] The memory may include non-permanent memory in the computer-readable medium, in the form of random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.

[0094] Computer-readable media includes permanent and non-permanent, removable and non-removable media that can be implemented by any method or technology for information storage. The information can be computer-readable instructions, data structures, program modules, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassette tapes, magnetic disk storage or other magnetic storage devices, or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media does not include transitory computer-readable media, such as modulated data signals and carrier waves.

[0095] It should also be noted that the term "comprising", "including" or any other variant thereof is intended to cover non-exclusive inclusion, so that a process, method, commodity or device comprising a series of elements not only includes those elements, but also includes other elements not expressly listed, or also includes elements inherent to such process, method, commodity or device. Without further limitation, an element defined by the statement "comprising an..." does not exclude the presence of additional identical elements in the process, method, commodity or device comprising the element.

[0096] The above are only embodiments of the present application and are not intended to limit the present application. For those skilled in the art, various changes and modifications can be made to the present application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included within the scope of the claims of the present application.

Claims

1. A method for extracting interface parameters based on slot filling, characterized in that: The method comprises: Receive a natural language query input by a user, and perform semantic analysis on the natural language query through a pre-trained large language model to generate a corresponding intermediate parameter set; wherein the intermediate parameter set includes intent type information and slot filling parameters; Performing multi-level standardization processing on the slot filling parameters to generate standardized API parameters compatible with the target API interface; According to the standardized API parameters and the intent type information, target API interface metadata is matched, and according to the target API interface metadata, an API call chain including interface dependencies is dynamically constructed; Execute the API call chain to obtain original response data, and perform interface specification verification on the original response data to generate a multi-interface return data set; Cross-interface aggregation calculation is performed on the multi-interface returned data set, and structured data and natural language description text are generated based on the aggregation result, so as to return a result report to the user based on the structured data and the natural language description text.

2. The method for extracting interface parameters based on slot filling according to claim 1, characterized in that: The slot filling parameters include: entity parameters and time parameters; Performing multi-level standardization processing on the slot filling parameters to generate standardized API parameters compatible with the target API interface, specifically including: Converting the unstructured text in the entity parameters into an interface specified data format; Performing interface adaptation processing on the time parameter to generate a machine-parseable time interval parameter; Interface constraint verification is performed on the converted slot filling parameters to generate the standardized API parameters.

3. The method for extracting interface parameters based on slot filling according to claim 1, characterized in that: According to the standardized API parameters and the intent type information, the target API interface metadata is matched, specifically including: Based on the key name set of the standardized API parameters, a candidate interface pool with compatible input parameters is screened out from an interface registration center, and business scenario filtering is performed on the candidate interface pool according to the intent type information to obtain a candidate interface set; The metadata of each candidate interface in the candidate interface set is determined, and the input parameter constraints contained in the metadata are matched with the value domain range of the standardized API parameters to determine the target API interface metadata.

4. The method for extracting interface parameters based on slot filling according to claim 3, characterized in that: According to the target API interface metadata, an API call chain including interface dependencies is dynamically constructed, specifically including: Parse the input and output dependency declarations in the target API interface metadata and construct a directed acyclic graph of interface dependencies; Generate an interface call strategy set according to the data characteristics of the standardized API parameters and the interface dependency directed acyclic graph, and set a node operation requirement mark for the call strategy in the interface call strategy set; wherein the interface call strategy set includes: parallel strategy, transaction strategy, and fuse strategy; Based on the node operation requirement mark, injecting a data conversion node into a corresponding position of the interface dependency directed acyclic graph; Generate an executable API call chain description file.

5. The method for extracting interface parameters based on slot filling according to claim 4, characterized in that: Executing the API call chain to obtain original response data, and performing interface specification verification on the original response data to generate a multi-interface return data set, specifically including: Monitor the response status code of each node in the interface call chain in real time, and trigger an automatic retry mechanism based on the exponential backoff algorithm for unsuccessful responses; Perform multi-dimensional verification on the successful response data, including verifying the consistency of the data format with the output mode declared in the interface metadata, checking whether the numeric field exceeds the value range defined in the interface document, and verifying the data primary key relationship and temporal continuity between related interfaces; Generate an exception mark for the data that fails the verification and trigger a processing flow, including at least one of calling a data cleaning pipeline to repair the format, automatically trimming out-of-bounds values ​​to a legal range, and initiating a compensatory secondary call of an associated interface.

6. The method for extracting interface parameters based on slot filling according to claim 1, characterized in that: Performing cross-interface aggregation calculation on the data sets returned by the multiple interfaces, specifically including: Perform time zone unification processing on time series data from different interfaces, detect the time zone identifier of the timestamp returned by each interface, and align the time axis according to the target time zone if there is a difference; Perform unit standardization on numeric fields, parse the unit declaration in the interface metadata and convert heterogeneous unit data to the International System of Units; Establish cross-interface data associations, perform table joins through primary key fields, and extract feature vectors from unstructured data to perform similarity matching; Perform multi-dimensional analysis according to preset aggregation strategies, including sliding window statistics based on the time dimension and multi-indicator correlation analysis based on business entities.

7. The method for extracting interface parameters based on slot filling according to claim 1, characterized in that: Generate structured data and natural language description text based on the aggregation results, including: Selecting an adaptive data display template from a template library according to the user's intention type, wherein the template includes preset statistical dimensions and visualization form configuration parameters; Perform outlier detection on the aggregated results and generate a data evaluation report containing data coverage metrics and quality scores; Extract key indicators and their changing trend characteristics from the aggregation results, dynamically select text generation rules including time comparison template, distribution feature template and association analysis template, inject structured indicator values ​​into the template to generate readable text and automatically add interpretation annotations based on data confidence.

8. The method for extracting interface parameters based on slot filling according to claim 1, characterized in that: Based on the structured data and the natural language description text, a result report is returned to the user, specifically including: Convert structured data into interactive visualization components, automatically select bar charts, line charts or heat maps for dynamic rendering based on data dimension characteristics, and generate drill-down data table views that support field sorting and conditional filtering; Build multimodal report documents, embed interactive data snapshots in natural language descriptions and associate the original response data traceability path, and add confidence labels based on data coverage and interface reliability calculations to key conclusions; It provides dynamic parameter adjustment controls, refreshes analysis results in real time in response to user operations, and displays detailed verification logs and data repair trajectories when users click on data anomaly marks.

9. An interface parameter extraction device based on slot filling, characterized in that: The device comprises: at least one processor; and, a memory communicatively coupled to the at least one processor; The memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can execute the interface parameter extraction method based on slot filling as described in any one of claims 1-8.

10. A non-volatile computer storage medium for slot filling-based interface parameter extraction, storing computer executable instructions, characterized in that: When the computer executable instructions are executed, an interface parameter extraction method based on slot filling as described in any one of claims 1 to 8 is implemented.

Images