+In Part 1 you self-hosted Hermes with persistent memory. This part connects it to the same Telegram bot from the OpenClaw series — the chat your users already know keeps working exactly as it did, just a different agent answering underneath. No new bot to announce, no channel to migrate people to.
+Say you've built a support chatbot or a RAG assistant on WEC. It's solid on your docs and on what the model already knows — but ask it something current ("what's the latest release of X?", today's pricing, a recent change) and it either guesses or tells you its knowledge is out of date. For anything that needs to stay current, that's a real gap.
WEC Inference now has a web-search tool built in. Add it to a normal
/v1/chat/completions call and the model can look things up on the live web — the search
runs on WiLine's own infrastructure (SearXNG), so nothing goes out to a third-party search
vendor. Let's test it.
+An agent that calls tools does two very different things: it reasons ("I should search the docs") and it acts (actually calls the tool). When something goes wrong, the first question is always which layer failed — did it think wrong, or did the doing break? A flat log can't answer that. A trace can.
In this tutorial you build a small tool-calling agent on WEC Inference, instrument it with Langfuse so every reasoning step and every tool call becomes an inspectable node, then debug two real failures from the trace tree — including the worst kind: a confident, wrong answer that never throws an error. Every command, error, and screenshot below is from a real run.
++
Most "self-host a WhatsApp AI" guides stop at "the container started." This one goes all the way: you deploy a real, programmable WhatsApp gateway (Evolution API), then write the bridge yourself — the ~50 lines that turn an incoming message into an LLM answer and send it back. That bridge (webhook → model → reply) is the reusable pattern behind every chat-AI integration: SMS, Slack, Telegram, voice — swap the channel, the shape is identical.
And because this is a real build, we hit — and fix — every gotcha: an image that moved publishers, a Baileys version loop, an infinite reply loop, group-chat spam, WhatsApp's new LID addressing, and a genuine delivery wall that most tutorials pretend doesn't exist. Every command, error, and output below is from an actual run.
+Telegram (Part 3) gave your agent a bot. WhatsApp gives it a phone line — the app ~3 billion people already use, reachable with zero friction. One catch worth understanding up front: WhatsApp has no bot account, so OpenClaw links to a real number as a companion device (like WhatsApp Web) and the agent acts as that account. Every command and error below is from a real run.
++Our GPT-5.6 token-economics analysis ended with a challenge: benchmark promises are a hypothesis, not a reason — run the eval on your workload before you believe a "fewer tokens per task" claim. This tutorial is us taking our own advice.
We take the RAG docs assistant from part 5,
wrap it in a DeepEval regression suite — containerized, judged by gemma4 on the WEC
Inference API, zero OpenAI dependency — and then use that suite to answer a genuinely open
question: should we swap the service's generation model? Qwen2.5-3B-Instruct (current) vs
gemma4 (candidate), pass rate and tokens per task, measured head to head.
Spoiler: the eval saved us from a pointless migration. And along the way we hit four real production failures — a disk-full death spiral, a startup race condition, a Docker Compose variable trap that silently evaluated the wrong model, and the fix that makes that class of bug impossible. Every command, number, and error below is from a real run.
+Everything in this series was building to this. You can prove a model works (part 1), make its output machine-reliable (part 2), generate real test data (part 3), and observe production (part 4). Now we spend all four skills at once on the pattern behind almost every serious LLM product: RAG — retrieval-augmented generation.
We'll build a docs assistant: a containerized HTTP service that answers customer questions from WEC's own documentation. Not a notebook — a service, Docker-first, the shape you'd actually deploy. And because this series doesn't do happy-path demos: along the way our RAG hallucinates a GPU price, we root-cause it to our own scraper, fix it, and pin the fix with a regression test. Every command, number, and error below is from a real run.
+A customer says your support bot promised them a refund policy that doesn't exist. Your feature made two LLM calls — classify, then reply. Which one invented it? If you can't answer that, your app is a black box — and this guide fixes exactly that.
You can now prove a model works (part 1), make its output machine-reliable (part 2), and generate a real test set to check it against (part 3). But all of that runs offline, in CI, on inputs you chose. Production doesn't play along.
This guide closes the gap. We'll self-host Langfuse — the open-source, self-hostable alternative to LangSmith — trace every real call, auto-score live traffic with an LLM judge, drill into the exact step that breaks, and feed failures back so your part-3 dataset gets stronger. Offline eval tells you it worked on your test set; this tells you it works in the wild.
++
Your eval passes 100% — of the two test cases you typed by hand. Real users won't phrase things the way you did.
In part 1 and part 2 we built a real eval harness — assertions, schema validation, a model matrix. But two cases can't tell you if your app works; they can only tell you it didn't crash on two inputs.
This guide fixes that. The skill is producing a dataset you can actually trust: we use the WEC Inference API to generate labeled tickets, then validate and curate them — because generated labels are not automatically correct, and treating them as gospel just moves the bug. The result is real test data at scale. When you finally run it through the part-2 harness, coverage surfaces the failures — genuine misclassifications and debatable labels — that two hand-picked cases hide.
++"Return only JSON" is one of the most common instructions in production LLM apps — and one
of the least reliable. Models wrap JSON in markdown fences, add a friendly sentence, or (if
they're reasoning models) narrate their entire thought process around it. Any of those
breaks a strict JSON.parse, and your pipeline falls over.
In this guide we build a Promptfoo eval that makes WEC
Inference API models classify support tickets into schema-validated JSON, then harden
it against real-world messiness — and use it to pick a model you can actually trust. This is
part 2 of the evals series (see part 1
for first-run setup). Everything here was run live against https://inference.wiline.com.
+You wouldn't ship code without tests — but most teams ship LLM features on "looks good to me." Evaluations (evals) fix that: you define test cases and pass/fail criteria, then measure your model objectively — catching regressions, comparing models, and gating deploys.
In this guide you'll build a real eval harness with Promptfoo
pointed at the WEC Inference API — the same OpenAI-compatible endpoint you call from
your apps. Everything here was run live against https://inference.wiline.com; the outputs
are real.
+Through Parts 1–4 you deployed OpenClaw, secured it with HTTPS, added Telegram, and made it private over a NetBird mesh — all pointed at OpenAI. This part swaps the model out from under it: point the same agent at WEC Models — WiLine's own OpenAI-compatible inference — and run it on an open-weight model, Llama 3.1 8B Instruct. Same box, no rebuild — just a base-URL, key, and model change via the OpenClaw CLI.
+
Hermes Agent is Nous Research's open-source (MIT) AI agent — "the agent that grows with you." Its standout feature is persistent memory: it learns your projects and doesn't forget across restarts. This guide deploys it on the same WEC Instance you already use for OpenClaw, points it at a model, and proves the memory survives a full reboot.
+
In Article 2 we put Caddy in front of
OpenClaw for HTTPS, and in Article 3
we added a Telegram channel. The gateway works — but Caddy is still listening on
0.0.0.0, reachable by anything that can route to the box. This is the capstone
of the series: we join the server and your laptop to a NetBird mesh,
repoint openclaw.local at the mesh IP, and close the public ports. The same
https://openclaw.local/chat URL keeps working — but only for your devices.
Every command and error below is from the actual run.
+You've deployed OpenClaw and secured it behind HTTPS. Now make it usable — talk to your agent from your phone via Telegram. We create a bot, connect it, clear OpenClaw's pairing gate, and get a real reply. Every command and gotcha below is from an actual run.
+In Article 1 we got OpenClaw running —
but only over plain HTTP, with an allowInsecureAuth workaround. Here we put
Caddy in front of it as a reverse proxy: real HTTPS,
device-paired auth, and the gateway's raw ports closed so the proxy is the only
way in. Every command and error below is from the actual deploy.
++Your AI assistant doesn't have to live in someone else's cloud.
Deploy a self-hosted OpenClaw AI agent on a WEC Instance with Docker Compose — from spinning up the VM to an agent that actually answers, using your own model API key. Every command, version, and error below was captured from a real deployment on a WEC Instance.