go-riskengine

name: go-riskengine description: Expert skill for the riskengine open-source Go project. Use when implementing, reviewing, or extending any component of the risk decision engine: rule engine, model engine, feature service, orchestrator, list service, audit, API layer, or deployment config. Provides concise domain knowledge, interface contracts, and implementation patterns to minimize context token usage.

RiskEngine Go Project Skill

Full design reference: 风控决策引擎深度设计方案.md Domain rules: .cursor/rules/riskengine-domain.mdc

Quick Reference

Project Layout

riskengine/
├── cmd/server/          # main.go – wire & serve
├── cmd/migrate/         # DB/config migration tool
├── internal/
│   ├── engine/          # DecisionEngine – top-level orchestration
│   ├── rule/            # Rule DSL parser, evaluator, hot-reload
│   ├── feature/         # Parallel feature fetching, velocity windows
│   ├── model/           # ONNX inference pool, champion-challenger
│   ├── list/            # Bloom+Redis+DB tiered list service
│   ├── orchestrator/    # DAG executor, A/B router, aggregator
│   ├── audit/           # Kafka audit writer, PII masking
│   ├── config/          # Config loader (Viper + Nacos/Etcd watch)
│   └── middleware/      # Rate limit, auth, trace injection
├── pkg/
│   ├── expr/            # Expression evaluator (wraps antonmedv/expr)
│   ├── sliding/         # Redis sliding-window velocity counter
│   ├── bloom/           # In-process Bloom filter
│   └── pool/            # Generic goroutine pool (ONNX CGO isolation)
├── api/
│   ├── http/v1/         # Gin handlers + OpenAPI spec
│   └── grpc/proto/      # Protobuf definitions
├── configs/             # YAML config templates
├── deployments/         # Docker, Kubernetes manifests
├── scripts/             # lint, test, benchmark scripts
└── docs/                # Architecture diagrams, ADRs

Core Interfaces (never change signatures without major version bump)

See reference.md for full interface definitions.

Key contracts:

• engine.Engine – Evaluate(ctx, *DecisionRequest) (*DecisionResult, error)
• rule.Evaluator – Evaluate(ctx, *rule.Context) ([]*rule.Result, error)
• feature.Fetcher – Fetch(ctx, *feature.Key) (feature.Map, error)
• model.Scorer – Score(ctx, feature.Map) (map[string]float64, error)
• list.Service – Check(ctx, *list.Query) (list.Status, error)

Decision Flow (implement in this order when adding a new scene)

1. Add scene code to api/http/v1/scenes.go
2. Define PolicySet YAML in configs/policies/<scene>.yaml
3. Register feature fetchers needed for the scene
4. Add/reuse rules in configs/rules/
5. Wire in internal/orchestrator/registry.go
6. Add integration test in internal/engine/testdata/<scene>/

Performance Targets

Key Dependencies

go.uber.org/zap          # logging
github.com/gin-gonic/gin # HTTP
google.golang.org/grpc   # gRPC
github.com/redis/go-redis/v9  # Redis
golang.org/x/sync        # errgroup
github.com/antonmedv/expr     # expression engine
github.com/prometheus/client_golang  # metrics
go.opentelemetry.io/otel  # tracing

Additional Resources

• Full interface contracts: reference.md
• Implementation examples: examples.md
• Feature implementation steps & /opsx: commands: skill riskengine-workflow