# Interpreting Environmental Sensor Data With Local "Edge" LLMs ## Overview ![Line chart showing the temperature data collected from the SEN6X sensor.](https://cdn-learn.adafruit.com/assets/assets/000/139/835/medium800/sensors_temperature_f_plot.png?1758578072 ) This guide documents experiments with using Large Language Models (LLMs) to summarize and provide interesting insights into data collected from an environmental sensor. It is not a fully fleshed out project that is ready to automate all of your environmental needs. It is still early days in the world of local and small LLMs. The goal with this guide is to evaluate different models and methods to find what current possibilities are, and see what kinds of things work and don't work. The experiments are fully open source. Code used to collect data, format it, and the prompts used are all made available. Do you know a model that is better for this type of task, or have ideas for better ways to prompt or feed data into the models? Feel free to reach out and share your own findings. These experiments were conducted with the[SEN6x environmental sensor](https://www.digikey.com/en/product-highlight/s/sensirion/environmental-sensor-node-sen6x), and accompanying [Adafruit SEN6x Breakout](https://www.adafruit.com/product/6331). The general principles of this experiment could of course be re-created or expanded upon with any other sensors that you have handy. ## Parts The SEN6X environmental sensor is not stocked by Adafruit. You can buy it from authorized distributors. Below is a link to the sensor available at DigiKey. You'll want the sensor (SEN66), not the development kit. ### [SEN6x Environmental Sensor Node from DigiKey](https://www.digikey.com/en/product-highlight/s/sensirion/environmental-sensor-node-sen6x) Other parts from Adafruit: ### Raspberry Pi 5 - 8 GB RAM [Raspberry Pi 5 - 8 GB RAM](https://www.adafruit.com/product/5813) The Raspberry Pi 5 is the newest Raspberry Pi computer, and the Pi Foundation knows you can always make a good thing _better_! And what could make the Pi 5 better than the 4? How about a _faster_ processor, USB 3.0 ports, and an updated Gigabit Ethernet chip... In Stock [Buy Now](https://www.adafruit.com/product/5813) [Related Guides to the Product](https://learn.adafruit.com/products/5813/guides) ![Angled shot of green Raspberry Pi microcontroller.](https://cdn-shop.adafruit.com/640x480/5813-01.jpg) ### Adafruit SEN6x Breakout for Sensirion SEN66 - STEMMA QT / Qwiic [Adafruit SEN6x Breakout for Sensirion SEN66 - STEMMA QT / Qwiic](https://www.adafruit.com/product/6331) Now you can quickly integrate the [Sensirion SEN6x environmental sensor node](https://blog.adafruit.com/2025/05/08/eye-on-npi-sensirion-sen66-environmental-sensor-node-eyeonnpi-digikey-digikey-sensirion-adafruit/) into your microcontroller or microcomputer project, with no... In Stock [Buy Now](https://www.adafruit.com/product/6331) [Related Guides to the Product](https://learn.adafruit.com/products/6331/guides) ![Overhead shot of SEN6 breakout board connected to a microcontroller and a Sensirion sensor.](https://cdn-shop.adafruit.com/640x480/6331-06.jpg) ### Adafruit Pi Stemma QT Breakout for Raspberry Pi and Compatibles [Adafruit Pi Stemma QT Breakout for Raspberry Pi and Compatibles](https://www.adafruit.com/product/6365) The **Adafruit Pi Stemma** is a small, easily removable breakout that easily adds a 4-pin JST SH pin (Stemma QT or [Qwiic](https://www.adafruit.com/?q=qwiic)) connector to your Raspberry Pi. The 2x3 socket design allows you to plug securely into the Pi's I2C bus... In Stock [Buy Now](https://www.adafruit.com/product/6365) [Related Guides to the Product](https://learn.adafruit.com/products/6365/guides) ![Demo Shot of the Adafruit Pi Stemma QT Breakout connected to the Raspberry Pi and then connected to the BMP280 Pressure Sensor via a Stemma Cable.](https://cdn-shop.adafruit.com/640x480/6365-04.jpg) ### Official Raspberry Pi 5 Active Cooler [Official Raspberry Pi 5 Active Cooler](https://www.adafruit.com/product/5815) The **Raspberry Pi 5 Active Cooler** is compatible with the [Raspberry Pi 5](https://www.adafruit.com/search?q=raspberry+pi+5) and the [Raspberry Pi 5 Case](http://www.adafruit.com/product/5816). Designed for anyone who wants to push the performance of their... In Stock [Buy Now](https://www.adafruit.com/product/5815) [Related Guides to the Product](https://learn.adafruit.com/products/5815/guides) ![Angled shot of a cooling fan installed on a green microcontroller.](https://cdn-shop.adafruit.com/640x480/5815-04.jpg) ### Official Raspberry Pi 45W USB-C Power Supply [Official Raspberry Pi 45W USB-C Power Supply](https://www.adafruit.com/product/6320) If you want a general-purpose USB Power Delivery supply, the official Raspberry Pi 45W USB-C power supply makes for a good quality PD supply that provides high current at a large option of voltages, including 12V which is not always supported, and 5A and 5V which also is a bit rare but makes... In Stock [Buy Now](https://www.adafruit.com/product/6320) [Related Guides to the Product](https://learn.adafruit.com/products/6320/guides) ![Angled Shot of the Official Raspberry Pi 45W USB-C Power Supply.](https://cdn-shop.adafruit.com/640x480/6320-03.jpg) # Interpreting Environmental Sensor Data With Local "Edge" LLMs ## Pi & Blinka Setup ## Raspberry Pi OS Setup First, get the latest release of Raspberry Pi OS installed on your Pi and update all of the built-in software with apt. If you are comfortable with the Raspberry Pi imaging and setup process, you can follow the steps listed [here under the quick start prerequisites](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/installing-circuitpython-on-raspberry-pi#prerequisite-pi-setup-3106227). If you'd like more details, a more [thorough guide page can be found here.](https://learn.adafruit.com/adafruit-voice-bonnet/raspberry-pi-setup) ## Virtual Environment This project will require installing several different Python libraries into the same virtual environment. You must always be sure to activate the environment before installing libraries or running the scripts that use them. I've used a venv at `~/venvs/sensor_llm_venv/`. Subsequent guide pages and instructions will all use the same venv created here. Use the exact same one if you want to follow along by copy/pasting commands or note the name of your own venv and substitute when appropriate. Here are the commands to create, then activate a virtual environment. ```terminal cd ~ sudo apt install python3-venv python3 -m venv ~/venvs/sensor_llm_venv --system-site-packages source ~/venvs/sensor_llm_venv/bin/activate ``` ## Blinka Setup The Blinka setup process is documented [on this guide page](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/installing-circuitpython-on-raspberry-pi). Refer to it if you've never done the process before. For this guide I used the [automated install instructions](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/installing-circuitpython-on-raspberry-pi#automated-install-3081632) from that page. Install Blinka with these commands. ```terminal source ~/venvs/sensor_llm_venv/bin/activate cd ~ pip3 install --upgrade adafruit-python-shell wget https://raw.githubusercontent.com/adafruit/Raspberry-Pi-Installer-Scripts/master/raspi-blinka.py sudo -E env PATH=$PATH python3 raspi-blinka.py ``` At the end of the install it will prompt for Y/N to reboot the Pi. Press 'Y' and enter to go ahead with the reboot. ## SEN6x Setup & Test If you are using a different sensor, then refer to the guide or documentation for your device to get it setup and make sure it can successfully get data readings. ### Wiring Connect the SEN6x breakout to the Raspberry Pi 5 via I2C pins, and connect the SEN6x node to the breakout with the 6 pin JST GH cable. - **Pi 3V** to **breakout** **VIN (red wire)** - **Pi GND** to **breakout**  **GND (black wire)** - **Pi SCL** to **breakout**  **SCL (yellow wire)** - **Pi SDA** to **breakout**  **SDA (blue wire)** - **SEN66 sensor** to **breakout JST GH port** The [Adafruit Pi Stemma QT Breakout](https://www.adafruit.com/product/6365) makes it easy to connect the the SEN6x breakout using a standard [STEMMA QT cable](https://www.adafruit.com/product/4210). ![Raspberry Pi 5 connected to SEN6x breakout via I2C interface](https://cdn-learn.adafruit.com/assets/assets/000/139/781/medium640/temperature___humidity_sensors_piStemma_bb.jpeg?1758299280) ![Raspberry Pi 5 connected to SEN6x breakout on a bread board via I2C interface](https://cdn-learn.adafruit.com/assets/assets/000/139/782/medium640/temperature___humidity_sensors_piBB_bb.jpeg?1758299298) ![Raspberry Pi 5 connected to SEN6x breakout via I2C interface with a STEMMA QT cable and the Adafruit Pi Stemma QT Breakout for Raspberry Pi.](https://cdn-learn.adafruit.com/assets/assets/000/139/783/medium640/temperature___humidity_pi5_connected_sen6x.png?1758299349) ## Python Installation of SEN6x Library Activate the same virtual environment created in the Blinka Setup step if it is not already active. From your command line run the following command: - `pip3 install adafruit-circuitpython-sen6x` If your default Python is version 3 you may need to run '`pip`' instead. Just make sure you aren't trying to use CircuitPython on Python 2.x, it isn't supported! ## Verify Sensor Data Readings Test that everything is setup properly with the following script, or a similar one modified for your sensor if you're using something other than the SEN6x. https://github.com/adafruit/Adafruit_CircuitPython_SEN6x/blob/main/examples/sen6x_simpletest.py The sensor takes several seconds to initialize and start giving readings for all of the different values. After a moment you should be seeing outputs similar to below being printed in your terminal. If you see zeros for some values, wait a few moments longer. If you see an exception traceback or have some other problem running the demo script, stop and troubleshoot that before moving on to the next pages. ![Screenshot of SEN6x demo script output showing temperature, humidity, PM2.5, VOC, NOx, and CO2 reading values.](https://cdn-learn.adafruit.com/assets/assets/000/139/784/medium800/temperature___humidity_sen6x_example_output.png?1758300046 ) # Interpreting Environmental Sensor Data With Local "Edge" LLMs ## Ollama Setup ![Screenshot of ollama.com webpage with llama logo and the text "Get up and running with large language models"](https://cdn-learn.adafruit.com/assets/assets/000/139/604/medium800/raspberry_pi_ollama_page.png?1757516537 ) [Ollama](https://ollama.com/) is an inference engine, which is a tool for managing and running local LLMs. It also provides a Python library for interacting with local LLMs, allowing them to be integrated into projects. Ollama runs on different hardware and operating systems (OS) including Mac, Windows, and Linux. Ollama supports [many different models](https://ollama.com/search), but the majority of them are made for running on fancy GPUs and higher powered computers than the Raspberry Pi. However, there are some that are small enough to work on the Raspberry Pi 5. ## Install Ollama To install Ollama, download and run the shell script from [ollama.com/download](https://ollama.com/download). ![Ollama downloads page showing the command to download and install the program](https://cdn-learn.adafruit.com/assets/assets/000/139/560/medium800/raspberry_pi_ollama_download.png?1757366169 ) ```terminal curl -fsSL https://ollama.com/install.sh | sh ``` On a Raspberry Pi 5, the process takes 3-5 minutes or longer for slower networks. During installation, it will print messages regarding the steps being taken and progress as well as a warning about not finding a GPU. ![Terminal output from running the Ollama install script](https://cdn-learn.adafruit.com/assets/assets/000/139/561/medium800/raspberry_pi_pi_ollama_install_complete.png?1757366488 ) After it is finished, verify that that Ollama installed successfully by running the help command: ```terminal ollama -h ``` ![Ollama help command output](https://cdn-learn.adafruit.com/assets/assets/000/139/562/medium800/raspberry_pi_pi_ollama_help.png?1757366676 ) ## Install Ollama Python Bindings Library Activate the same virtual environment created in the steps on the [Pi & Blinka Setup page](https://learn.adafruit.com/interpreting-environmental-sensor-data-with-llms/pi-blinka-setup) if it is not already active. Next, install `ollama` with pip using this command. ```terminal source ~/venvs/sensor_llm_venv/bin/activate pip install ollama ``` For more detailed instructions, and a demo script to verify the installation worked see the [Python Integration page in the Local LLMs on Raspberry Pi guide](https://learn.adafruit.com/local-llms-on-raspberry-pi/ollama-python-integration). # Interpreting Environmental Sensor Data With Local "Edge" LLMs ## Collect Data It's time to start collecting some data. This project uses the [`SQLAlchemy`](https://pypi.org/project/SQLAlchemy/) Python library to conveniently and efficiently store data in a [SQLite database](https://en.wikipedia.org/wiki/SQLite). Once data is collected in the database it can be queried from specified rooms, time ranges, or sensor types and exported into various formats. That makes it easy to experiment with how much, and what formats of data, are given to the LLMs. ## Install SQLAlchemy Activate the same virtual environment created in the steps on the [Pi & Blinka Setup page](https://learn.adafruit.com/interpreting-environmental-sensor-data-with-llms/pi-blinka-setup) if it is not already active. Next, install `SQLAlchemy` with pip using this command. ```terminal source ~/venvs/sensor_llm_venv/bin/activate pip install SQLAlchemy ``` ## Database & Table Setup The database must be initialized and have its table defined before it can start accepting records to store. To do that with SQLAlchemy requires writing something called a "Model" class, which is just a way of listing out what fields will be stored and the types of data that they will contain.  The following script defines a `SensorReading` model to store the data values that will be read from a SEN6x sensor and when run from the terminal it ill initialize a database and table from the `SensorReading` class. If you're using a different sensor you may need to add, remove, or tweak fields to suite the data from your sensor. When the model is set as needed run the script with this command to initialize the database. ```terminal python db_models.py ``` https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/Raspberry_Pi_LLM_Sensor_Data/db_models.py It will output the SQL command used to create the table, and other logging information. If successful it will create the file **sensor\_data.db**. ## Taking Readings & Storing Data SQLAlchemy makes it easy to insert new records into the database. Simply get a session for the DB, then create an instance of the `SensorReading` class setting each field to a data value taken from a sensor, `add()` the record to the database, and then `commit()` the changes to save it into the database file. The following script will initialize the DB session and SEN6x sensor and then run a loop that takes readings and stores them in the database once per minute by default. The `INTERVAL` variable can be changed in order to collect data at intervals other than 1 minute. The `ROOM_NAME` variable is a string that will be stored in database and associated with each reading. Change it to whatever room you plan to keep the sensor in. Save the file as **take\_sensor\_readings.py** run it with the this command. ```terminal python take_sensor_readings.py ``` https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/Raspberry_Pi_LLM_Sensor_Data/take_sensor_readings.py ## Running in the Background Running this script normally with `python` will result in it running in the foreground in the terminal that launched it. If the terminal is closed or the user logs out, the script will end and won't keep taking sensor readings.  If you want to keep this sensor running over a longer period of time, it is convenient to have it launch automatically and run in the background. That way it will run anytime the Pi is powered on, whether or not a user is actively logged in. Linux has a utility called `systemctl` that is used to set up automated programs running in the background. It comes installed by default in Raspberry Pi OS. `systemctl` is configured by creating a **.service** file inside of `/etc/systemd/system/`. This **sensor-reading.service** file is configured for the following: - Linux username: `pi` - Project code directory: `/home/pi/RaspberryPi_LLM_Sensor_Data/` - Python virtual environment located at: `/home/pi/venvs/sensor_llm_venv/` If any of these values differ for you, then you will need to update the relevant parts of the config file to include the proper username, project code directory, and python virtual environment locations for your setup. Use nano to create the file, then paste the configuration into it. ```terminal sudo nano /etc/systemd/system/sensor-reading.service ``` https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/Raspberry_Pi_LLM_Sensor_Data/sensor-reading.service It's easier to launch a shell script with `systemctl` then it is to launch a Python script inside of a specific virtual environment. The following **start\_service.sh** file will move to the appropriate directory, activate the virtual environment, and launch the sensor reading python script. Again, you will need to update the directories in this file if you have a different username, or stored the project or virtual environment in different locations. https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/Raspberry_Pi_LLM_Sensor_Data/start_service.sh Once the config and shell script are in place, enable and start the service with these commands: ```terminal sudo systemctl daemon-reload sudo systemctl enable sensor-reading.service sudo systemctl start sensor-reading.service ``` A tool called `journalctl` can be used to verify that the script is running successfully. ```terminal journalctl -e -u sensor-reading.service ``` This command will show output or error messages that come from the shell or Python scripts being launched by the service. If everything is working properly you'll see sensor readings being printed out. Press the `q` key to exit. ```terminal Sep 22 08:42:31 raspberrypi your-service-name[779]: <SensorReading(room='RoomC', datetime='2025-09-22 13:42:31.173043', temp_c=20.925, humidity=65.98)> Sep 22 08:42:31 raspberrypi your-service-name[779]: Temperature: 20.9°C Sep 22 08:42:31 raspberrypi your-service-name[779]: Humidity: 66.0% Sep 22 08:42:31 raspberrypi your-service-name[779]: PM2.5: 3.8 µg/m³ Sep 22 08:42:31 raspberrypi your-service-name[779]: VOC Index: 31.0 Sep 22 08:42:31 raspberrypi your-service-name[779]: NOx Index: 1.0 Sep 22 08:42:31 raspberrypi your-service-name[779]: CO2: 422.0 ppm Sep 22 08:42:31 raspberrypi your-service-name[779]: ---------------------------------------- Sep 22 08:43:31 raspberrypi your-service-name[779]: <SensorReading(room='RoomC', datetime='2025-09-22 13:43:31.309236', temp_c=20.925, humidity=65.98)> Sep 22 08:43:31 raspberrypi your-service-name[779]: Temperature: 20.9°C Sep 22 08:43:31 raspberrypi your-service-name[779]: Humidity: 66.0% Sep 22 08:43:31 raspberrypi your-service-name[779]: PM2.5: 3.8 µg/m³ Sep 22 08:43:31 raspberrypi your-service-name[779]: VOC Index: 31.0 Sep 22 08:43:31 raspberrypi your-service-name[779]: NOx Index: 1.0 Sep 22 08:43:31 raspberrypi your-service-name[779]: CO2: 421.0 ppm ``` # Interpreting Environmental Sensor Data With Local "Edge" LLMs ## Format Data & Prompt LLMs Once the data collector has been running for a while, it's time to start prompting the LLMs to analyze and summarize it. There is one final hurdle to overcome: the LLMs in use process text input only, they cannot operate directly on the SQLite database. There are many possible ways that the data could be formatted and fed into the model prompt. I chose to use comma separated values (CSV) because it's relatively simple, compact in size, and text based. The Python script below handles everything by carrying out these high level tasks: - Query data out of the database using the given room name and date range. - Structure the data as CSV and write it to a file. - Substitute the CSV data into the prompt template. - Send the final prompt to the selected model and stream it's output to the console. The prompt script relies on both `sqlalchemy` and `ollama` Python libraries. Their setup is detailed on the [Collect Data](https://learn.adafruit.com/interpreting-environmental-sensor-data-with-llms/collect-data) and [Ollama Setup](https://learn.adafruit.com/interpreting-environmental-sensor-data-with-llms/ollama-setup) pages. ## Configuration There are a handful of variables near the top of the script that can be used to configure the behavior of the database query and LLM prompt. - `DATABASE_URL` - The path to the SQLite database file to query from. All code included in this project uses **sensor\_data.db**. - `MODEL` - The model name to pass to ollama. These are the same ones used with the `ollama run` command. For example: `gemma3:270m`, `gemma3:1b`, `qwen3:0.6b`, or `alibayram/smollm3:latest` - `ROOM` - The room name to query data for. This should match the value used in **take\_sensor\_readings.py**. - `QUERY_START` - A `datetime` object to use as the beginning of the query window. The default value `None` will use 24 hours ago. - `QUERY_END` - A `datetime` object to use as the end of the query window. The default value `None` will use now. - `SAMPLE_RATE` - What interval of time to use when pulling data from the database. By default  **take\_sensor\_readings.py** saves one reading per minute. This is likely more readings than are needed, and the small models we are testing have limited context windows so it's good to pare down the data to the smallest amount we reasonably can before prompting the LLMs with it. The default `SAMPLE_RATE` value is `30` which means it will query for readings that are 30 minutes apart. The best value to use will depend on how much data has been collected and whether you are interested in acute environmental conditions, or trends over a longer period of time. - `PROMPT` - The prompt template that data will be inserted into and then sent to the LLM to process. By default the prompt asks the model for a general summary of the data including key patterns, insights and trends. You could try experimenting by asking about specific reading types or provide specific patterns of interest to look for.  ## Run Prompt Script Activate the same virtual environment created in the steps on the [Pi & Blinka Setup page](https://learn.adafruit.com/interpreting-environmental-sensor-data-with-llms/pi-blinka-setup) if it is not already active. Once all the configuration values are set run the script with this command. ```terminal python prompt_llm_for_summary.py ``` https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/Raspberry_Pi_LLM_Sensor_Data/prompt_llm_for_summary.py Be patient, it can take several minutes for the model to fully process all of the input and generate its response.  The script will stream the response back once the model starts writing it, but it will appear stuck or frozen for multiple minutes before that while it's crunching the input. Most models took 5-8 minutes on the Raspberry P 5 with 8gb RAM, but some were longer. See the results page for details about how long each model took during our experiments. # Interpreting Environmental Sensor Data With Local "Edge" LLMs ## LLM Results This page shows the results generated by various models as well as some notes and observations about them. Unless noted otherwise, all tests were performed on a Raspberry Pi 5 with 8gb RAM. The primary experiments were run on a dataset that included 133 records each taken 30 minutes apart and included datetime, temperature, humidity, PM2.5, VOC, NOX, and CO2. The results are grouped into 3 categories: - [Context Troubles](https://learn.adafruit.com/interpreting-environmental-sensor-data-with-llms/llm-results#context-troubles-3207766) - Early experiments, failures to learn from. - [Context Reminder](https://learn.adafruit.com/interpreting-environmental-sensor-data-with-llms/llm-results#context-reminder-3207776) - Tests run with a modified prompt that placed key info and instructions after the data. - [Big Models](https://learn.adafruit.com/interpreting-environmental-sensor-data-with-llms/llm-results#big-models-3207781) - The same experiment run on larger models requiring network access, or more powerful hardware. ## Context Troubles These first few results highlight a limitation of the very small models: they can only keep so much information in context at once. In these tests the data came after the instructions in the prompt. The 133 data points tested proved to be too much for the models to handle. The models seem to have forgotten key parts of the prompt instructions that came before the data. They resort to trying to figure out what the data could be from, asking for more details, or making stuff up. The prompt template for this set of tests is below. ```auto Analyze the following environmental sensor data. Provide a summary of its content, identify key patterns or insights, and suggest potential further analysis or questions based on this data. The data fields are: - UTC Datetime - Temperature in degrees F - Humidity percent - pm2.5 in µg/m³ - VOC index - NOx index - CO2 in ppm Data: --- {csv_data} --- ``` ### gemma:1b Took about 5 minutes to process the input and generate the full response.  ```auto Okay, let's analyze the data you provided. It looks like you're giving me a sequence of time intervals, likely representing measurements of some kind. Here’s a breakdown of what we can observe: **Observations & Potential Interpretation** 1. **Time Intervals:** The data consists of `[time_interval1, time_interval2, ...]`. The `time_interval` seems to be in seconds. 2. **Values:** Each `time_interval` contains a numerical value. It looks like the values are relatively small and consistent, indicating a measure of some kind of phenomenon. 3. **Possible Interpretations (Based on the Context):** * **Sensor Readings:** The most probable interpretation is that these values represent readings from sensors. Each interval could represent a particular time point and associated measurement. * **Process Tracking:** These intervals could be intervals during a process. For example, if the intervals represent times when a certain event occurs, each measurement might be related to the event. * **Data Points:** They could represent a series of data points collected over time. **To help me understand this better and potentially provide more useful insights, could you tell me:** * **What kind of data is this?** (e.g., temperature readings, wind speed, pressure, light intensity, etc.)? * **What is the context of this data?** (e.g., what is being measured, what is the purpose of collecting this data?) ``` ### qwen3:0.6b It forgot the context of the data, but did seem to realize that it didn't have enough information and asked for more. It took 5-6 minutes total to process the data and generate the response. ```auto <think> Okay, let me try to figure out what the user is asking here. They provided a long text that seems to be a series of data points or some kind of structured information. The user's query is to "Analyze the data and provide some insights." But the text is a mix of dates, times, numbers, and maybe some patterns. First, I need to check if there's any specific analysis they want. The text looks like a list of entries, each starting with a date and time, followed by some numerical values. Maybe they're looking to find trends, correlations, or patterns in the data over time. Since the user mentioned "analyze," I should ask them to clarify what kind of analysis they need, like correlation, trends, or anything else. But wait, the original text is in a format that's hard to parse. Each line seems to have a date, time, and some values. Maybe they're providing a dataset that needs analysis. However, without more context, it's hard to tell. The user might be a student or researcher needing to process this data for a report, exam, or project. They might need help interpreting the data, such as checking for anomalies, identifying trends, or correlating variables. I should respond by asking them to specify the type of analysis they want, like correlation, time trends, or anything else. Also, offer to help with any specific aspects they have in mind. That way, I can provide the necessary assistance based on their needs. </think> To help you analyze the data, could you clarify what specific insights you need? For example: - Are you looking for trends over time? - Are you trying to identify patterns or correlations? - Do you want to check for anomalies or correlations with other variables? Let me know, and I'll assist accordingly! ``` ### smollm3 The smollm3 model took by far the longest to process the input and produce a result, about 23 minutes total. It was the longest output produced of all models tested as well. It did a little better than the other models at remembering the original instructions that came before the data. But it did completely hallucinate several key aspects during its summary, falsely claiming the data covered a full year, mixing up temperature units between C and F, and ignored all data types except for temperature. ```auto <think> Okay, let's see what I need to do here. The user provided a dataset of temperatures recorded over several days and wants me to analyze it. They mentioned looking for patterns or trends in the data. First, I'll start by understanding the structure of the data. Each row represents a day with specific temperature readings at different times. There are columns for date (formatted as "YYYY-MM-DD"), time (in 24-hour format), and temperature (in degrees Celsius). Looking at the dates, they seem to be in chronological order from January 1st to December 31st of some year. The temperatures vary each day, so I need to check if there's a consistent pattern or if certain days have higher/lower temperatures. I notice that on most days, the temperature peaks around midday (e.g., 12:00 PM) and then decreases in the evening. For example, on January 1st, the highest temperature was recorded at noon with 61°C, followed by a drop to 58°C at midnight. Similarly, other days show similar patterns where temperatures are higher during the day and cooler at night. Another observation is that there might be some variation between weekdays (Monday to Friday) and weekends (Saturday and Sunday). For instance, on Monday, the highest temperature was recorded in the morning with 60°C, while on Saturday it was around noon. This suggests that maybe the data collection method or environmental factors change slightly during these periods. I also see that there are some days where temperatures don't follow a clear pattern, like January 3rd and January 5th, which have lower temperature readings at different times. These might be anomalies or unusual weather conditions for this location. To further analyze the data, I could calculate the average daily maximum and minimum temperatures to understand the overall range of temperatures over time. Additionally, plotting these temperatures against date or time could help visualize any trends or seasonal patterns. Another approach is to check if there are any correlations between temperature readings at different times of day. For example, does a higher temperature in the morning correlate with lower temperatures later in the day? Or vice versa? I should also consider possible external factors that might influence the temperature readings, such as weather events (e.g., storms), changes in local geography affecting wind patterns, or shifts in human activity levels. In summary, the key steps would be to: 1. Analyze daily maximum and minimum temperatures. 2. Plot temperature data over time to identify seasonal trends. 3. Examine variations between weekdays and weekends. 4. Investigate correlations between different times of day. 5. Consider external factors affecting temperature readings. 6. Identify any anomalies or unusual patterns in the data. By following these steps, I can gain insights into the temperature behavior at this location over time and determine if there are consistent trends or if certain days have unique characteristics. </think> ### Analysis of Temperature Data (January 1 to December 31) #### **Overview** The dataset contains daily temperature records from January 1 to December 31, with readings recorded every hour. The data spans a full year, providing insights into seasonal and diurnal patterns. --- #### **Key Observations** 1. **Diurnal Cycle**: - Temperatures typically peak in the afternoon (12:00 PM) and drop at night. - Example: On January 28th, temperatures reached 61°C at noon before dropping to 58°C by midnight. 2. **Seasonal Trends**: - Higher maximum temperatures are observed during spring and summer months (March–August). - Lower maximum temperatures occur in autumn and winter (September–December), with the lowest readings typically occurring overnight. - Example: On January 1st, the highest temperature was 60°C at noon, while on December 31st, it was 58°C. 3. **Weekday vs. Weekend Differences**: - Weekdays often show higher maximum temperatures in the morning (e.g., 61°C on a Monday). - Weekends tend to have lower maxima later in the day (e.g., 59°C on a Saturday at noon). 4. **Anomalies and Variability**: - Some days, such as January 3rd or December 5th, exhibit unusual temperature patterns without clear diurnal variation. - Days like January 28th show significant fluctuations between morning and evening readings. --- #### **Statistical Summary** - **Maximum Temperatures (°C)**: - Average: ~58.0°C - Range: 46–61°C - **Minimum Temperatures (°C)**: - Average: ~45.5°C - Range: 40–62°C --- #### **Correlation Analysis** - **Time of Day**: - Maximum temperatures are most consistently observed in the afternoon. - Minimum temperatures occur overnight, with some exceptions. - **Seasonal Correlations**: - Higher maximums correlate with warmer months (March–August). - Lower maxima and minimums align with cooler seasons (September–December). --- #### **External Factors** - **Human Activity**: No apparent impact from human activity on temperature readings. - **Weather Events**: No storms or extreme weather events evident in the data. - **Geographic Features**: The location appears to be a flat, open area without significant topography affecting wind patterns. --- #### **Visualizations** 1. **Daily Temperature Plots**: - Show peaks at noon and valleys overnight, with seasonal shifts. 2. **Seasonal Trends**: - Maximum temperatures increase from January (46°C) to August (62°C), then decrease gradually. 3. **Weekday/Weekend Comparison**: - Weekdays have slightly higher maxima in the morning; weekends show lower maxima later. --- #### **Conclusion** The data reveals a clear diurnal and seasonal pattern, with temperatures peaking during the day and dropping at night. There is no evidence of significant human impact or external weather events affecting the readings. The temperature range spans 15°C (46–61°C), indicating moderate climate variability for this location. **Recommendations**: - Continue monitoring to identify long-term trends. - Investigate potential causes for anomalies like January 3rd and December 5th. - Explore correlations between different times of day or seasonal shifts. ``` ## Context Reminder From the above results it was clear I was attempting to give too much data to the model. I did trials with smaller datasets of 24 and 48 data records and the models do perform better in their attempts to summarize the data. More experiments could be performed to find the sweet spot of how much data to give to any specific model. But I also wanted to experiment with other ways to work around this limitation to see what kinds of results are possible even with the same sized dataset. For all remaining tests I used this updated prompt template which moved the data field descriptions to after the data and added an additional short reminder of the instructions at the end of the prompt. With this approach, I assume that the model is forgetting the earliest data in the prompt, just like it was with the instructions before. But it does allow the models to output passable summaries that do contain some correct facts and details about some of the data, so it is an improvement. ```auto Analyze the following environmental sensor data. Provide a summary of its content, identify key patterns or insights, and suggest potential further analysis or questions based on this data. Data: --- {csv_data} --- The data fields are: - UTC Datetime - Temperature in degrees F - Humidity percent - pm2.5 in µg/m³ - VOC index - NOx index - CO2 in ppm Please summarize the data, identify key patterns, insights, or trends. ``` ### qwen3:0.6b Took 7 minutes total to process input and generate output. It correctly identified the time frame of the data, but did still hallucinate several things like CO2 levels consistently increasing. CO2 levels in the data set rise and fall a few times which correlated to a car pulling into the garage near where the sensor was located. It tries to draw conclusion about climate impact even though it identified the very limited sample size of only about 3 days worth of data.  ```auto <think> Okay, let me try to figure out what the user is asking here. They provided a dataset with multiple columns: UTC datetime, temperature, humidity, PM2.5, VOC index, NOx, and CO2. The task is to summarize the data, identify key patterns, and maybe find trends or insights. First, I need to look at the data fields. The UTC datetime seems to be the time when the data is collected. The temperature is in Fahrenheit, so that's a temperature measurement. Humidity is a percentage, so that's a humidity level. PM2.5 is in micrograms per cubic meter, which is a pollution index. VOC and NOx are also given, along with CO2. Now, summarizing the data. Maybe I should check if there's any obvious patterns. For example, if PM2.5 is increasing over time, that would be a trend. Or if there's a correlation between VOC and NOx, that could be a key pattern. Also, looking at the CO2 levels, maybe they are increasing, which could be important for environmental monitoring. Looking at the VOC index. If that's a pollutant, maybe there's a trend in concentration. Similarly, NOx could indicate air quality. CO2 levels might be a good indicator of climate change. Wait, the user said to identify patterns and insights. So maybe I should mention that there's a correlation between PM2.5 and CO2, which could be related to climate change. Also, the VOC index could show pollution levels. For the NOx, that's nitrogen oxides, which are important pollutants. I should also check if there are any anomalies or outliers. For example, if PM2.5 is unusually high, that might indicate a problem. But since the user is asking for patterns, maybe I should focus on the trends without outliers. Another thing to consider is the time frame. The data starts from 2025-09-16 and goes up to the latest date. So maybe the data is collected over time, and there's a growing trend in CO2. Also, the PM2.5 could be increasing, which might be linked to climate change. I need to make sure I'm not missing any key patterns. For example, if the VOC index is increasing, that could mean pollution is rising. Also, NOx and CO2 levels might be indicating that air quality is deteriorating. Putting it all together, the summary would highlight these trends: increasing CO2, rising PM2.5, increasing VOC and NOx levels, and potential correlations with air quality and climate change. That should cover the user's request. </think> Here's a summary of the data: ### Key Patterns and Insights: 1. **CO2 Trends**: - CO2 levels are consistently increasing over time, indicating a growing climate impact. This trend suggests potential environmental changes, though precise timing and scale are not fully captured. 2. **PM2.5 and Climate Change**: - PM2.5 values (micrograms/m³) are rising, which aligns with climate change drivers like increased industrial emissions. This could highlight urbanization or technological changes affecting air quality. 3. **Pollution Indicators**: - **VOC Index**: Increasing pollution levels reflect elevated anthropogenic emissions, indicating urbanization or industrial activity. - **NOx Index**: Elevated NOx levels (nitrogen dioxide) further underscore air quality deterioration, likely due to vehicle emissions or industrial processes. 4. **Temporal Trends**: - The data spans from 2025-09-16 to the latest, showing a gradual progression of pollution metrics. While some patterns (e.g., CO2 growth) are consistent, others (e.g., PM2.5) may require further data resolution for clarity. ### Summary: The data highlights a progression in air quality pollutants, with rising CO2 and PM2.5 levels linked to climate change. VOC and NOx trends suggest environmental degradation, while CO2 trends point to climate impacts. These patterns indicate a possible link between pollution and environmental change, though more detailed data may refine the conclusions. ``` ### gemma3:1b This was the best result with a data set this size generated by any of the small models running on the Pi. It correctly highlighted some of the trends in the data, and even made a correct guess at vehicle exhaust as a potential source for some of the readings. It seems to have silently converted all temperatures to Celsius units and used that for the output which is a little odd, the data contained temperature in Fahrenheit only. ```auto Okay, here's a summary and analysis of the provided data, broken down into key observations: **1. Overall Trends:** * **Temperature & Humidity Correlation:** There’s a strong positive correlation between temperature and humidity. As temperature increases, humidity generally increases. This is a fairly consistent pattern across the dataset. * **VOC & CO2 Spike:** There's a noticeable spike in VOC (Volatile Organic Compounds) and CO2 levels, especially around the evening/night hours. This suggests potential events or conditions contributing to these increases. The magnitude of these spikes varies significantly. * **Time of Day Variations:** The data seems to have diurnal variations, with higher values generally occurring during the day (especially after the 12:00 PM mark). There’s a very slight (and perhaps subtle) increase in the evening hours. **2. Specific Observations & Patterns:** * **Temperature and Humidity Peaks:** The data shows periods of high temperatures and humidity, frequently within a few hours of each other. This suggests a period of elevated environmental conditions. * **VOC Spike - Timing is Key:** The most significant increase in VOC is concentrated between 12:00 PM and 6:00 PM. This strongly indicates a potential link between increased outdoor activity and increased emissions. * **Temperature and Humidity Correlation – Consistent Trend:** The temperature and humidity fluctuate around a relatively stable baseline (around 22-28°C), suggesting a thermal equilibrium. **3. Potential Insights & Questions:** * **Event Correlation:** Given the spike in VOC and temperature during the day, we could investigate if there’s a link between these conditions and specific events (e.g., increased traffic, construction, outdoor gatherings). * **Climate Influence:** The correlations suggest a potential influence of climate patterns on air quality. Long-term trends in temperature and humidity could be driving these observations. * **Source of VOC:** Understanding the sources of the VOC is critical. Are these from industrial emissions, vehicle exhaust, natural sources (vegetation, soil), or something else? * **Spatial Variation:** While the data is spread out, it’s important to understand *where* the peaks are occurring. Are they localized to certain areas or regions? **4. Recommendations for Further Analysis** * **Time-Series Analysis:** A time-series analysis would help reveal underlying patterns and trends in the data. * **Correlation Analysis:** Statistical correlation analysis could be done to understand the strength and significance of the relationships between temperature, humidity, VOCs, and CO2. * **Source Identification:** A more detailed investigation of the VOC sources would be needed to fully understand the impact of those spikes. * **Geographic Mapping:** Mapping the location of these peaks would aid in identifying areas of concern. --- To give a more tailored analysis, I’d need to know the source of this data. Is it a real-time monitoring system, or something else? Knowing the context would allow for a more precise interpretation. ``` ## Big Models These trials were done with larger models that require more powerful hardware than what the Raspberry Pi can provide. I included them for comparison to get an idea of how much better they are than the smaller models in data summarization capabilities. ### gpt-oss:20b [gpt-oss:20b](https://openai.com/index/introducing-gpt-oss/) is one of Open AI's models that supports running locally. This can be done with Ollama just like the ones used on the Raspberry Pi in the rest of this guide, however it requires a more powerful computer with a GPU. My test was performed the following hardware: - Intel i7 CPU - 96gb System RAM - AMD Radeon RX 6950 XT GPU 16gb video RAM It did a pretty good job. Better than the smaller models unsurprisingly, but did still clock in around 5 minutes total to generate the full response which is similar to some of the smaller models. It didn't hallucinate anything obvious. It correctly identified day/night cycle, but does seem slightly confused by the UTC timezone used in the data not matching perfectly with the real day/night cycle from where data was collected in US Central timezone. I suspect that providing it the timezones as part of the prompt or data would improve this, but didn't test. ```auto ## 1. High‑level summary | Period | Avg T (°F) | Min T | Max T | Avg H % | Min H | Max H | Avg PM₂.₅ µg/m³ | Peak PM₂.₅ | Avg VOC index | Avg CO₂ ppm | |--------|------------|-------|-------|----------|-------|-------|------------------|-------------|---------------|-------------| | 17 Sep 2025 | 68.4 | 65.8 | 70.4 | 60.7 | 56.4 | 63.9 | 3.9 | 5.1 | 39.4 | 590 | | 18 Sep 2025 | 69.5 | 65.6 | 70.2 | 59.3 | 56.4 | 65.1 | 3.3 | 4.5 | 38.4 | 466 | * **Temperature:** 65–70 °F throughout the day, with a gentle rise in the morning (≈65 °F) to a peak in late afternoon (~70 °F). * **Humidity:** 56–65 % overall, slightly decreasing as the day progresses. * **PM₂.₅:** Very low (≤ 5 µg/m³) with short‑lived spikes around 4.5–5.1 µg/m³, mainly in the early morning of 17 Sep. * **VOC index:** 36–47, peaking at 47 (17 Sep, 00:28 h). Mostly stable around 38–40. * **NOx index:** Constant 1.0 (likely the instrument’s lower detection limit). * **CO₂:** 400–850 ppm. The highest values (> 800 ppm) occur between 00:00–04:00 on 17 Sep. By 18 Sep, nighttime CO₂ falls to the 530–675 ppm range. --- ## 2. Key patterns & insights | Pattern | Observation | Possible explanation | |---------|-------------|----------------------| | **Diurnal temperature rise** | 65 °F → 70 °F | Sunlight, heating, indoor thermal inertia | | **Humidity drop over day** | 65 % → 56 % | Evaporation, increased ventilation, reduced indoor water sources | | **Morning CO₂ spike (17 Sep)** | 829 ppm at 00:29 → 675 ppm at 00:58 | Possible overnight buildup due to closed windows/poor ventilation; 17 Sep may have had high occupancy or a heat‑pump cycle start | | **Nighttime CO₂ drop on 18 Sep** | 534 ppm at 00:58 | Better ventilation (windows opened) or lower occupancy | | **PM₂.₅ spikes at 4.5–5.1 µg/m³** | 17 Sep 00:28, 18 Sep 08:28/12:28 | Likely indoor combustion (cooking, cleaning) or short bursts of outdoor air infiltration | | **VOC index peak at 47 (17 Sep 00:28)** | 47 | Indoor volatile emissions from cleaning products, new furniture, or HVAC start‑up | | **Strong correlation between CO₂ & VOC?** | Not obvious from visual scan | CO₂ rises with human occupancy; VOCs can also be occupancy‑related (e.g., cooking). A correlation matrix would clarify | | **NOx at the detection limit** | Always 1.0 | Indoor environment; outdoor NOx may be negligible or sensor not sensitive enough | --- ## 3. Suggested next steps / further analysis 1. **Compute daily statistics** * Mean, median, standard deviation, min/max for each sensor per day. * 5‑min rolling averages to smooth noise. 2. **Correlation matrix** * Pearson / Spearman between all variables (T, H, PM₂.₅, VOC, CO₂). * Look for lagged relationships (e.g., CO₂ leading VOC by a few minutes). 3. **Anomaly detection** * Use a simple z‑score or more advanced methods (Isolation Forest) to flag PM₂.₅ and CO₂ spikes. * Identify the exact times and possible triggers (occupancy, HVAC, cooking). 4. **Time‑of‑day profiles** * Group data into hourly bins (00–01, 01–02, …) and compute average values to see typical patterns. * Compare 17 Sep vs 18 Sep to assess day‑to‑day variability. 5. **Occupancy inference** * High CO₂ (> 600 ppm) with low PM₂.₅ may indicate occupied but well‑ventilated spaces. * Combine with temperature/humidity to estimate occupant load. 6. **Ventilation assessment** * Compare CO₂ decay curves after a presumed “ventilation event” (e.g., opening windows). * Estimate air changes per hour (ACH). 7. **Source apportionment** * If VOC data is further detailed (specific compounds), identify likely sources (cleaners, fresh paint, cooking). * Cross‑check with PM₂.₅ to see if both spike simultaneously (combustion source). 8. **Predictive modeling** * Build a simple regression to predict CO₂ based on temperature, humidity, time of day, and occupancy proxy. * Use the model to flag when ventilation is insufficient. --- ## 4. Quick‑look questions for the data owner | Question | Why it matters | |----------|----------------| | **Did you change HVAC settings or open/close windows on 17 Sep?** | Could explain overnight CO₂ surge. | | **Was there any cooking, cleaning, or new furniture in the building around 00:28 h?** | Likely source of PM₂.₅ & VOC spike. | | **Is the CO₂ sensor calibrated?** | The high nighttime values may be sensor drift or poor ventilation. | | **What is the building occupancy schedule?** | Helps interpret CO₂ and VOC patterns. | --- ### Bottom line The environment is generally comfortable: temperatures stay within 65–70 °F, humidity stays moderate, and PM₂.₅ stays below typical indoor limits (< 5 µg/m³). However, there are clear periodic spikes in CO₂ and VOC that suggest ventilation or indoor source issues, especially around midnight on 17 Sep. A deeper statistical analysis (as outlined) will confirm these patterns and help design targeted HVAC or cleaning interventions. ``` ### claude:sonnet4 This was the only model tested that doesn't run locally. It also did a good job and was much faster than all local models. It took less than a full minute to produce the summary output. However, it does have access to high powered hardware in a data center so it's definitely not a level playing field. It did miscount the total readings 120 vs. 133, but correctly identified the time range and reading interval. It also correctly identified correlated data points and min/max values. ```auto Environmental Sensor Data Summary This dataset contains 120 readings from environmental sensors collected over approximately 3 days (September 16-18, 2025), with measurements taken roughly every 30 minutes. Data Overview Time period: September 16, 12:58 AM through September 18, 6:59 PM (UTC) Frequency: ~30-minute intervals Location: Indoor environment (based on temperature stability and CO2 patterns) Key Patterns and Insights Temperature Trends Range: 64.9°F to 70.2°F (relatively narrow 5.3°F span) Clear daily cycles with cooler temperatures overnight (65-67°F) and warmer during day (68-70°F) Peak temperatures typically occur in late afternoon/early evening Gradual warming trend over the 3-day period Humidity Patterns Range: 56.4% to 65.4% Strong inverse correlation with temperature - humidity drops as temperature rises Daily cycles mirror temperature but inverted Generally comfortable indoor humidity levels Air Quality Indicators PM2.5: Consistently good (2.0-5.1 µg/m³, well below 12 µg/m³ WHO guideline) VOC Index: Moderate levels (36-47), showing some variability but no concerning spikes NOx Index: Consistently low (1.0 throughout), indicating minimal nitrogen oxide pollution CO2 Levels (Most Notable Pattern) Range: 393-866 ppm with significant daily fluctuations Daily pattern: Low during day (400-500 ppm), elevated at night (600-800+ ppm) Peak levels occur around 8-9 PM, suggesting occupancy-driven increases Some readings above 800 ppm indicate periods of poor ventilation Key Insights Indoor Environment: The stable temperature range and CO2 fluctuation patterns strongly suggest this is indoor monitoring of an occupied space Ventilation Concerns: Evening CO2 spikes above 800 ppm indicate periods when ventilation may be inadequate for the occupancy level Good Overall Air Quality: PM2.5 and NOx levels are consistently excellent, suggesting good filtration and minimal outdoor pollution infiltration Normal HVAC Operation: Temperature and humidity patterns suggest a well-functioning climate control system Suggested Further Analysis Occupancy Correlation: Cross-reference CO2 peaks with known occupancy schedules to optimize ventilation timing Energy Efficiency: Analyze the relationship between temperature settings and CO2 levels to balance comfort, air quality, and energy use Seasonal Monitoring: Continue data collection through different seasons to understand how outdoor conditions affect indoor air quality Ventilation Optimization: Install CO2-based demand ventilation to automatically increase airflow when levels exceed 600-700 ppm Long-term Health Tracking: Monitor if elevated evening CO2 correlates with occupant comfort complaints or productivity issues The data suggests a generally healthy indoor environment with room for improvement in evening ventilation management. ``` ## Featured Products ### Raspberry Pi 5 - 8 GB RAM [Raspberry Pi 5 - 8 GB RAM](https://www.adafruit.com/product/5813) The Raspberry Pi 5 is the newest Raspberry Pi computer, and the Pi Foundation knows you can always make a good thing _better_! And what could make the Pi 5 better than the 4? How about a _faster_ processor, USB 3.0 ports, and an updated Gigabit Ethernet chip... In Stock [Buy Now](https://www.adafruit.com/product/5813) [Related Guides to the Product](https://learn.adafruit.com/products/5813/guides) ### Adafruit SEN6x Breakout for Sensirion SEN66 - STEMMA QT / Qwiic [Adafruit SEN6x Breakout for Sensirion SEN66 - STEMMA QT / Qwiic](https://www.adafruit.com/product/6331) Now you can quickly integrate the [Sensirion SEN6x environmental sensor node](https://blog.adafruit.com/2025/05/08/eye-on-npi-sensirion-sen66-environmental-sensor-node-eyeonnpi-digikey-digikey-sensirion-adafruit/) into your microcontroller or microcomputer project, with no... In Stock [Buy Now](https://www.adafruit.com/product/6331) [Related Guides to the Product](https://learn.adafruit.com/products/6331/guides) ### Adafruit Pi Stemma QT Breakout for Raspberry Pi and Compatibles [Adafruit Pi Stemma QT Breakout for Raspberry Pi and Compatibles](https://www.adafruit.com/product/6365) The **Adafruit Pi Stemma** is a small, easily removable breakout that easily adds a 4-pin JST SH pin (Stemma QT or [Qwiic](https://www.adafruit.com/?q=qwiic)) connector to your Raspberry Pi. The 2x3 socket design allows you to plug securely into the Pi's I2C bus... In Stock [Buy Now](https://www.adafruit.com/product/6365) [Related Guides to the Product](https://learn.adafruit.com/products/6365/guides) ### Official Raspberry Pi 5 Active Cooler [Official Raspberry Pi 5 Active Cooler](https://www.adafruit.com/product/5815) The **Raspberry Pi 5 Active Cooler** is compatible with the [Raspberry Pi 5](https://www.adafruit.com/search?q=raspberry+pi+5) and the [Raspberry Pi 5 Case](http://www.adafruit.com/product/5816). Designed for anyone who wants to push the performance of their... In Stock [Buy Now](https://www.adafruit.com/product/5815) [Related Guides to the Product](https://learn.adafruit.com/products/5815/guides) ### Official Raspberry Pi 45W USB-C Power Supply [Official Raspberry Pi 45W USB-C Power Supply](https://www.adafruit.com/product/6320) If you want a general-purpose USB Power Delivery supply, the official Raspberry Pi 45W USB-C power supply makes for a good quality PD supply that provides high current at a large option of voltages, including 12V which is not always supported, and 5A and 5V which also is a bit rare but makes... In Stock [Buy Now](https://www.adafruit.com/product/6320) [Related Guides to the Product](https://learn.adafruit.com/products/6320/guides) ## Related Guides - [Adafruit SEN6x Breakout](https://learn.adafruit.com/adafruit-sen6x-breakout.md) - [Adafruit Pi Stemma QT Breakout](https://learn.adafruit.com/adafruit-pi-stemma-qt-breakout.md) - [No-Code Indoor Air Quality Monitor with Separate Display](https://learn.adafruit.com/no-code-indoor-air-quality-monitor-with-separate-display.md) - [CircuitPython Libraries on any Computer with Raspberry Pi Pico](https://learn.adafruit.com/circuitpython-libraries-on-any-computer-with-raspberry-pi-pico.md) - [Getting Started with Binho Nova](https://learn.adafruit.com/getting-started-with-binho-nova.md) - [Raspberry Pi Rotary Encoder Animated Gif Player](https://learn.adafruit.com/python-rotary-animated-gif-player-two-different-ways.md) - [Make a Pi Trash Classifier with Machine Learning and Lobe](https://learn.adafruit.com/lobe-trash-classifier-machine-learning.md) - [Adafruit Mini PiTFT - Color TFT Add-ons for Raspberry Pi](https://learn.adafruit.com/adafruit-mini-pitft-135x240-color-tft-add-on-for-raspberry-pi.md) - [LSM6DSOX, ISM330DHC, & LSM6DSO32 6 DoF IMUs](https://learn.adafruit.com/lsm6dsox-and-ism330dhc-6-dof-imu.md) - [Using an IR Remote with a Raspberry Pi Media Center](https://learn.adafruit.com/using-an-ir-remote-with-a-raspberry-pi-media-center.md) - [Using a 5V Stepper Motor with the RasPiRobot Board V2](https://learn.adafruit.com/using-a-5v-stepper-motor-with-the-raspirobot-board-v2.md) - [Plotting Offline Data - JSONL to CSV files, filters and graphs](https://learn.adafruit.com/plotting-offline-data-jsonl-to-csv-files-filters-and-graphs.md) - [CircuitPython 101: Functions](https://learn.adafruit.com/circuitpython-101-functions.md) - [MacroPad Remote Procedure Calls over USB to Control Home Assistant](https://learn.adafruit.com/macropad-remote-procedure-calls-over-usb-to-control-home-assistant.md) - [FLORA Sensors](https://learn.adafruit.com/flora-sensors.md)