So bringst du ChatGPT und Claude auf deinen ESP32

Hier bei Pollux Labs gibt es mittlerweile eine Vielzahl von Projekten, die KI-Modelle wie ChatGPT verwenden. Dabei kommt oft der Raspberry Pi und die Sprache Python zum Einsatz. Aber es geht auch anders: Mit einem ESP32 und der passenden Bibliothek kannst du direkt aus deinem Mikrocontroller-Projekt heraus mit den großen Sprachmodellen kommunizieren – wahlweise mit OpenAI (ChatGPT) oder mit Claude von Anthropic.

In diesem Tutorial lernst du, wie du deinen ESP32 mit der API von OpenAI und Anthropic sprechen lässt, um dir Fragen beantworten zu lassen. Du kommunizierst dabei über den Seriellen Monitor: Deine Fragen sendest du als Nachricht an deinen ESP32 und erhältst die Antwort direkt im Textfeld des Monitors.

Für die folgende Anleitung benötigst du je nach Anbieter einen Account samt API-Key. Für OpenAI erstellst du dir einen Schlüssel unter platform.openai.com/api-keys, für Claude unter console.anthropic.com. Wie du einen OpenAI-Account und -Key erstellst, erfährst du außerdem zu Beginn dieses Tutorials.

Und falls du deinen ESP32 zum ersten Mal einrichtest: Wie du ihn mit der Arduino IDE programmierst und mit dem Internet verbindest, erfährst du in diesen beiden Grundlagen-Tutorials.

Die Bibliothek: ESPAI

Früher haben wir für diese Aufgabe die Bibliothek OpenAI-ESP32 verwendet. Sie funktioniert zwar noch, wird aber seit 2023 nicht mehr weiterentwickelt und kennt die neueren Sprachmodelle nur eingeschränkt. Deshalb setzen wir in diesem aktualisierten Tutorial auf ESPAI – eine aktiv gepflegte Bibliothek, die gleich mehrere Anbieter unter einer einheitlichen Schnittstelle zusammenfasst: OpenAI, Anthropic (Claude), Google Gemini und Ollama (für lokale Modelle).

Der große Vorteil: Der Code für OpenAI und Claude ist nahezu identisch. Hast du das eine verstanden, kannst du das andere mit wenigen Handgriffen ausprobieren.

___STEADY_PAYWALL___

ESPAI installieren

ESPAI findest du aktuell noch nicht im Bibliotheksverwalter der Arduino IDE – du installierst sie stattdessen als ZIP-Datei. Lade dir dazu von der Releases-Seite auf GitHub die neueste Version herunter. Anschließend fügst du sie in der Arduino IDE über Sketch -> Bibliothek einbinden -> ZIP Bibliothek hinzufügen ein und wählst die heruntergeladene Datei aus.

Nutzt du PlatformIO, genügt stattdessen dieser Eintrag in deiner platformio.ini:

lib_deps =
    enkei0x/ESPAI@^0.9.0

ESPAI läuft auf allen ESP32-Varianten (ESP32, ESP32-S2, ESP32-S3, ESP32-C3). Als Abhängigkeit wird ArduinoJson benötigt – falls diese Bibliothek noch nicht installiert ist, installiere sie über den Bibliotheksverwalter.

Deine Zugangsdaten in einer secrets.h

Deine WLAN-Zugangsdaten und deinen API-Key solltest du nicht direkt in den Sketch schreiben, sondern in eine separate Datei auslagern. Lege dazu im selben Ordner wie deinen Sketch eine Datei namens secrets.h an und trage dort deine Daten ein:

#ifndef SECRETS_H
#define SECRETS_H

const char* WIFI_SSID     = "dein-WLAN-Name";
const char* WIFI_PASSWORD = "dein-WLAN-Passwort";

// OpenAI-Key von https://platform.openai.com/api-keys
const char* OPENAI_API_KEY = "sk-...";

// Anthropic-Key von https://console.anthropic.com/ (erst später nötig)
const char* ANTHROPIC_API_KEY = "sk-ant-...";

#endif

Der erste Sketch: Chat mit OpenAI

Jetzt geht es los. Der folgende Sketch verbindet deinen ESP32 mit dem WLAN und schickt anschließend eine Frage an OpenAI. Kopiere ihn in einen neuen Sketch (die Datei secrets.h muss im selben Ordner liegen):

#include <WiFi.h>
#include <ESPAI.h>
#include "secrets.h"

using namespace ESPAI;

// OpenAI als Anbieter anlegen
OpenAIProvider openai(OPENAI_API_KEY);

void setup() {
  Serial.begin(115200);

  // Mit dem WLAN verbinden
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Verbinde mit WLAN");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println(" verbunden!");

  // Eine Nachricht zusammenstellen
  std::vector<Message> messages;
  messages.push_back(Message(Role::User, "Warum ist der Himmel blau? Antworte in einem Satz."));

  // Anfrage senden
  ChatOptions options;
  Response response = openai.chat(messages, options);

  // Antwort ausgeben
  if (response.success) {
    Serial.println(response.content);
  } else {
    Serial.println("Fehler: " + response.errorMessage);
  }
}

void loop() {
  delay(10000);
}

Lade den Sketch auf deinen ESP32 und öffne nach dem Upload den Seriellen Monitor mit einer Baudrate von 115200. Nach der WLAN-Verbindung schickt dein ESP32 die Frage an OpenAI und gibt die Antwort im Monitor aus.

Das passiert im Code

Mit OpenAIProvider openai(OPENAI_API_KEY); legst du deinen Zugang zu OpenAI an. Deine Fragen und Anweisungen sammelst du in einer Liste vom Typ std::vector<Message>. Jede Nachricht bekommt eine Rolle: Role::User für deine Frage und – optional – Role::System, um dem Modell eine Persönlichkeit oder Anweisung mitzugeben (z.B. „Antworte immer kurz und auf Deutsch“).

Der eigentliche Aufruf passiert in openai.chat(messages, options). Das Ergebnis landet in einem Response-Objekt. Über response.success prüfst du, ob alles geklappt hat, und in response.content steckt die eigentliche Antwort – die du also nicht nur ausgeben, sondern z.B. auch auf einem OLED-Display anzeigen könntest. Zusätzlich liefert dir das Objekt mit response.promptTokens, response.completionTokens und response.totalTokens() die verbrauchten Tokens.

Modell wählen und Kosten im Griff behalten

Standardmäßig verwendet ESPAI für OpenAI das Modell gpt-4.1-mini – schnell, günstig und für die meisten Aufgaben völlig ausreichend. Möchtest du ein anderes Modell nutzen, legst du das mit einer einzigen Zeile in der Setup-Funktion fest. Zum Beispiel:

openai.setModel("gpt-4.1");   // leistungsfähiger
// openai.setModel("gpt-5-mini");   // neueste Generation

Damit die Antworten nicht zu lang und damit zu teuer werden, kannst du die Anzahl der Tokens begrenzen. Bei klassischen Modellen wie gpt-4.1-mini geschieht das über maxTokens:

ChatOptions options;
options.maxTokens = 300;
options.systemPrompt = "Antworte kurz und auf Deutsch.";

Ein praktischer Vorteil von ESPAI: Für die neueren „Reasoning“-Modelle der GPT-5-Reihe, die den Parameter maxTokens nicht mehr akzeptieren, gibt es maxCompletionTokens. Damit behältst du auch bei diesen Modellen eine Kostenbremse – etwas, das ältere Bibliotheken nicht können. Die jeweils aktuellen Preise findest du in der Preisliste von OpenAI. Mit gpt-4.1-mini bewegst du dich pro Anfrage im Bereich von Bruchteilen eines Cents.

Interaktiv: Fragen über den Seriellen Monitor

Schöner als eine einzelne, fest verdrahtete Frage ist natürlich ein echter Dialog. Mit einer kleinen Erweiterung im loop() liest dein ESP32 das, was du oben in das Nachrichtenfeld des Seriellen Monitors eintippst, und schickt es an OpenAI. Ersetze dazu die Funktion loop() durch diese Variante (und entferne den einmaligen Aufruf aus setup(), falls du möchtest):

void loop() {
  // Warten, bis eine Nachricht im Seriellen Monitor eingegeben wurde
  if (Serial.available()) {
    String frage = Serial.readStringUntil('\n');
    frage.trim();
    if (frage.length() == 0) return;

    // Deine Frage noch einmal ausgeben - der Monitor zeigt die Eingabe
    // sonst nicht selbst an
    Serial.println("Du: " + frage);

    std::vector<Message> messages;
    messages.push_back(Message(Role::System, "Antworte kurz und auf Deutsch."));
    messages.push_back(Message(Role::User, frage.c_str()));

    ChatOptions options;
    options.maxTokens = 300;

    Response response = openai.chat(messages, options);

    if (response.success) {
      Serial.print("KI: ");
      Serial.println(response.content);
    } else {
      Serial.println("Fehler: " + response.errorMessage);
    }
  }
}

Trage jetzt oben im Feld Nachricht deine Frage ein und sende sie mit Enter ab. Kurz darauf erscheint die Antwort im Monitor. Damit du den Überblick behältst, gibt der Sketch deine Frage mit vorangestelltem „Du:“ noch einmal aus (der Serielle Monitor zeigt deine Eingabe von sich aus nämlich nicht an) und die Antwort mit „KI:“. Stelle im Seriellen Monitor außerdem sicher, dass als Zeilenende „Neue Zeile“ (Newline) eingestellt ist, damit deine Eingabe korrekt erkannt wird.

Statt OpenAI: Claude von Anthropic nutzen

Und jetzt kommt die Stärke von ESPAI voll zum Tragen: Um statt ChatGPT das Modell Claude von Anthropic zu verwenden, tauschst du im Grunde nur den Anbieter aus. Statt des OpenAIProvider legst du einen AnthropicProvider mit deinem Anthropic-Key an:

// Oben im Sketch, statt (oder zusätzlich zu) OpenAI:
AnthropicProvider claude(ANTHROPIC_API_KEY);

Anschließend rufst du einfach claude.chat(messages, options) statt openai.chat(…) auf – der restliche Code bleibt gleich. Auch die Rollen und ChatOptions funktionieren identisch; um die System-Anweisung kümmert sich ESPAI im Hintergrund automatisch im für Anthropic passenden Format.

Standardmäßig verwendet ESPAI hier das Modell claude-sonnet-4-20250514. Möchtest du ein günstigeres und schnelleres oder ein besonders leistungsfähiges Modell, wählst du es wieder mit setModel():

claude.setModel("claude-haiku-4-5-20251001");   // schnell und günstig
// claude.setModel("claude-opus-4-20250514");   // besonders leistungsfähig

Du kannst sogar beide Anbieter im selben Projekt anlegen und je nach Aufgabe zwischen ihnen wechseln – zum Beispiel ein günstiges Modell für einfache Fragen und ein leistungsfähigeres für kniffligere Aufgaben.

Fazit

Wie du in diesem Tutorial gesehen hast, sind die großen Sprachmodelle längst nicht mehr Python und leistungsstarken Computern vorbehalten. Mit einem ESP32 und ESPAI genügen wenige Zeilen Code, um mit OpenAI oder Claude zu sprechen. Von hier aus ist es nur noch ein kleiner Schritt zu eigenen Projekten – etwa einem sprechenden Assistenten mit Display, einem smarten Helfer im Haus oder einem KI-gestützten Messgerät. Viel Spaß beim Ausprobieren!