[//]: # (title: Ultimate self-hosted automation with Platypush) [//]: # (description: Get started with Platypush to automate your smart home and beyond) [//]: # (image: /img/dashboard-1.png) [//]: # (author: Fabio Manganiello ) [//]: # (published: 2019-07-28) In the last few years we have experienced a terrific spike of products and solutions targeting home automation and automation in general. After a couple of years of hype around IoT, assistants and home automation the market is slowly cooling down, and a few solutions are emerging out of the primordial oh-look-at-this-shiny-new-toy chaos. There are however a couple of issues I’ve still got with most of the available solutions that led me to invest more time in building [Platypush](https://git.platypush.tech/platypush/platypush). The rationale behind a self-hosted, open-source and modular automation service ------------------------------------------------------------------------------ First, one class of solutions for home automation is provided by large for-profit companies. Such solutions, like the Google Home platform and Alexa, are intuitive to set up and use, but they’re quite rigid in the possibility of customization — meaning that you’ve only got the integrations that Google or Amazon provide you with, based on the partnerships they decide to build, you’ve only got to use the user interfaces they provide you with on the devices they decide to support, you can’t install the platform wherever you like or interact with it in any way outside of what’s provided by the company, and such decisions also subject to change over time. Additionally, a truly connected house will generate a lot of data about you (much more than what you generate by browsing the web), and I feel a bit uncomfortable sharing that data with [people who don’t seem to bother to share it with anyone else without my consent](https://www.cnbc.com/2019/07/11/google-admits-leaked-private-voice-conversations.html). Plus, the integrations provided by such platforms often break (see this, this and this, and they’re only a few examples) . It can be quite annoying if all of a sudden you can no longer control your expensive lights or cameras from your expensive assistant or smart screen, and the code for controlling them runs on somebody else’s cloud, and that somebody else just informs you that “they’re working on that”. Another issue with home automation solutions so far is fragmentation. You’ll easily have to buy 3–4 different bridges, devices or adapters if you want to control your smart lights, smart buttons, switches or a living room media centre. Compatibility with existing remotes is also most of the times neglected. Not to mention the number of apps you’ll have to download — each provided by a different author, each eating up space on your phone, and don’t expect that many options to make them communicate with each other. Such fragmentation has been indeed one of the core issues I’ve tried to tackle when building platypush, as I aimed to have only one central entry point, one control panel, one dashboard, one protocol to control everything, while still providing all the needed flexibility in terms of supported communication backends and APIs. The need for multiple bridges for home automation also goes away once you provide modules to manage Bluetooth, Zigbee and Z-Wave, and all you need to interact with your devices is a physical adapter connected to any kind of computer. The core idea is that, if there is a Python library or API to do what you want to do (or at least something that can be wrapped in a simple Python logic), then there should also be a plugin to effortlessly integrate what you want to do into the ecosystem you already have. It’s similar to the solution that Google has later tried to provide with the [device custom actions](https://developers.google.com/assistant/sdk/guides/library/python/extend/custom-actions), even though the latter is limited to assistant interactions so far, and it’s currently subject to change because of the [deprecation of the assistant library](https://developers.google.com/assistant/sdk/guides/library/python/). Another class of solutions for such problems come from open source products like [Home Assistant](https://www.home-assistant.io/). While Platypush and the Home Assistant share quite a few things — they both started being developed around the same time, both started out as a bunch of scripts that we developers used to control our own things, and we eventually ended up gluing together in a larger platform for general use, both are open source and developed in Python, and both aim to bring the logic for controlling your house inside your house instead of running it on somebody else’s cloud — there are a couple of reasons why I eventually decided to keep working on my own platform instead of converging my efforts into Home Assistant. First, Home Assistant has a strong Raspberry Pi-first approach. The suggested way to get started is to flash the Hass.io image to an SD card and boot up your RPi. While my solution is heavily tested within the Raspberry Pi ecosystem as well, it aims to run on any device that comes with a CPU and a Python interpreter. You can easily install it and run it on any x86/x86_64 architecture too if you want to handle your automation logic on an old laptop, a desktop or any Intel-based micro-computer. You can easily run it on other single-board computers, such as the Asus Tinkerboard, any BananaPi or Odroid device. You can even run it on Android if you have an implementation of the Python interpreter installed. You can even run a stripped-down version on a microcontroller that runs MicroPython. While Home Assistant has tackled its growth and increasing complexity by narrowing down the devices it supports, and providing pre-compiled OS and Docker images to reduce the complex process of getting it to run on bare-metal, I've tried to keep Platypush as modular, lightweight and easy to setup and run as possible. You can run it in a Python virtual environment, in a Docker container, in a virtual machine or KVM — if you can name it, you can probably do it already. I have even managed to run it on an old Nokia N900, both on the original Maemo and Arch Linux, and on several Android smartphones and tablets. And, most of all, it has a very small memory and CPU footprint. Running hotword detection, assistant, web panel, camera, lights, music control and a few sensors on a small Raspberry Zero is guaranteed to take not more than 5-10% of CPU load and just a few MBs of RAM. The flexibility of Platypush comes however a slightly steeper learning curve, but it rewards the user with much more room for customization. You are expected to install it via [pip](https://pypi.org/project/platypush/) or the [Gitlab](https://git.platypush.tech/platypush/platypush) repo, install the dependencies based on the plugins you want (although managing per-plugin dependencies is quite easy via `pip`), and manually create or edit a configuration file. But it provides much, much more flexibility. It can listen for messages on MQTT, HTTP (but you don’t have to run the webserver if you don’t want to), websocket, TCP socket, Redis, Kafka, Pushbullet — you name it, it has probably got it already. It allows you to create powerful procedures and event hooks written either in an intuitive YAML-based language or as drop-in Python scripts. Its original mission is to simplify home automation, but it doesn't stop there: you can use it to send text messages, read notifications from Android devices, control robots, turn your old box into a fully capable media center (with support for torrents, YouTube, Kodi, Plex, Chromecast, vlc, subtitles and many other players and formats) or a music center (with support for local collections, Spotify, SoundCloud, radios etc.), stream audio from your house, play raw or sampled sounds from a MIDI interface, monitor access to the file system on a server, run custom actions when some NFC tag is detected by your reader, read and extract content from RSS feeds and send it to your Kindle, read and write data to a remote database, send metrics to Grafana, create a custom voice assistant, run and train machine learning models, and so on — basically, you can do anything that comes with [one of the hundreds of supported plugin](https://docs.platypush.tech/en/latest/). Another issue I’ve tried to tackle is the developer and power user experience. I wanted to make it easy to use the automation platform as a library or a general-purpose API, so you can easily invoke a custom logic to turn on the lights or control the music in any of your custom scripts through something as simple as a get_plugin('light.hue').on() call, or by sending a simple JSON request over whichever API, queue or socket communication you have set up. I also wanted to make it easy to create complex custom actions (something like “when I get home, turn on the lights if it’s already dark, turn on the fan if it’s hot, the thermostat if it’s cold, the dehumidifier if it’s too humid, and play the music you were listening on your phone”) through native pre-configured action — similar to what is offered by Node-Red but with more flexibility and ability to access the local context, and less agnostic when it comes to plugins, similar to what is offered by IFTTT and Microsoft Flow but running in your own network instead of somebody else’s cloud, similar to the flexibility offered by apps like Tasker and AutoApps, but not limited to your Android device. My goal was also to build a platform that aims to be completely agnostic about how the messages are exchanged and which specific logic is contained in the plugins. As long as you’ve got plugins and backends that implement a certain small set of elements, then you can plug them in. Another issue I’ve tried to tackle is the developer and power user experience. I wanted to make it easy to use the automation platform as a library or a general-purpose API, so you can easily invoke a custom logic to turn on the lights or control the music in any of your custom scripts through something as simple as a `get_plugin('light.hue').on()` call, or by sending a simple JSON request over whichever API, queue or socket communication you have set up. I also wanted to make it easy to create complex custom actions (something like _“when I get home, turn on the lights if it’s already dark, turn on the fan if it’s hot, the thermostat if it’s cold, the dehumidifier if it’s too humid, and play the music I was listening on my phone”_) through native pre-configured action — similar to what is offered by Node-Red but with more flexibility and ability to access the local context, and without delegating too much of the integrations logic to other blocks; similar to what is offered by IFTTT and Microsoft Flow, but running in your own network instead of somebody else’s cloud; similar to the flexibility offered by apps like Tasker and AutoApps, but not limited to your Android device. Finally, extensibility was also a key factor I had in mind. I know how fundamental the contribution of other developers is if you want your platform to support as many things as possible out there. One of my goals has been to provide developers with the possibility of building a simple plugin in around 15 lines of Python code, and a UI integration in around 40 lines of HTML+Javascript code thanks to a consistent API that takes care of all the boilerplate. Let’s briefly analyze how platypush is designed to better grasp how it can provide more features and flexibility than most of the platforms I’ve seen so far. The building blocks ------------------- There are a couple of connected elements at the foundations of platypush that allow users to build whichever solution they like: - **Plugins**: they are arguably the most important component of the platform. A plugin is a Python class that handles a type of device or service (like lights, music, calendar etc.), and it exposes a set of methods that enable you to programmatically invoke _actions_ over those devices and services (like turn on, play, get upcoming events etc.). All plugins implement an abstract `Plugin` class and their configuration is completely transparent to the constructor arguments of the plugin itself - i.e. you can look at the constructor itself in the source code to understand which arguments a plugin takes, and you can fill those variables directly in your `config.yaml`. Example: ```yaml light.hue: bridge: 192.168.1.100 groups: - Living Room - Bathroom ``` - **Backends**: they are threads that run in the background and listen for something to happen (an HTTP request, a websocket or message queue message, a voice assistant interaction, a new played song or movie…). When it happens, they will trigger _events_, and other parts of the platform can asynchronously react to those events. - **Messages**: a message in platypush is just a simple JSON string that comes with a type and a set of arguments. You have three main types of messages on the platform: - **Requests**: they are messages used to require a certain plugin action to be executed. The format of the action name is quite simple (`plugin_name.method_name`), and you can, of course, pass extra arguments to the action. Actions are mapped one-to-one to methods in the associated plugin class through the `@action` annotation. It means that a request object is transparent to the organization of the plugin, and such a paradigm enables the user to build flexible JSON-RPC-like APIs. For example, the `on` action of the `light.hue` plugin accepts lights and groups as optional parameters. It means that you can easily build a request like this and deliver it to platypush through whichever backend you prefer (note that `args` are optional in this case): ```json { "type":"request", "action":"light.hue.on", "args": { "groups": [ "Living Room", "Bathroom" ] } } ``` If you have the HTTP backend running, for example, you can easily dispatch such a request to it through the available JSON-RPC execute endpoint. First create a user through the web panel at `http://localhost:8008`, then generate a token for the user to authenticate the API calls - you can easily generate a token from the web panel itself, Settings -> Generate token. Store the token under an environment variable (e.g. `$PP_TOKEN`) and use it in your calls over the `Authorization: Bearer` header: ```shell # cURL example curl -XPOST -H 'Content-Type: application/json' \ -H "Authorization: Bearer $PP_TOKEN" \ -d '{"type":"request", "action":"light.hue.on", "args": {"groups": ["Living Room", "Bedroom"]}}' \ http://localhost:8008/execute # HTTPie example echo '{ "type":"request", "action":"light.hue.on", "args": { "groups": ["Living Room", "Bedroom"] } }' | http http://localhost:8008/execute "Authorization: Bearer $PP_TOKEN" ``` And you can also easily send requests programmatically through your own Python scripts, basically using Platypush as a library in other scripts or projects: ```python from platypush.context import get_plugin response = get_plugin('light.hue').on(groups=['Living Room', 'Bathroom']) print(response) ``` - **Responses**: they are messages that contain the `output` and `errors` resulting from the execution of a request. If you send this request for example: ```json { "type":"request", "action":"light.hue.get_lights" } ``` You'll get back something like this: ```json { "id": "6e5383cee53e8330afc5dfb9bde12a25", "type": "response", "target": "http", "origin": "your_server_name", "_timestamp": 1564154465.715452, "response": { "output": { "1": { "state": { "on": false, "bri": 254, "hue": 14916, "sat": 142, "effect": "none", "xy": [ 0.4584, 0.41 ], "ct": 366, "alert": "lselect", "colormode": "xy", "mode": "homeautomation", "reachable": true }, "type": "Extended color light", "name": "Living Room Ceiling Right", "manufacturername": "Philips", "productname": "Hue color lamp" }, "errors": [ ] } } } ``` If you send a request over a synchronous backend (e.g. the HTTP or TCP backend) then you can expect the response to be delivered back on the same channel. If you send it over an asynchronous backend (e.g. a message queue or a websocket) then the response will be sent asynchronously, creating a dedicated queue or channel if required. - **Events**: they are messages that can be triggered by backends (and also some plugins) when a certain condition is verified. They can be delivered to connected web clients via websocket, or you can build your own custom logic on them through pre-configured *event hooks*. Event hooks are similar to applets on IFTTT or profiles in Tasker — they execute a certain action (or set of actions) when a certain event occurs. For example, if you enable the Google Assistant backend and some speech is detected then a `SpeechRecognizedEvent` will be fired. You can create an event hook like this in your configuration file to execute custom actions when a certain phrase is detected (note that regular expressions and extractions of parts from the phrase, at least to some extent, are also supported): ```yaml # Play a specific radio on the mpd (or mopidy) plugin event.hook.PlayRadioParadiseAssistantCommand: if: type: platypush.message.event.assistant.SpeechRecognizedEvent phrase: "play (the)? radio paradise" then: action: music.mpd.play args: resource: tunein:station:s13606 # Search and play a song by an artist. Note the use of ${} to identify # parts of the target attribute that should be preprocessed by the hook event.hook.SearchSongVoiceCommand: if: type: platypush.message.event.assistant.SpeechRecognizedEvent phrase: "play ${title} by ${artist}" then: - action: music.mpd.clear # Clear the current playlist - action: music.mpd.search args: artist: ${artist} # Note the special map variable "context" to access data from the current context title: ${title} # music.mpd.search will return a list of results under "output". context['output'] will # therefore always contain the output of the last request. We can then get the first # result and play it. - action: music.mpd.play args: resource: ${context['output'][0]['file']} ``` You may have noticed that you can wrap Python expression by `${}` . You can also access context data through the special context variable. As we saw in the example above, that allows you to easily access the output and errors of the latest executed command (but also the event that triggered the hook, through `context.get('event')`). If the previous command returned a key-value map, or if we extracted named-value pairs from one of the event arguments, then you can also omit the context and access those directly by name — in the example above you can access the artist either through `context.get('artist')` or simply `artist`, for example. And you can also define event hooks directly in Python by just creating a script under `~/.config/platypush/scripts`: ```python from platypush.context import get_plugin from platypush.event.hook import hook from platypush.message.event.assistant import SpeechRecognizedEvent @hook(SpeechRecognizedEvent, phrase='play (the)? radio paradise') def play_radio_hook(event, **context): mpd = get_plugin('music.mpd') mpd.play(resource='tunein:station:s13606') ``` - **Procedures**: the last fundamental element of platypush are procedures. They are groups of actions that can embed more complex logic, like conditions and loops. They can also embed small snippets of Python logic to access the context variables or evaluate expressions, as we have seen in the event hook example. For example, this procedure can execute some custom code when you get home that queries a luminosity and a temperature sensor connected over USB interface (e.g. Arduino), and turns on your Hue lights if it’s below a certain threshold, says a welcome message over the text-to-speech plugin, switches on a fan connected over a TPLink smart plug if the temperature is above a certain threshold, and plays your favourite Spotify playlist through mopidy: ```yaml # Note: procedures can be synchronous (`procedure.sync` prefix) or asynchronous # (`procedure.async` prefix). In a synchronous procedure the logic will wait for # each action to be completed before proceeding with the next - useful if you # want to link actions together, letting each action access the response of the # previous one(s). An asynchronous procedure will execute instead all the actions # in parallel. Useful if you want to execute a set of actions independent from # each other, but be careful not to stack too many of them - each action will be # executed in a new thread. procedure.sync.at_home: - action: serial.get_measurement # Your device should return a JSON over the serial interface structured like: # {"luminosity":45, "temperature":25} # Note that you can either access the full output of the previous command through # the `output` context variable, as we saw in the event hook example, or, if the # output is a JSON-like object, you can access individual attributes of it # directly through the context. It is indeed usually more handy to access individual # attributes like this: the `output` context variable will be overwritten by the # next response, while the individual attributes of a response will remain until # another response overwrites them (they're similar to local variables) - if ${luminosity < 30}: - action: light.hue.on - if ${temperature > 25}: - action: switch.tplink.on args: device: Fan - action: tts.google.say args: text: Welcome home - action: music.mpd.play args: resource: spotify:user:1166720951:playlist:0WGSjpN497Ht2wYl0YTjvz ``` Again, you can also define procedures purely in Python by dropping a script under `~/.config/platypush/scripts` - just make sure that those procedures are also imported in `~/.config/platypush/scripts/__init__.py` so they are visible to the main application: ```python # ~/.config/platypush/scripts/at_home.py from platypush.procedure import procedure from platypush.utils import run @procedure def at_home(**context): sensors = run('serial.get_measurement') if sensors['luminosity'] < 30: run('light.hue.on') if sensors['temperature'] > 25: run('switch.tplink.on', device='Fan') run('tts.google.say', text='Welcome home') run('music.mpd.play', resource='spotify:user:1166720951:playlist:0WGSjpN497Ht2wYl0YTjvz') # ~/.config/platypush/scripts/__init__.py from scripts.at_home import at_home ``` In both cases, you can call the procedure either from an event hook or directly through API: ```shell # cURL example curl -XPOST -H 'Content-Type: application/json' \ -H "Authorization: Bearer $PP_TOKEN" \ -d '{"type":"request", "action":"procedure.at_home"}' \ http://localhost:8008/execute ``` You can also create a Tasker profile with a WiFi-connected or an AutoLocation trigger that fires when you enter your home area, and that profile can send the JSON request to your platypush device over e.g. HTTP `/execute` endpoint or MQTT — and you’ve got your custom welcome when you arrive home! Now that you’ve got a basic idea of what’s possible with Platypush and which are its main components, it’s time to get the hands dirty, getting it installed and configure your own plugins and rules. Installation - Quickstart ------------------------- First of all, Platypush relies on Redis as in-memory storage and internal message queue for delivering messages, so that's the only important dependency to install: ```shell # Installation on Debian and derived distros [sudo] apt install redis-server # Installation on Arch and derived distros [sudo] pacman -S redis # Enable and start the service [sudo] systemctl enable redis.service [sudo] systemctl start redis.service ``` You can then install Platypush through pip: ```shell [sudo] pip install platypush ``` Or through the Gitlab repo: ```shell git clone https://git.platypush.tech/platypush/platypush cd platypush python setup.py build [sudo] python setup.py install ``` In both the cases, however, this will install only the dependencies for the core platform - that, by design, is kept very small and relies on backends and plugins to actually do things. The dependencies for each integration are reported in the documentation of that integration itself ( see [official documentation](https://docs.platypush.tech/en/latest/)), and there are mainly four ways to install them: - Through `pip` extras: this is probably the most immediate way, although (for now) it requires you to take a look at the `extras_require` section of the [`setup.py`](https://git.platypush.tech/platypush/platypush/-/blob/master/setup.py#L169) to see what's the name of the extra required by your plugin/backend. For example, a common use case usually includes enabling the HTTP backend (for the `/execute` endpoint and for the UI), and perhaps you may want to enable a plugin for managing your lights (e.g. `light.hue`), your music server (e.g. `music.mpd`) and your Chromecasts (e.g. `media.chromecast`). If that's the case, then you can just get the name of the extras required by these integrations from `setup.py` and install them via pip: ```shell # If you are installing Platypush directly from pip [sudo] pip install 'platypush[http,hue,mpd,chromecast]' # If you are installing Platypush from sources cd /your/path/to/platypush [sudo] pip install '.[http,hue,mpd,chromecast]' ``` - From `requirements.txt`. The file reports the core required dependencies as uncommented lines, and optional dependencies as commented lines. Uncomment the dependencies you need for your integrations and then from the Platypush source directory type: ```shell cd /your/path/to/platypush [sudo] pip install -r requirements.txt ``` - Manually. The official documentation reports the dependencies required by each integration and the commands to install them, so an option would be to simply paste those commands. Another way to check the dependencies is by inspecting the `__doc__` item of a plugin or backend through the Python interpreter itself: ```python >>> from platypush.context import get_plugin >>> plugin = get_plugin('light.hue') >>> print(plugin.__doc__) Philips Hue lights plugin. Requires: * **phue** (``pip install phue``) ``` - Through your OS package manager. This may actually be the best option if you want to install Platypush globally and not in a virtual environment or in your user dir, as it helps keeping your system Python modules libraries clean without too much pollution from `pip` modules and it would let your package manager take care of installing updates when they are available or when you upgrade your version of Python. However, you may have to map the dependencies provided by each integration to the corresponding package name on Debian/Ubuntu/Arch/CentOS etc. Configuration ------------- Once we have our dependencies installed, it’s time to configure the plugin. For example, if you want to manage your Hue lights and your music server, create a `~/.config/platypush/config.yaml` configuration file (it's always advised to run Platypush as a non-privileged user) with a configuration that looks like this: ```yaml # Enable the web service and UI backend.http: enabled: True light.hue: bridge: 192.168.1.10 # IP address of your Hue bridge groups: # Default groups that you want to control - Living Room # Enable also the light.hue backend to get events when the status # of the lights changes backend.light.hue: poll_seconds: 20 # Check every 20 seconds music.mpd: host: localhost # Enable either backend.music.mpd, or backend.music.mopidy if you # use Mopidy instead of MPD, to receive events when the playback state # or the played track change backend.music.mpd: poll_seconds: 10 # Check every 10 seconds ``` A few notes: - The list of events triggered by each backend is also available in the documentation of those backends, and you can write your own hooks (either in YAML inside of `config.yaml` or as Python drop-in scripts) to capture them and execute custom logic - for instance, [`backend.light.hue`](https://docs.platypush.tech/en/latest/platypush/backend/light.hue.html) can trigger [`platypush.message.event.light.LightStatusChangeEvent`](https://docs.platypush.tech/en/latest/platypush/events/light.html#platypush.message.event.light.LightStatusChangeEvent). - By convention, plugins are identified by the lowercase name of their class without the `Plugin` suffix (e.g. `light.hue`) while backends are identified by the lowercase name of their class without the `Backend` suffix. - The configuration of a plugin or backend expects exactly the parameters of the constructor of its class, so it's very easy to look either at the source code or the documentation and get the parameters required by the configuration and their default values. - By default, the HTTP backend will run the web service directly through a Flask wrapper. If you are planning to run the service on a machine with more traffic or in production mode, then it's advised to use a uwsgi+nginx wrapper - the [official documentation](https://docs.platypush.tech/en/latest/platypush/backend/http.html) explains how to do that. - If the plugin or the backend doesn't require parameters, or if you want to keep the default values for the parameters, then its configuration can simply contain `enabled: True`. You can now add your hooks and procedures either directly inside the `config.yaml` (if they are in YAML format) or in `~/.config/platypush/scripts` (if they are in Python format). Also, the `config.yaml` can easily get messy, especially if you add many integrations, hooks and procedures, so you can split it on multiple files and use the `include` directive to include those external files (if relative paths are used then their reference base directory will be `~/.config/platypush`): ```yaml include: - integrations/lights.yaml - integrations/music.yaml - integrations/media.yaml - hooks/home.yaml - hooks/media.yaml # - ... ``` Finally, launch the service from the command line: ```shell $ platypush # If the executable is installed in your PATH $ python -m platypush # If you want to run it from the sources folder ``` You can also create a systemd service for it and have it to automatically start. Copy something like this to `~/.config/systemd/user/platypush.service`: ``` [Unit] Description=Universal command executor and automation platform After=network.target redis.service [Service] ExecStart=/usr/bin/platypush Restart=always RestartSec=5 [Install] WantedBy=default.target ``` Then: ```shell systemctl --user start platypush # Will start the service systemctl --user enable platypush # Will spawn it at startup ``` If everything went smooth and you have e.g. enabled the Hue plugin, you will see a message like this on your logs/stdout: ``` Bridge registration error: The link button has not been pressed in the last 30 seconds. ``` As you may have guessed, you’ll need to press the link button on your Hue bridge to complete the pairing. After that, you’re ready to go, and you should see traces with information about your bridge popping up in your log file. If you enabled the HTTP backend then you may want to point your browser to `http://localhost:8008` to create a new user. Then you can test the HTTP backend by sending e.g. a `get_lights` command: ```shell curl -XPOST \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $PP_TOKEN" \ -d '{"type":"request", "action":"light.hue.get_lights"}' \ http://localhost:8008/execute ``` You may also notice that a panel is accessible on `http://localhost:8008` upon login that contains the UI for each integration that provides it. Example for the `light.hue` plugin: ![Example image of a Platypush integration UI](../img/light-hue-ui-1.png) Now you’ve got all the basic notions to start playing with Platypush on your own! Remember that all you need to know to initialize a specific plugin, interact with it and which dependencies it requires is in the official documentation. Stay tuned for the next articles that will show you how to do more with platypush — configuring your voice assistant, control your media, manage your music collection, read data from sensors or NFC tags, control motors, enable multi-room music control, implement a security system for your house with real-time video and audio stream, control your switches and smart devices, turn your old TV remote into a universal remote to control anything attached to platypush, and much more.