The AvantMaker team has just rolled out an exciting update to the ESP32_AI_Connect library, introducing streaming support for real-time communication with large language models like OpenAI, DeepSeek, Gemini, and Claude. This update brings a dynamic, conversation-like experience to ESP32-based projects, making AI integration more responsive and engaging.
What is Streaming Chat?
Streaming chat enables real-time interaction with AI models by delivering responses as they are generated, rather than waiting for the entire output. This creates a more natural and engaging user experience, mimicking the flow of a live conversation. With this update, the ESP32_AI_Connect library leverages streaming to bring cutting-edge AI capabilities to the resource-constrained ESP32 platform.
New Streaming Features
The latest update equips the ESP32_AI_Connect library with powerful streaming capabilities, optimized for IoT and embedded systems. Key features include:
Real-time Response: See AI responses as they are generated, word by word.
Interactive Experience: More natural, conversation-like interaction.
Immediate Feedback: Get instant responses without waiting for complete generation.
User Control: Interrupt or stop responses at any time.
Performance Metrics: Monitor streaming performance with detailed statistics.
Multi-platform Support: Works with OpenAI, Claude, Gemini, DeepSeek, and Open-Compatible platforms.
Thread-safe Design: Built on FreeRTOS primitives for reliable operation.
Memory Efficient: Optimized for ESP32’s limited resources.
This update builds upon the foundation of the ESP32_AI_Connect library, which aims to simplify the integration of AI into embedded projects. As highlighted in AvantMaker’s previous articles (you can read more here and about Tool Calling features here), the library strives to provide a user-friendly and efficient way to leverage the power of AI in your microcontroller applications.
Explore the Update
Ready to bring real-time AI to your ESP32 projects? The updated ESP32_AI_Connect library is available now on GitHub. Visit the ESP32_AI_Connect GitHub repository to download the latest version, explore the documentation, and try out example codes that showcase streaming in action.
Our ESP32_AI_Connect library has just received an update, introducing new tool calling features that significantly enhance its capabilities. This open-source library, designed to integrate AI functionalities into ESP32 microcontrollers.
What’s New: Tool Calling Features
The latest update to the ESP32_AI_Connect library adds robust tool calling capabilities, allowing developers to seamlessly integrate external functions and tools into their AI-driven ESP32 projects. This feature enables the ESP32 to dynamically interact with APIs, control hardware peripherals, or execute custom functions based on AI model outputs, making it easier to create sophisticated, responsive applications.
With tool calling, developers can now:
Invoke external APIs directly from the ESP32 to fetch real-time data, such as weather or stock updates.
Control connected devices, like motors or sensors, based on AI-driven decisions.
Extend AI model capabilities by integrating custom logic or third-party services without modifying the core model.
This addition makes the library even more versatile, enabling developers to build smarter IoT devices with minimal overhead, all while leveraging the compact and power-efficient ESP32 platform.
Why This Matters
The introduction of tool calling features positions ESP32_AI_Connect as a leading solution for developers looking to combine AI with IoT. By simplifying the integration of external tools and services, the library reduces development time and complexity, allowing hobbyists and professionals alike to focus on innovation.
As highlighted in our previous article, the ESP32_AI_Connect library already offers seamless AI model integration, optimized performance, and broad compatibility with popular AI frameworks. The addition of tool calling builds on this foundation, making it an even more powerful tool for embedded AI development.
Get Started Today
Ready to explore the new tool calling features? The updated ESP32_AI_Connect library is available now on GitHub. Head over to the official repository to download the latest version, check out the documentation, and dive into example projects that showcase the power of this update.
We’re super excited to share this news with you all—our team at AvantMaker has just dropped a brand-new Arduino library for the ESP32! Say hello to ESP32_AI_Connect, the library for bringing AI magic to your ESP32 projects. 🎉
What’s ESP32_AI_Connect All About?
Picture this: your ESP32 microcontroller chatting with some of the coolest AI platforms out there, like OpenAI, Google Gemini, all with a single, easy-to-use interface. That’s what ESP32_AI_Connect does! Whether you’re building a smart IoT gadget, a voice-activated gizmo, or something totally out-of-the-box, this library makes it a breeze to connect your ESP32 to powerful AI APIs.
ESP32_AI_Connect Main Features:
Works with multiple AI platforms—OpenAI, Google Gemini, DeepSeek, and more to come!
Tool calls support for two-way interaction (think AI asking your ESP32 to do stuff!).
Memory-efficient and modular, so it won’t hog your microcontroller’s resources.
Super configurable—tweak temperature, max tokens, system roles, and even custom headers.
Built to grow, with an expandable framework for adding new AI models down the road.
Tool Calls: The Coolest Part
Okay, let’s talk about the feature—tool calls. This is where things get really fun! With tool calls, the AI can ask your ESP32 to perform specific tasks, like reading sensor data, controlling hardware, or crunching numbers. It’s like giving your AI a direct line to your project.
Here’s what makes tool calls so awesome:
Two-way street: The AI can request actions, and your ESP32 can send back results.
Structured data: Everything comes in neatly formatted JSON, so parsing is a snap.
Custom tools: You define what your ESP32 can do, and the AI will work with it.
Context keeper: Your conversation with the AI stays intact, even during tool interactions.
Imagine building a weather station where the AI asks your ESP32 for real-time temperature data or a smart home device where the AI tells your ESP32 to dim the lights. The possibilities are endless!
Why We Built This
The ESP32 is already a powerhouse for IoT, and with ESP32_AI_Connect, we wanted to supercharge it by bringing AI into the mix. Plus, we designed it to be developer-friendly—whether you’re a seasoned coder or just starting out, this library is built to make your life easier.
More Exciting Features on the Way!
We’re not stopping here! Our team is hard at adding more features for ESP32_AI_Connect. Soon, you’ll be able to enjoy streaming responses for real-time AI interactions and support for even more AI platforms like Anthropic Claude, Grok, Hugging Face, and others. Stay tuned, because we’re just getting started!
Hello, makers, tinkerers, and IoT enthusiasts! The AvantMaker Team is buzzing with excitement because we’ve just rolled out a fresh update to our beloved ESP32-WebFS. If you’re new to this tool, it’s like turning your ESP32 into a mini web server with a slick interface that makes managing files on SPIFFS (that’s the flash storage on your ESP32) as easy as organizing your toolbox—minus the rusty screws.
ESP32 WebFS Main Interface Screenshot
This update brings some neat improvements to make your projects smoother and, dare we say, a tad more stylish. Let’s dive into what’s new!
SPIFFS Check: Know Your Storage Like the Back of Your Hand
Ever wondered how much room you’ve got left on your ESP32’s SPIFFS for all those cool project files? Wonder no more! We’ve added a SPIFFS Check Feature that spills the beans on your storage stats. It shows you the total SPIFFS size and how much free space is left—think of it like checking the fuel gauge before a road trip. Now you can plan your file uploads without playing storage roulette.
ESP32-WebFS SPIFFS Info Page Screenshot
A Spruced-Up Interface (Without Overdoing It)
We get it—nobody wants a clunky interface that feels like navigating a maze. So, we’ve given the ESP32-WebFS web interface a little glow-up with some minimal CSS tweaks. It’s not a full-on fashion makeover—just enough to make things look cleaner and more inviting, like tidying up your workbench before starting a new project. Best part? We kept the extra code light, so your ESP32 doesn’t feel like it’s lugging around a heavy backpack.
ESP32 WebFS File List Page Screenshot
Code Format Fix: Because Details Matter
We also squashed a pesky bug in the code formatting. It’s a small tweak, but it’s like tightening a loose screw—everything just works a bit more reliably now. Your ESP32-WebFS is ready to hum along without any hiccups.
Ready to Take It for a Spin?
Head over to our GitHub repository to grab the latest version and give it a whirl. It’s like getting a new toy for your ESP32—without the assembly instructions headache!
We can’t wait to see what awesome projects you’ll create with this update. Happy making!
Exciting news from the AvantMaker team! We know many of you are harnessing the power of the ESP32 to create amazing connected projects. A core part of many IoT applications is sending data from your ESP32 to a web server – whether it’s logging sensor readings, controlling a device remotely, or interacting with an online API. Often, this involves using the HTTP POST method via the ESP32’s HTTPClient library.
But have you ever stopped to wonder what’s really happening under the hood when you call http.POST() in your Arduino sketch? What does that data packet actually look like as it travels across the internet?
To help demystify this crucial process, we’ve just published a brand new, in-depth tutorial page:
In this new guide, we go beyond just providing example code. We take a practical ESP32 sketch that sends data to the popular testing service httpbin.org and break down:
The Arduino Sketch: A quick look at the code responsible for initiating the POST request.
The Raw HTTP POST Request: We reconstruct the actual data packet sent by the ESP32, line by line. You’ll learn about the request line (POST method, path, HTTP version), essential headers like Host, Content-Type, and Content-Length, the crucial blank line separator, and the formatted data payload itself.
The Server’s Response: We analyze the response from httpbin.org to confirm how the server received and interpreted the data sent by your ESP32.
Why is this important?
Understanding the structure of HTTP requests isn’t just academic. It empowers you to:
Troubleshoot effectively: When your ESP32 can’t connect or send data correctly, knowing what the request should look like is key to finding the problem.
Interact with APIs confidently: Many web services require data to be POSTed in a specific format. Understanding the components lets you craft the correct requests.
Design better projects: Knowing how data is packaged and sent helps you design more efficient and reliable communication for your IoT devices.
This new page is part of our ongoing effort to build a comprehensive collection of references and tutorials within the AvantMaker ESP32 Resources Hub, helping you turn your innovative ideas into reality.
Ready to deepen your understanding of how your ESP32 communicates with the web?
Hey there, makers, tinkerers, and curious minds! If you’ve ever hooked up an IoT gadget, built a DIY server, or dabbled in AI projects, you’ve probably stumbled across terms like “CA Certificate,” “Client Certificate,” and “Private Key.” They sound like the secret ingredients to a tech potion, don’t they? Well, they kind of are! These armored guardians of secure network communication keep your data safe from prying eyes. Let’s break them down in a way that won’t make your brain feel like it’s rebooting.
What Are These Things, Anyway?
Picture the internet as a bustling marketplace. You’re selling your latest 3D-printed gizmo, and someone wants to buy it. But how do you know they’re legit—and how do they know you’re not a shady bot? That’s where our crypto trio comes in. They’re like the bouncers, ID cards, and secret handshakes of the digital world.
CA Certificate: The Trusty Referee
First up, the CA Certificate—or Certificate Authority Certificate. This is issued by a Certificate Authority (CA), a fancy name for an organization that’s basically the internet’s hall monitor. Companies like DigiCert or Let’s Encrypt are CAs, and they vouch for websites or devices by handing out digital “trust badges.” When you visit a site with “https” in the URL, your browser checks the CA Certificate to confirm, “Yup, this site is who it says it is.” No CA Certificate? It’s like showing up to a party without an invite—everyone’s suspicious.
Client Certificate: Your Digital Passport
Next, the Client Certificate. This one’s all about you (or your device) proving your identity. Think of it as your VIP pass to a secure server. When your IoT temperature sensor wants to send data to a cloud platform, the server might say, “Hold up, show me your ID!” The Client Certificate steps in, saying, “Here’s my name, my credentials, and proof I’m not a random hacker.” It’s signed by a CA, so the server knows it’s not just a doodle you made in Paint.
Private Key: The Secret Decoder Ring
Finally, the Private Key. This is the super-secret half of a key pair (the other half is the public key, but more on that in a sec). The Private Key is like the combination to your personal safe—it’s yours alone, and you never share it. When you send encrypted data, the Private Key locks it up tight. Only someone with the matching public key can unlock it, and vice versa. Lose this key, and you’re basically handing your safe’s combo to a stranger. Guard it like it’s the last slice of pizza at a maker meetup.
Why Do They Matter?
Okay, so we’ve got our trio: the referee, the passport, and the decoder ring. But why should you care? Let’s say you’re building a smart doorbell with a camera. You want it to send video feeds to your phone without some creep intercepting them. Or maybe you’re running an AI model on a Raspberry Pi that talks to a remote server. Without secure communication, your data’s as exposed as a cardboard robot in a rainstorm.
Here’s how they team up:
The CA Certificate ensures the server you’re talking to isn’t a fake. No one wants their doorbell chatting with a scammer’s impostor site.
The Client Certificate proves your device is legit, so the server doesn’t slam the door in its face.
The Private Key scrambles your data, keeping it safe from anyone snooping on the network—like that nosy neighbor who always wants to know what you’re building.
Together, they create a secure handshake. The server trusts your device, your device trusts the server, and your data stays locked up tighter than a vault. This is called mutual TLS (Transport Layer Security), and it’s the gold standard for keeping networked projects safe.
Real-World Maker Magic
Let’s get practical. Suppose you’re setting up an IoT weather station. You generate a Private Key and a Client Certificate for your device, signed by a CA. The server you’re sending data to has its own CA Certificate. When your station reports that it’s 72°F and sunny, the Private Key encrypts the message, the Client Certificate proves it’s really your station, and the CA Certificate confirms the server isn’t a weather-data-stealing impostor. Result? Your app gets the update, and no one else does.
Without these, your weather station might as well be shouting your data through a megaphone. Hackers could spoof your server, steal your info, or even send fake readings to make you think it’s snowing in July. Not cool.
Wrapping It Up
CA Certificates, Client Certificates, and Private Keys might sound like a techy tongue twister, but they’re the unsung heroes of secure communication. For makers like us, they’re the difference between a project that works safely and one that’s a free-for-all for digital troublemakers. So next time you’re wiring up that DIY gadget or coding an AI bot, give a little nod to this trio—they’ve got your back.
Welcome, fellow tinkerers, to the wild world of digital security! If you’re building an IoT gadget, a DIY server, or just want to flex your maker muscles, you’ve probably stumbled across terms like “private key” and “certificate.” They sound like something out of a spy movie, but they’re actually the unsung heroes keeping your projects safe from digital ne’er-do-wells. Today, we’re diving into how to create them—without needing a PhD or a secret handshake.
What Are We Even Talking About?
A private key and certificate are like the lock and key to your digital front door. The private key is your super-secret code—guard it like it’s the last slice of pizza at a party. The certificate, on the other hand, is a public badge of trust, signed by someone (or something) saying, “Yep, this is legit.” Together, they’re the backbone of secure communication, whether it’s your Raspberry Pi talking to a server or your AI bot chatting with the cloud.
Think of it like this: the private key is your house key, and the certificate is the note from your locksmith proving it’s yours. Without both, you’re either locked out or looking sketchy to your neighbors.
Why Bother Making Your Own?
Sure, you could buy a certificate from a fancy authority or use someone else’s setup, but where’s the fun in that? Creating your own gives you control, saves a few bucks, and lets you say, “I built this!” when your smart toaster starts chatting securely with your phone. Plus, for testing or personal projects, self-made keys and certificates are more than enough—no need to call in the big guns.
Tools of the Trade
For this adventure, we’ll use OpenSSL—a free, open-source tool that’s like the Swiss Army knife of cryptography. It’s available for Windows, Mac, and Linux, so no excuses! If you don’t have it yet, grab it from your package manager (like apt install openssl on Linux) or download it from openssl.org. Got it? Great, let’s roll.
Step 1: Crafting Your Private Key
First up, the private key. Open your terminal—yes, that black box with the blinking cursor—and type this:
openssl genrsa -out myprivatekey.pem 2048
What’s happening here? You’re telling OpenSSL to generate a shiny new RSA private key with 2048 bits of strength (big enough to keep the baddies out) and save it as myprivatekey.pem. That “.pem” part? It’s just a file format, like .jpg for cat pics. You’ll see a bunch of gibberish in that file—don’t panic, it’s supposed to look like that.
Pro Tip: Keep this file safe. If someone snags it, they’ve got the keys to your kingdom. Maybe don’t store it next to your Wi-Fi password on a sticky note.
Step 2: Making a Certificate Signing Request (CSR)
Next, we need to ask for a certificate. Think of this as filling out a form to prove who you are. Run this command:
OpenSSL will ask you some questions—like your country, name, and project name. You can mash “Enter” for defaults if it’s just for testing, or get fancy and fill it out. This spits out a myrequest.csr file, which is your formal request for a certificate.
Step 3: Signing Your Own Certificate
Since we’re DIY-ing this, you’ll be your own certificate authority (CA). It’s like declaring yourself mayor of your own little digital town. Use this command:
Breaking it down: you’re signing your request with your private key, making a certificate (mycertificate.crt) that’s good for 365 days. Boom—you’ve got a certificate! It’s self-signed, so it won’t impress Google, but it’s perfect for your IoT weather station or AI-powered dog feeder.
Putting It to Work
Now what? Slap that private key and certificate onto your project. If you’re running a web server on a Raspberry Pi, drop them into the config files (like Nginx or Apache). Testing an IoT device? Load them into your code. Your devices will now whisper sweet, encrypted nothings to each other, safe from prying eyes.
Not sure how to use them? Check your project’s docs—every setup’s a little different, like snowflakes or badly assembled IKEA furniture.
A Word of Caution
Self-signed certificates are awesome for personal projects, but if you’re going public—like hosting a website for your smart coffee maker empire—browsers might throw a tantrum and show a “Not Secure” warning. For that, you’ll need a certificate from a trusted authority. But for tinkering? You’re golden.
Wrap-Up
And there you have it, makers! You’ve just whipped up a private key and certificate faster than you can say “soldering iron.” With these in your toolkit, you’re ready to secure your DIY creations and keep the digital gremlins at bay. Got questions? Drop them in the comments below—we’re here to help you turn ideas into reality, one secure byte at a time.
These guides break down all the essential functions for using the ESP32 in both Station and Access Point modes. Whether you’re looking to connect your ESP32 to a WiFi network or set it up as an Access Point, these guides will walk you through everything you need to know.
But that’s not all — we’re currently adding more guides to cover even more functions within the ESP32 WiFi Library. So if you’re eager to learn more, stay tuned, and we’ll have fresh content coming your way soon!
Thanks for following along, and as always, happy making!
Welcome to AvantMaker! If you’re diving into the world of IoT, AI, or Smart Home projects, you’ve probably heard of the ESP32. It’s one of the most powerful and flexible microcontrollers on the market, offering wireless connectivity, low power consumption, and endless possibilities. Here at AvantMaker, we’re excited to share that we’re currently building a Comprehensive Guide to the ESP32 Arduino Core Library to help you make the most of this amazing tool!
Library Functions’ Descriptions: Clear explanations of what each function does.
Syntax: Easy-to-understand examples of how to use each function.
Example Code: Real-world code snippets that demonstrate how you can apply these functions in your own projects.
And more…
We believe this guide will be a valuable resource to help you navigate the ESP32 Arduino Core Library with ease.
Why We’re Doing This
You know that information can be hard to find. While the ESP32 is gaining massive attention and is being widely used in IoT, AI, Smart Home, and DIY projects, there’s still a lack of comprehensive guides and documentation for resources on the ESP32 Arduino Core Library. Based on our own experience trying to find clear and thorough resources, we know how frustrating it can be. Many of the existing tutorials are either outdated or scattered across different sites, making it difficult to get a complete picture.
That’s why we’re creating this guide — to fill the gap and provide you with everything you need in one place. Our aim is to save you time and help you get your ESP32 projects up and running without the hassle of sifting through countless incomplete or unclear tutorials.
What’s Coming Next?
But that’s not all! We’re also planning to roll out online video tutorials and ESP32-based projects in the near future. These will go hand-in-hand with our written guides, offering you a complete learning experience. So, be sure to check back later as we continue to expand our content.
We can’t wait to see what you build with the ESP32! Stay tuned for updates!
