Ir para o conteúdo

Integrações de IA com ESP32 e HTTP Client

Integre microcontroladores ESP32 com provedores de IA em nuvem e LLMs auto-hospedados utilizando o ESP32HTTPClient.

Com o ESP32HTTPClient, conectar o ESP32 a Modelos de Linguagem (LLMs) é tão simples e direto quanto consumir qualquer API REST convencional. A biblioteca gerencia o transporte HTTP e extrai os campos da resposta diretamente para as suas variáveis usando notação de ponto — sem SDKs proprietários pesados, sem manipulação manual de strings e sem árvores DOM consumindo a memória RAM.

Deseja expor o hardware do ESP32 como servidor de ferramentas para IA?

Enquanto o ESP32-HTTP-Client é focado em requisições de saída (ESP32 → LLMs na Nuvem/Locais), conheça nossa biblioteca parceira ESP32-MCP caso queira um servidor MCP (Model Context Protocol) que permita a assistentes como Claude Desktop e Cursor descobrirem e executarem comandos e leituras de sensores diretamente no seu microcontrolador.


Provedores de IA em Nuvem

Conecte-se diretamente às principais APIs de IA em nuvem. Configure sua chave de API, monte o corpo da requisição com .body() e extraia o texto gerado via .getBody().


1. OpenAI

Consulta a Responses API da OpenAI para geração de texto com modelos GPT modernos (ex.: gpt-6-luna, gpt-6.1-sol ou gpt-6-astra).

Endpoint: POST https://api.openai.com/v1/responses

#include <Arduino.h>
#include <WiFi.h>
#include "ESP32HTTPClient.h"

const char* ssid     = "SEU_WIFI_SSID";
const char* password = "SUA_SENHA_WIFI";
const char* apiKey   = "SUA_CHAVE_OPENAI";

ESP32HTTPClient openaiClient("https://api.openai.com");

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) { delay(500); }

    openaiClient.bearer(apiKey);
    openaiClient.setTimeout(30000); // 30s de timeout para inferência
}

void loop() {
    char answer[512] = {0};
    int tokens = 0;

    openaiClient.post("/v1/responses")
        .body("model", "gpt-6-luna")
        .body("input", "Explique em ate 20 palavras o que e um ESP32.")
        .getBody("output.0.content.0.text", answer, sizeof(answer))
        .getBody("usage.total_tokens", &tokens);

    if (openaiClient.isSuccess()) {
        Serial.printf("OpenAI (%d tokens):\n%s\n", tokens, answer);
    } else {
        Serial.printf("Erro: %s (HTTP %d)\n",
                      openaiClient.getErrorMessage().c_str(), openaiClient.getStatusCode());
    }

    delay(60000);
}

2. Google Gemini

Conecta-se à Interactions API do Gemini utilizando o cabeçalho x-goog-api-key para gerar texto com modelos Gemini (como gemini-3.8-flash).

Endpoint: POST https://generativelanguage.googleapis.com/v1beta/interactions

#include <Arduino.h>
#include <WiFi.h>
#include "ESP32HTTPClient.h"

const char* ssid     = "SEU_WIFI_SSID";
const char* password = "SUA_SENHA_WIFI";
const char* apiKey   = "SUA_CHAVE_GEMINI";

ESP32HTTPClient geminiClient("https://generativelanguage.googleapis.com");

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) { delay(500); }

    geminiClient.setHeader("x-goog-api-key", apiKey);
    geminiClient.setTimeout(30000);
}

void loop() {
    char reply[512] = {0};

    geminiClient.post("/v1beta/interactions")
        .body("model", "gemini-3.8-flash")
        .body("input", "Resuma 3 protocolos de comunicacao IoT em 25 palavras.")
        .getBody("steps.0.content.0.text", reply, sizeof(reply));

    if (geminiClient.isSuccess()) {
        Serial.println("Resposta Gemini:");
        Serial.println(reply);
    } else {
        Serial.printf("Erro: %s (HTTP %d)\n",
                          geminiClient.getErrorMessage().c_str(), geminiClient.getStatusCode());
    }

    delay(60000);
}

3. Anthropic Claude

Interage com a Claude Messages API utilizando x-api-key e a versão de protocolo anthropic-version com modelos como claude-haiku-5-5.

Endpoint: POST https://api.anthropic.com/v1/messages

#include <Arduino.h>
#include <WiFi.h>
#include "ESP32HTTPClient.h"

const char* ssid     = "SEU_WIFI_SSID";
const char* password = "SUA_SENHA_WIFI";
const char* apiKey   = "SUA_CHAVE_ANTHROPIC";

ESP32HTTPClient claudeClient("https://api.anthropic.com");

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) { delay(500); }

    claudeClient.setHeader("x-api-key", apiKey);
    claudeClient.setHeader("anthropic-version", "2026-10-21");
    claudeClient.setTimeout(30000);
}

void loop() {
    char response[512] = {0};
    char stopReason[32] = {0};

    claudeClient.post("/v1/messages")
        .body("model", "claude-haiku-5-5")
        .body("max_tokens", 100)
        .getBody("content.0.text", response, sizeof(response))
        .getBody("stop_reason", stopReason, sizeof(stopReason));

    if (claudeClient.isSuccess()) {
        Serial.printf("Claude (stop: %s):\n%s\n", stopReason, response);
    } else {
        Serial.printf("Erro: %s (HTTP %d)\n",
                          claudeClient.getErrorMessage().c_str(), claudeClient.getStatusCode());
    }

    delay(60000);
}

4. DeepSeek

Conecta-se à API do DeepSeek (deepseek-flash ou deepseek-v4-pro) usando autenticação Bearer e requisições HTTP POST padronizadas.

Endpoint: POST https://api.deepseek.com/v1/responses

#include <Arduino.h>
#include <WiFi.h>
#include "ESP32HTTPClient.h"

const char* ssid     = "SEU_WIFI_SSID";
const char* password = "SUA_SENHA_WIFI";
const char* apiKey   = "SUA_CHAVE_DEEPSEEK";

ESP32HTTPClient deepseekClient("https://api.deepseek.com");

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) { delay(500); }

    deepseekClient.bearer(apiKey);
    deepseekClient.setTimeout(35000);
}

void loop() {
    char output[512] = {0};

    deepseekClient.post("/v1/responses")
        .body("model", "deepseek-flash")
        .body("input", "De 2 dicas para economizar energia no WiFi do ESP32.")
        .getBody("output.0.content.0.text", output, sizeof(output));

    if (deepseekClient.isSuccess()) {
        Serial.println("Resposta DeepSeek:");
        Serial.println(output);
    } else {
        Serial.printf("Erro: %s (HTTP %d)\n",
                          deepseekClient.getErrorMessage().c_str(), deepseekClient.getStatusCode());
    }

    delay(60000);
}

Modelos Auto-Hospedados (Self-Hosted)

Execute modelos em hardware próprio na sua rede local (LAN), sem custos por token ou preocupações de privacidade. Conexões HTTP puro eliminam o processamento TLS e economizam ~45 KB de heap no ESP32.


5. Ollama

Consulta uma instância local do Ollama na rede (porta padrão 11434) através do endpoint nativo /api/generate. O parâmetro "stream", false garante o recebimento de uma resposta completa em objeto único.

Endpoint: POST http://<HOST_IP>:11434/api/generate

#include <Arduino.h>
#include <WiFi.h>
#include "ESP32HTTPClient.h"

const char* ssid     = "SEU_WIFI_SSID";
const char* password = "SUA_SENHA_WIFI";

// Configure o IP do host na rede local e a porta 11434
ESP32HTTPClient ollamaClient("http://192.168.1.150", 11434);

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) { delay(500); }

    ollamaClient.setTimeout(45000);
}

void loop() {
    char answer[512] = {0};
    int tokens = 0;

    ollamaClient.post("/api/generate")
        .body("model", "gemma4")
        .body("prompt", "Qual e o ponto de ebulicao da agua em Celsius?")
        .body("stream", false)
        .getBody("response", answer, sizeof(answer))
        .getBody("eval_count", &tokens);

    if (ollamaClient.isSuccess()) {
        Serial.printf("Ollama (%d tokens):\n%s\n", tokens, answer);
    } else {
        Serial.printf("Erro: %s (HTTP %d)\n",
                          ollamaClient.getErrorMessage().c_str(), ollamaClient.getStatusCode());
    }

    delay(30000);
}

Acesso em Rede no Ollama

Por padrão o Ollama escuta apenas em 127.0.0.1. Para aceitar requisições de outros dispositivos da sua rede local (como o ESP32), inicie o serviço com a variável de ambiente OLLAMA_HOST=0.0.0.0:11434.


6. vLLM

Envia requisições para um servidor vLLM auto-hospedado através do seu endpoint compatível com OpenAI.

Endpoint: POST http://<HOST_IP>:8000/v1/chat/completions

#include <Arduino.h>
#include <WiFi.h>
#include "ESP32HTTPClient.h"

const char* ssid     = "SEU_WIFI_SSID";
const char* password = "SUA_SENHA_WIFI";

ESP32HTTPClient vllmClient("http://192.168.1.120", 8000);

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) { delay(500); }

    vllmClient.setTimeout(30000);
}

void loop() {
    char answer[512] = {0};
    int tokens = 0;

    vllmClient.post("/v1/chat/completions")
        .body("model", "meta-llama/Llama-3.1-8B-Instruct")
        .body("temperature", 0.3f)
        .getBody("choices.0.message.content", answer, sizeof(answer))
        .getBody("usage.total_tokens", &tokens);

    if (vllmClient.isSuccess()) {
        Serial.printf("vLLM (%d tokens):\n%s\n", tokens, answer);
    } else {
        Serial.printf("Erro: %s (HTTP %d)\n",
                          vllmClient.getErrorMessage().c_str(), vllmClient.getStatusCode());
    }

    delay(30000);
}

7. LM Studio

Executa inferência com modelos locais servidos pelo LM Studio (porta padrão 1234).

Endpoint: POST http://<HOST_IP>:1234/v1/chat/completions

#include <Arduino.h>
#include <WiFi.h>
#include "ESP32HTTPClient.h"

const char* ssid     = "SEU_WIFI_SSID";
const char* password = "SUA_SENHA_WIFI";

ESP32HTTPClient lmStudioClient("http://192.168.1.105", 1234);

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) { delay(500); }

    lmStudioClient.setTimeout(30000);
}

void loop() {
    char message[512] = {0};

    lmStudioClient.post("/v1/chat/completions")
        .body("max_tokens", 80)
        .getBody("choices.0.message.content", message, sizeof(message));

    if (lmStudioClient.isSuccess()) {
        Serial.println("Resposta LM Studio:");
        Serial.println(message);
    } else {
        Serial.printf("Erro: %s (HTTP %d)\n",
                          lmStudioClient.getErrorMessage().c_str(), lmStudioClient.getStatusCode());
    }

    delay(30000);
}

8. Backend Customizado / Proxy de Borda

Em projetos de produção com dispositivos distribuídos, um backend intermediário ou proxy (Node.js, FastAPI, Cloudflare Workers) protege as credenciais de nuvem contra extração da memória flash e entrega um payload JSON compacto e filtrado para o ESP32.

Endpoint: POST https://api.exemplo-ai.com/v1/analyze

#include <Arduino.h>
#include <WiFi.h>
#include "ESP32HTTPClient.h"

const char* ssid        = "SEU_WIFI_SSID";
const char* password    = "SUA_SENHA_WIFI";
const char* deviceToken = "TOKEN_SECRETO_DISPOSITIVO";

// --- Assinaturas de rotinas de hardware ---
float readTemperature(); // implementação de hardware
float readHumidity();    // implementação de hardware

ESP32HTTPClient aiClient("https://api.exemplo-ai.com");

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) { delay(500); }

    aiClient.bearer(deviceToken);
    aiClient.setTimeout(20000);
}

void loop() {
    float temp = readTemperature();
    float hum  = readHumidity();

    char insight[256] = {0};
    int alertLevel = 0;

    aiClient.post("/v1/analyze")
        .body("temperature", temp)
        .body("humidity", hum)
        .body("deviceId", "esp32-sensor-01")
        .getBody("insight", insight, sizeof(insight))
        .getBody("alertLevel", &alertLevel);

    if (aiClient.isSuccess()) {
        Serial.printf("Nivel de Alerta: %d\nInsight: %s\n", alertLevel, insight);
    } else {
        Serial.printf("Erro: %s (HTTP %d)\n",
                          aiClient.getErrorMessage().c_str(), aiClient.getStatusCode());
    }

    delay(60000);
}

Boas Práticas e Dicas para Embarcados

  • Extração com Buffers Estáticos: Sempre priorize getBody("caminho", buffer, sizeof(buffer)) com vetores char[] normais. Isso transfere os dados do socket diretamente para a variável sem manter o documento JSON inteiro na memória heap.
  • Defina Timeouts Apropriados: Respostas de LLMs podem levar entre 2 e 20 segundos para serem geradas. Use client.setTimeout(30000) ou client.setTimeout(45000) para evitar que o ESP32 encerre a conexão prematuramente.
  • Tratamento de Rate Limits (HTTP 429): Se a cota por minuto for excedida, leia o cabeçalho Retry-After usando .getHeader("Retry-After", &retrySec) para aguardar o intervalo necessário antes da próxima chamada.
  • Segurança TLS em Produção: Caso o seu projeto corporativo exija validação estrita com certificados raiz (Root CA pinning) ou fail-closed TLS, confira o guia completo em Segurança e Certificados TLS / HTTPS.
  • Liberação de Sockets: Chame client.end() quando não houver requisições ativas para fechar conexões e liberar recursos.

Documentação Relacionada