DEV Community: Kernel Cero

🤖 Building a Private, Local WhatsApp AI Assistant with Node.js & Ollama

Kernel Cero — Fri, 10 Apr 2026 23:45:07 +0000

Hello, dev community! 👋 I’ve been working on a personal project lately: a WhatsApp AI Bot that actually keeps track of conversations. No more "forgetful" bots, and best of all: it runs entirely on my own hardware! 🧠💻
🛠️ The Tech Stack

Runtime: Node.js 🟢

AI Engine: Ollama (Running Llama 3 / Mistral locally) 🦙

WhatsApp Interface: WPPConnect 📱

Database: SQLite for persistent conversation memory 🗄️

OS: Linux 🐧

🚀 The Journey

The goal was to create an assistant that doesn't rely on external APIs like OpenAI. By combining WPPConnect with Ollama, I have full control over the data and the model.

Here is the project structure:
Bash

user@remote-server:~/whatsapp-bot$ ls
database.db # Long-term memory (SQLite)
node_modules # The heavy lifters
package.json # Project DNA
server.js # The brain connecting WPPConnect + Ollama
tokens/ # Session persistence (No need to re-scan QR)

🔍 Key Features

Local Intelligence: Using Ollama means zero latency from external servers and 100% privacy.

True Context: Instead of stateless replies, I use SQLite to feed the previous chat history back into Ollama. It remembers who you are! 🔄

Session Persistence: Thanks to the tokens folder, the bot stays logged in even after a server reboot.

💡 Quick Snippet (The Connection)

Here is how I bridge the WhatsApp message to the local Ollama instance:
JavaScript

const wppconnect = require('@wppconnect-team/wppconnect');
const axios = require('axios'); // To talk to Ollama's local API

async function askOllama(prompt) {
const response = await axios.post('http://localhost:11434/api/generate', {
model: 'llama3',
prompt: prompt,
stream: false
});
return response.data.response;
}

wppconnect.create({ session: 'ai-session' })
.then((client) => {
client.onMessage(async (message) => {
const aiReply = await askOllama(message.body);
await client.sendText(message.from, aiReply);
});
});

🚧 What's next?

I'm working on "System Prompts" to give the bot a specific personality and improving the SQLite query speed for massive chat histories.

Are you running LLMs locally? I’d love to hear how you optimize Ollama performance for real-time chat! 👇

nodejs #ollama #ai #wppconnect #javascript #opensource #linux

🚀 Why I Ditched venv for uv: My Python Migration Journey on Linux Mint

Kernel Cero — Sun, 29 Mar 2026 08:04:41 +0000

Hello world, kernelcero here! 💻

If you've been in the Python ecosystem for a while, you know the "dependency dance": creating a venv, activating it, waiting for pip to resolve conflicts, and ending up with a massive site-packages folder that eats your disk space. 🐢

I recently decided to migrate my entire workflow to uv, and honestly? There is no going back.
What is uv? 🤔

Created by the team at Astral (the folks behind Ruff), uv is an extremely fast Python package installer and resolver written in Rust. It’s designed to replace pip, pip-tools, and virtualenv in one fell swoop.
🔥 Why the switch was a no-brainer

Blazing Fast ⚡: It’s 10x to 100x faster than pip. It uses a global cache, so if you've downloaded a library once, it's instantly available for your next project without re-downloading.

Built-in Python Management 🐍: No more messing with deadsnakes PPAs or apt for specific Python versions. Need Python 3.12 on an older Mint install? Just run uv python install 3.12.

The Power of uv.lock 🔒: It creates a deterministic lockfile. This means "it works on my machine" actually translates to "it works on EVERY machine."

Single Binary 🛠️: No dependencies required to install the tool itself. Clean and efficient.

The Python community is shifting towards faster, Rust-powered tooling. If you value your time and your disk space, give uv a try. It feels like a superpower for your terminal.

Are you still rocking the traditional venv + pip combo, or have you made the jump to Rust-based tooling? Let's discuss in the comments! 👇

python #linux #rust #productivity #softwaredevelopment

Taking Morgan Willis’s 10-Minute Agent to the Next Level: Meet Alfred

Kernel Cero — Sat, 28 Mar 2026 00:21:30 +0000

I recently came across this fantastic post by @morganwilliscloud: "AI Agents don’t need complex workflows: Build one in Python in 10 minutes." Her point was clear: we often overcomplicate Agentic AI. You don't need massive enterprise frameworks to build something functional. Inspired by that "build-to-understand" philosophy, I decided to create Alfred—my personal digital butler running locally on my Linux Mint machine.
🧠 The Brains: Local & Private

Following Morgan’s lead, I skipped the heavy cloud APIs. Instead, I used Ollama with the Qwen 2.5 Coder (7B) model. It’s incredibly snappy at function calling and runs entirely on my hardware.
🛠️ Giving Alfred "Hands" (The Tools)

While a basic agent might just do math, I wanted Alfred to actually manage my OS. Using Python’s subprocess and psutil, I gave him four specific skills:

System Health Check: He monitors CPU, RAM, and Disk usage in real-time.

Multimedia Control: He scans my ~/Videos and ~/Music folders to launch VLC or Audacious on command.

Deep Search: A smart wrapper around the find command to locate any file across the system.

Content Discovery: Using grep to find specific strings inside text files without me having to remember complex flags.

💻 The Implementation

I used a lightweight orchestration layer to handle the loop, ensuring Alfred maintains his "impeccable British butler" persona while executing technical tasks.

The heart of the Butler

agente = Agent(
model=model,
tools=[media_play, system_status, fast_search, find_text],
system_prompt=(
"You are ALFRED, kernel's digital butler. Your tone is impeccable and polite.\n"
"RULES:\n"
"- ALWAYS call a tool if the request is technical.\n"
"- Be brief and address him as 'Sir' or 'kernel'."
)
)

🛡️ Security First

As Morgan emphasizes in her cloud architecture sessions, automation must be secure. Since Alfred has access to my shell, I implemented shlex for input sanitization:

Sanitizing user input for safe shell execution

safe_query = shlex.quote(query.strip())
cmd = f"find {USER_HOME} -iname '{query}' -type f 2>/dev/null | head -n 10"

🚀 Why This Matters

Building this taught me that the "10-minute agent" isn't just a toy—it's a foundation. Alfred now saves me several minutes a day by fetching files and checking system vitals through a simple chat interface.

A huge thanks to @morganwilliscloud for stripping away the complexity and showing that the best way to learn AI is to give it the keys to your terminal (carefully!).