# स्टिलियोबोट रिलीज श्रृंखला: साईडकार वास्तुकला *स्टेलोबोट का पता लगाने वाला इंजन ASP है।* [StyloBot](https://www.stylobot.net) > ** `github.com/scottgal/stylobot-go` SDK, `github.com/scottgal/caddy-stylobot` प्लगइन, और `Mostlylucid.BotDetection.Sidecar` कन्टेनर शीघ्र प्रकाशित होगा** नीचे सब कुछ उन सतह का वर्णन करता है जो वे प्रदर्शित करेंगे > **स्टिलियोबोट रिलेस शृंखला** > > 1. [**व्यवहार, पहचान नहीं**](/blog/stylobot-fingerprint): क्यों StyloBot ग्राहक व्यवहारिक रूप से मॉडल करता है > 2. [**व्यवहार-Aware ASP.NET UI**](/blog/behaviour-aware-ux)सर्वर : NET अनुप्रयोगों के लिए प्रदान किया गया सतह > 3. [**लंबे समय तक चलाने वाले नेट सेवाओं में असीमित विकास का पता लगाना और स्थिर करना**](/blog/stylobot-release-reliability): विश्वसनीयता अनुशासन जो उत्पादन में इंजन को नीरस बनाए रखता है > 4. [**व्यवहार-Aware TypeScript UI**](/blog/typescript-sdk): Express , Fastify, और ब्राउज़र घटक > 5. **साइडकार वास्तुकला**: इस लेख > 6. [**तेजी से सीखना**](/blog/stylobot-release-learning)अनुकूलन सीखने की प्रणाली > 7. [**उस चीज़ का परीक्षण जो सफल नहीं हो रही है**](/blog/stylobot-release-nondeterministic-testing): सत्यापन अनुशासन > 8. [**स्टिलियोएक्सट्रैक्ट - एक स्थानीय सीखने के HTML को मार्कडाउन रूपांतरक में**](/blog/stylobot-release-styloextract): एचटीएमएल\→\मार्कडाउन परत जो डिटेक्टर के साथ जोड़ता है\,\walker bug lucidVIEW पकड़ा\M SK3\ और कुत्तेfood लूप कि यह ईमानदार बना # छेदगाड़ी क्यों एक उल्टा प्रॉक्सी बॉट पता चलाने के लिए स्पष्ट स्थान है। *अलग-अलग करना* जो अनुरोध कर रहा है के आधार पर | . | एक गेटवे जो सीधे ब्लॉक करता है |; | अधिकांश अनुप्रयोगों को वास्तव में एक निर्णय की आवश्यकता होती है, जिस पर वे एक ही समय में कई तरह से कार्य कर सकते हैं छेदगाड़ी पैटर्न दो चिंताओं को अलग करता है। [तेजी से सीखना](/blog/stylobot-release-learning)दो स्थानीय नेटवर्क पर संचार करते हैं. एक ही होस्ट या एक ही पोड. यह नया नमूना नहीं है [प्रेषक प्रॉक्सी](https://www.envoyproxy.io/) सेवा के लिए यह ठीक करता है-मेश संबंधित M SK1mTLS, रिट्रीस [दमर](https://dapr.io/) यह राज्य और pub के लिए करता है [ओपन टेलीमीटरी कलेक्टर](https://opentelemetry.io/docs/collector/) टेलीमीटरी के लिए यह करता है। [TOC] ## इसे केवल एक लाइब्रेरी के रूप में क्यों नहीं सम्मिलित करें वैकल्पिक है गेटवे में सीधे पता लगाने को कम्पाइल करना। इस जटिलता के एक इंजन के लिए भी यथार्थ नहीं है . स्टिलोबोट में चार निष्पादनों पर \49\सूचक संगठित हैं **लहरें** (अगामी तरंगों को तभी चलाया जाता है जब पहले से आने वाले संकेत इसे गारंटी देते हैं। **मार्कोव श्रृंखला वेक्टर** एक 129-आयामी अंतरिक्ष में\ .\ A Markov श्रृंखला केवल एक संभाव्यता मॉडल के ऊपर है & # 160; "\ given the last thing this session did\ M SK3\ what comes next\ ?",\ and 129\ dimensions captures enough page\ MSC6\ transition shape to tell humans and bots apart\ MST7\ It runs **लीडन समुदाय पहचान** उन सदिशों के ऊपर-:, एक ग्राफ, -, समूहबद्ध एल्गोरिथ्म जो सत्रों को समान रूप से व्यवहार करते हैं समूहित करता है,,, जो कि है StyloBot एक बॉट नेटवर्क को पता लगाता है जब व्यक्तिगत सत्र ठीक दिखते हैं तब भी। एक पार्श्वगाड़ी प्रत्येक अवयव को ऐसा करने देता है जो यह अच्छी है ```mermaid graph TD classDef input fill:none,stroke:#3b82f6,stroke-width:2px classDef async fill:none,stroke:#a855f7,stroke-width:2px classDef good fill:none,stroke:#22c55e,stroke-width:2px classDef store fill:none,stroke:#f59e0b,stroke-width:2px GW["Gateway
Caddy / YARP / nginx"]:::input SD["StyloBot Sidecar · ASP.NET Core
gRPC :5090 · REST :5091
≤50ms per Detect RPC"]:::async APP["Upstream Application
Node / Go / ASP.NET
reads req.stylobot.verdict"]:::good DB[("SQLite
sessions · signatures · reputation")]:::store GW --> SD SD <--> DB GW --> APP ``` गेटवे छेदगाड़ी को कॉल करता है, परिणाम HTTP हेडर के रूप में इंजेक्शन करता है। # छेदगाड़ी `Mostlylucid.BotDetection.Sidecar` एक न्यूनतम ASP है - **:5090**के लिए HTTP - **:5091**REST क्लाइंटों के लिए : HTTP/1.1 `/api/v1/*` अंतबिन्दु ## जीआरपीसी [जीआरपीसी](https://grpc.io/) Google में विकसित एक उच्च निष्पादन दूरस्थ प्रक्रिया कॉल फ्रेमवर्क है [प्रोटोकॉल बफर](https://protobuf.dev/) अपने तार प्रारूप के रूप में (protobuf) एक संक्षिप्त द्विआधारी एनकोडिंग जो JSON की तुलना में तार पर क्रमबद्ध करने में तेजी से और छोटा होता है। इंटरफेस एक में परिभाषित किया गया है `.proto` फ़ाइल. उस फ़ाइल से कूट जनरेटर किसी भी समर्थित भाषा में टाइप किए गए क्लाइंट और सर्वर स्टब्स को उत्पन्न करते हैं `.proto` कोई भी भाषा जो जीआरपीसी क्रियान्वयन के साथ है, साइडकार को बुला सकता है ## जीआरपीसी इंटरफेस सेवा में तीन आरपीसी हैं ```protobuf service DetectionService { rpc Detect(DetectRequest) returns (DetectResponse); rpc DetectBatch(DetectBatchRequest) returns (DetectBatchResponse); rpc RenderWidget(RenderWidgetRequest) returns (RenderWidgetResponse); } ``` **`Detect`** per है। - request hot path; .; Pass it method; ,; path;,; headers; MSC4; remote IP; M SK5; and optional TLS fingerprint data; MRK6; It runs the wave pipeline; (; only the detectors that the request; MST8; signals warrant; M ST9; updates the session vector; Mst10; scores against the reputation store; M st11; and returns a verdict. **`DetectBatch`** अनुक्रमिक रूप से बहुविध अनुरोध चलाता है. लॉग रिप्ले और ऑफ़लाइन विश्लेषण के लिए उपयोग किया जाता है **`RenderWidget`** एक तरल टेम्प्लेट स्ट्रिंग को स्वीकार करता है। ## खोज कॉल के अंदर क्या होता है चित्र से पहले एक त्वरित शब्दकोश, क्योंकि ये नाम प्रकट होंगे - **ब्लैकबोर्ड**एक प्रति-request key -value bag `request.ip.is_datacenter`, `detection.useragent.confidence`). डिटेक्टर इसके लिए संकेत लिखते हैं, ; बाद में एक ही तरंग के डिटेक्टर उन्हें पढ़ते हैं। - **संश्लेषित एचटीटीपी संदर्भ**: एक स्टैंड `HttpContext` जीआरपीसी सेवा प्रोटो अनुरोध क्षेत्रों से बनाता है `HttpContext`एक संश्लेषण करने से एक जीआरपीसी कॉल के अंदर एक ही इंजन बिना बदले चलाता है - **पता लगाना योगदान** / **संयुक्त साक्ष्य**डिटेक्टर आउटपुट (सिग्नल लिखता है ```mermaid sequenceDiagram participant GW as Gateway (Caddy) participant SD as gRPC Service participant ORC as BlackboardOrchestrator participant DET as Detectors (up to 49, 4 waves) participant DB as SQLite GW->>SD: Detect RPC { method, path, headers, remoteIp } SD->>ORC: DetectAsync(syntheticHttpContext) ORC->>DET: Wave 0 - Identity + ContentSequence ORC->>DET: Wave 1 - Fast path <1ms: UA, Header, IP, Heuristic ... ORC->>DET: Wave 2 - Session vectors, Behavioural waveform ORC->>DET: Wave 3 - Slow path: DNS, advanced fingerprinting DET-->>ORC: DetectionContributions (signals, confidence deltas) ORC->>DB: update session vector and reputation score DB-->>ORC: ok ORC-->>SD: AggregatedEvidence { botProbability, riskBand, ... } SD-->>GW: DetectResponse { isBot, riskBand, recommendedAction, ... } ``` पूरी पाइपलाइन एकल जीआरपीसी कॉल के अंदर चलती है # जीओ एसडीके गो में गेटवे कोड ASP को आयात नहीं कर सकता है`github.com/scottgal/stylobot-go`एक टाइप्ड इंटरफेस प्रदान करता है जो कलर से उत्पन्न प्रोटोबॉफ़ प्रकारों को पूरी तरह छुपाता है ### क्यों SDK प्रोटोबॉफ़ प्रकार छिपाता है प्रोटोबॉफ़-generated code is verbose and has an unusual API`RISK_BAND_HIGH`, नहीं `"High"`). क्षेत्र नाम ऊंट हैं कुछ जेनेरेटरों में केस और सांप के साथ-साथ SDK एक बार सीमा पर (प्रो एनम को कैनोनिक स्ट्रिंगों में अनुवाद करता है ```go // the only interface you depend on: no proto imports required type Client interface { Detect(ctx context.Context, req DetectRequest) (*Verdict, error) DetectBatch(ctx context.Context, reqs []DetectRequest) ([]*Verdict, error) RenderWidget(ctx context.Context, req RenderRequest) (*RenderResponse, error) Close() error } ``` `DetectRequest` और `Verdict` सादा Go स्ट्रक्चर हैं ```go type DetectRequest struct { Method string Path string Headers map[string]string RemoteIP string Protocol string // "http" or "https"; defaults to "https" if empty TLS *TLSInfo } type Verdict struct { IsBot bool BotProbability float32 Confidence float32 BotType string // "AiBot", "Scraper", "GoodBot", ... BotName string RiskBand string // "VeryLow", "Low", "Elevated", "Medium", "High", "VeryHigh" RecommendedAction string // "Allow", "Throttle", "Challenge", "Block" ThreatScore float32 ThreatBand string ProcessingTimeMs float32 DetectorsRun int32 Reasons []Reason } ``` एक क्लाइंट बनाना और पता चलाना ```go import ( stylobot "github.com/scottgal/stylobot-go" "context" "time" ) client, err := stylobot.NewClient( "localhost:5090", stylobot.WithTimeout(50 * time.Millisecond), stylobot.WithAPIKey(os.Getenv("SB_API_KEY")), ) if err != nil { log.Fatal(err) } defer client.Close() verdict, err := client.Detect(ctx, stylobot.DetectRequest{ Method: r.Method, Path: r.URL.RequestURI(), RemoteIP: r.RemoteAddr, Headers: extractHeaders(r), Protocol: "https", }) if err != nil { // fail open: log and continue log.Printf("stylobot detect failed: %v", err) return next(w, r) } if verdict.RecommendedAction == "Block" { http.Error(w, "Forbidden", http.StatusForbidden) return } ``` ### लचीला कनेक्शन और स्टार्टअप सुरक्षा `grpc.NewClient` एक क्लाइंट चैनल बनाता है लेकिन तत्काल टीसीपी कनेक्शन स्थापित नहीं करता। यह HTTP क्लाइंटों से भिन्न है, जहाँ आप आमतौर पर निर्माण पर जुड़ते हैं [जीआरपीसी गो दस्तावेज़ीकरण](https://pkg.go.dev/google.golang.org/grpc#NewClient) जीवन चक्र को विस्तृत रूप से शामिल करता है ### समय समाप्ति क्रिया `WithTimeout` पर `NewClient` प्रत्येक के भीतर लागू एक डिफ़ॉल्ट per-call तारीख़ सेट करता है `Detect` कॉल. यदि आपका कॉल कोड |( |या Caddy प्लगइन जैसे मिडवेअर | ) |आगत अनुरोध से सीमाबद्ध संदर्भ | МSK3 |से पहले समाप्त होने वाले किसी भी समयावधि को लागू करता है `WithTimeout` से `NewClient` और प्लगइन को इसे नियंत्रित करने दें `NewClient` जैसा कि ऊपर दिखाया गया है # Caddy प्लगइन [कैडीCity name (optional, probably does not need a translation)](https://caddyserver.com/) एक Go-आधारित वेब सर्वर और स्वचालित HTTPS के साथ उल्टे प्रॉक्सी है [एक्सकैडी](https://github.com/caddyserver/xcaddy) एक अनुकूल Caddy द्विआधारी बनाने के लिए जो आपके प्लगइनों को शामिल करता है`.so` रनटाइम पर लोड फ़ाइलें). स्टेलोबोट प्लगइन`github.com/scottgal/caddy-stylobot`प्रत्येक अनुरोध पर गो एसडीके को कॉल करने वाले मध्यवेयर हैंडलर को पंजीकृत करता है Caddyfile विन्यास: ```caddy { order stylobot before respond } :80 { stylobot { endpoint localhost:5090 # gRPC host:port of the sidecar timeout 50ms # per-request deadline; fails open on expiry # on_block 503 # optional: change the block status code (default: 403) } reverse_proxy upstream:3000 } ``` प्लगइन प्रत्येक अग्रेषित अनुरोध पर नौ निर्णायक हेडर डालता है हेडर |---|---| | `X-StyloBot-IsBot` | `isBot` 0 bool | `X-StyloBot-Probability` | `botProbability` (0.0-1.0) | | `X-StyloBot-Confidence` | `confidence` (0.0-1.0) | | `X-StyloBot-BotType` | `AiBot`, `Scraper`, `GoodBot` | | `X-StyloBot-BotName` | `GPTBot`, `Googlebot` | | `X-StyloBot-RiskBand` | `VeryLow` ... `VeryHigh` | | `X-StyloBot-Action` | `Allow` / `Throttle` / `Challenge` / `Block` | | `X-StyloBot-ThreatScore` संख्यात्मक | `X-StyloBot-ThreatBand` | `None` ... `Critical` | जहाँ अनुरोध करता है `isBot=true` और `Action=Block` एक 403 के साथ गेटवे पर रोके जाते हैं और कभी ऊपरी धारा तक नहीं पहुँचते हैं `Throttle` या `Challenge` सिफारिश) सभी नौ शीर्ष intact के साथ अग्रेषित किया जाता है `on_block` जब गेटवे ब्लॉक करता है तब उपयोग की जाने वाली स्थिति कोड बदलता है `on_block 503` scrapers में पुनः प्रयास तर्क को दबाने के लिए जो 403 को पुनः प्रयास योग्य के रूप में देखता है ## हर अनुरोध पर मिडलवेयर क्या करता है ```mermaid flowchart TD classDef input fill:none,stroke:#3b82f6,stroke-width:2px classDef async fill:none,stroke:#a855f7,stroke-width:2px classDef good fill:none,stroke:#22c55e,stroke-width:2px A["1. Strip inbound X-StyloBot-* headers"]:::input B["2. context.WithTimeout(r.Context(), 50ms)"]:::input C["3. sbClient.Detect(ctx, DetectRequest)"]:::async D{error?} E["log warn - fail open
forward unchanged"]:::good F["4. injectHeaders
X-StyloBot-IsBot, Probability, Confidence,
BotType, BotName, RiskBand, Action,
ThreatScore, ThreatBand"]:::input I["next.ServeHTTP - forward to upstream
with all verdict headers injected"]:::good A --> B --> C --> D D -->|yes| E --> I D -->|no| F --> I ``` **चरण 1, स्ट्रिप इनबाउंड हेडर** एक ग्राहक जो जानता है कि `X-StyloBot-*` हेडर नाम स्वंयः---एक अनुकूल निर्णय दे सकता है और यह असफलता से बच सकता है। **चरण 2, संदर्भ समय-सीमा** समय समाप्ति से व्युत्पन्न है `r.Context()` उपयोग `context.WithTimeout` (जो एक सापेक्ष अवधि लेता है `context.WithDeadline` एक पूर्ण समय लेता है `r.Context()` बजाय `context.Background()` कुंजी बिंदु है **चरण 3 और 4, पता लगाना और इंजेक्शन करें** नौ निर्णायक क्षेत्र नौ हो जाते हैं `X-StyloBot-*` हेडर. हेडर ब्लॉक जाँच से पहले सेट किए जाते हैं `styloBotMiddleware({ mode: 'headers' })` सभी non-blocked अनुरोधों के लिए `isBot=true` और `recommendedAction=Block` गेटवे पर 403 के रूप में लौटाया जाता है क्रियान्वयन ```go // from sdk/caddy/stylobot.go func (s *StyloBot) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyhttp.Handler) error { for _, name := range stylobotHeaders { r.Header.Del(name) } ctx, cancel := context.WithTimeout(r.Context(), s.timeout) defer cancel() verdict, err := s.sbClient.Detect(ctx, sb.DetectRequest{ Method: r.Method, Path: r.URL.RequestURI(), RemoteIP: ExtractIP(r), Protocol: r.Proto, Headers: ExtractHeaders(r), }) if err != nil { s.logger.Warn("stylobot detect failed, failing open", zap.Error(err)) return next.ServeHTTP(w, r) } injectHeaders(r, verdict) if verdict.IsBot && s.OnBlock > 0 && verdict.RecommendedAction == "Block" { http.Error(w, "Forbidden", s.OnBlock) return nil } return next.ServeHTTP(w, r) } ``` ## xcaddy के साथ निर्माण केडीई प्लगइन को द्विआधारी में कम्पाइल किया जाना चाहिए [एक्सकैडी](https://github.com/caddyserver/xcaddy)एकीकरण परीक्षणों में Dockerfile पैटर्न दिखाता है ```dockerfile # from tests/integration/caddy-sidecar/Dockerfile FROM caddy:2-builder AS builder WORKDIR /build COPY sdk/caddy/ caddy-plugin/ COPY sdk/go/ go/ WORKDIR /build/caddy-plugin RUN xcaddy build \ --with github.com/scottgal/caddy-stylobot=/build/caddy-plugin \ --with github.com/scottgal/stylobot-go=/build/go FROM caddy:2 COPY --from=builder /build/caddy-plugin/caddy /usr/bin/caddy COPY tests/integration/caddy-sidecar/Caddyfile /etc/caddy/Caddyfile ``` ### एक्सकैडी प्रतिस्थापन निर्देशिका प्लगइन `go.mod` समाहित है: ``` replace github.com/scottgal/stylobot-go => ../go ``` यह कहता है कि जब आप देखते हैं Go औजार श्रृंखला " `stylobot-go`मॉड्यूल प्रॉक्सी से लाने के बजाय स्थानीय निर्देशिका का उपयोग करें `go build` और `go test` प्लगइन निर्देशिका में xcaddy अपने निर्माण के लिए एक नया अस्थायी जा मॉड्यूल बनाता है `replace` प्लगइन से निर्देश `go.mod`. बिना दूसरे `--with` तर्क, xcaddy डाउनलोड करने की कोशिश करेगा `stylobot-go` से `pkg.go.dev` (जहां यह अभी प्रकाशित नहीं हुआ है `--with module=path` तर्क xcaddy's एक का मूल समकक्ष है `replace` निर्देशिका: यह निर्माण समय पर स्थानीय निर्देशिका में एक मॉड्यूल पथ का नक्शा बनाता है # gRPC पर रेंडरवाइडजेट: तरल टेम्प्लेट्स `RenderWidget` एक जीआरपीसी आरपीसी है जो एक तरल टेम्प्लेट स्ट्रिंग को स्वीकार करता है। ### तरल टेम्प्लेट [तरल](https://shopify.github.io/liquid/) Shopify द्वारा बनाया गया एक टेम्पलेटिंग भाषा है। [तरल](https://github.com/sebastienros/fluid), एक उच्च पार्श्वगाड़ी कार्यान्वयन ```csharp // from src/Mostlylucid.BotDetection.Sidecar/Services/DetectionGrpcService.cs private static readonly FluidParser Parser = new(); // static, shared, compiled templates cached public override async Task RenderWidget( Proto.RenderWidgetRequest request, ServerCallContext context) { if (!Parser.TryParse(request.Template, out var template, out var error)) return new Proto.RenderWidgetResponse { Success = false, Error = error }; var ctx = new TemplateContext(); if (request.Verdict is { } v) { ctx.SetValue("isBot", v.IsBot); ctx.SetValue("botProbability", (double)v.BotProbability); ctx.SetValue("botType", v.BotType); ctx.SetValue("botName", v.BotName); ctx.SetValue("riskBand", v.RiskBand.ToString()); ctx.SetValue("recommendedAction", v.RecommendedAction.ToString()); ctx.SetValue("threatScore", (double)v.ThreatScore); ctx.SetValue("threatBand", v.ThreatBand.ToString()); } foreach (var kv in request.Vars) ctx.SetValue(kv.Key, kv.Value); var html = await template.RenderAsync(ctx); return new Proto.RenderWidgetResponse { Html = html, Success = true }; } ``` तरल.Core एक आंतरिक कम्पाइलित टेम्प्लेट कैश रखता है `FluidParser` स्थिर है और सभी जीआरपीसी कॉलों में साझा है नोड `StyloBotGrpcClient.renderWidget()` उदाहरण और पूरा टेम्प्लेट चल संदर्भ में हैं [टाइपस्क्रिप्ट एसडीके अनुच्छेद](/blog/typescript-sdk). इसे Go से बुला रहे हैं ```go rendered, err := client.RenderWidget(ctx, stylobot.RenderRequest{ Template: `{% if isBot %}

Bot: {{ botType }}

{% endif %}`, Verdict: verdict, Vars: map[string]string{"locale": "en-GB"}, }) if err == nil && rendered.Success { fmt.Fprint(w, rendered.HTML) } ``` टेम्प्लेट वाक्य संरचना समान है चाहे आप कॉल करें `RenderWidget` से Go, Node, या उपयोग `` ब्राउज़र में # उत्पादन सजावट ```mermaid graph LR classDef input fill:none,stroke:#3b82f6,stroke-width:2px classDef async fill:none,stroke:#a855f7,stroke-width:2px classDef good fill:none,stroke:#22c55e,stroke-width:2px classDef store fill:none,stroke:#f59e0b,stroke-width:2px INT([Internet]) CF["Cloudflare
Tunnel / CDN"] CA["Caddy
+ caddy-stylobot"]:::input SD["StyloBot Sidecar
:5090 gRPC · :5091 REST"]:::async WEB["Upstream App
Node / Go / ASP.NET"]:::good DB[("SQLite
sessions · reputation")]:::store INT --> CF --> CA CA -->|"gRPC Detect
≤50ms"| SD SD <-->|"persist"| DB CA -->|"X-StyloBot-* headers"| WEB WEB -->|"/_stylobot/partials/render
(widget rendering)"| SD ``` उपप्रणाली अनुप्रयोग छेदकार को सीधे विजेट रेंडरिंग के लिए बुलाता है, गेटवे को पार करने के लिए ## हर परत पर खोलें Caddy प्लगइन, नोड मिडिल्डवेयर, और Go SDK सभी खोलने में विफल होते हैं। व्यापार से यह एनकोड करता है। legitimate traffic blocking because detection is unavailable worse than missing bot traffic during a sidecar outage --- जारी जारी जारी है - [व्यवहार, पहचान नहीं](/blog/stylobot-fingerprint): क्यों पता लगाने के लिए व्यवहारिक होना चाहिए - [व्यवहार-Aware ASP.NET UI](/blog/behaviour-aware-ux)निर्णय को Razor में बदलना : नियंत्रक नीति - [लंबे समय तक चलाने वाले नेट सेवाओं में असीमित विकास का पता लगाना और स्थिर करना](/blog/stylobot-release-reliability): विश्वसनीयता अनुशासन जो लगातार ट्रैफिक के तहत इंजन को नीरस बनाए रखता है - [व्यवहार-Aware TypeScript UI](/blog/typescript-sdk): एक ही निर्णय एक्सप्रैस में उभरा है - **साइडकार वास्तुकला** (this article): how the engine plugs into any stack via gRPC कार्यान्वयन के लिए स्रोत [github.comM SK1scottgal/stylobot](https://github.com/scottgal/stylobot). लाइव इंजन [stylobot.net](https://www.stylobot.net).