Shapefile automatic processing model based on large language model and multi-agent collaboration

Abstract

The invention discloses a Shapefile automatic processing model based on a large language model and multi-agent collaboration, and relates to the technical field of computer processing, and the Shapefile automatic processing model comprises: an input layer, a user uploads a to-be-processed Shapefile and a task instruction; the processing layer is used for extracting to obtain the Shapefile and a task instruction and obtaining a processing task; the thinking decision-making layer is used for generating sub-tasks needing to be executed based on the acquired processing tasks and according to processing of a preset strategy; the execution layer is used for executing the received subtasks needing to be executed and collecting execution results to obtain feedback data; and the judgment layer is used for judging whether the current subtask needing to be executed is completed or not on the basis of the obtained feedback data. According to the method, the problems of high technical threshold, low automation level and complex interaction mode when a user processes the Shapefile are solved, the user does not need to master professional GIS knowledge or programming skills, complex Shapefile processing tasks can be completed only through natural language description, and the Shapefile operation process is remarkably simplified.

Description

Technical Field

[0001] The present invention relates to the field of computer processing technologies, and particularly to an automatic processing model for Shapefile files based on large language models and multi-agent collaboration. Background Art

[0002] In the application of Geographic Information System (GIS), vector data is the core data structure for describing geographic objects and their spatial relationships, capable of accurately recording the positions of geometric figures and their related attribute information. As the most widely used vector data storage format at present, Shapefile files have become the industry standard due to their excellent compatibility and flexibility. The processing of Shapefile files has become an important part of the daily work of GIS practitioners. Currently, the processing technologies for Shapefile files mainly rely on professional GIS software and tools, such as ArcGIS and QGIS. In addition, existing automated processing methods usually require writing scripts in languages such as Python and R to automate some tasks, which poses relatively high requirements for the technical capabilities of users.

[0003] Refer to Chinese Patent, Publication No.: CN114328779A, a geographic information cloud disk for efficient retrieval and browsing based on cloud computing;

[0004] And Chinese Patent, Publication No.: CN117372642A, a three-dimensional modeling method and visualization system based on digital twin;

[0005] In the prior art including the above two patents, the application of Shapefile files in Geographic Information System (GIS) is of great importance. However, there are still the following significant defects in the field of Shapefile file processing in the prior art:

[0006] High technical threshold and lack of usability: The processing requirements of Shapefile files extend beyond the geographical field, and many practitioners in other industries also need to process them. However, professional geographic information system software (such as ArcGIS and QGIS) has relatively high requirements for the GIS knowledge level of users, and it is difficult for non-professional users to complete complex Shapefile processing tasks;

[0007] Insufficient automation level and low efficiency: Existing automated processing methods (such as those based on Python scripts) are usually only applicable to specific tasks and lack flexibility and generality;

[0008] The interaction mode between existing tools and users is complex: The current interaction mode between Shapefile file processing tools and users is complex, with a high learning cost, and it is difficult for personnel in other fields to get started quickly.

[0009] In summary, how to simplify the operation process of Shapefile files, thereby reducing the operation difficulty of the system, so that users can operate the relevant application systems without the need to have a certain level of GIS knowledge or programming skills has become an urgent problem to be solved at this stage. Summary of the Invention

[0010] For the above technical problems, the technical solution adopted by the present invention is an automatic processing model for Shapefile files based on large language models and multi-agent collaboration, including:

[0011] An input layer where the user uploads the Shapefile file to be processed and the task instructions;

[0012] A processing layer that extracts information about the Shapefile file and the task instructions to obtain a processing task;

[0013] A thinking and decision-making layer that generates subtasks to be executed based on the obtained processing task and processes them according to a predetermined strategy;

[0014] An execution layer that executes the received subtasks to be executed and collects the execution results to obtain feedback data;

[0015] A judgment layer that makes a judgment based on the obtained feedback data as to whether the currently required subtask has been completed:

[0016] If so, the processing is completed, and the final processing result of the Shapefile file is sorted out to obtain a first feedback file;

[0017] If not, return to the thinking and decision-making layer to obtain the remaining subtasks different from the subtasks to be executed, and then transfer them to the execution layer - the execution layer until the total task is completed to obtain a second feedback file;

[0018] A presentation layer that sends the obtained first feedback file and second feedback file to the user.

[0019] Preferably, the method for the thinking and decision-making layer to generate the subtasks to be executed includes the following steps:

[0020] S11. Extract the text information of the processing task, use the large language model to gradually output the text result, and describe the text result in a specific structured format to obtain the semantics;

[0021] S12. Extract the task core and multiple subtasks related to the task core based on the obtained semantics;

[0022] S13. Configure the execution instructions for the current subtask, and the execution instructions include parameter configuration and expected output.

[0023] Preferably, in the execution of step S12, it further includes an evaluation of the parameter requirements of each subtask. The evaluation determines whether the logical order between the subtask and the task core is correct according to the programming logic. If it is correct, proceed to the next step; if it is incorrect, return to step S11.

[0024] Preferably, the execution layer includes a pre-created function library, which stores tool functions. The tool functions include the name of the function, parameter definitions, usage rules, examples, and default values.

[0025] The method for the execution to receive the subtasks to be executed includes the following steps:

[0026] S21. Analyze the currently to-be-executed subtask and match a suitable API document from the function library. The API document includes multiple tool functions.

[0027] S22. Automatically create the parameter logic required for the currently to-be-executed subtask based on the API document.

[0028] S23. Execute the call of the tool function in an isolated sandbox environment. If the subtask is completed, proceed to the next step; if the subtask is not completed, return to the first step and continue to execute the next tool function.

[0029] S24. Generate feedback data according to the execution status of step S23 and according to the predetermined feedback terms.

[0030] Preferably, the API document adopts the YAML file format. After obtaining the suitable API document in step S21, a mapping relationship of the tool functions corresponding to the logic in the function library will be automatically generated.

[0031] Preferably, when executing the call of the tool function in step S23, the result of the call will be evaluated. If the evaluation fails, a fault tolerance mechanism will be triggered, and the parameters of the tool function will be dynamically adjusted according to the error log and a new call instruction will be generated.

[0032] It also includes adjusting the upper limit of the number of times the fault tolerance mechanism is triggered. After reaching the upper limit of the number of times, the generation of new call instructions will be suspended and feedback will be given.

[0033] Preferably, the return to the thinking and decision-making layer to obtain the remaining subtasks different from the subtasks to be executed includes:

[0034] S31. Obtain the feedback log after the execution of the currently to-be-executed subtask fails.

[0035] S32. Analyze the feedback log and execute a dynamic adjustment plan based on the feedback log. The dynamic adjustment plan includes modifying the parameters of the tool function and adjusting the task order;

[0036] S33. Regenerate the subtasks that need to be executed currently to obtain the remaining subtasks.

[0037] Preferably, the execution of the model operation is performed by accessing and running the large language model deployed locally or / and the API interface of the provider.

[0038] The present invention has at least the following beneficial effects:

[0039] 1. Through the collaborative design of the thinking decision-making layer and the execution layer, a Shapefile file processing system based on natural language description is realized. Among them, the thinking decision-making layer can dynamically parse the natural language task description input by the user, decompose it into logically clear subtasks, and generate standardized task instructions; the execution layer is responsible for executing specific subtasks, and by calling the predefined Shapefile function library, completes parameter configuration and task execution, and finally generates a processing result file that meets the user's needs, thereby realizing the full-process automation and efficient execution of complex Shapefile operation tasks;

[0040] 2. Enables users to directly describe the processing tasks of Shapefile files in natural language without the need to master professional GIS knowledge or write complex codes, thereby significantly reducing the usage threshold;

[0041] 3. The execution layer will analyze the execution result and then feedback it to the thinking decision-making layer. At this time, the thinking decision-making layer will re-analyze the task reason based on the failure feedback and dynamically adjust the execution plan, and may try to recover by modifying parameters, adjusting the task order or regenerating subtasks, thereby significantly improving the fault tolerance and success rate of the task to ensure the efficient execution of complex tasks and the accuracy of the results;

[0042] 4. Supports replacing the LLM from the cloud API with a locally deployed model, meets the requirements of data privacy, security and scenarios without network connection, greatly enhances the flexibility and adaptability of the system, avoids problems such as low task execution efficiency and complex user interaction in traditional tools, and greatly improves the convenience and intelligent level of Shapefile file processing. BRIEF DESCRIPTION OF THE DRAWINGS

[0043] To more clearly illustrate the technical solutions in the embodiments of the present invention, the following will briefly introduce the accompanying drawings required for the description of the embodiments. Obviously, the accompanying drawings in the following description are only some embodiments of the present invention. For those of ordinary skill in the art, without creative efforts, other accompanying drawings can be obtained based on these drawings.

[0044] Figure 1 It is an architecture diagram of an automatic processing model for Shapefile files based on a large language model and multi-agent collaboration provided in Embodiment 1 of the present invention;

[0045] Figure 2 It is a flowchart of the thinking and decision-making layer provided in Embodiment 1 of the present invention;

[0046] Figure 3 It is a flowchart of the execution layer provided in Embodiment 1 of the present invention;

[0047] Figure 4 It is a flowchart of the judgment layer provided in Embodiment 1 of the present invention;

[0048] Figure 5 It is the storage format of the API document provided in Embodiment 1 of the present invention;

[0049] Figure 6 It is a specific example of the function API provided in Embodiment 1 of the present invention. Specific Embodiment

[0050] The following will clearly and completely describe the technical solutions in the embodiments of the present invention with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, rather than all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative efforts belong to the scope of protection of the present invention.

[0051] It should be noted that the terms "first", "second", etc. in the specification and claims of the present invention and the above accompanying drawings are used to distinguish similar objects, and do not necessarily need to describe a specific order or sequence. It should be understood that such used data can be interchanged under appropriate circumstances so that the embodiments of the present invention described here can be implemented in an order other than those illustrated or described here. In addition, the terms "include" and "have" and any variations thereof are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or server including a series of steps or units does not necessarily need to be limited to those clearly listed steps or units, but may include other steps or units not clearly listed or inherent to these processes, methods, products, or devices.

[0052] Embodiment 1

[0053] This embodiment provides an automatic processing model for Shapefile files based on large language models and multi-agent collaboration, including: as Figure 1 shown, the architecture of this model includes the following parts:

[0054] Input layer, where the user uploads the Shapefile file to be processed, as well as the task instruction and the task instruction;

[0055] Specifically, the uploaded Shapefile file can be a geospatial dataset containing vector data, and the input task can be a readable functional description or an overview of the function to be completed, such as operations of data format conversion, spatial analysis, geographic information extraction, or spatial query.

[0056] Processing layer, which extracts information about the Shapefile file and the task instruction to obtain the processing task;

[0057] Specifically, when the processing layer receives the task instruction input by the user and the uploaded Shapefile file, it extracts the summary of the Shapefile file information, including the geometric type, spatial reference system, attribute fields, data structure, etc. of the file, and at the same time performs a deep semantic analysis on the above "readable functional description or overview of the function to be completed" to obtain what the total task that this model needs to complete for the Shapefile file is.

[0058] Thinking and decision-making layer (the core component is the Planner agent), based on the obtained processing task, and according to the processing of the predetermined strategy, generates the subtasks to be executed;

[0059] Specifically, as shown in Figure 2 shown, the method for generating the subtasks to be executed includes the following steps:

[0060] S11. Extract the text information of the processing task, use the large language model to gradually output the text result, and describe the text result in a specific structured format to obtain the semantics;

[0061] S12. Extract the task core and multiple subtasks related to the task core based on the obtained semantics;

[0062] S13. Configure the execution instructions for the current subtask, and the execution instructions include parameter configuration and expected output.

[0063] Furthermore, in the execution of step S12, it also includes an evaluation of the parameter requirements of each subtask. The evaluation judges whether the logical order between the subtask and the task core is correct according to the programming logic. If it is correct, continue to the next step; if it is wrong, return to step S11.

[0064] As described above, by interpreting the overall task, the core objectives of the task are extracted and decomposed into several sub-tasks with clear logic, independent of each other but related. For example, for the user task of "generating a buffer and clipping to a polygon", the Planner agent infers that "buffer generation" is a priority task, while "clipping the polygon" depends on the result of buffer generation. At this stage, the parameter requirements of each sub-task are evaluated separately, such as the buffer radius or clipping range, to ensure the logical coherence and correctness of all tasks.

[0065] Before dispatching the currently required sub-task to the execution layer, detailed execution instructions are generated for each sub-task, including parameter configuration and expected output. For example, for the "generate buffer" task, the thinking and decision-making layer generates an instruction of "generate a buffer for the file points.shp and set the buffer radius to 500 meters" and dispatches it to the execution layer for execution.

[0066] It should be noted that after the execution layer returns the feedback data, the thinking and decision-making layer will re-observe the current task status, re-analyze, re-extract the core objectives of the task, as well as multiple sub-tasks that are logically related to the core objectives of the task and independent of each other, and re-dispatch them to the execution layer.

[0067] The execution layer (the core component is the Worker agent) executes the received sub-tasks to be executed and collects the execution results to obtain feedback data;

[0068] Specifically, the execution layer includes a pre-created function library, which stores tool functions. The tool functions include the name of the function, parameter definition, usage rules, examples, and default values;

[0069] Furthermore, based on the above embodiments and in combination with Figure 3 As shown, the method for the execution layer to execute the received sub-tasks to be executed includes the following steps:

[0070] S21. Analyze the currently required sub-task and match the appropriate API documentation from the function library. The API documentation includes multiple tool functions;

[0071] S22. Automatically create the parameter logic required for the currently required sub-task based on the API documentation;

[0072] S23. Execute the call of the tool function in an isolated sandbox environment. If the sub-task is completed, proceed to the next step. If the sub-task is not completed, return to the first step and continue to execute the next tool function;

[0073] S24. Generate feedback data according to the execution status of step S23 and according to the predetermined feedback terms.

[0074] In summary, when the execution layer needs to execute subtasks, it needs to use the tool functions in the function library to execute specific subtasks, and its operation depends on the following three elements:

[0075] I. Function library: It contains predefined functions for operating on Shapefile, such as "buffer generation", "clipping operation", etc.

[0076] II. API documentation: It provides the name, parameter definition, usage rules and examples of each function to ensure that the execution layer can correctly configure and call functions.

[0077] III. Shapefile file information: It contains information about the current Shapefile to be processed, such as geometric type, field name and attribute table content, to avoid referring to non-existent fields or incorrect parameters when calling functions.

[0078] And when executing subtasks, the current subtask will be analyzed and the most suitable API documentation will be matched from the function library. For example, for the instruction of "generating a 500-meter buffer for point data", the Worker intelligent agent will select the CreateBuffer function. Then, according to the instruction content, the Worker intelligent agent will automatically construct the required parameters, such as buffer radius, input data path, etc. This process uses the parameter definition and examples in the API documentation to ensure the correctness of parameter configuration. When the execution layer executes function calls in an isolated sandbox environment for subtasks, if the subtask is completed, it will proceed to the next step; if the subtask is not completed, it will return to the first step and continue to execute the next function.

[0079] And the above-mentioned predefined feedback terms include whether the task is successful or whether the result file meets the logical requirements, etc., which can be set according to personal preferences.

[0080] Furthermore, in combination with Figure 5 and Figure 6 As shown, the API documentation in the above embodiments adopts the YAML file format, and after obtaining the appropriate API documentation in step S21, a mapping relationship of the tool functions corresponding to the logic in the function library will be automatically generated.

[0081] Secondly, when calling the tool function in the execution of step S23, the result of the call will be evaluated. If the evaluation fails, the fault tolerance mechanism will be triggered, and the parameters of the tool function will be dynamically adjusted according to the error log and a new call instruction will be generated.

[0082] It also includes adjusting the upper limit of the number of times the fault tolerance mechanism is triggered. After reaching the upper limit of the number of times, the generation of new call instructions will be suspended and feedback will be given.

[0083] In the above technology, the API documentation is stored in the YAML file format, recording the name, function description, input parameter types, and default values of each function, providing standardized function call information for the system. At the same time, since the essence of large language models is to generate text content, they do not have the ability to directly call functions or execute code. Through a cleverly designed prompt strategy, combined with the function call format defined in the API documentation, the LLM is guided to output a text representation of the function call in a fixed structure. For example, during the implementation process, the prompt will clearly require the model to return something like "#ReadingDataFromShapefile(input_file=points.shp')#".

[0084] After that, the model parses this structured output through regular expressions, extracts the function name and parameter list, and maps them to the actual Shapefile function library for execution, thus indirectly achieving the ability to call functions.

[0085] The judgment layer makes a judgment based on the obtained feedback data on whether the subtask to be currently executed is completed:

[0086] If so, the processing is completed, and the final processing result of the Shapefile file is sorted out to obtain the first feedback file;

[0087] If not, it returns to the thinking and decision-making layer to obtain the remaining subtasks different from the subtask to be executed, and then passes them to the execution layer - the execution layer until the total task is completed, obtaining the second feedback file;

[0088] Specifically, as shown in Figure 4 the above return to the thinking and decision-making layer to obtain the remaining subtasks different from the subtask to be executed, including:

[0089] S31. Obtain the feedback log after the execution of the subtask to be currently executed fails;

[0090] S32. Analyze the feedback log and execute a dynamic adjustment plan based on the feedback log. The dynamic adjustment plan includes modifying the parameters of the tool function and adjusting the task order;

[0091] S33. Regenerate the subtask to be currently executed to obtain the remaining subtasks.

[0092] As described above, when a function call fails, a fault tolerance mechanism is triggered to dynamically adjust parameters based on error logs and regenerate call instructions. The fault tolerance mechanism supports up to 20 retries and allows developers to set the upper limit of the retry count according to specific requirements, thereby further improving the execution stability of tasks. It can overcome the limitation that the LLM can only generate text and cannot directly execute functions, enabling it to flexibly and efficiently participate in the processing of complex tasks. The system can not only dynamically adapt to newly added functions and parameters in the API documentation but also support extension to function call scenarios in other fields. This design not only enhances the automation of the system but also significantly improves the flexibility and reliability of task execution, providing strong technical support for implementing complex Shapefile processing tasks.

[0093] The presentation layer sends the obtained first feedback file and second feedback file to the user.

[0094] It should be noted that in the above embodiments, the execution model runs by accessing the large language model deployed locally or / and the API interface of the provider. That is, it is all achieved by calling the API interface of the model provider and at the same time supports replacement with a locally deployed large language model. On the one hand, by using the API interface of the large language model, the system can quickly implement task processing functions without relying on local computing power. Users can obtain fast inference response times without caring about the operating environment and hardware configuration of the underlying model. On the other hand, the system architecture design supports replacing the default API interface with a locally deployed large language model. This replaceability enables the system to adapt to different usage scenarios and requirements, such as scenarios where there is no network connection.

[0095] In the first embodiment, through the collaborative design of the thinking and decision-making layer and the execution layer, a Shapefile file processing system based on natural language description is realized. Among them, the thinking and decision-making layer can dynamically parse the natural language task description input by the user, decompose it into logically clear subtasks, and generate standardized task instructions; the execution layer is responsible for executing specific subtasks, and by calling a predefined Shapefile function library, completes parameter configuration and task execution, and finally generates a processing result file that meets the user's needs, thus realizing the full-process automation and efficient execution of complex Shapefile operation tasks; and enables users to directly describe the processing tasks of Shapefile files in natural language without mastering professional GIS knowledge or writing complex code, thus significantly reducing the usage threshold; secondly, the execution layer will analyze the execution results and then feedback them to the thinking and decision-making layer. At this time, the thinking and decision-making layer will re-analyze the task reasons based on the failure feedback and dynamically adjust the execution plan, and may try to recover by modifying parameters, adjusting the task order or regenerating subtasks, thus significantly improving the fault tolerance and success rate of the task to ensure the efficient execution of complex tasks and the accuracy of the results; furthermore, it supports replacing the LLM from the cloud API with a locally deployed model to meet the requirements of data privacy, security and scenarios without network connection, greatly enhancing the flexibility and adaptability of the system, avoiding problems such as low task execution efficiency and complex user interaction in traditional tools, and greatly improving the convenience and intelligence level of Shapefile file processing.

[0096] Embodiment 2

[0097] An embodiment of the present invention provides a non-transitory computer-readable storage medium, in which at least one instruction or at least one program segment is stored, and at least one instruction or at least one program segment is loaded and executed by a processor to implement the steps:

[0098] The user uploads the Shapefile file to be processed and the task instructions;

[0099] Extract the Shapefile file and the task instructions to obtain a processing task;

[0100] Based on the obtained processing task and according to the processing of a predetermined strategy, generate subtasks to be executed;

[0101] Execute the received subtasks to be executed and collect the execution results to obtain feedback data;

[0102] Based on the obtained feedback data, judge whether the currently to-be-executed subtask is completed:

[0103] If so, the processing is completed, and the final processing results of the Shapefile are sorted out to obtain the first feedback file;

[0104] If not, return to the thinking and decision-making layer to obtain the remaining subtasks that are different from the subtasks to be executed, and then transfer them to the execution layer - the execution layer until the total task is completed to obtain the second feedback file;

[0105] Send the obtained first feedback file and second feedback file to the user.

[0106] Those of ordinary skill in the art can understand that all or part of the processes in the methods of the above embodiments can be completed by instructing relevant hardware through a computer program. The computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above methods. Among them, any reference to a memory, storage, database, or other medium used in the various embodiments provided in the present application can include non-volatile and / or volatile memories. Non-volatile memories can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memories can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in many forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDR SDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and Rambus dynamic RAM (RDRAM), etc.

[0107] Those skilled in the art can clearly understand that for the convenience and simplicity of description, only the above division of each functional unit and module is used as an example. In practical applications, the above functions can be allocated to different functional units and modules as needed, that is, the internal structure of the device is divided into different functional units or modules to complete all or part of the functions described above.

[0108] Embodiment III

[0109] The embodiment of the present invention provides an electronic device, including a processor and a memory. At least one instruction or at least one program segment is stored in the memory, and the at least one instruction or the at least one program segment is loaded and executed by the processor to implement the steps:

[0110] The user uploads the Shapefile file to be processed and the task instructions;

[0111] Extract the Shapefile file and the task instructions to obtain the processing task;

[0112] Based on the obtained processing task and according to the processing of the predetermined strategy, generate the subtasks to be executed;

[0113] Execute the received subtasks to be executed and collect the execution results to obtain feedback data;

[0114] Based on the obtained feedback data, determine whether the currently executed subtask is completed:

[0115] If so, the processing is completed, and the final processing result of the Shapefile file is sorted out to obtain the first feedback file;

[0116] If not, return to the thinking and decision-making layer to obtain the remaining subtasks different from the subtasks to be executed, and then transfer them to the execution layer - the execution layer until the total task is completed to obtain the second feedback file;

[0117] Send the obtained first feedback file and second feedback file to the user.

[0118] The above is only a preferred embodiment of the present invention, and it is not intended to limit the present invention in any form. Although the present invention has been disclosed above with a preferred embodiment, it is not intended to limit the present invention. Any person skilled in the art can make some changes or modifications within the scope of the technical solution of the present invention to make equivalent changes or modifications. However, as long as it does not depart from the content of the technical solution of the present invention, any simple modification, equivalent change and modification made to the above embodiment according to the technical essence of the present invention still fall within the scope of the technical solution of the present invention.

Claims

1. A Shapefile automatic processing model based on a large language model and multi-agent collaboration, characterized in that: include: Input layer, where users upload shapefiles to be processed and task instructions; The processing layer extracts the Shapefile and the task instructions to obtain the processing task; The thinking decision layer generates subtasks to be executed based on the acquired processing tasks and the processing according to the predetermined strategy; The execution layer executes the received subtasks to be executed and collects the execution results to obtain feedback data; The judgment layer judges whether the subtask to be executed is completed based on the feedback data obtained: If yes, the processing is completed, and the final processing result of the Shapefile is sorted to obtain the first feedback file; If not, return to the thinking and decision layer to obtain the remaining subtasks different from the subtasks that need to be executed, and then pass them to the execution layer-the execution layer until the overall task is completed to obtain a second feedback file; The presentation layer sends the obtained first feedback file and the second feedback file to the user.

2. The Shapefile automatic processing model based on large language model and multi-agent collaboration according to claim 1 is characterized in that: The method for generating the subtasks to be executed by the thinking decision layer comprises the following steps: S11, extracting text information of the processing task, gradually outputting text results using a large language model, and describing the text results in a specific structured format to obtain semantics; S12, extracting a task core and a plurality of subtasks related to the task core based on the acquired semantics; S13. Configure execution instructions for the current subtask, wherein the execution instructions include parameter configuration and expected output.

3. The Shapefile automatic processing model based on large language model and multi-agent collaboration according to claim 2 is characterized in that: The execution of step S12 also includes evaluating the parameter requirements of each subtask. The evaluation determines whether the logical order between the subtask and the task core is correct based on the programming logic. If correct, proceed to the next step. If incorrect, return to step S11.

4. The Shapefile automatic processing model based on large language model and multi-agent collaboration according to claim 1 is characterized in that: The execution layer includes a pre-created function library, in which tool functions are stored, and the tool functions include function names, parameter definitions, usage rules and examples, and default values; The method for executing the received subtask to be executed comprises the following steps: S21, analyzing the subtask that needs to be executed currently, and matching a suitable API document from a function library, wherein the API document includes a plurality of the tool functions; S22, automatically creating parameter logic required for the subtask that needs to be executed currently based on the API document; S23, executing the call of the tool function in the isolated sandbox environment, if the subtask is completed, proceeding to the next step, if the subtask is not completed, returning to the first step and continuing to execute the next tool function; S24. Generate feedback data according to the execution status of step S23 and the predetermined feedback terms.

5. The Shapefile automatic processing model based on large language model and multi-agent collaboration according to claim 4 is characterized in that: The API document adopts the YAML file format, and after obtaining the appropriate API document in step S21, a mapping relationship of the tool function of the corresponding logic in the function library is automatically generated.

6. The Shapefile automatic processing model based on large language model and multi-agent collaboration according to claim 4 is characterized in that: When the tool function is called in step S23, the result of the call is evaluated. If the result is a failure, the fault tolerance mechanism is triggered to dynamically adjust the parameters of the tool function according to the error log and regenerate the call instruction. It also includes adjusting the upper limit of the number of times the fault tolerance mechanism is triggered. After the upper limit is reached, the regeneration of the call instruction is suspended and feedback is provided.

7. The Shapefile automatic processing model based on large language model and multi-agent collaboration according to claim 1 is characterized in that: The returning to the thinking and decision-making layer to obtain remaining subtasks different from the subtasks that need to be executed includes: S31, obtaining a feedback log after the subtask that needs to be executed fails; S32, analyzing the feedback log, and executing a dynamic adjustment plan based on the feedback log, wherein the dynamic adjustment plan includes modifying parameters of a tool function and adjusting a task sequence; S33: regenerate the subtasks currently required to be executed to obtain remaining subtasks.

8. The Shapefile automatic processing model based on large language model and multi-agent collaboration according to claim 1 is characterized in that: The model operation is executed by accessing the locally deployed large language model and / or the provider's API interface.

9. A non-transitory computer-readable storage medium, wherein at least one instruction or at least one program is stored in the non-transitory computer-readable storage medium, characterized in that: The at least one instruction or the at least one program is loaded and executed by the processor to implement the method for automatic Shapefile file processing model based on a large language model and multi-agent collaboration as described in any one of claims 1-8.

10. An electronic device, characterized in that: It includes a processor and a memory, wherein the memory stores at least one instruction or at least one program, and the at least one instruction or the at least one program is loaded and executed by the processor to implement the method for automatically processing the Shapefile file model based on a large language model and multi-agent collaboration as described in any one of claims 1 to 8.

Images