MCP generation and calling method and device in low-code platform, equipment and medium

Abstract

The invention discloses an MCP generation and calling method and device in a low-code platform, equipment and a medium, and relates to the field of artificial intelligence low-code, and the method comprises the steps: carrying out the semantic analysis and structure standardization of initial metadata generated in the application development process of the low-code platform, and obtaining target metadata; converting the target metadata into an MCP description file, converting a business description corresponding to the MCP service in the initial metadata into a natural language description which can be understood by a large model, and integrating the natural language description into the MCP description file to obtain a target MCP description file; constructing a standardized MCP warehouse, and managing the MCP service corresponding to the target MCP description file by using the MCP warehouse; and acquiring a user request by utilizing the large model, and performing MCP calling on the MCP service by utilizing the large model based on the current running state data in the application running process, so that the large model responds to the user request. According to the method, deep fusion of low codes and large models is promoted.

Description

Technical Field

[0001] This application relates to the field of low-code artificial intelligence, and in particular to a method, apparatus, device and medium for generating and invoking MCP in a low-code platform. Background Technology

[0002] Significant progress has been made in the integration of low-code and large models. Low-code platforms possess modular development and microservice generation capabilities, enabling the encapsulation of business logic into reusable components and the export of functionality via APIs (Application Programming Interfaces). Simultaneously, the Model Context Protocol (MCP) is evolving, defining the interaction specifications between AI (Artificial Intelligence) models and external systems, supporting dynamic service discovery and bidirectional communication. Some platforms have attempted to embed large models into low-code development processes, generating code or configuring components through natural language. Furthermore, MCP repositories and related tool ecosystems have emerged, supporting zero-code MCP server setup and achieving the integration of AI with external tools.

[0003] However, existing technologies still have many shortcomings. In terms of dynamically generating MCPs, automation is severely lacking, relying heavily on manual configuration of interface parameters, protocol formats, and calling logic. This makes it difficult to meet the dynamic calling needs of large models, and protocol adaptation is costly. Regarding MCP standardization and interoperability, interface descriptions lack unified specifications, making it difficult for MCPs generated by different low-code platforms to understand each other, resulting in poor cross-platform compatibility and relatively closed ecosystems. Furthermore, large model integration faces the challenge of insufficient context management, relying on static prompt word templates, and having inadequate security and permission mechanisms. Summary of the Invention

[0004] In view of this, the purpose of this application is to provide a method, apparatus, device, and medium for generating and invoking MCPs in a low-code platform, promoting the deep integration of low-code and large models, and improving development efficiency and application quality. The specific solution is as follows:

[0005] Firstly, this application provides a method for generating and invoking MCPs in a low-code platform, including:

[0006] The initial metadata generated during the development of low-code platform applications is obtained, and semantic analysis and structural standardization are performed on the initial metadata to obtain the target metadata;

[0007] The target metadata is converted into an MCP description file that conforms to the MCP protocol specification. Natural language processing technology is used to convert the business description corresponding to the MCP service in the initial metadata into a natural language description that the large model can understand. The natural language description is then integrated into the MCP description file to obtain the target MCP description file.

[0008] A standardized MCP repository is built based on preset metadata specifications and interface standards, and the MCP repository is used to manage the MCP services corresponding to the target MCP description file.

[0009] The system uses a large model to obtain user requests sent by the client, and based on the user requests and the current running status data of the low-code platform application, it uses the large model to make an MCP call to the MCP service in the MCP repository. The large model then obtains the operation result returned after the MCP call and uses the operation result to respond to the user request.

[0010] Optionally, the step of obtaining the initial metadata generated during the development of low-code platform applications and performing semantic analysis and structural standardization on the initial metadata to obtain the target metadata includes:

[0011] Obtain the initial metadata generated during the development of low-code platform applications, determine each component in the initial metadata as well as the component type and component attributes corresponding to each component, and determine the business function corresponding to each component based on the component type and component attributes;

[0012] A data flow diagram is constructed based on the component type, the component attributes, and the business function. The business scenario corresponding to each component combination is determined based on the data transmission path between components described in the data flow diagram.

[0013] The components, the data models and business processes in the initial metadata are mapped to knowledge graph nodes. A knowledge graph is constructed based on the data flow graph, the knowledge graph nodes and the business scenarios corresponding to the combinations of the components. The data model is used to standardize the storage and processing of data. The business process is a dynamic execution chain formed by the components according to logical order and interaction relationships.

[0014] The knowledge graph is structured and encapsulated based on a preset format to transform it into semantic target metadata. The target metadata includes component functions, data flow relationships between components, and business rules. The business rules are the constraints, logical rules, or operational specifications that business processes or components must follow during application development.

[0015] Optionally, converting the target metadata into an MCP description file conforming to the MCP protocol specification includes:

[0016] Based on a predefined rule base, the data in the target metadata that corresponds to the MCP protocol fields are mapped to the corresponding fields in the MCP protocol, and the business process logic in the target metadata is converted into the corresponding action definitions and execution order in the MCP protocol to obtain an MCP description file that conforms to the MCP protocol specification.

[0017] Optionally, the step of using natural language processing technology to transform the business description corresponding to the MCP service in the initial metadata into a natural language description that the large model can understand includes:

[0018] The template filling method is used to establish scenario description templates corresponding to different business scenarios in the initial metadata, and the scenario description templates are filled according to the business descriptions corresponding to MCP services in the initial metadata to obtain the initial natural language descriptions corresponding to the structured MCP services.

[0019] The initial natural language description is optimized using a pre-defined large language model to obtain a target natural language description that the large model can understand.

[0020] Optionally, the construction of a standardized MCP repository based on preset metadata specifications and interface standards includes:

[0021] Establish unified basic information specifications, data format specifications, interface call specifications, and function description specifications for MCP services generated by different low-code platforms; the basic information includes the name, version number, creator, creation time, update time, and unique identifier of the MCP service;

[0022] Based on the aforementioned basic information specifications, data format specifications, interface call specifications, and functional description specifications, a standardized MCP repository for storing MCP services is constructed.

[0023] Optionally, the MCP generation and invocation method in the low-code platform further includes:

[0024] The system obtains MCP service recommendation requests sent by users during application development on a low-code platform, uses a pre-trained model to score each MCP service in the MCP repository, obtains the scoring results, and sorts each MCP service in descending order of the scoring results.

[0025] The sorted MCP services are sent as recommendations to the user's client in response to the MCP service recommendation request.

[0026] Optionally, the step of making MCP calls to the MCP service in the MCP repository based on the user request and the current running status data during the low-code platform application's operation, and utilizing the large model, includes:

[0027] Remove noisy and duplicate data from the current running status data, and perform structured processing on the preprocessed current running status data according to a predefined format to obtain the current target running status data;

[0028] Semantic analysis techniques are used to extract target information corresponding to the current target running status data, and based on the target information, the MCP call information corresponding to the current target running status data is determined.

[0029] The MCP call information is added to the user request obtained by the large model to obtain the target user request, so that the large model can use the target user request to make an MCP call to the MCP service in the MCP repository.

[0030] Secondly, this application provides an MCP generation and invocation apparatus in a low-code platform, comprising:

[0031] The data processing module is used to acquire the initial metadata generated during the development of low-code platform applications and perform semantic analysis and structural standardization on the initial metadata to obtain the target metadata;

[0032] The file determination module is used to convert the target metadata into an MCP description file that conforms to the MCP protocol specification, use natural language processing technology to convert the business description corresponding to the MCP service in the initial metadata into a natural language description that the large model can understand, and integrate the natural language description into the MCP description file to obtain the target MCP description file.

[0033] The repository construction module is used to build a standardized MCP repository based on preset metadata specifications and interface standards, and to manage the MCP services corresponding to the target MCP description file using the MCP repository;

[0034] The MCP invocation module is used to obtain user requests sent by the client using a large model, and based on the user requests and the current running status data of the low-code platform application, to make MCP invocations to the MCP services in the MCP repository using the large model, so that the large model can obtain the operation results returned after the MCP invocations, and use the operation results to respond to the user requests.

[0035] Thirdly, this application provides an electronic device, comprising:

[0036] Memory, used to store computer programs;

[0037] A processor is used to execute the computer program to implement the aforementioned MCP generation and invocation method in the low-code platform.

[0038] Fourthly, this application provides a computer-readable storage medium for storing a computer program, wherein the computer program, when executed by a processor, implements the aforementioned method for generating and invoking MCPs in a low-code platform.

[0039] In this application, initial metadata generated during the development of a low-code platform application is obtained, and semantic analysis and structural standardization are performed on the initial metadata to obtain target metadata. The target metadata is then converted into an MCP description file conforming to the MCP protocol specification. Natural language processing technology is used to convert the business descriptions corresponding to the MCP services in the initial metadata into natural language descriptions that a large model can understand, and these natural language descriptions are integrated into the MCP description file to obtain the target MCP description file. A standardized MCP repository is constructed based on preset metadata specifications and interface standards, and the MCP repository is used to manage the MCP services corresponding to the target MCP description file. The large model is used to obtain user requests sent by the user terminal. Based on the user requests and the current running status data during the operation of the low-code platform application, the large model is used to perform MCP calls on the MCP services in the MCP repository so that the large model can obtain the operation results returned after the MCP calls and use the operation results to respond to the user requests. As shown above, this application performs semantic analysis and structural standardization on initial metadata, ultimately transforming it into an MCP description file. This process achieves automated mapping from metadata to MCP without requiring manual intervention in parameter configuration. By constructing a standardized MCP repository based on preset metadata specifications and interface standards, the metadata format and interface call protocol of MCPs are unified, ensuring that MCPs generated by different low-code platforms are compatible and interoperable within the repository. When large models call MCP services, the calling logic can be dynamically adjusted not only based on user requests but also by incorporating the current running status data of the low-code platform application. Simultaneously, the natural language descriptions in the MCP description file provide large models with a clear foundation for understanding service functions, replacing the original static prompt word templates and enabling context-aware dynamic calling, thus improving the accuracy of large models' understanding and calling of MCP services. Attached Figure Description

[0040] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only embodiments of this application. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0041] Figure 1 This application discloses a flowchart of an MCP generation and invocation method in a low-code platform.

[0042] Figure 2 This is a schematic diagram illustrating a specific method for generating and calling MCPs in a low-code platform disclosed in this application;

[0043] Figure 3 This is a schematic diagram of the structure of an MCP generation and invocation device in a low-code platform disclosed in this application;

[0044] Figure 4 This is a schematic diagram of the structure of an electronic device disclosed in this application. Detailed Implementation

[0045] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0046] Existing technologies still have many shortcomings. In terms of dynamically generating MCPs, automation is severely lacking, relying heavily on manual configuration of interface parameters, protocol formats, and calling logic. This makes it difficult to meet the dynamic calling requirements of large models, and protocol adaptation costs are high. Regarding MCP standardization and interoperability, interface descriptions lack unified specifications, making it difficult for MCPs generated by different low-code platforms to understand each other, resulting in poor cross-platform compatibility and relatively closed ecosystems. Furthermore, large model integration faces the challenge of insufficient context management, relying on static prompt word templates, and having inadequate security and permission mechanisms. To address these issues, this application provides a method for generating and calling MCPs in a low-code platform, promoting the deep integration of low-code and large models, and improving development efficiency and application quality.

[0047] See Figure 1 As shown in the embodiment of this application, a method for generating and calling MCPs in a low-code platform is disclosed, including:

[0048] Step S11: Obtain the initial metadata generated during the development of low-code platform applications and perform semantic analysis and structural standardization on the initial metadata to obtain the target metadata.

[0049] In this embodiment, when developing applications on a low-code platform, the system can collect and record various metadata generated during the development process in real time, including but not limited to page layout, form configuration, business process logic, and data model definition. Using semantic analysis technology, this metadata is deeply parsed to identify the functions of different components, data flow, and interrelationships, transforming it into a structured information format that is easy for computers to understand, laying the foundation for subsequent dynamic generation of MCPs.

[0050] Specifically, this can include: first, acquiring the initial metadata generated during the development of low-code platform applications; identifying each component in the initial metadata, as well as the component type and attributes of each component; and then determining the business function corresponding to each component based on the component type and attributes. For example, identifying component types in the low-code editor, such as buttons, forms, and charts, and extracting component attributes, such as size, position, and style, through feature point matching. A rule-based inference system combined with a machine learning model infers business functions based on component configuration parameters, such as:

[0051] definfer_component_function(component):

[0052] ifcomponent.type=='Form'and'password'incomponent.fields:

[0053] return {'Function':'User Authentication','Domain':'Identity Management','Data Model':['User']}

[0054] elifcomponent.type=='Chart'andcomponent.data_source=='inventory':

[0055] return {'Function':'Inventory Analysis','Domain':'Supply Chain Management','Metrics':['Inventory Turnover Rate']}

[0056] Then, a data flow diagram (DFG) is constructed based on the component type, component attributes, and business functions:

[0057] deftrace_data_flow(components):

[0058] flow_graph=DirectedGraph()

[0059] forcompincomponents:

[0060] ifcomp.type=='DataSource':

[0061] flow_graph.add_node(comp.id,data_type=comp.data_type)

[0062] elifcomp.type=='Processor':

[0063] forinput_idincomp.inputs:

[0064] flow_graph.add_edge(input_id,comp.id,operation=comp.operation)

[0065] returnflow_graph

[0066] The business scenarios corresponding to each component combination are determined based on the data transmission paths between components as described in the data flow diagram. This can be achieved by training a scene recognition model using a Naive Bayes classifier, and then using the trained model to identify the business scenarios corresponding to each component combination, such as:

[0067] fromsklearn.naive_bayesimportGaussianNB

[0068] #Training Data: [Login Component, Payment Component, Product List, Order Management] → Business Scenarios

[0069] X=[[1,0,0,0],[1,1,1,1],[1,0,0,1]]

[0070] y = ['Enterprise System', 'E-commerce Platform', 'Order Management System']

[0071] clf=GaussianNB().fit(X,y)

[0072] Next, the data models and business processes in each component and initial metadata are mapped to knowledge graph nodes. A knowledge graph is then constructed based on the data flow graph, knowledge graph nodes, and the business scenarios corresponding to each component combination. The data model standardizes data storage and processing methods; the business process is a dynamic execution chain formed by the components according to logical order and interaction relationships. For example, by mapping components, data models, and business processes to knowledge graph nodes and identifying associations through relation extraction algorithms, a basic knowledge graph containing entities and relationships is constructed, forming a structured semantic representation of business logic. Then, based on the basic knowledge graph, external knowledge bases, such as Wikidata and industry standard dictionaries, are connected, and entity alignment technology is used to enhance semantic understanding. For example, "order number" in low-code is mapped to the "order identifier" entity in Wikidata. This process injects standardized semantic information from external knowledge bases into the constructed knowledge graph, supplementing the standardized attributes and cross-domain associations of nodes, resolving the semantic ambiguity caused by "different names for the same entity" in low-code platforms, and improving the semantic consistency and richness of the knowledge graph. For example:

[0073] defextract_relations(component1,component2):

[0074] ifcomponent2.data_source==component1.output:

[0075] return {'Subject': component1.id, 'Relationship': 'Data Supply', 'Object': component2.id}

[0076] elifcomponent2.trigger_event==component1.action:

[0077] return {'Subject': component1.id, 'Relationship': 'Event Trigger', 'Object': component2.id}

[0078] Finally, the knowledge graph is structurally encapsulated based on a preset format to transform it into semantic target metadata. This target metadata includes, but is not limited to, component functionality, data flow relationships between components, and business rules. Business rules are the constraints, logical rules, or operational specifications that must be followed during application development or component runtime. For example, semantic metadata can be represented using JSON-LD format.

[0079] {

[0080] "@context":"https: / / schema.org / ",

[0081] "Component ID":"comp-4567",

[0082] "Semantic type":"Data display component",

[0083] "Domain": "Sales Management"

[0084] Function: "Performance Report"

[0085] "Input / Output":[

[0086] {

[0087] "Name":"Sales Data",

[0088] "Type":"Array",

[0089] "element":{

[0090] "Type":"object",

[0091] "property":{

[0092] "Sales Revenue":{"Type":"Number"},

[0093] "Sales Date":{"Type":"Date"}

[0094] }

[0095] }

[0096] },

[0097] {

[0098] "Name": "Trend Analysis Chart",

[0099] "Type":"Image",

[0100] Format: "SVG"

[0101] }

[0102] ],

[0103] Business Rules: "Automatically display sales data grouped by quarter."

[0104] }

[0105] Because new component types constantly emerge in low-code platforms, such as new forms and custom business components, the initially trained semantic analysis model may not be able to recognize the functions and attributes of these new components. Therefore, a federated learning framework can be used to collaboratively update the model using distributed data from multiple clients without collecting local user data. This allows the semantic analysis model to quickly learn the characteristics of new components and maintain the accuracy of metadata parsing. In other words, the semantic analysis model is updated through a client-server architecture. For example:

[0106] #Client code

[0107] deflocal_train(new_components):

[0108] model = load_local_model()

[0109] model.partial_fit(extract_features(new_components))

[0110] returnmodel.get_weights()

[0111] #Server code

[0112] defaggregate_updates(client_weights):

[0113] global_model=load_global_model()

[0114] global_model.aggregate(client_weights)

[0115] global_model.save()

[0116] Step S12: Convert the target metadata into an MCP description file that conforms to the MCP protocol specification. Use natural language processing technology to convert the business description corresponding to the MCP service in the initial metadata into a natural language description that the large model can understand. Integrate the natural language description into the MCP description file to obtain the target MCP description file.

[0117] In this embodiment, after obtaining semantic target metadata, data in the target metadata that corresponds to MCP protocol fields can be mapped to corresponding fields in the MCP protocol based on a predefined rule base. The business process logic in the target metadata can be converted into the corresponding action definitions and execution order in the MCP protocol to obtain an MCP description file that conforms to the MCP protocol specification.

[0118] It should be noted that this embodiment converts metadata into the MCP specification using an intelligent mapping algorithm, mainly including the pre-construction of a rule base and an algorithm model. The rule base stores the correspondence between component types, parameter types in the low-code platform and MCP protocol fields; for example, the string data type in the low-code platform corresponds to the string type in the MCP protocol. The algorithm model is trained through machine learning to learn the mapping patterns between historical metadata and MCP description files. For example:

[0119] fromsklearn.ensembleimportRandomForestClassifier

[0120] classMappingEngine:

[0121] def__init__(self):

[0122] self.rule_engine=RuleEngine() # Predefined mapping rules

[0123] self.ml_model=RandomForestClassifier() #Machine learning model

[0124] defmap_to_mcp(self,metadata):

[0125] #The rules engine handles deterministic mappings

[0126] initial_mapping=self.rule_engine.apply_rules(metadata)

[0127] #Machine learning models for handling fuzzy mappings

[0128] refined_mapping=self.ml_model.predict(initial_mapping)

[0129] return refined_mapping

[0130] When the target metadata is obtained, the algorithm model first performs a quick mapping of explicit content based on the rule base, such as converting the data type of the low-code component to the MCP protocol type:

[0131] TYPE_MAPPING={

[0132] "string":"string",

[0133] "integer":"integer",

[0134] "Boolean":"boolean",

[0135] "Date":"string(format='date-time')",

[0136] "array":"array",

[0137] "object":"object"

[0138] }

[0139] defmap_data_type(metadata_type):

[0140] returnTYPE_MAPPING.get(metadata_type,"string")

[0141] Convert the validation rules of the low-code platform into parameter constraints of MCP:

[0142] CONSTRAINT_MAPPING={

[0143] "Required":{"required":True},

[0144] "Maximum Length":lambdav:{"maxLength":int(v)},

[0145] "Minimum":lambdav:{"minimum":float(v)},

[0146] "regular expression":lambdav:{"pattern":v},

[0147] "enumeration value":lambdav:{"enum":v.split(",")}

[0148] }

[0149] defgenerate_constraints(field_metadata):

[0150] constraints={}

[0151] forrule_name,rule_valueinfield_metadata.validation_rules.items():

[0152] ifrule_nameinCONSTRAINT_MAPPING:

[0153] constraints.update(CONSTRAINT_MAPPING[rule_name](rule_value))

[0154] returnconstraints

[0155] For complex operational logic, such as conditional judgments and data processing steps in business processes, the algorithm model analyzes the logical relationships in the metadata and transforms them into the corresponding Action definitions and execution order in the MCP protocol:

[0156] defgenerate_action(operation):

[0157] return{

[0158] "name":operation.name,

[0159] "parameters":[{"name":p.name,"type":map_data_type(p.type)}

[0160] [forpinoperation.parameters],

[0161] "description":generate_nl_description(operation),

[0162] "output":map_data_type(operation.output_type),

[0163] "required":operation.is_required

[0164] }

[0165] By combining rules and models, we can achieve accurate matching and automatic generation of MCP protocol fields from metadata.

[0166] Furthermore, natural language processing (NLP) techniques can be used to transform the business descriptions corresponding to the MCP services in the initial metadata into natural language explanations that the large model can understand. Specifically, this can include: first, using template filling to create scenario description templates corresponding to different business scenarios in the initial metadata; then, filling these templates with the business descriptions of the MCP services from the initial metadata to obtain structured initial natural language explanations for the MCP services. Finally, using a pre-defined large language model, the initial natural language explanations are optimized to obtain target natural language explanations that the large model can understand.

[0167] Understandably, to enable large models to better understand the functions of MCP services, natural language processing (NLP) techniques can be used to transform the business descriptions in the initial metadata into natural language descriptions. On one hand, template-based methods can be used to create description templates for different business scenarios. For example, the template for the "data query" scenario could be "Query {entity} data in {domain}, supporting {condition} filtering." Based on specific information in the metadata, such as the business domain, involved entities, and query conditions, these are filled into the template to generate a preliminary description. On the other hand, large language models can be used to optimize the generated preliminary descriptions, making them more consistent with human language habits and with clearer semantic expression. This facilitates the large model's rapid understanding of the specific functions and uses of the MCP service, thereby achieving automatic conversion of business logic into natural language descriptions and improving the content of the MCP description file. For example:

[0168] DESCRIPTION_TEMPLATES={

[0169] "Data Query": "Query the data of {entities} within {domain}, supporting {condition} filtering".

[0170] "Data Creation": "Create a new {entity} record containing {field} information",

[0171] "Data Update": "Update the {entity} record and modify the {field} information",

[0172] "Business Calculation": "Calculates {metrics} based on {data source} and {algorithm}".

[0173] }

[0174] defgenerate_nl_description(operation):

[0175] template = DESCRIPTION_TEMPLATES.get(operation.type,"Execute {operation}")

[0176] return template.format(

[0177] domain = operation.domain,

[0178] entity = operation.entity,

[0179] Condition=",".join(operation.filters),

[0180] field=",".join(operation.fields),

[0181] Metric = operation.metric

[0182] Data source = operation.data_source,

[0183] Algorithm = operation.algorithm,

[0184] operation = operation.name )

[0186] defrefine_description(raw_description):

[0187] prompt=f"""The following technical descriptions have been optimized to make them clearer and easier to understand:"

[0188] Original description: {raw_description}

[0189] After optimization: """

[0190] return call_gpt_api(prompt)

[0191] After converting business descriptions in metadata into natural language explanations using natural language processing (NLP) technology, metadata required for service discovery can be generated based on semantic analysis results. This involves integrating the natural language explanations with other key information, such as service names, tags, feature lists, and security requirements, into a standardized structure. For example:

[0192] defgenerate_service_metadata(metadata):

[0193] return{

[0194] "name":metadata.name,

[0195] "description":generate_nl_description(metadata),

[0196] "tags":metadata.tags+[metadata.domain,metadata.entity],

[0197] "capabilities":[{"name":op.name,"parameters":op.parameters}

[0198] foropinmetadata.operations],

[0199] "required_context":metadata.required_context,

[0200] "security":metadata.security_requirements

[0201] }

[0202] The "tags" field in the service discovery metadata combines business domain and entity information, while the "capabilities" field lists the operations and parameters included in the service. This information, together with the natural language description, constitutes complete information that can not only be understood by large models but also support intelligent retrieval and recommendation in the subsequent MCP repository.

[0203] Furthermore, the rule base, MCP fields processed by the algorithm model, natural language descriptions, parameter constraints, and other content can be assembled into a JSON format file according to the MCP protocol specification, completing a closed loop from metadata to target MCP description file automatic generation, such as:

[0204] {

[0205] "name":"Order Management Service",

[0206] "description":"Handles order creation, querying, and management on e-commerce platforms",

[0207] "version":"1.0.0",

[0208] "type":"mcp-service",

[0209] "capabilities":[

[0210] {

[0211] "name":"createOrder",

[0212] "description":"Create a new order record, including product information, customer information, and delivery address",

[0213] "parameters":[

[0214] {

[0215] "name":"orderItems",

[0216] "type":"array",

[0217] "items":{

[0218] "type":"object",

[0219] "properties":{

[0220] "productId":{"type":"string","description":"product ID"},

[0221] "quantity":{"type":"integer","minimum":1,"description":"purchase quantity"}

[0222] }

[0223] },

[0224] "required":true

[0225] },

[0226] {

[0227] "name":"customerInfo",

[0228] "type":"object",

[0229] "properties":{

[0230] "name":{"type":"string","maxLength":100,"description":"Customer Name"},

[0231] "email":{"type":"string","pattern":"^\\S+@\\S+$","description":"email address"}

[0232] },

[0233] "required":true

[0234] }

[0235] ],

[0236] "output":{

[0237] "type":"object",

[0238] "properties":{

[0239] "orderId":{"type":"string","description":"Generated order ID"},

[0240] "status":{"type":"string","enum":["Pending payment","Paid","Shipped","Completed"]}

[0241] }

[0242] }

[0243] }

[0244] ],

[0245] "context":{

[0246] "required":["userRole","tenantId"],

[0247] "optional":["locale","timezone"]

[0248] }

[0249] }

[0250] Step S13: Construct a standardized MCP repository based on preset metadata specifications and interface standards, and use the MCP repository to manage the MCP services corresponding to the target MCP description file.

[0251] In this embodiment, a unified metadata specification and interface standard can be established, and an open, standardized MCP repository can be built to ensure that MCPs generated by different low-code platforms can achieve compatibility and interoperability within this repository. Specifically, this can include: establishing unified basic information specifications, data format specifications, interface call specifications, and functional description specifications for MCP services generated by different low-code platforms; wherein, the basic information includes, but is not limited to, the MCP service's name, version number, creator, creation time, update time, and unique identifier. Then, based on the basic information specifications, data format specifications, interface call specifications, and functional description specifications, a standardized MCP repository for storing MCP services can be constructed.

[0252] For example: 1. Define the basic attribute standards for MCP: including unique identifier (ID), name, version number, creator, creation time, and update time; where the ID is generated using UUID (Universally Unique Identifier) ​​to ensure global uniqueness, and the version number follows semantic versioning specifications to clearly indicate function changes, new features, or bug fixes. 2. Provide a structured description of MCP functions: standardize the expression of service function names, function descriptions, and detailed function specifications. For example, function names should be concise, clear, and accurately reflect the core of the service; function descriptions should be limited to 50 characters, summarizing the service's function; detailed function specifications should use a fixed format, including input parameters, output parameters, operation logic, usage restrictions, etc., so that developers and large models can quickly understand the functional boundaries of the MCP. 3. Standardize the format of MCP input and output data: adopt the JSON (JavaScript Object Notation) universal data exchange format and define data structure rules. Clearly define the name, type, length limit, and whether each data field is required. For complex data structures, such as nested objects or multi-level arrays, provide clear structural examples and documentation to ensure that MCPs generated by different platforms can be correctly parsed and processed during data interaction. 4. Establish a unified interface call protocol (RESTful API): Clearly define the interface's request methods, request address format, parameter requirements for request headers and bodies, response format, and status code definitions. MCPs generated by different low-code platforms must adhere to this interface protocol, allowing other systems or large models to call MCPs without needing to consider the source platform; they only need to make requests and receive responses according to the unified interface specification, achieving cross-platform interactive operations. 5. Establish a metadata conversion layer: Develop corresponding conversion tools or adapters for the unique metadata formats and semantics of different low-code platforms. This layer can convert metadata from various platforms into a format conforming to the unified repository specification. Simultaneously, when calling an MCP, it converts the unified format request into a format recognizable by the corresponding platform's MCP. For example, by writing mapping rules and conversion scripts, component attribute descriptions unique to platform A can be converted into standard repository metadata descriptions, achieving "language translation" between metadata from different platforms and thus achieving compatibility.

[0253] Step S14: Use the large model to obtain the user request sent by the user terminal, based on the user request and the current running status data of the low-code platform application, and use the large model to make an MCP call to the MCP service in the MCP repository, so that the large model can obtain the operation result returned after making the MCP call, and use the operation result to respond to the user request.

[0254] In this embodiment, a real-time context-aware system can be built to integrate and optimize MCP and large models. The system continuously monitors the running status of low-code applications, including information such as user roles, data permissions, and business process progress, and injects this context into the MCP call flow in real time. The MCP call strategy is dynamically adjusted according to different contexts, and the prompt word templates of the large model are optimized to improve the accuracy of the large model calling the MCP service. This includes a running status data acquisition module, a context information processing module, a real-time injection and call flow association module, and a dynamic strategy adjustment and prompt word optimization module.

[0255] Runtime Status Data Acquisition Module: Collects real-time runtime status data of low-code platform applications during operation. For example, it collects various types of runtime status data in real time through a lightweight monitoring agent embedded in the application.

[0256] Context Information Processing Module: After receiving the operational status data, the data processing center cleans, integrates, and analyzes it. For example, it uses data cleaning algorithms to remove noisy and duplicate data from the current operational status data, and performs structured processing on the pre-processed data according to a predefined format to obtain the current target operational status data. Semantic analysis technology is used to extract target information corresponding to the current target operational status data, and based on this target information, the corresponding MCP call information is determined. For example, semantic analysis technology extracts key information from the current target operational status data and associates it with the corresponding MCP call scenario, forming a complete set of context information. For instance, when the user role is detected as "ordinary employee" and the business process is in the "reimbursement application submission" stage, the MCP service call requirements and constraints corresponding to this context are clarified.

[0257] The real-time injection and call flow association module adds MCP call information to the user requests obtained by the large model, thus obtaining the target user request. This allows the large model to use the target user request to make MCP calls to the MCP services in the MCP repository. For example, a middleware is built as a bridge between the MCP call flow and context information. When the large model initiates an MCP service call request, the middleware intercepts the request and embeds the real-time updated context information into the call request. By adding specific context fields to the request header or request body, information such as user roles, data permissions, and business process progress is accurately passed to the MCP service, enabling the MCP service to make decisions based on the context when processing requests.

[0258] The dynamic strategy adjustment and prompt word optimization module: A pre-built strategy rule base is established to formulate corresponding MCP invocation strategies based on different context scenarios. When a call request containing context information is received, the strategy engine matches the corresponding strategy from the rule base. For example, if the user role has low privileges and the business process involves sensitive data, the invocation strategy is adjusted to limit the amount of data returned or perform data anonymization processing, ensuring security during the MCP invocation process. Simultaneously, based on context information and the matched strategy, natural language generation technology is used to optimize the prompt word templates of the large model. Specific contextual constraints are added to the prompt words to guide the large model to generate instructions that better meet actual needs, thereby improving the accuracy of MCP service invocation.

[0259] It should be noted that this embodiment provides a visual MCP debugging tool and orchestration interface, facilitating intuitive debugging and optimization of dynamically generated MCPs by developers. Developers can use the visual interface to view the MCP's call flow, parameter passing, and interaction with large models, quickly locating and resolving problems.

[0260] This embodiment can also introduce an AI-based intelligent recommendation algorithm. This algorithm, based on traditional categories and keywords, combines low-code development contextual information, such as project type, business scenario, and user needs, to intelligently match the most suitable MCP service for the user. This algorithm integrates multi-dimensional information and adopts a hybrid recommendation strategy. Its principle and recommendation mechanism form a complete closed loop from data collection, feature extraction and processing, model construction and training, to the final generation of recommendation results. Specifically, it can include: 1. During low-code development, the system collects a large amount of data as the basis for the recommendation algorithm. On the one hand, it obtains metadata information for each MCP service in the MCP repository, including service name, function description, category, applicable scenario, input and output parameters, etc. This data constitutes the basic information of the MCP service. On the other hand, it collects low-code development contextual information in real time, such as the project type the developer is building, business scenario, user-inputted requirements, and the developer's past operating habits and usage preferences. Simultaneously, it records historical call data for the MCP service, including the number of calls, feedback on successful or failed calls, and user ratings of the service, to evaluate the actual usage effect and popularity of the service. 2. Deep feature extraction and processing are performed on the collected data. For MCP service metadata, key features are extracted using natural language processing (NLP) techniques. For example, core business keywords are extracted from functional descriptions, and text classification models are used to determine the precise business domain to which the service belongs. Structured data such as input and output parameters are standardized and encoded into vector forms that can be processed by the algorithm. For low-code development context information, NLP techniques are used to parse user requirement descriptions and extract key requirement features. Information such as project type and business scenario is numerically encoded, for example, "e-commerce system" is encoded as 1 and "enterprise OA" as 2. For user operation habit data, user preference features are extracted by analyzing operation frequency and order. Finally, these processed features are integrated to form a dataset containing MCP service feature vectors and user context feature vectors, providing input for subsequent algorithms. 3. A hybrid recommendation algorithm model is constructed based on collaborative filtering, content-based recommendation, and deep learning recommendation models. When a user triggers a recommendation request, the model retrieves the MCP service recommendation request sent by the user during application development on the low-code platform. The pre-trained model is used to obtain the low-code development context feature vector, and each MCP service in the MCP repository is scored. The model outputs a score result, which is then sorted according to the score from highest to lowest. The sorted MCP services are sent as the recommendation result to the user to respond to the MCP service recommendation request.

[0261] The collaborative filtering algorithm analyzes users' historical usage of MCP services to identify "neighbor" users with similar usage patterns. For example, if users A and B frequently use the "User Login Verification" and "Order Data Query" MCP services, then users A and B are considered "neighbor" users. Based on the usage of other MCP services by these "neighbor" users, services that the current user has not yet used but that have received high ratings from "neighbor" users are recommended. The content-based recommendation algorithm matches the metadata features of MCP services with the user's needs. It calculates the similarity between the MCP service's functional description, applicable scenarios, and other content with the user's input of their needs, such as the type of project under development. For example, it uses a cosine similarity algorithm to calculate the similarity of text vectors, prioritizing MCP services with high similarity to the user. The deep learning recommendation model constructs deep neural networks (DNNs). The integrated MCP service feature vector and user context feature vector are used as input to the model. Through the computation and learning of multi-layer neurons, complex nonlinear relationships and potential patterns in the data are mined, and the influence weight of different features on the recommendation results is automatically learned, thereby predicting the user's preference for each MCP service.

[0262] As can be seen from the above and see also Figure 2 As shown, this embodiment captures initial metadata generated during the development of low-code platform applications in real time and performs metadata parsing and preprocessing to obtain target metadata. Then, the target metadata is converted into an MCP description file conforming to the MCP protocol specification. A standardized MCP repository is built and managed based on preset metadata specifications and interface standards to manage the MCP services corresponding to the MCP description files. Furthermore, a real-time context-aware system is built to integrate and optimize MCP with a large model, and the integrated and optimized large model is used to call MCP services in the MCP repository. Finally, visual debugging is used to debug and optimize dynamically generated MCPs, and a feedback mechanism is used to continuously improve the generation and calling effect of MCPs, continuously improving the accuracy and reliability of dynamically generated MCPs. In this way, this embodiment focuses on dynamically generating application MCPs for low-code platforms. During the development phase, metadata is captured in real time, and semantic analysis technology is used to analyze component functions and data flow. With the help of intelligent mapping algorithms and natural language processing, metadata is automatically converted into a description file conforming to the MCP protocol without manual configuration. A standardized MCP repository is built, unified specifications are established, and recommendation algorithms are introduced to improve the compatibility and retrieval efficiency of MCPs. A real-time context-aware system was built to monitor application runtime status, dynamically adjust invocation strategies, and optimize model suggestion templates. This promoted the deep integration of low-code and large-scale models, improving development efficiency and application quality.

[0263] See Figure 3 As shown in the embodiments of this application, an MCP generation and invocation device in a low-code platform is also disclosed, comprising:

[0264] Data processing module 11 is used to acquire initial metadata generated during the development of low-code platform applications and perform semantic analysis and structural standardization on the initial metadata to obtain target metadata;

[0265] The file determination module 12 is used to convert the target metadata into an MCP description file that conforms to the MCP protocol specification, use natural language processing technology to convert the business description corresponding to the MCP service in the initial metadata into a natural language description that the large model can understand, and integrate the natural language description into the MCP description file to obtain the target MCP description file.

[0266] The repository construction module 13 is used to build a standardized MCP repository based on preset metadata specifications and interface standards, and to manage the MCP services corresponding to the target MCP description file using the MCP repository.

[0267] MCP call module 14 is used to obtain user requests sent by the user terminal using a large model, and based on the user requests and the current running status data of the low-code platform application during operation, and to make MCP calls to the MCP services in the MCP repository using the large model, so that the large model can obtain the operation results returned after making the MCP calls, and use the operation results to respond to the user requests.

[0268] In some specific embodiments, the data processing module 11 includes:

[0269] The data analysis unit is used to acquire the initial metadata generated during the development of low-code platform applications, determine each component in the initial metadata and the component type and component attributes corresponding to each component, and determine the business function corresponding to each component based on the component type and component attributes.

[0270] The scenario determination unit is used to construct a data flow diagram based on the component type, the component attributes and the business function, and to determine the business scenario corresponding to each component combination based on the data transmission path between components described in the data flow diagram.

[0271] The knowledge graph construction unit is used to map the components, the data models and business processes in the initial metadata to knowledge graph nodes, and to construct a knowledge graph based on the data flow graph, the knowledge graph nodes and the business scenarios corresponding to the combinations of the components; the data model is used to standardize the storage and processing methods of data; the business process is a dynamic execution chain formed by the components according to logical order and interaction relationship;

[0272] The knowledge graph transformation unit is used to structurally encapsulate the knowledge graph based on a preset format, so as to transform the knowledge graph into semantic target metadata. The target metadata includes component functions, data flow relationships between components, and business rules. The business rules are the constraints, logical rules, or operational specifications that need to be followed during application development or component operation.

[0273] In some specific embodiments, the file determination module 12 includes:

[0274] The file acquisition unit is used to map the data in the target metadata that corresponds to the MCP protocol fields to the corresponding fields in the MCP protocol based on a predefined rule base, and to convert the business process logic in the target metadata into the corresponding action definition and execution order in the MCP protocol, so as to obtain an MCP description file that conforms to the MCP protocol specification.

[0275] In some specific embodiments, the file determination module 12 includes:

[0276] The template filling unit is used to establish scenario description templates corresponding to different business scenarios in the initial metadata using the template filling method, and to fill the scenario description templates according to the business descriptions corresponding to the MCP service in the initial metadata to obtain the structured initial natural language descriptions corresponding to the MCP service.

[0277] The language optimization unit is used to optimize the initial natural language description using a preset large language model to obtain a target natural language description that the large model can understand.

[0278] In some specific embodiments, the warehouse construction module 13 includes:

[0279] The specification development unit is responsible for developing unified basic information specifications, data format specifications, interface call specifications, and functional description specifications for MCP services generated by different low-code platforms. The basic information includes the name, version number, creator, creation time, update time, and unique identifier of the MCP service.

[0280] The repository construction unit is used to construct a standardized MCP repository for storing MCP services based on the basic information specifications, the data format specifications, the interface call specifications, and the functional description specifications.

[0281] In some specific embodiments, the MCP generation and invocation device in the low-code platform further includes:

[0282] The scoring unit is used to obtain the MCP service recommendation request sent by the user during the application development process on the low-code platform, use the pre-trained model to score each MCP service in the MCP repository, obtain the scoring results, and sort each MCP service in descending order of the scoring results.

[0283] The request-response unit is used to send the sorted MCP services as recommendation results to the user terminal in response to the MCP service recommendation request.

[0284] In some specific embodiments, the MCP calling module 14 includes:

[0285] The data processing unit is used to remove noise and duplicate data from the current running status data, and to perform structured processing on the preprocessed current running status data according to a predefined format to obtain the current target running status data.

[0286] An information determination unit is used to extract target information corresponding to the current target running status data using semantic analysis technology, and to determine the MCP call information corresponding to the current target running status data based on the target information.

[0287] The MCP invocation unit is used to add the MCP invocation information to the user request obtained by the large model to obtain the target user request, so that the large model can use the target user request to make an MCP invocation to the MCP service in the MCP repository.

[0288] Furthermore, embodiments of this application also disclose an electronic device, Figure 4 This is a structural diagram of an electronic device 20 according to an exemplary embodiment. The content of the diagram should not be construed as limiting the scope of this application.

[0289] Figure 4This is a schematic diagram of the structure of an electronic device 20 provided in an embodiment of this application. Specifically, the electronic device 20 may include: at least one processor 21, at least one memory 22, a power supply 23, a communication interface 24, an input / output interface 25, and a communication bus 26. The memory 22 stores a computer program, which is loaded and executed by the processor 21 to implement the relevant steps in the MCP generation and invocation method of the low-code platform disclosed in any of the foregoing embodiments. Alternatively, the electronic device 20 in this embodiment may specifically be an electronic computer.

[0290] In this embodiment, the power supply 23 is used to provide operating voltage for each hardware device on the electronic device 20; the communication interface 24 can create a data transmission channel between the electronic device 20 and external devices, and the communication protocol it follows can be any communication protocol applicable to the technical solution of this application, and is not specifically limited here; the input / output interface 25 is used to acquire external input data or output data to the outside world, and its specific interface type can be selected according to specific application needs, and is not specifically limited here.

[0291] In addition, the memory 22, as a carrier for resource storage, can be a read-only memory, random access memory, disk or optical disk, etc. The resources stored thereon can include operating system 221, computer program 222, etc., and the storage method can be temporary storage or permanent storage.

[0292] The operating system 221 is used to manage and control the various hardware devices on the electronic device 20 and the computer program 222, which may be Windows Server, Netware, Unix, Linux, etc. In addition to including computer programs capable of performing the MCP generation and invocation methods in the low-code platform executed by the electronic device 20 as disclosed in any of the foregoing embodiments, the computer program 222 may further include computer programs capable of performing other specific tasks.

[0293] Furthermore, this application also discloses a computer-readable storage medium for storing a computer program; wherein, when the computer program is executed by a processor, it implements the aforementioned low-code platform MCP generation and invocation method. Specific steps of this method can be found in the corresponding content disclosed in the foregoing embodiments, and will not be repeated here.

[0294] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the apparatus disclosed in the embodiments, since it corresponds to the method disclosed in the embodiments, the description is relatively simple; relevant parts can be referred to in the method section.

[0295] Those skilled in the art will further recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0296] The steps of the methods or algorithms described in conjunction with the embodiments disclosed herein can be implemented directly by hardware, a software module executed by a processor, or a combination of both. The software module can be located in random access memory (RAM), main memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, removable disk, CD-ROM, or any other form of storage medium known in the art.

[0297] Finally, it should be noted that in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0298] The technical solutions provided in this application have been described in detail above. Specific examples have been used to illustrate the principles and implementation methods of this application. The descriptions of the above embodiments are only for the purpose of helping to understand the methods and core ideas of this application. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of this application. Therefore, the content of this specification should not be construed as a limitation of this application.

Claims

1. A method for generating and calling MCPs in a low-code platform, characterized in that, include: The initial metadata generated during the development of low-code platform applications is obtained, and semantic analysis and structural standardization are performed on the initial metadata to obtain the target metadata; The target metadata is converted into an MCP description file that conforms to the MCP protocol specification. Natural language processing technology is used to convert the business description corresponding to the MCP service in the initial metadata into a natural language description that the large model can understand. The natural language description is then integrated into the MCP description file to obtain the target MCP description file. A standardized MCP repository is built based on preset metadata specifications and interface standards, and the MCP repository is used to manage the MCP services corresponding to the target MCP description file. The system uses a large model to obtain user requests sent by the client, and based on the user requests and the current running status data of the low-code platform application, it uses the large model to make an MCP call to the MCP service in the MCP repository. The large model then obtains the operation result returned after the MCP call and uses the operation result to respond to the user request.

2. The method for generating and calling MCPs in a low-code platform according to claim 1, characterized in that, The process of acquiring initial metadata generated during the development of low-code platform applications and performing semantic analysis and structural standardization on the initial metadata to obtain target metadata includes: Obtain the initial metadata generated during the development of low-code platform applications, determine each component in the initial metadata as well as the component type and component attributes corresponding to each component, and determine the business function corresponding to each component based on the component type and component attributes; A data flow diagram is constructed based on the component type, the component attributes, and the business function. The business scenario corresponding to each component combination is determined based on the data transmission path between components described in the data flow diagram. The components, the data models and business processes in the initial metadata are mapped to knowledge graph nodes. A knowledge graph is constructed based on the data flow graph, the knowledge graph nodes and the business scenarios corresponding to the combinations of the components. The data model is used to standardize the storage and processing of data. The business process is a dynamic execution chain formed by the components according to logical order and interaction relationships. The knowledge graph is structured and encapsulated based on a preset format to transform it into semantic target metadata. The target metadata includes component functions, data flow relationships between components, and business rules. The business rules are the constraints, logical rules, or operational specifications that business processes or components must follow during application development.

3. The method for generating and calling MCPs in a low-code platform according to claim 1, characterized in that, The step of converting the target metadata into an MCP description file conforming to the MCP protocol specification includes: Based on a predefined rule base, the data in the target metadata that corresponds to the MCP protocol fields are mapped to the corresponding fields in the MCP protocol, and the business process logic in the target metadata is converted into the corresponding action definitions and execution order in the MCP protocol to obtain an MCP description file that conforms to the MCP protocol specification.

4. The method for generating and calling MCPs in a low-code platform according to claim 1, characterized in that, The step of using natural language processing technology to transform the business description corresponding to the MCP service in the initial metadata into a natural language description that the large model can understand includes: The template filling method is used to establish scenario description templates corresponding to different business scenarios in the initial metadata, and the scenario description templates are filled according to the business descriptions corresponding to MCP services in the initial metadata to obtain the initial natural language descriptions corresponding to the structured MCP services. The initial natural language description is optimized using a pre-defined large language model to obtain a target natural language description that the large model can understand.

5. The method for generating and calling MCPs in a low-code platform according to claim 1, characterized in that, The construction of a standardized MCP repository based on preset metadata specifications and interface standards includes: Establish unified basic information specifications, data format specifications, interface call specifications, and function description specifications for MCP services generated by different low-code platforms; the basic information includes the name, version number, creator, creation time, update time, and unique identifier of the MCP service; Based on the aforementioned basic information specifications, data format specifications, interface call specifications, and functional description specifications, a standardized MCP repository for storing MCP services is constructed.

6. The method for generating and calling MCPs in a low-code platform according to claim 1, characterized in that, Also includes: The system obtains MCP service recommendation requests sent by users during application development on a low-code platform, uses a pre-trained model to score each MCP service in the MCP repository, obtains the scoring results, and sorts each MCP service in descending order of the scoring results. The sorted MCP services are sent as recommendations to the user's client in response to the MCP service recommendation request.

7. The method for generating and calling MCPs in a low-code platform according to any one of claims 1 to 6, characterized in that, The process of making MCP calls to the MCP services in the MCP repository based on the user request and the current running status data of the low-code platform application, and using the large model, includes: Remove noisy and duplicate data from the current running status data, and perform structured processing on the preprocessed current running status data according to a predefined format to obtain the current target running status data; Semantic analysis techniques are used to extract target information corresponding to the current target running status data, and based on the target information, the MCP call information corresponding to the current target running status data is determined. The MCP call information is added to the user request obtained by the large model to obtain the target user request, so that the large model can use the target user request to make an MCP call to the MCP service in the MCP repository.

8. An MCP generation and invocation device in a low-code platform, characterized in that, include: The data processing module is used to acquire the initial metadata generated during the development of low-code platform applications and perform semantic analysis and structural standardization on the initial metadata to obtain the target metadata; The file determination module is used to convert the target metadata into an MCP description file that conforms to the MCP protocol specification, use natural language processing technology to convert the business description corresponding to the MCP service in the initial metadata into a natural language description that the large model can understand, and integrate the natural language description into the MCP description file to obtain the target MCP description file. The repository construction module is used to build a standardized MCP repository based on preset metadata specifications and interface standards, and to manage the MCP services corresponding to the target MCP description file using the MCP repository; The MCP invocation module is used to obtain user requests sent by the client using a large model, and based on the user requests and the current running status data of the low-code platform application, to make MCP invocations to the MCP services in the MCP repository using the large model, so that the large model can obtain the operation results returned after the MCP invocations, and use the operation results to respond to the user requests.

9. An electronic device, characterized in that, include: Memory, used to store computer programs; A processor for executing the computer program to implement the MCP generation and invocation method in a low-code platform as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, Used to store computer programs, which, when executed by a processor, implement the MCP generation and invocation method in a low-code platform as described in any one of claims 1 to 7.

Images