Method for matching data with enterprise intelligence

Abstract

The application discloses a method for matching data with enterprise intelligence, comprising the following steps: receiving a matching instruction; when the matching instruction is a fuzzy matching instruction, calling a fuzzy matching structured query language generation template to generate a fuzzy matching structured query statement, and a language large model executing the fuzzy matching structured query statement to query an enterprise wide table stored in a relational database, and outputting a matching enterprise list of target data; when the matching instruction is a precise matching instruction, calling a precise matching structured query language generation template to generate a precise matching structured query statement, and the language large model executing the precise matching structured query statement to query the enterprise wide table stored in the relational database, and outputting the matching enterprise list of the target data. According to different matching instructions, corresponding structured query statements are automatically generated, different needs of users can be met without modifying codes, the matching mode of supporting information and enterprises is automatically switched according to user needs, user experience is optimized, and the efficiency of matching results is improved.

Description

Technical Field

[0001] This invention relates to the field of data processing technology, and more specifically, to a method for matching data with enterprise intelligence. Background Technology

[0002] Against the backdrop of optimizing the business environment and supporting high-quality enterprise development, the irregularly released support information is readable. This support information is characterized by its large quantity, frequent updates, complex terms, and refined application conditions. Furthermore, the target enterprise groups for this support information are dispersed, and the enterprise attribute information is complex and heterogeneous from multiple sources, making it difficult to match support information with suitable enterprises.

[0003] Traditionally, matching support information with businesses relies primarily on manual labor: staff first study the support information, break it down, and manually create screening criteria. Based on these criteria, they then use Excel spreadsheets or simple database query tools to select eligible companies from the business directory. With the surge in the amount of support information and the size of the businesses, this manual approach can no longer meet the demands for efficient and accurate matching. Therefore, rule-based automated matching systems have gradually emerged in the industry, attempting to match support information with business information through pre-defined, hard-coded rules.

[0004] The prior art (application number: 202310001137.8, application date: 2023.01.03) discloses a method and system for intelligently matching enterprises based on policy texts, including: step S1, constructing a policy text database by acquiring policy text information through multiple channels and updating the corresponding policy resources in real time; step S2, constructing an enterprise information database by collecting enterprise entity information through multiple channels and updating the corresponding enterprise information in real time; step S3, extracting policy-related information from the text, performing a coarse-sorting match, and extracting the position of the information required for the next stage in the text; step S4, putting the information obtained from the coarse-sorting into a soft negative example contrastive learning model for fine-sorting match, and obtaining the matching result of text features and enterprise information. Step S4.1: Using the semantically informative features and their locations selected in Step S3.2, find the sentences corresponding to the segments obtained in Step S3.1, and combine the resulting sentences as the feature text of the policy. Step S4.2: Integrate a portion of enterprise information into a short text according to a fixed template, and then combine it with the company profile text as the feature text for the enterprise side. Step S4.3: Input the feature text of the policy side and the feature text of the enterprise side into the SNCSE model to obtain the similarity between the policy text and the enterprise text. Filter enterprises that match the policy using a pre-set threshold, and place the final matching results in the enterprise database. In other words, existing technologies extract feature text from the policy side and feature text from the enterprise side, and perform similarity ranking on the feature text of the policy side and the enterprise side. The matching strategy is fixed and singular, the rules are hard-coded and cannot be flexibly adjusted, and it cannot simultaneously take into account different scenarios of "preliminary screening" and "precise targeting".

[0005] Therefore, how to automatically switch the matching method between support information and enterprises according to user needs is an urgent problem to be solved. Summary of the Invention

[0006] In view of this, the present invention provides a method for matching data with enterprise intelligence, comprising:

[0007] Call the data acquisition interface to obtain the target data;

[0008] The target data is preprocessed to obtain structured text, which includes a unique primary key and a classification tag. The structured text is then encapsulated into a structured data table and stored in a relational database.

[0009] The tag extraction template is invoked, which includes extraction rules and output constraints. The tag extraction template is then populated based on the structured data table.

[0010] The language model is invoked, and the filled-in tag extraction template is input into the language model. The language model follows the extraction rules and the output constraints, and outputs the tag results according to the contents of the filled structured data table.

[0011] The label results are cleaned, and the cleaned label results are encapsulated into a system extraction table and stored in the relational database;

[0012] The relational database also includes a custom label table, which is set up in a one-to-one correspondence with the system extraction table, and the custom label table and the corresponding system extraction table have the same unique primary key;

[0013] The system extracts the unique primary key to retrieve the corresponding custom tag table, and merges the system-extracted tags with the retrieved custom tag table to obtain a valid tag set.

[0014] Based on the classification tags corresponding to the unique primary key in the system extraction table, a set of high-priority tags and a combination of exclusion tags are obtained from the relational database.

[0015] Receive a matching instruction, which may be a fuzzy matching instruction or a precise matching instruction; invoke a language big model to generate a structured query statement based on the matching instruction; and use the structured query statement to perform enterprise matching, including:

[0016] When the matching instruction is the fuzzy matching instruction, a fuzzy matching structured query language generation template is invoked. This template includes fuzzy matching conditions, which require matching at least two tags from the valid tag set, and the matched tags from the valid tag set include necessary tags. The valid tag set, the high-priority tag set, and the excluded tags are then combined and filled into the fuzzy matching structured query language generation template. The language model is then invoked, and the filled fuzzy matching structured query language generation template is input into the language model. The language model then... The high-priority tag set serves as a positive priority constraint, while the excluded tag combination serves as a negative filtering condition. This, combined with the fuzzy matching conditions and the valid tag set, generates a fuzzy matching structured query statement. The fuzzy matching structured query statement is then verified. If the verification fails, the process returns to the language model, which generates a structured query statement based on the matching instructions. If the verification passes, the language model executes the fuzzy matching structured query statement to query the enterprise wide table stored in the relational database, outputting a list of matching enterprises for the target data.

[0017] When the matching instruction is the exact match instruction, the exact match structured query language generation template is invoked. The exact match structured query language generation template includes exact match conditions, including the existence of a North Star tag and matching of a core tag group. The valid tag set, the high-priority tag set, and the exclusion tag combination are filled into the exact match structured query language generation template. The language model is invoked, and the filled exact match structured query language generation template is input into the language model. The language model uses the high-priority tag set as the positive priority constraint condition and the exclusion tag combination as the negative filtering condition, and generates an exact match structured query statement in combination with the exact match conditions. The exact match structured query statement is verified. If the exact match structured query statement verification fails, the process returns to invoking the language model to generate a structured query statement according to the matching instruction. If the exact match structured query statement verification passes, the language model is invoked to execute the exact match structured query statement to query the enterprise wide table stored in the relational database, and outputs a list of matching enterprises for the target data.

[0018] Compared with existing technologies, the data and enterprise intelligent matching method provided by this invention achieves at least the following beneficial effects:

[0019] 1. The method for intelligent matching of data and enterprises provided by this invention includes: receiving a matching instruction, and calling a language big model to generate a structured query statement based on the matching instruction. Specifically, when the matching instruction is a fuzzy matching instruction, a fuzzy matching structured query language generation template is called to generate a fuzzy matching structured query statement; the language big model executes the fuzzy matching structured query statement to query a wide table of enterprises stored in a relational database, and outputs a list of matching enterprises for the target data. When the matching instruction is a precise matching instruction, a precise matching structured query language generation template is called to generate an exact matching structured query statement; the language big model executes the exact matching structured query statement to query a wide table of enterprises stored in a relational database, and outputs a list of matching enterprises for the target data. This method automatically generates corresponding structured query statements based on different matching instructions, meeting different user needs without modifying the code. It automatically switches the matching method between support information and enterprises according to user needs, optimizing user experience and effectively improving the efficiency of matching results.

[0020] 2. The method for intelligent matching of data and enterprises provided by this invention includes: verifying the fuzzy matching structured query statement after generating it, or verifying the exact matching structured query statement after generating it. By automatically verifying the structured query statement after it is generated, it ensures that the structured query statement can be directly executed by the large language model without redundancy, thus guaranteeing the stability of subsequent query execution.

[0021] Of course, any product implementing this invention does not necessarily need to achieve all of the technical effects described above at the same time.

[0022] Other features and advantages of the invention will become clear from the following detailed description of exemplary embodiments of the invention with reference to the accompanying drawings. Attached Figure Description

[0023] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments of the invention and, together with their description, serve to explain the principles of the invention.

[0024] Figure 1 This is a flowchart illustrating a method for intelligent matching of data and enterprises provided by the present invention.

[0025] Figure 2 This is a schematic diagram of an architecture for implementing the data and enterprise intelligent matching method provided by this invention.

[0026] Figure 3 This is a flowchart illustrating a label result recognition process.

[0027] Figure 4 This is a flowchart illustrating a dual-mode matching process.

[0028] Figure 5 This is another flowchart illustrating the method for intelligent matching of data and enterprises provided by the present invention.

[0029] Figure 6 This is a flowchart illustrating a user behavior learning process.

[0030] In the diagram: 1. Relational database; 2. Target data acquisition and storage module; 3. Tag management module; 4. Dual-mode enterprise matching module; 5. Matching result processing and push module; 6. User behavior learning module. Detailed Implementation

[0031] Various exemplary embodiments of the present invention will now be described in detail with reference to the accompanying drawings. It should be noted that, unless otherwise specifically stated, the relative arrangement, numerical expressions, and values ​​of the components and steps set forth in these embodiments do not limit the scope of the invention.

[0032] The following description of at least one exemplary embodiment is merely illustrative and is in no way intended to limit the invention or its application or use.

[0033] Techniques, methods, and equipment known to those skilled in the art may not be discussed in detail, but where appropriate, such techniques, methods, and equipment should be considered part of the specification.

[0034] In all the examples shown and discussed herein, any specific values ​​should be interpreted as merely exemplary and not as limitations. Therefore, other examples of exemplary embodiments may have different values.

[0035] It should be noted that similar labels and letters in the following figures indicate similar items; therefore, once an item is defined in one figure, it does not need to be discussed further in subsequent figures.

[0036] Example 1

[0037] Reference Figures 1 to 4 , Figure 1 This is a flowchart illustrating a method for intelligent matching of data and enterprises provided by the present invention. Figure 2 This is a schematic diagram of an architecture for implementing the data and enterprise intelligent matching method provided by this invention. Figure 3 This is a flowchart illustrating a label result recognition process. Figure 4 This is a flowchart illustrating a dual-mode matching process, used to explain a specific embodiment of the data and enterprise intelligent matching method provided by this invention, including:

[0038] S101: Call the data acquisition interface to obtain target data;

[0039] S102: Preprocess the target data to obtain structured text, which includes a unique primary key and a classification tag. Encapsulate the structured text into a structured data table and store it in a relational database.

[0040] S103: Call the tag extraction template, which includes extraction rules and output constraints. Populate the tag extraction template based on the structured data table.

[0041] S104: Call the language big model, input the filled label extraction template into the language big model, the language big model follows the extraction rules and output constraints, and outputs the label results according to the contents of the filled structured data table;

[0042] S105: Clean the label results and encapsulate the cleaned label results into a system extraction table and store it in a relational database;

[0043] Relational databases also include custom label tables, which are set up in a one-to-one correspondence with the system extraction tables, and the custom label tables and the corresponding system extraction tables have the same unique primary key;

[0044] S106: Retrieve the corresponding custom tag table based on the unique primary key of the system extraction table, merge the system-extracted tags with the retrieved custom tag table to obtain a valid tag set;

[0045] S107: Based on the classification tags corresponding to the unique primary keys of the system extraction table, retrieve the set of high-priority tags and the combination of exclusion tags from the relational database;

[0046] S108: Receives a matching instruction, which can be either a fuzzy matching instruction or a precise matching instruction. It then calls the language model to generate a structured query statement based on the matching instruction, and uses this structured query statement to perform enterprise matching, including:

[0047] S1081: When the matching instruction is a fuzzy matching instruction, the fuzzy matching structured query language generation template is invoked. The fuzzy matching structured query language generation template includes fuzzy matching conditions, which are to match tags from at least two valid tag sets, and the tags in the matched valid tag sets include necessary tags. The valid tag set, high-priority tag set, and exclusion tag combination are filled into the fuzzy matching structured query language generation template. The language model is invoked, and the filled fuzzy matching structured query language generation template is input into the language model. The language model uses the high-priority tag set as a positive priority constraint and the exclusion tag combination as a negative filtering condition, and combines the fuzzy matching conditions and the valid tag set to generate a fuzzy matching structured query statement. The fuzzy matching structured query statement is verified. If the fuzzy matching structured query statement verification fails, the process returns to invoking the language model to generate a structured query statement based on the matching instruction. If the fuzzy matching structured query statement verification passes, the language model is invoked to execute the fuzzy matching structured query statement to query the enterprise wide table stored in the relational database, and outputs a list of matching enterprises for the target data.

[0048] S1082: When the matching instruction is an exact match instruction, the exact match structured query language generation template is invoked. The exact match structured query language generation template includes exact match conditions, which include the existence of a North Star tag and matching of the core tag group. The valid tag set, high-priority tag set, and exclusion tag combination are filled into the exact match structured query language generation template. The language big model is invoked, and the filled exact match structured query language generation template is input into the language big model. The language big model uses the high-priority tag set as a positive priority constraint and the exclusion tag combination as a negative filtering condition, and generates an exact match structured query statement in combination with the exact match conditions. The exact match structured query statement is verified. If the exact match structured query statement verification fails, the process returns to invoking the language big model to generate a structured query statement according to the matching instruction. If the exact match structured query statement verification passes, the language big model is invoked to execute the exact match structured query statement to query the enterprise wide table stored in the relational database and outputs a list of matching enterprises for the target data.

[0049] It should be noted that the target data is usually supportive information, which can also be understood as information that is helpful to the company's development. (Refer to...) Figure 2The architecture of the data and enterprise intelligent matching method provided by this invention is based on a B / S architecture. The underlying layer uses a relational database 1 (PostgreSQL) to store data. The core relies on the API interface of the language big model to achieve text parsing and structured query statement (SQL) generation. The language big model uses the GPT big model. The overall system can be divided into multiple core functional modules, which work collaboratively to complete the entire business loop. The target data acquisition and storage module 2 is used to implement steps S101 to S102, and is also used for updating, archiving, and querying target data. The language big model interface is called, passing in a customized tag extraction template (Prompt) and a structured data table. The language big model automatically extracts the tag results and returns them to the tag management module 3. The tag management module 3 provides tag display, editing, and deletion functions, supports users adding custom tags, and stores the system-extracted tag results and user-defined tags separately in the system extraction table and custom tag table of the relational database 1, providing a valid tag set to the dual-mode enterprise matching module 4. When displaying tags, the tag management module 3 categorizes them by type and indicates whether the tags originated from system extraction or user addition. When deleting tags, only the "validity" status is modified; no physical deletion is performed, ensuring data traceability. When a user adds a custom tag, it is validated, inserted into the custom tag table, and associated with the corresponding system extraction table using a unique primary key. The dual-mode enterprise matching module 4 provides both fuzzy and precise matching modes. It calls the language model's API interface, passing in either a fuzzy matching structured query language generation template (fuzzy matching Prompt) or a precise matching structured query language generation template (precise matching Prompt). It then combines the valid tag set, high-priority tag set, and excluded tag combinations to generate a clean, executable structured query statement (SQL). After validating the structured query statement, it executes the statement to query the enterprise wide table to obtain matching results, which are then passed to the matching result processing and push module 5. The high-priority tag set and excluded tag combinations are learning preference data. The matching result processing and push module 5 filters the matching results, such as removing processed companies, and then performs weighted sorting. It provides company removal, saving, and push functions, and feeds the processing results back to the user. At the same time, it transmits the operation log to the user behavior learning module 6. The user behavior learning module 6 extracts behavioral data in real time based on the removal and saving operations in the operation log and updates it to the temporary operation table and long-term feature table. It also extracts learning preference data such as high-priority tags and exclusion tag combinations to provide preference constraints for the dual-mode company matching module 4.

[0050] In step S101, when the data acquisition interface obtains target data, the data acquisition interface key and request frequency limit can be configured to construct batch acquisition tasks. Configuring the request frequency limit is to avoid interface rate limiting. Target data may include: matter level, implementing department, matter type, matter theme, matter item, redemption method, applicable object, whether it is long-term valid, applicable region, release date, application cycle, application (enjoyment) conditions, etc. In step S102, the classification label can be a single category or a combination of multiple categories. For example, the classification label can be only technology category, or it can be technology and finance / tax category. When the classification label is a combination of multiple categories, each category is stored in a comma-separated string or array format to adapt to the classification management of cross-domain target data and subsequent behavior learning and enterprise matching logic. In step S103, the label extraction template is filled according to the structured data table, including placeholders for the label extraction template. The process involves filling in empty fields, ignoring those that are not filled. For example, if the structured data table does not have "item level" data, the placeholder will not be filled. Simultaneously, dirty data in the fields is filtered out, i.e., meaningless placeholders and irrelevant characters / numbers. In step S104, when calling the language model, the HTTP / HTTPS protocol is used to call the language model API. A reasonable request timeout (default 30 seconds) and retry mechanism (retrying twice after failure) are set. The API request parameters include: API key (authentication), the content of the filled tag extraction template, and response format constraints (single string, separated by commas). In step S105, the tag results are cleaned, including: removing leading and trailing spaces and redundant commas; deduplicating again (to avoid the large model returning duplicate tags); and validating the tag format (ensuring it is a single string, separated by commas). After cleaning, the tag results are associated with a unique primary key and category tag and encapsulated into a structured data table for storage. This implementation provides a specific core logic for calling the large model, as follows:

[0051] / / 1. Constructing GPT API request parameters

[0052] String apiKey = "GPT Large Model API Key";

[0053] String prompt "Content of the completed label recognition prompt";

[0054] GptRequest request = new GptRequest();

[0055] request.setApiKey(apiKey);

[0056] request.setPrompt(prompt);

[0057] request.setMaxTokens(2048); / / Set the number of response tokens

[0058] request.setTenperature(0.1); / / Low randomness, ensuring accurate tag extraction

[0059] / / 2. Call the GPT API and process the response

[0060] try{

[0061] GptResponse response = gptApiClient.sendRequest(request);

[0062] String tagResult = response.qetContent(); / / Receive the returned tag string (e.g., "City X, High-tech Enterprise, Specialized and Innovative Enterprise, Annual Reward")

[0063] / / 3. Label Result Cleaning

[0064] String cleanTagResult = cleanPolicyTags(tagResult);

[0065] return cleanTagResult;

[0066] }catch (Exception e) {

[0067] / / Retry mechanism implementation

[0068] log.error("GPT API call failed, retrying", e);

[0069] / / Retry logic...

[0070] }

[0071] Of course, the specific calling logic can be adjusted according to actual needs, and is not limited to this.

[0072] In step S106, the system-extracted tags are merged with the retrieved custom tag table to form a comma-separated set of valid tags, such as "City X, High-tech Enterprise, Specialized and Innovative, Custom Tag 1," providing input data for the dual-mode enterprise matching module. In step S108, the enterprise wide table is constructed by cleaning, associating, and structuring multi-source heterogeneous enterprise data, serving as a unified query data source for enterprise matching. In step S1081, necessary tags belong to the valid tag set. Fuzzy matching conditions can be understood as satisfying the necessary tags, and satisfying any one of the remaining tags in the valid tag set excluding the necessary tags; this can be considered an "OR" association condition. Based on this, tags in the high-priority tag set are prioritized for matching, and exclusion tag combinations are prohibited from appearing simultaneously in the matching conditions of the fuzzy matching structured query statement. In step S1082, the North Star tag is the core mandatory tag in the exact matching mode, an indispensable key threshold condition in the target data declaration conditions. Enterprises must fully meet the North Star tag requirements to participate in subsequent matching; it is the core constraint with the highest priority in exact matching. The tags in the core tag group can all belong to the valid tag set, or only some of them can belong to the valid tag set, with the other part being conditions supplemented by the user. The exact match condition can be understood as prioritizing the North Star tag, which is the highest priority and must be 100% met by the enterprise. Furthermore, all tags in the core tag group must also be met; this can be seen as an "AND" association condition. Similarly, based on this, combined with weighted high-priority tag sets and filtering by excluding tag combinations, target enterprises that fully meet the requirements are precisely selected.

[0073] Understandably, automatically generating corresponding structured query statements based on different matching instructions can meet diverse user needs without modifying code. This allows for automatic switching between matching support information and enterprises based on user requirements, optimizing user experience and effectively improving the efficiency of matching results. By automatically verifying the generated structured query statements, it ensures that they can be directly executed by the language's large-scale model without redundancy, guaranteeing the stability of subsequent query execution.

[0074] Example 2

[0075] Reference Figure 5 and Figure 6 , Figure 5 This is another flowchart illustrating the data and enterprise intelligent matching method provided by the present invention. Figure 6 This is a flowchart illustrating a user behavior learning process, used to explain another specific embodiment of the method for providing data and intelligent matching with enterprises according to the present invention, including:

[0076] S201: Call the data acquisition interface to obtain target data;

[0077] S202: Preprocess the target data to obtain structured text, which includes a unique primary key and a classification tag. Encapsulate the structured text into a structured data table and store it in a relational database.

[0078] The process of preprocessing the target data to obtain structured text includes: cleaning the target data of noise; splitting the cleaned target data into multiple sentences based on logical connectors; annotating the sentences with dimensions; and encapsulating the annotated sentences into structured text.

[0079] S203: Call the tag extraction template, which includes extraction rules and output constraints. Populate the tag extraction template based on the structured data table.

[0080] S204: Call the language big model, input the filled label extraction template into the language big model, the language big model follows the extraction rules and output constraints, and outputs the label results according to the contents of the filled structured data table;

[0081] S205: Clean the label results and encapsulate the cleaned label results into a system extraction table and store it in a relational database;

[0082] Relational databases also include custom label tables, which are set up in a one-to-one correspondence with the system extraction tables, and the custom label tables and their corresponding system extraction tables have the same unique primary key;

[0083] S206: Retrieve the corresponding custom tag table based on the unique primary key of the system extraction table, merge the system-extracted tags with the retrieved custom tag table to obtain a valid tag set;

[0084] S207: Based on the classification tags corresponding to the unique primary keys of the system extraction table, retrieve the set of high-priority tags and the combination of exclusion tags from the relational database;

[0085] S208: Receives a matching instruction, which can be either a fuzzy matching instruction or a precise matching instruction. It then calls the language model to generate a structured query statement based on the matching instruction, and uses this structured query statement for enterprise matching, including:

[0086] S2081: When the matching instruction is a fuzzy matching instruction, the fuzzy matching structured query language generation template is invoked. The fuzzy matching structured query language generation template includes fuzzy matching conditions, which require matching labels from at least two valid label sets, and the matched labels from the valid label sets must include necessary labels. The valid label set, the high-priority label set, and the exclusion label combination are then filled into the fuzzy matching structured query language generation template. The language model is invoked, and the filled fuzzy matching structured query language generation template is input into the language model. The language model uses the high-priority label set as a positive priority constraint and the exclusion label combination as a negative filtering condition, combining the fuzzy matching conditions and the valid label set to generate a fuzzy matching structured query language generation template. Matching structured query statements; verifying fuzzy matching structured query statements, including: calling the preprocessing function of the relational database to perform syntax validation on the fuzzy matching structured query statement; if the syntax validation fails, the fuzzy matching structured query statement verification fails; if the syntax validation passes, parsing the fuzzy matching structured query statement, extracting the tags contained in the query conditions of the fuzzy matching structured query statement, and comparing the extracted tags contained in the query conditions of the fuzzy matching structured query statement with the valid tag set and the excluded tag combination respectively to perform semantic validation; if the semantic validation fails, the fuzzy matching structured query statement verification fails; if the semantic validation passes, performing security validation on the fuzzy matching structured query statement, including: The security check process involves determining whether a fuzzy matching structured query statement contains dangerous keywords, whether the query conditions are enclosed in single quotes, and whether the query restricts the range of data. If at least one of the following occurs: dangerous keywords, query conditions not enclosed in single quotes, or no data restriction, the security check fails. If no dangerous keywords are present, the query conditions are enclosed in single quotes, and the query restricts the range of data, the security check passes. Otherwise, the fuzzy matching structured query fails. The verification of the structured query statement fails. If the security verification passes, a compatibility verification is performed on the fuzzy matching structured query statement, including: determining whether the functions contained in the fuzzy matching structured query statement are compatible with relational databases and Highgo databases, whether the boolean field of the fuzzy matching structured query statement is 1, and whether the fuzzy matching structured query statement contains a fuzzy matching operator that adds a percentage sign for full matching. If at least one of the following conditions is not met: all functions contained in the fuzzy matching structured query statement are compatible with relational databases and Highgo databases, the boolean field of the fuzzy matching structured query statement is not 1, or the fuzzy matching structured query statement does not contain a fuzzy matching operator that adds a percentage sign for full matching, then the compatibility verification fails.If the functions included in the fuzzy matching structured query statement are compatible with both relational databases and Highgo databases, the boolean field of the fuzzy matching structured query statement is 1, and the fuzzy matching structured query statement contains a fuzzy matching operator that adds a percentage sign for full matching, then the compatibility check passes. If the compatibility check passes, the fuzzy matching structured query statement passes verification. If the compatibility check fails, the fuzzy matching structured query statement fails verification. If the fuzzy matching structured query statement fails verification, the process returns to calling the language big model to generate a structured query statement based on the matching instructions. If the fuzzy matching structured query statement passes verification, the language big model is called to execute the fuzzy matching structured query statement to query the enterprise wide table stored in the relational database and outputs a list of matching enterprises for the target data.

[0087] S2082: When the matching instruction is an exact match instruction, the exact match structured query language generation template is invoked. The exact match structured query language generation template includes exact match conditions, which include the existence of a North Star tag and matching of the core tag group; the effective tag set, high-priority tag set, and exclusion tag combination are filled into the exact match structured query language generation template; the language big model is invoked, and the filled exact match structured query language generation template is input into the language big model. The language big model uses the high-priority tag set as a positive priority constraint and the exclusion tag combination as a negative filtering condition, and combines the exact match conditions to generate an exact match structured query statement; the exact match structured query statement is verified, including: invoking... The relational database preprocessing function performs syntax validation on the exact match structured query statement. If the syntax validation fails, the exact match structured query statement fails validation. If the syntax validation passes, the exact match structured query statement is parsed, and the tags contained in the query conditions are extracted. These extracted tags are then compared with the set of valid tags, the set of matching core tags, and the excluded tag combinations for semantic validation. If the semantic validation fails, the exact match structured query statement fails. If the semantic validation passes, the exact match structured query statement undergoes security validation, including: determining whether the exact match structured query statement contains dangerous keywords, and checking the exact match... The security check will fail if the structured query statement's query conditions are enclosed in single quotes and if the exact match structured query statement restricts the range of query data. If at least one of the following occurs: the exact match structured query statement contains dangerous keywords, the query conditions are not enclosed in single quotes, or the exact match structured query statement does not restrict the range of query data, the security check will pass. If the exact match structured query statement does not contain dangerous keywords, the query conditions are enclosed in single quotes, and the exact match structured query statement restricts the range of query data, the security check will pass. If the security check fails, the exact match structured query statement verification will fail. If the security check passes, the exact match structured query statement... The query performs compatibility checks, including: determining whether the functions contained in the exact match structured query are compatible with relational databases and Highgo databases, and whether the Boolean field of the exact match structured query is 1; if the functions contained in the fuzzy match structured query are all compatible with relational databases and Highgo databases, or the Boolean field of the exact match structured query is not 1, then the compatibility check fails; if the functions contained in the exact match structured query are all compatible with relational databases and Highgo databases, and the Boolean field of the exact match structured query is 1, then the compatibility check passes; if the compatibility check passes, the exact match structured query passes verification; if the compatibility check fails, the exact match structured query fails verification.If the exact match structured query statement verification fails, return to the language big model to generate a structured query statement based on the matching instructions; if the exact match structured query statement verification passes, call the language big model to execute the exact match structured query statement to query the enterprise wide table stored in the relational database, and output the list of matching enterprises of the target data.

[0088] S209: Receive operation logs, which include operation type, unique primary key, category tag corresponding to the unique primary key, and tag matched when querying the enterprise wide table for the target data corresponding to the unique primary key;

[0089] S210: Save the operation log to a temporary operation table in the relational database;

[0090] Operation types include save operations and remove operations:

[0091] S2111: When the operation type is a save operation, extract the unique primary key from the temporary operation table, and query the relational database to see if a corresponding long-term feature table exists based on the unique primary key; if no corresponding long-term feature table exists, create the corresponding long-term feature table based on the unique primary key; extract the category tag corresponding to the unique primary key from the temporary operation table, and write the category tag corresponding to the unique primary key into the long-term feature table corresponding to the unique primary key; extract the tags matched when querying the enterprise wide table with the target data corresponding to the unique primary key from the temporary operation table, and count the tag items as save tag items based on the tags matched when querying the enterprise wide table with the target data corresponding to the unique primary key, calculate the save count for each save tag item, and write the save tag items and the save count for each save tag item into the long-term feature table corresponding to the unique primary key; if a corresponding long-term feature table exists, extract the tags matched when querying the enterprise wide table with the target data corresponding to the unique primary key from the temporary operation table, count the tag items as save tag items based on the tags matched when querying the enterprise wide table with the target data corresponding to the unique primary key, calculate the save count for each save tag item, and update the long-term feature table corresponding to the unique primary key based on the save tag items and the save count for each save tag item.

[0092] S2112: When the operation type is a removal operation, extract the unique primary key from the temporary operation table, and query the corresponding long-term feature table in the relational database based on the unique primary key; extract the tags matched when querying the enterprise wide table for the target data corresponding to the unique primary key from the temporary operation table, and count the tag items as removal tag items based on the tags matched when querying the enterprise wide table for the target data corresponding to the unique primary key, calculate the removal count for each removal tag item, and update the long-term feature table corresponding to the unique primary key based on the removal tag items and the removal count for each removal tag item.

[0093] It should be noted that step S202 is essentially a lightweight natural language processing (NLP) preprocessing + semantic regularization + structured field encapsulation technique for the plain text of the target data. Specifically, noise cleaning refers to removing meaningless noise, which includes: line breaks, tabs, consecutive spaces, special symbols, redundant polite phrases, invalid placeholders, repetitive expression fragments, etc., to retain only the core statements of the declaration conditions in the target data, thus completing the text purity processing; based on the general sentence structure rules of the target data text, through string matching + rule-based word segmentation, logical connectors (and, or, must satisfy, include, exclude, simultaneously, should, must not, etc.) are identified in the text, splitting a whole unstructured long text into multiple independent and complete short sentences of declaration conditions; after splitting, an ordered list of sentences "Condition 1, Condition 2, Condition 3..." is formed, without modifying the original wording or adding or subtracting semantics, only performing logical segmentation; based on the general classification dimensions of the declaration conditions (enterprise qualifications, regional requirements, intellectual property rights, financial indicators, industry type, personnel size, etc.), the text is further segmented. (e.g., establishment period), and weak labeling is applied to the split short sentences using keyword rule matching: for example, the sentence "the company's registered address is located in a certain city" is labeled as "regional dimension," and the sentence "possesses more than one invention patent" is labeled as "intellectual property dimension." This process only performs dimension classification and does not perform deep semantic analysis, which is a lightweight structured processing. Finally, the cleaned, split, and labeled declaration condition text is encapsulated in key-value pair format / JSON semi-structured format (e.g., {"declaration_clause":["sentence 1","sentence 2"],"dimension":["region","intellectual property"]}), and stored as a dedicated structured field in a structured data table in a relational database. This is different from the original unstructured long text storage, forming a regular structured text that can be directly called by the language large model Prompt template. Among them, this embodiment provides a specific structured data table design:

[0094] CREATE TABLE governnent_reward_policy (

[0095] policy_id VARCHAR(64) PRIMARY KEY COMMENT 'Unique primary key',

[0096] `policy_category VARCHAR(100) NOT NULL COMMENT 'Category tags (technology / finance / tax, etc.)'`

[0097] sxcj VARCHAR(200) COMMENT 'Event Level',

[0098] ssbm VARCHAR(200) COMMENT 'Implementation Department',

[0099] sxlx VARCHAR(200) COMMENT 'Event Type',

[0100] sxzt VARCHAR(200) COMMENT 'Subject of Item',

[0101] sxmd VARCHAR(500) COMMENT 'Project',

[0102] dxfs VARCHAR(200) COMMENT 'Payout Method',

[0103] sydx VARCHAR(500) COMMENT 'Applicable Objects',

[0104] sfcqyx VARCHAR(20) COMMENT 'Is it valid indefinitely?'

[0105] sydq VARCHAR(500) COMMENT 'Applicable Regions',

[0106] fbrq DATE COMMENT 'Release Date',

[0107] sbzq VARCHAR(200) COMMENT 'Reporting Cycle',

[0108] sbxstj TEXT NOT NULL COMMENT 'Application (Enjoyment) Conditions',

[0109] `create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT 'Inbound Time'`

[0110] update_time TIMESTAMP DEFAULT CURRENT TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT 'update time',

[0111] is_valid VARCHAR(2) DEFAULT '1' COMMENT 'Is it valid? (1: Valid; 0: Filing)' );

[0113] Of course, the design of structured data tables can be adjusted according to actual needs and is not limited to this.

[0114] In steps S204 and S208, the language large model is the series of models such as GPT-3.5 and GPT-4 launched by OpenAI. They are all generative pre-trained language models based on the Transformer architecture, which is a mature existing large language model technology. This embodiment does not modify the underlying architecture of the model, but only calls its capabilities through a customized Prompt project.

[0115] In step S206, this embodiment provides a specific custom label table design:

[0116] CREATE TABLE policy_custom_tag (

[0117] tag_id VARCHAR(64) PRIMARY KEY COMMENT 'Unique primary key',

[0118] policy_id VARCHAR(64) NOT NULL COMMENT 'Related target data primary key',

[0119] `custom_tag VARCHAR(200) NOT NULL COMMENT 'User-defined tag content'`

[0120] create_user VARCHAR(64) NOT NULL COMMENT 'Create User ID',

[0121] `create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT 'Creation Time'`

[0122] FOREIGN KEY (policy_id) REFERENCES government_reward_policy(policy_id) );

[0124] Of course, the custom label table can be adjusted according to actual needs, and is not limited to this.

[0125] In step S2081, the tags contained in the query conditions of the extracted fuzzy matching structured query statement are compared with the valid tag set and the excluded tag combination for semantic verification, including:

[0126] Compare the tags contained in the query conditions of the extracted fuzzy matching structured query statement with the set of valid tags; if the tags contained in the query conditions of the extracted fuzzy matching structured query statement do not all belong to the set of valid tags, the semantic verification fails.

[0127] If all the tags contained in the query conditions of the extracted fuzzy matching structured query statement belong to the valid tag set, compare the tags contained in the query conditions of the extracted fuzzy matching structured query statement with the exclusion tag combination. The exclusion tag combination includes at least one pair of exclusion tags. If the tags contained in the query conditions of the extracted fuzzy matching structured query statement intersect with at least one pair of exclusion tags, then the semantic verification fails.

[0128] If the tags included in the query conditions of the extracted fuzzy matching structured query statement have no intersection with the excluded tags, determine whether there is a conditional branch statement in the join function of the fuzzy matching structured query statement that includes a valid tag set. If there is no conditional branch statement in the join function of the fuzzy matching structured query statement that includes a valid tag set, the semantic verification fails; if there is a conditional branch statement in the join function of the fuzzy matching structured query statement that includes a valid tag set, the semantic verification passes.

[0129] In step S2082, the tags contained in the query conditions of the extracted exact matching structured query statement are semantically verified by comparing them with the set of valid tags, the set of matching core tag groups, and the excluded tag combinations, including:

[0130] The semantic validation fails if the extracted exact match structured query conditions contain tags and a set of valid tags and matching core tags; if the extracted exact match structured query conditions do not contain tags that belong to the set of valid tags and matching core tags, the semantic validation fails.

[0131] If the tags included in the query conditions of the extracted exact match structured query statement all belong to the set of valid tags and the set of matching core tags, compare the tags included in the query conditions of the extracted exact match structured query statement with the combination of excluded tags. The combination of excluded tags includes at least one pair of excluded tags. If the tags included in the query conditions of the extracted exact match structured query statement intersect with at least one pair of excluded tags, then the semantic validation fails.

[0132] If the tags included in the query conditions of the extracted exact match structured query statement have no intersection with the excluded tags, determine whether there is a conditional branch statement in the join function of the exact match structured query statement that includes a valid tag set. If there is no conditional branch statement in the join function of the exact match structured query statement that includes a valid tag set, the semantic validation fails; if there is a conditional branch statement in the join function of the exact match structured query statement that includes a valid tag set, the semantic validation passes.

[0133] Specifically, in the syntax validation, the preprocessing function for relational databases is the `pg_prepare` function of the PostgreSQL database, which checks for syntax errors, missing fields, incorrect table names, and other issues. The PostgreSQL database's JDBC driver is called to execute the pre-compiled structured query statement, catching SQLException exceptions, extracting error information, and returning it. The validation focuses on whether the table name is `sdm.enterprise_data_info`, whether the returned fields are only `enterprise_id`, `credit_code`, `enterprise_name`, and `match_tags`, and whether the syntax is compliant. In the semantic validation, the query conditions of the structured query statement are verified to be consistent with the valid tag set and learning preference data, with no redundant, missing, or duplicate conditions. The tags extracted from the query conditions of the structured query statement are specifically the tags extracted from the WHERE clause of the structured query statement. When comparing the tags extracted from the exact matching structured query conditions, all extracted tags must belong to the valid tag set or a set consisting of the valid tag set and the matching core tag group to ensure the tag source is legitimate. The extracted tags must not contain any exclusion tag pairs to avoid negative matching rules. Furthermore, high-priority tags can be used as positive optimization items, not mandatory, but only for subsequent weighted sorting of results. The system checks whether the join function of the structured query contains a conditional branch statement that includes the valid tag set; that is, it checks whether the `concat_ws()` function of the `match_tags` field contains a `CASE WHEN` statement for all valid tags. Semantic checks apply to query conditions without invalid tags, exclusion tag combinations not appearing simultaneously, high-priority tags displayed first, and no duplicate field query conditions. In security checks, dangerous keywords such as `DROP`, `ALTER`, and `INSERT` are only allowed in this embodiment via `SELECT` statements. The query data range is limited to the `sdm.enterprise_data_info` table, with no cross-table queries. Of course, dangerous keywords and the query data range can be adjusted according to actual needs and are not limited to these. Security checks also include verifying that query conditions in structured query statements are not enclosed in single quotes and that there is no concatenated, unescaped user input. Compatibility checks include verifying functions in structured query statements such as `concat_ws()`, and checking if boolean fields in structured query statements are 1. This can be expanded to verify field type matching, and the fuzzy matching operator is specifically "LIKE," though it is not limited to these.

[0134] In steps S2081 and S2082, SQL statements are used to match enterprise attributes (enterprise tags) in the enterprise wide table with the tags, ultimately filtering out a list of matching enterprises. This includes all tags extracted from the target data (region, qualifications, indicators, etc.), which are pre-mapped to standardized fields in the enterprise wide table `sdm.enterprise_data_info` (e.g., city → registered location field in the enterprise wide table; high-tech enterprise → enterprise qualification field). The validated SQL statements, carrying WHERE matching rules, filter enterprise data row by row in the enterprise wide table: the enterprise field value corresponds to the enterprise's own tag, and the SQL condition value corresponds to the target data's required tag; if both are completely consistent, the tag match is considered successful. All enterprises that meet the matching rules are automatically aggregated into a list of matching enterprises, along with detailed matching tag information.

[0135] In steps S209 to S211, the temporary operation table and the long-term feature table are two lightweight newly added data tables that do not modify existing core system tables to ensure compatibility: the temporary operation table `current_policy_enterprise_operation` records user operations for a single target data matching, avoiding data backlog. The long-term feature table `policy_category_behavior` records label behavior features aggregated according to target data categories, supporting long-term learning. Before calling the large model to generate structured query statements, the two newly added tables are queried in real time to extract learning preference data. The operation records in the table originate from user behavior data collected and synchronized into the database in real time when users perform operations on the matched companies on the system front end. These are native business records generated manually by users, synchronous operations, and have no performance pressure due to small data volumes. As the data volume increases, it can be switched to asynchronous database entry + Redis caching of preference data. When there is no behavior data, it automatically reverts to the original matching logic without affecting functionality. A scheduled task archives / deletes archived target data in the temporary operation table to avoid data backlog. Configuration optimization is implemented, with core parameters (retention rate threshold, number of tags) configured in the system configuration table, supporting dynamic adjustment in the backend. This embodiment provides a specific temporary operation table and long-term feature table structure design, as follows:

[0136] Temporary operation table (records single user operations)

[0137] CREATE TABLE current_policy_enterprise_operation (

[0138] id VARCHAR(64) PRIMARY KEY COMMENT 'Unique Primary Key',

[0139] policy_id VARCHAR(64) NOT NULL COMMENT 'Related target data primary key',

[0140] `policy_category VARCHAR(100) NOT NULL COMMENT 'Category Tag'`

[0141] enterprise_id VARCHAR(64) NOT NULL COMMENT 'Related Enterprise ID',

[0142] operation_type VARCHAR(20) NOT NULL COMMENT 'Operation type (save: save; remove: remove)',

[0143] `match_tags VARCHAR(1000) NOT NULL COMMENT 'The set of valid tags matched this time',

[0144] Create time TIMESTAMP DEFAULT CURRENT_TIMESTAMP 'Operation time',

[0145] is_archived VARCHAR(2) DEFAULT '0' COMMENT 'Is it archived? (1: Yes; 0: No)' )

[0147] Long-term characteristic table (records the behavioral characteristics of target data categories and tags)

[0148] CREATE TABLE policy_category_behavior (

[0149] id VARCHAR(64) PRIMARY KEY COMMENT 'Unique Primary Key',

[0150] `policy_category VARCHAR(100) NOT NULL COMMENT 'Category Tag'`

[0151] effective_tag VARCHAR(200) NOT NULL COMMENT 'Valid tag',

[0152] save_count INT DEFAULT 0 COMMENT 'Number of saves',

[0153] remove_count INT DEFAULT 0 COMMENT 'Number of removals',

[0154] save_rate DECIMAL(5,2) DEFAULT 0.00 COMMENT 'Save rate < save_count / (save_count+ remove_count)>',

[0155] update time TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT 'update time',

[0156] is_valid VARCHAR(2) DEFAULT '1' COMMENT 'Is this valid? (1: Valid; 0: Invalid)' )

[0158] Of course, the structure design of temporary operation tables and long-term characteristic tables can be adjusted according to actual needs, and is not limited to this.

[0159] The matching result processing and push module filters processed companies, removing those marked "removed" from the priority push list to ensure processed companies do not appear repeatedly. A weighted sort is applied, prioritizing saved companies (in descending order of save time), and the remaining companies are sorted in descending order of the number of high-priority tags in "match_tags". User operations include removing (marked as remove), saving (marked as save), and pushing (supporting SMS / WeChat Work / API integration platform) companies. Result feedback and log transmission: The processed company list is returned to the user's front end, and user operation logs are simultaneously transmitted to the user behavior learning module for subsequent preference extraction.

[0160] In step S207, a set of high-priority labels is obtained from the relational database based on the classification tags corresponding to the unique primary keys of the system-extracted tables, including:

[0161] Filter the long-term feature table from the relational database, including the classification tags corresponding to the unique primary keys of the system-extracted tables;

[0162] Based on the selected long-term feature table, the saved tag items are counted as the filtered saved items, and the total number of times each filtered saved item is saved is calculated; based on the selected long-term feature table, the removed tag items are counted as the filtered removed items, and the total number of times each filtered removed item is removed is calculated.

[0163] Calculate the retention rate for each filter item, including: selecting any filter item and determining the total number of times the same filter removal items are removed; adding the total number of times the selected filter item is saved to the total number of times the same filter removal items are removed to obtain the total number of times; dividing the total number of times the selected filter item is saved by the total number of times to obtain the retention rate of the selected filter item.

[0164] Select items with a retention rate greater than or equal to a preset threshold and form a high-priority tag set.

[0165] The system extracts exclusion label combinations from the relational database based on the category tags corresponding to the unique primary keys in the extraction table, including:

[0166] Filter the long-term feature table from the relational database, including the classification tags corresponding to the unique primary keys of the system-extracted tables;

[0167] The removal labels are statistically analyzed based on the selected long-term feature table and used as the removal items. Multiple different removal pairs are generated based on all the removal items. Each removal pair includes two removal items and must belong to at least one of the selected long-term feature tables.

[0168] Calculate the number of times the removal pair appears in the selected long-term feature table, and take the removal pair with the maximum number of occurrences as the exclusion label pair. All exclusion label pairs constitute the exclusion label combination.

[0169] Specifically, this embodiment takes the example of forming a high-priority tag set by selecting and saving items with a retention rate greater than or equal to a preset threshold. Alternatively, the retention rates can be sorted from high to low, and the top N selected and saved items can be formed into a high-priority tag set. Similarly, this embodiment takes the removal pairs corresponding to the maximum number of occurrences as exclusion tag pairs, and all exclusion tag pairs as exclusion tag combinations. Alternatively, the occurrences can be sorted from high to low, and the top N removal pairs can be used as exclusion tag pairs, and all exclusion tag pairs can be formed into exclusion tag combinations. Of course, it is not limited to this.

[0170] It is understood that the data and enterprise intelligent matching method provided by this invention, driven by a large language model (GPT), combines customized Prompt engineering, dual-mode matching logic, user behavior closed-loop learning, and a full-process SQL verification mechanism to solve the core pain point of efficient and accurate matching of target data and enterprises. It constructs a fully automated system encompassing "target data parsing - tag extraction - enterprise matching - behavior learning - accuracy optimization," achieving intelligent, scalable, secure, and controllable matching of target data and enterprise information, adapting to diverse information implementation needs in business environment optimization. Customized Prompt engineering-driven large language model tag recognition and SQL generation achieve accurate mapping between target data and enterprises. The dual-mode design of fuzzy matching and precise matching meets diverse scenario requirements. A closed-loop learning mechanism based on user binary behavior continuously optimizes matching accuracy. A four-fold SQL verification mechanism ensures system security and query stability. Enterprise filtering and weighted sorting improve user experience and filtering efficiency. This invention achieves automatic tag extraction through a large model and customized prompts, improving efficiency by over 90% and accuracy by over 95% compared to manual methods. It also supports tag editing and custom additions, balancing flexibility and reusability, and can handle fuzzy and diverse target data text descriptions. The dual-mode matching design allows for free switching according to user needs. Matching rules are fixed through prompts, adapting to different target data matching requirements without code modification. The implementation efficiency of complex rules (regional constraints, multi-tag combinations) is significantly improved, with matching result effectiveness exceeding 60% compared to traditional rule engines. Continuous optimization of matching accuracy is achieved, building a "more accurate with use" closed loop, addressing the pain point of existing technologies' "no learning, no optimization": existing systems can only complete a single match, cannot utilize historical user behavior to optimize matching logic, and have high redundancy over long-term use. A lightweight user behavior learning mechanism is constructed, extracting preference data from "remove / save" operations to continuously constrain the matching logic. As usage time increases, the redundancy of matching results gradually decreases, and the proportion of results requiring no secondary manual screening continuously increases, significantly reducing labor costs. The generated SQL is secure, controllable, and highly compatible, addressing the pain points of existing technologies that are "risky, incompatible, and not directly executable": Existing basic large-scale model matching systems generate SQL that lacks effective validation, is prone to syntax errors and SQL injection risks, and has poor compatibility. A four-fold validation mechanism ensures that the SQL is free of syntax errors, redundancy, and security risks, and can be executed directly (with a 100% query success rate). It is also compatible with two mainstream databases, PostgreSQL and Highgo, adapting to existing data storage environments without requiring additional database modifications. Optimizing user experience and improving filtering efficiency, it addresses the pain points of existing technologies that suffer from "duplicate matching and chaotic sorting": Existing systems cannot mark processed enterprises, are prone to duplicate matching, increase the workload of secondary filtering for users, and lack intelligent sorting.By filtering processed enterprises at the system level, duplicate matching is completely avoided. Simultaneously, weighted sorting prioritizes the display of high-quality, followed enterprises, improving user filtering efficiency by over 70% and significantly reducing repetitive workload. The system boasts strong scalability and low adaptation costs, addressing the pain points of existing technologies: "code modification, high cost, and long cycle." Traditional rule engine systems require modifying core code and redeploying when adding target data categories or adjusting rules, resulting in high adaptation costs. Adopting a modular, decoupled, and configurable design, core parameters can be dynamically adjusted in the backend. Custom tags and system tags are stored in separate tables. When adapting to new target data or new enterprise attribute fields, only supplementary configuration is needed, without modifying the core code, significantly reducing system iteration and scenario adaptation costs and enhancing the system's lifecycle value. The entire process is fully automated, greatly reducing reliance on manual labor: Existing technologies require manual intervention in multiple stages such as tag extraction, rule configuration, SQL validation, and secondary filtering, resulting in high labor costs. This invention automates the entire process from target data collection, tag extraction, enterprise matching, SQL verification to result processing and behavior learning. Users only need to perform simple mode switching and tag confirmation operations, greatly reducing manual intervention and adapting to the needs of scenarios where the amount of target data and the size of enterprises are surging.

[0171] As can be seen from the above embodiments, the data and enterprise intelligent matching method provided by the present invention achieves at least the following beneficial effects:

[0172] 1. The method for intelligent matching of data and enterprises provided by this invention includes: receiving a matching instruction, and calling a language big model to generate a structured query statement based on the matching instruction. Specifically, when the matching instruction is a fuzzy matching instruction, a fuzzy matching structured query language generation template is called to generate a fuzzy matching structured query statement; the language big model executes the fuzzy matching structured query statement to query a wide table of enterprises stored in a relational database, and outputs a list of matching enterprises for the target data. When the matching instruction is a precise matching instruction, a precise matching structured query language generation template is called to generate an exact matching structured query statement; the language big model executes the exact matching structured query statement to query a wide table of enterprises stored in a relational database, and outputs a list of matching enterprises for the target data. This method automatically generates corresponding structured query statements based on different matching instructions, meeting different user needs without modifying the code. It automatically switches the matching method between support information and enterprises according to user needs, optimizing user experience and effectively improving the efficiency of matching results.

[0173] 2. The method for intelligent matching of data and enterprises provided by this invention includes: verifying the fuzzy matching structured query statement after generating it, or verifying the exact matching structured query statement after generating it. By automatically verifying the structured query statement after it is generated, it ensures that the structured query statement can be directly executed by the large language model without redundancy, thus guaranteeing the stability of subsequent query execution.

[0174] While specific embodiments of the invention have been described in detail by way of examples, those skilled in the art should understand that the examples are for illustrative purposes only and not intended to limit the scope of the invention. Those skilled in the art should understand that modifications can be made to the above embodiments without departing from the scope and spirit of the invention. The scope of the invention is defined by the appended claims.

Claims

1. A method for matching data with enterprise intelligence, characterized in that, include: Call the data acquisition interface to obtain the target data; The target data is preprocessed to obtain structured text, which includes a unique primary key and a classification tag. The structured text is then encapsulated into a structured data table and stored in a relational database. The tag extraction template is invoked, which includes extraction rules and output constraints. The tag extraction template is then populated based on the structured data table. The language model is invoked, and the filled-in tag extraction template is input into the language model. The language model follows the extraction rules and the output constraints, and outputs the tag results according to the contents of the filled structured data table. The label results are cleaned, and the cleaned label results are encapsulated into a system extraction table and stored in the relational database; The relational database also includes a custom label table, which is set up in a one-to-one correspondence with the system extraction table, and the custom label table and the corresponding system extraction table have the same unique primary key; The system extracts the unique primary key to retrieve the corresponding custom tag table, and merges the system-extracted tags with the retrieved custom tag table to obtain a valid tag set. Based on the classification tags corresponding to the unique primary key in the system extraction table, a set of high-priority tags and a combination of exclusion tags are obtained from the relational database. Receive a matching instruction, which may be a fuzzy matching instruction or a precise matching instruction; invoke a language big model to generate a structured query statement based on the matching instruction; and use the structured query statement to perform enterprise matching, including: When the matching instruction is the fuzzy matching instruction, a fuzzy matching structured query language generation template is invoked. This template includes fuzzy matching conditions, which require matching at least two tags from the valid tag set, and the matched tags from the valid tag set include necessary tags. The valid tag set, the high-priority tag set, and the excluded tags are then combined and filled into the fuzzy matching structured query language generation template. The language model is then invoked, and the filled fuzzy matching structured query language generation template is input into the language model. The language model then... The high-priority tag set serves as a positive priority constraint, while the excluded tag combination serves as a negative filtering condition. This, combined with the fuzzy matching conditions and the valid tag set, generates a fuzzy matching structured query statement. The fuzzy matching structured query statement is then verified. If the verification fails, the process returns to the language model, which generates a structured query statement based on the matching instructions. If the verification passes, the language model executes the fuzzy matching structured query statement to query the enterprise wide table stored in the relational database, outputting a list of matching enterprises for the target data. When the matching instruction is the exact match instruction, the exact match structured query language generation template is invoked. The exact match structured query language generation template includes exact match conditions, including the existence of a North Star tag and matching of a core tag group. The valid tag set, the high-priority tag set, and the exclusion tag combination are filled into the exact match structured query language generation template. The language model is invoked, and the filled exact match structured query language generation template is input into the language model. The language model uses the high-priority tag set as the positive priority constraint condition and the exclusion tag combination as the negative filtering condition, and generates an exact match structured query statement in combination with the exact match conditions. The exact match structured query statement is verified. If the exact match structured query statement verification fails, the process returns to invoking the language model to generate a structured query statement according to the matching instruction. If the exact match structured query statement verification passes, the language model is invoked to execute the exact match structured query statement to query the enterprise wide table stored in the relational database, and outputs a list of matching enterprises for the target data.

2. The method for intelligent matching of data and enterprises according to claim 1, characterized in that, The verification of the fuzzy matching structured query statement includes: The preprocessing function of the relational database is invoked to perform syntax validation on the fuzzy matching structured query statement; if the syntax validation fails, the fuzzy matching structured query statement fails validation. If the syntax check passes, the fuzzy matching structured query statement is parsed, and the tags contained in the query conditions of the fuzzy matching structured query statement are extracted. The extracted tags contained in the query conditions of the fuzzy matching structured query statement are compared with the valid tag set and the excluded tag combination for semantic verification. If the semantic verification fails, the fuzzy matching structured query statement verification fails. If the semantic verification passes, a security verification is performed on the fuzzy matching structured query statement, including: determining whether the fuzzy matching structured query statement contains dangerous keywords, whether the query conditions of the fuzzy matching structured query statement are enclosed in single quotes, and whether the fuzzy matching structured query statement restricts the range of query data; if at least one of the following occurs: the fuzzy matching structured query statement contains dangerous keywords, the query conditions of the fuzzy matching structured query statement are not enclosed in single quotes, and the fuzzy matching structured query statement does not restrict the range of query data, then the security verification fails; if the fuzzy matching structured query statement does not contain dangerous keywords, the query conditions of the fuzzy matching structured query statement are enclosed in single quotes, and the fuzzy matching structured query statement restricts the range of query data, then the security verification passes; if the security verification fails, then the fuzzy matching structured query statement verification fails. If the security check passes, a compatibility check is performed on the fuzzy matching structured query statement, including: determining whether the functions contained in the fuzzy matching structured query statement are compatible with the relational database and the Highgo database, whether the boolean field of the fuzzy matching structured query statement is 1, and whether the fuzzy matching structured query statement contains a fuzzy matching operator that adds a percentage sign for full matching; if the following conditions are not met: all functions contained in the fuzzy matching structured query statement are compatible with the relational database and the Highgo database, the boolean field of the fuzzy matching structured query statement is not 1, and the fuzzy matching structured query statement does not exist... If at least one of the following conditions is met in the fuzzy matching operator that adds a percentage sign for full matching, the compatibility check fails: If all functions included in the fuzzy matching structured query statement are compatible with both the relational database and the Highgo database, the boolean field of the fuzzy matching structured query statement is 1, and the fuzzy matching structured query statement contains the fuzzy matching operator that adds a percentage sign for full matching, then the compatibility check passes: If the compatibility check passes, the fuzzy matching structured query statement passes verification; if the compatibility check fails, the fuzzy matching structured query statement fails verification.

3. The method for intelligent matching of data and enterprises according to claim 1, characterized in that, The verification of the precisely matched structured query statement includes: The preprocessing function of the relational database is invoked to perform syntax validation on the exact match structured query statement; if the syntax validation fails, the exact match structured query statement fails validation. If the syntax check passes, the exact matching structured query statement is parsed, and the tags contained in the query conditions of the exact matching structured query statement are extracted. The extracted tags contained in the query conditions of the exact matching structured query statement are compared with the set of valid tags, the set of matching core tags, and the exclusion tag combination for semantic verification. If the semantic verification fails, the exact matching structured query statement fails. If the semantic verification passes, a security verification is performed on the exact matching structured query statement, including: determining whether the exact matching structured query statement contains dangerous keywords, whether the query conditions of the exact matching structured query statement are enclosed in single quotes, and whether the exact matching structured query statement restricts the range of query data; if at least one of the following occurs: the exact matching structured query statement contains dangerous keywords, the query conditions of the exact matching structured query statement are not enclosed in single quotes, and the exact matching structured query statement does not restrict the range of query data, then the security verification fails; if the exact matching structured query statement does not contain dangerous keywords, the query conditions of the exact matching structured query statement are enclosed in single quotes, and the exact matching structured query statement restricts the range of query data, then the security verification passes; if the security verification fails, then the exact matching structured query statement verification fails. If the security check passes, a compatibility check is performed on the exact matching structured query statement, including: determining whether the functions contained in the exact matching structured query statement are compatible with the relational database and the Highgo database, and whether the boolean field of the exact matching structured query statement is 1; if the functions contained in the fuzzy matching structured query statement are all compatible with the relational database and the Highgo database, or the boolean field of the exact matching structured query statement is not 1, then the compatibility check fails; if the functions contained in the exact matching structured query statement are all compatible with the relational database and the Highgo database, and the boolean field of the exact matching structured query statement is 1, then the compatibility check passes; if the compatibility check passes, the exact matching structured query statement passes verification; if the compatibility check fails, the exact matching structured query statement fails verification.

4. The method for intelligent matching of data and enterprises according to claim 2, characterized in that, The step of semantically validating the tags included in the extracted fuzzy matching structured query conditions by comparing them with the valid tag set and the excluded tag combination, includes: The tags contained in the extracted fuzzy matching structured query conditions are compared with the set of valid tags; if the tags contained in the extracted fuzzy matching structured query conditions do not all belong to the set of valid tags, then the semantic verification fails. If all the tags contained in the query conditions of the extracted fuzzy matching structured query statement belong to the valid tag set, compare the tags contained in the query conditions of the extracted fuzzy matching structured query statement with the exclusion tag combination, the exclusion tag combination includes at least one pair of exclusion tags; if the tags contained in the query conditions of the extracted fuzzy matching structured query statement intersect with at least one pair of exclusion tags, then the semantic verification fails. If the tags included in the query conditions of the extracted fuzzy matching structured query statement have no intersection with the excluded tag pair, determine whether there is a conditional branch statement in the join function of the fuzzy matching structured query statement that includes the valid tag set. If the join function of the fuzzy matching structured query statement does not have a conditional branch statement that includes the valid tag set, then the semantic verification fails; if the join function of the fuzzy matching structured query statement has a conditional branch statement that includes the valid tag set, then the semantic verification passes.

5. The method for intelligent matching of data and enterprises according to claim 3, characterized in that, The step of semantically validating the extracted tags contained in the query conditions of the precisely matched structured query statement by comparing them with the set of valid tags, the set of matching core tags, and the excluded tag combinations, includes: The semantic verification fails if the tags included in the extracted precise matching structured query conditions are compared with the set consisting of the effective tag set and the matching core tag group; if the tags included in the extracted precise matching structured query conditions do not all belong to the set consisting of the effective tag set and the matching core tag group, then the semantic verification fails. If the tags included in the extracted precise matching structured query conditions all belong to the set consisting of the valid tag set and the matching core tag group, compare the tags included in the extracted precise matching structured query conditions with the exclusion tag combination, where the exclusion tag combination includes at least one pair of exclusion tags; if the tags included in the extracted precise matching structured query conditions intersect with at least one pair of exclusion tags, then the semantic verification fails. If the tags included in the extracted exact match structured query conditions do not intersect with the excluded tag pairs, determine whether there is a conditional branch statement in the join function of the exact match structured query that includes the valid tag set. If the join function of the exact match structured query does not have a conditional branch statement that includes the valid tag set, the semantic verification fails; if the join function of the exact match structured query has a conditional branch statement that includes the valid tag set, the semantic verification passes.

6. The method for intelligent matching of data and enterprises according to claim 1, characterized in that, Also includes: Receive operation logs, the operation logs including operation type, the unique primary key, the category tag corresponding to the unique primary key, and the tag matched when the target data corresponding to the unique primary key is queried in the enterprise wide table; The operation log is saved to a temporary operation table in the relational database; The operation types include save operations and remove operations; When the operation type is the save operation, the unique primary key is extracted from the temporary operation table, and the unique primary key is used to query the relational database to see if there is a corresponding long-term feature table. If no corresponding long-term feature table exists, create the corresponding long-term feature table based on the unique primary key; Extract the classification tag corresponding to the unique primary key from the temporary operation table, and write the classification tag corresponding to the unique primary key into the long-term feature table corresponding to the unique primary key; Extract the tags matched when querying the enterprise wide table with the target data corresponding to the unique primary key from the temporary operation table. Calculate the tag items as saved tag items based on the tags matched when querying the enterprise wide table with the target data corresponding to the unique primary key. Calculate the number of times each saved tag item is saved. Write the saved tag items and the number of times each saved tag item is saved into the long-term feature table corresponding to the unique primary key. If a corresponding long-term feature table exists, extract the tags matched when querying the enterprise wide table for the target data corresponding to the unique primary key from the temporary operation table. Calculate the tag items as the saved tag items based on the tags matched when querying the enterprise wide table for the target data corresponding to the unique primary key. Calculate the number of times each saved tag item is saved. Update the long-term feature table corresponding to the unique primary key based on the saved tag items and the number of times each saved tag item is saved. When the operation type is the removal operation, the unique primary key is extracted from the temporary operation table, and the corresponding long-term feature table is queried in the relational database according to the unique primary key. Extract the tags matched when querying the enterprise wide table for the target data corresponding to the unique primary key from the temporary operation table. Calculate the tag items as the removal tag items based on the tags matched when querying the enterprise wide table for the target data corresponding to the unique primary key. Calculate the removal count for each removal tag item. Update the long-term feature table corresponding to the unique primary key based on the removal tag items and the removal count for each removal tag item.

7. The method for intelligent matching of data and enterprises according to claim 6, characterized in that, The step of retrieving a set of high-priority tags from the relational database based on the classification tags corresponding to the unique primary key in the system extraction table includes: The long-term feature table, which includes the classification tags corresponding to the unique primary keys of the system extraction table, is filtered from the relational database. Based on the selected long-term feature table, the saved tag items are counted as the filtered saved items, and the total number of times each of the filtered saved items is calculated; based on the selected long-term feature table, the removed tag items are counted as the filtered removed items, and the total number of times each of the filtered removed items is calculated. Calculating the retention rate of each of the filtered items includes: selecting any of the filtered items to be saved, determining the total number of times the same filtered items to be removed are removed; adding the total number of times the selected filtered items to be saved to the total number of times the same filtered items to be removed are removed to obtain a total number of times; and dividing the total number of times the selected filtered items to be saved by the total number of times to obtain the retention rate of the selected filtered items. The selected and saved items with a retention rate greater than or equal to a preset threshold constitute the high-priority tag set.

8. The method for intelligent matching of data and enterprises according to claim 6, characterized in that, The step of obtaining the exclusion label combination from the relational database based on the classification tag corresponding to the unique primary key in the system extraction table includes: The long-term feature table, which includes the classification tags corresponding to the unique primary keys of the system extraction table, is filtered from the relational database. The removal tag items are statistically analyzed based on the selected long-term feature table and used as the removal items. Multiple different removal pairs are generated based on all the removal items. Each removal pair includes two removal items and belongs to at least one of the selected long-term feature tables. Calculate the number of times the removal pair appears in the filtered long-term feature table, and take the removal pair corresponding to the maximum number of appearances as the exclusion label pair. All the exclusion label pairs constitute the exclusion label combination.

9. The method for intelligent matching of data and enterprises according to claim 1, characterized in that, The preprocessing of the target data to obtain structured text includes: The target data is then cleaned of noise. The cleaned target data is split into multiple clauses based on logical connectors; Dimensional annotation is performed on the aforementioned clauses; The annotated sentences are then encapsulated into the structured text.

Images