When we run technical integration for toy factories, the question we hear most is: how exactly do you wire up this module? Here is an integration guide that spells it out.
Wiring an AI toy module into your toy does not start with code - it starts with deciding which integration path you are on. At Shenzhen Nablai Intelligent Technology Co., Ltd. (Nablai), both main lines, TY (based on Tuya T5E) and LX (based on Espressif ESP32S3), use a dual-stack architecture of local SDK plus cloud API, while NT (based on PY32) is a pure UART command module. The three integrate very differently, and picking the wrong one makes joint debugging painful later on.
First, to be clear: a dual stack is not two paths, it is two capabilities of the same module
TY002 and LX002 are both a dual stack of local SDK plus cloud API: the local SDK handles firmware, audio capture and servo control; the cloud API handles LLM inference, content updates and user data. The difference is ecosystem ownership and brand sovereignty (TY rides on Tuya, LX ships with the Nablai app and the AMS private cloud) - it is absolutely not "API versus SDK" as two parallel options. NanoToy (PY32) is the pure UART command module: no semantics, no cloud, no SDK. It takes commands and acts on them.
How to choose between the three integration methods
- Local SDK (TY / LX): firmware-level control, for teams that need deeply customized interaction and custom firmware logic. The SDK exposes low-level interfaces for audio capture, wake word and servo drive.
- Cloud API (TY / LX): handles LLM conversation, content push, and user and device management. No need to build your own LLM or your own servers - call it and go.
- UART serial port (NT): the simplest option. The host controller sends commands and the module executes them. For toys that only want action triggers and do not want to touch the AI chain.
In one line: for intelligence depth, take the TY/LX dual stack; for actions only, take the NT serial port.
What the interfaces look like
Whichever line you take, the physical interfaces are kept as simple as possible so toy factories can assemble easily:
Standard integration process
- Assessment: confirm the toy structure, the power budget and the target features, then pick TY, LX or NT.
- SDK integration (TY/LX): integrate the local SDK into your host controller and get audio and servos working.
- Cloud API joint debugging (TY/LX): request credentials and connect LLM conversation and content services.
- Functional joint debugging: run the wake - conversation - action loop end to end.
- Launch and operations: manage devices, content and data through the Nablai app / AMS.
A few easy traps
- Coordinate system mismatch: servo angle definitions have to line up with the module firmware, or the actions will run inverted.
- Permissions and credentials: cloud API credentials need to be managed in tiers, so a single leak does not hand over everything.
- Latency expectations: semantic understanding on TY/LX runs in the cloud, so watch for cross-continental latency in overseas markets. NT is purely local and has no such problem.
- Firmware consistency: lock the firmware version before mass production, so behavior does not drift between batches.
- Firmware OTA channel: TY/LX support remote firmware and content OTA, so fixes and upgrades keep coming after mass production. NT does not support OTA, and later maintenance means returning units to the factory - build that into the long-term cost at selection time.
One more recommendation: write maintainability into the selection review. With the same TY/LX module you can still push fixes and new content from the cloud after the first firmware release, which matters a lot for teams building long-lifecycle toys. A pure-UART NT fits categories that ship once with no plan to operate them afterwards.
A real integration scenario
Take an IP figure as an example: the customer uses their own MCU as the host controller and wants the figure to talk and to strike poses. We recommended the LX dual stack - the host controller takes over wake word and servos through the local SDK, semantic understanding goes through the cloud API, and the customer manages lines and voice themselves in AMS. Week one: SDK integration and servo joint debugging. Week two: connect the cloud API and run the wake - conversation - action loop. Week three: lock the firmware and move into pilot production. The customer never built a single server.
What the dual stack buys you
Precisely because TY/LX is a dual stack of local SDK plus cloud API rather than two separate systems, you get low-latency on-device control and continuous cloud-side evolution from the same module: the device handles deterministic actions and capture, the cloud handles non-deterministic semantics and content. NT keeps things as simple as they get - a pure UART command module for toys that only want action triggers and do not yet want to touch the AI chain. The three families are not high-end versus low-end; they are three different business models.
Three questions to ask yourself before integrating
- Is my toy going overseas? If it is, put TY first: certification and languages are pre-loaded, which saves a lot of trouble. For a purely domestic product where data sovereignty matters, pick LX.
- Do I have an embedded team? If not, take the TY out-of-the-box route, or lean on the LX SDK and our support. Do not try to chew on a bare chip.
- Do I want to run a content subscription? If you want long-term service revenue, the LX Nablai app plus AMS is a ready-made operations console.
FAQ
Q1: Can we integrate without an embedded team? Yes. TY rides the Tuya ecosystem and is ready out of the box; LX ships with a complete SDK and documentation, and we provide technical support as well.
Q2: Does the cloud API mean running our own servers? No. LX uses the Nablai cloud and supports both general-purpose LLMs and your own model; TY runs on the Tuya cloud.
Q3: How is data security guaranteed? On the LX Series, 100% of user data belongs to the brand owner, and AMS provides independent accounts and data management.
Q4: Can NT be upgraded to TY/LX? The architecture is different, so there is no direct upgrade path. You can switch on the next product generation, and we will give you migration advice.
About Nablai
Nablai is an AI company, and AI smart toys are the application area we focus on today. Our product is the AI smart toy module, and our goal is to give toy companies a product-level solution for bringing AI into their toys.
We have built three product families:
- TY Series: built on Tuya T5E, 60+ languages, the fast lane into global markets
- LX Series: built on Espressif ESP32S3, full brand ownership, deep customization
- NT Series: built on PY32, a low-cost way to test the smart toy market
- Website: https://www.nablai.com.cn
- Phone: 15917703502
- Slogan: Driven by gradients, optimized by intelligence. Powered by Nabla, Optimized by AI.
Shenzhen Nablai Intelligent Technology Co., Ltd. — AI module specialists for smart toys
📧 contact@nablai.com.cn 🌐 www.nablai.com.cn