rulego MCP工具

Installation

Install RuleGo using the go get command: ```bash go get github.com/rulego/rulego

Use Cases

RuleGo is an orchestrable rule engine that excels at decoupling your systems. - If your system's business is complex and the code is bloated - If your business scenarios are highly customized or frequently changing - If your system needs to interface with a large number of third-party applications or protocols - Or if you need an end-to-end IoT solution - Or if you need centralized processing of heterogeneous system data - Or if you want to try hot deployment in the Go language... Then the RuleGo framework will be a very good solution. #### Typical Use Cases Edge Computing: Deploy RuleGo on edge servers to preprocess data, filter, aggregate, or compute before reporting to the cloud. Data processing rules and distribution rules can be dynamically configured and modified through rule chains without restarting the system. IoT: Collect device data reports, make rule judgments through rule chains, and trigger one or more actions, such as sending emails, alarms, and linking with other devices or systems. Data Distribution: Distribute data to different systems using HTTP, MQTT, or gRPC based on different message types. Application Integration: Use RuleGo as glue to connect various systems or protocols, such as SSH, webhook, Kafka, message queues, databases, ChatGPT, third-party application systems. Centralized Processing of Heterogeneous System Data: Receive data from different sources (such as MQTT, HTTP, WS, TCP/UDP, etc.), then filter, format convert, and distribute to databases, business systems, or dashboards. Highly Customized Business: Decouple highly customized or frequently changing business and manage it with RuleGo rule chains. Business requirements change without needing to restart the main program. Complex Business Orchestration: Encapsulate business into custom components, orchestrate and drive these custom components through RuleGo, and support dynamic adjustment and replacement of business logic. Microservice Orchestration: Orchestrate and drive microservices through RuleGo, or dynamically call third-party services to process business and return results. Decoupling of Business Code and Logic: For example, user points calculation systems, risk control systems. Automation: For example, CI/CD systems, process automation systems, marketing automation systems. * Low Code: For example, low-code platforms, iPaaS systems, ETL, LangFlow-like systems (interfacing with large models to extract user intent, then triggering rule chains to interact with other systems or process business).

Rule Chain Running Example Diagram

<img src="doc/imgs/rulechain/demo.png" style="height:40%;width:100%;"/> More Running Modes

Usage

RuleGo is extremely simple to use. Just follow these 3 steps: 1. Define rule chains using JSON: - Rule Chain DSL Doc - example_chain.json 2. Import the RuleGo package and use the rule chain definition to create a rule engine instance:

import "github.com/rulego/rulego"
//Load the rule chain definition file.
ruleFile := fs.LoadFile("chain_call_rest_api.json")
// Create a rule engine instance using the rule chain definition
ruleEngine, err := rulego.New("rule01", ruleFile)

// Define message metadata
metaData := types.NewMetadata()
metaData.PutValue("productType", "test01")
// Define message payload and message type
msg := types.NewMsg(0, "TELEMETRY_MSG", types.JSON, metaData, "{\"temperature\":35}")

// Hand over the message to the rule engine for processing
ruleEngine.OnMsg(msg)

Rule Engine Management API

- Dynamically update rule chains

// Dynamically update rule chain logic
err := ruleEngine.ReloadSelf(ruleFile)
// Update a node under the rule chain
ruleEngine.ReloadChild("node01", nodeFile)
// Get the rule chain definition
ruleEngine.DSL()

// Load all rule chain definitions in a folder into the rule engine pool
rulego.Load("/rules", rulego.WithConfig(config))
// Get an already created rule engine instance by ID
ruleEngine, ok := rulego.Get("rule01")
// Delete an already created rule engine instance
rulego.Del("rule01")

// Create a default configuration
config := rulego.NewConfig()
// Debug node callback, the node configuration must be set to debugMode:true to trigger the call
// Both node entry and exit information will call this callback function
config.OnDebug = func (chainId,flowType string, nodeId string, msg types.RuleMsg, relationType string, err error) {
}
// Use the configuration
ruleEngine, err := rulego.New("rule01", []byte(ruleFile), rulego.WithConfig(config))

Input Endpoint Components

• Endpoint Components
• Endpoint DSL

Rule Chain Node Components

The core feature of RuleGo is its component-based architecture, where all business logic is encapsulated in components that can be flexibly configured and reused. Currently, RuleGo has built-in a vast array of commonly used components. - Standard Components - rulego-components :Documentation - rulego-components-ai - rulego-components-ci - rulego-components-iot - rulego-components-etl - rulego-marketplace :Dynamic component and rule chain marketplace - Custom Node Component Example :Documentation

Data Integration

RuleGo provides the Endpoint module for unified data integration and processing of heterogeneous systems. For details, refer to: Endpoint