Forem: Abiodun Paul Ogunnaike

Built a Fully Offline AI Assistant on My Mac (Using Local LLMs)

Abiodun Paul Ogunnaike — Mon, 13 Apr 2026 18:31:50 +0000

Most AI apps today rely on APIs.

I wanted something different:

A fully offline AI assistant
Runs locally on my Mac
No API keys, no internet required

So I built one.

What I Built

A local AI assistant that:

Runs using a small language model (LLaMA / Mistral)
Works entirely offline
Supports chat + memory
Can be extended into a RAG system

Architecture

[CLI / Terminal] 
      ↓ 
[Node.js App] 
      ↓ 
[Ollama (Local AI Engine)] 
      ↓ 
[Local LLM]

Step 1 — Install Ollama on your local Machine

brew install ollama

Start the server:

ollama serve

Pull a model:

ollama run qwen2.5:latest

I choose qwen:2.5:latest because its just 4.7GB in size

Step 2 — Build CLI Assistant

mkdir local-ai-assistant 
cd local-ai-assistant 
npm init -y 
npm install axios readline-sync

Create a file in the local-ai-assistant folder

assistant.js

!/usr/bin/env node

const axios = require('axios');
const readline = require('readline-sync');

let history = [];

async function chat() {
    while (true) {
        const input = readline.question("You: ");

        history.push({ role: "user", content: input });

        const response = await axios.post('http://localhost:11434/api/chat', {
            model: 'qwen2.5:latest',
            messages: history,
            stream: false
        });

        const reply = response.data.message?.content || "No response";

        history.push({ role: "assistant", content: reply });

        console.log("AI:", reply);
    }
}

chat();

Step 3 — Make It a Global CLI Tool

Update package.json:

{
  "name": "local-ai",
  "bin": {
    "local-ai": "./assistant.js"
  }
}

Run:

npm link

Now you can run:

local-ai

What I Learned

Local LLMs are powerful enough for real use cases
You don’t need Python to start — Node works fine
The real value is in architecture, not just models

What i intend to build next

Add file-based memory (RAG)
Add tools (agent behavior)
Connect to Laravel API
Deploy via Docker + AWS

Final Thought

Running AI locally changes how you think about systems.

You’re no longer dependent on external APIs — you own the stack.

If you’re building something similar, I’d love to connect

https://github.com/abbeymaniak
https://linkedin.com/in/abiodun-paul-ogunnaike

Stateless vs. Stateful Systems in Software Architecture

Abiodun Paul Ogunnaike — Fri, 27 Mar 2026 19:58:22 +0000

TD;LR:

Stateless systems scale easily and recover quickly. (Scale with stateless.)
Stateful systems enable deeper, continuous user experiences. (Experience with stateful.)
Great architecture isn’t about choosing one it’s about placing state intentionally. (Win by controlling where state lives.)

Modern software architecture often comes down to one fundamental question: Should your system remember anything between requests? That single decision shapes scalability, complexity, performance, and even cost. Let’s break it down clearly and practically.

What Does “Remembering Between Requests” Really Mean?

When a system remembers, it retains information about a user or process across multiple interactions.

A stateful system keeps that memory internally (e.g., user session stored on a server).
A stateless system treats every request as independent no memory of the past.

Think of it like this:

Stateful = a waiter who remembers your order without asking again
Stateless = a waiter who asks you to repeat your order every time

Stateless Systems: Simple, Scalable, Cloud-Friendly

A stateless system does not store client context between requests. Each request must contain all the information needed to process it.

How it works

No session stored on the server State is passed via:
Tokens (e.g., JWT)
Query params / headers
External storage (DB, cache)

Advantages

1. Horizontal scalability (effortless scaling)
You can spin up multiple servers behind a load balancer without worrying about where a user’s data lives.

2. Fault tolerance
If one server dies, another can handle the next request seamlessly.

3. Simpler infrastructure
No need for session replication or sticky sessions.

Trade-offs

Larger request sizes (state sent every time)
More work pushed to clients or external systems
Can feel less intuitive for complex workflows

Real-world examples

REST APIs
Microservices architectures
Serverless functions (e.g., AWS Lambda)

Stateful Systems: Powerful but Complex

A stateful system stores data about a user/session on the server across multiple requests.

How it works

Server stores session data (memory, Redis, DB)
Client sends a session ID (cookie)
Server retrieves stored context

Advantages

1. Simpler client logic
The server “remembers,” so the client doesn’t have to send everything every time.

2. Efficient for long-lived interactions
Great for workflows like:

Shopping carts
Multiplayer games
Real-time collaboration

Trade-offs

1. Harder to scale
You need:

Sticky sessions, or
Shared session stores (e.g., Redis)

2. Reduced fault tolerance
If the server holding the session crashes, state may be lost.

3. Operational complexity
Session replication, synchronization, and consistency become real challenges.

The Hybrid Reality (What Most Systems Actually Do)

Here’s the truth: most modern systems are not purely stateless or stateful—they’re a mix.

A common pattern:

Keep application servers stateless Store state in external systems:
Databases
Caches (Redis)
Object storage

This gives you:

Stateless scalability
Stateful capability (via external persistence)

For Example in Celebrateme.co a digital platform focused on helping people to never miss important moments like birthdays and making those moments more meaningful with Physical and digital gifts currently in development:

The API is stateless
Authentication uses JWT (stateless)
User data lives in a database (stateful, but externalized)

The following Non-Function Requirements will determine which approach to take:

1. How much scale do you need?

Massive / unpredictable traffic → Stateless (JWT)
Controlled / predictable → Stateful can work (cookies)

2. How critical is resilience?

High uptime requirement → Stateless wins

3. How complex is the interaction?

Multi-step workflows → Stateful or hybrid
Simple request-response → Stateless

4. What’s your team’s operational maturity?

Small team → stateless reduces headaches
Experienced infra team → stateful is manageable

My advice: default to stateless, and introduce state only where it’s truly needed.

This keeps your system:

Easier to scale
Easier to debug
Easier to deploy

Stateless systems optimize for scale and resilience.
Stateful systems optimize for rich, continuous interactions.

The best architects don’t pick one blindly, they control where state lives.

10 REST API MISTAKES TO AVOID

Abiodun Paul Ogunnaike — Fri, 20 Mar 2026 15:47:55 +0000

If you're building APIs with Wordpress, Laravel or Node.js, this might hit a bit close to home

A lot of developers aren’t really designing APIs
they’re just returning JSON and calling it a day.

And that’s where things start to fall apart.

Because a solid API isn’t just something that “works.”
It should be consistent, scalable, predictable, and easy for other developers to use.

Let’s break down some of the most common mistakes and how to fix them 👇

❌ 1. Using Verbs in URLs

Wrong

GET /getBooks  
POST /createBook 
DELETE /deleteBook/1

Right

GET /books  
POST /books 
DELETE /books/1

👉 URLs should represent resources (nouns) — not actions.
HTTP methods already define the action.

❌ 2. Ignoring HTTP Status Codes

Wrong

200 OK
{ "status": "error", "message": "User not found" }

Right

200 → Success
201 → Created
400 → Bad Request
401 → Unauthorized
403 → Forbidden
404 → Not Found
422 → Validation Error
500 → Server Error

👉 Status codes are part of your API contract.

❌ 3. Inconsistent JSON Structure

Wrong

{ "userName": "Paul" }
{ "username": "Paul" }

Right

Pick one style: snake_case OR camelCase
Use it everywhere

👉 Consistency builds trust.

❌ 4. No API Versioning

Wrong

/books

Right

/api/v1/books
/api/v2/books

👉 Versioning prevents breaking existing clients.

❌ 5. No Pagination

Wrong

GET /books → returns 10,000 records

Right

GET /books?page=1&limit=10
{
  "data": [],
  "meta": {
    "current_page": 1,
    "total": 1000
  }
}

👉 Pagination improves performance, scalability, and UX.

❌ 6. Mixing Authentication & Authorization

Authentication = Who are you?
Authorization = What can you do?

👉 Use proper tools:

JWT / OAuth
Laravel Sanctum / Passport
Never trust frontend validation alone.

❌ 7. Poor Error Handling

Bad

"Something went wrong"

Good

{
  "error": {
    "code": 404,
    "message": "Book not found"
  }
}

👉 Errors should be predictable and structured.

❌ 8. Bad Filtering & Sorting

Wrong

GET /getActiveEventsSortedByName

Right

GET /events?status=active&sort=name

👉 Keep it clean, flexible, and scalable.

❌ 9. Ignoring Security

Common mistakes:

No rate limiting
No validation
No HTTPS
Exposing sensitive data

👉 Best practices:

Always use HTTPS
Validate all inputs
Add rate limiting
Hide sensitive/internal fields

❌ 10. Designing APIs Around Your Database

Bad mindset

“This is my table structure”

Good mindset

“This is what the client needs”

👉 Your API is a contract, not a database mirror.

What Good APIs Look Like

Versioned endpoints
Consistent naming
Proper status codes
Pagination
Filtering & sorting
Secure authentication
Structured errors
Resource-based URLs

REST API design isn’t about returning JSON.

It’s about:

Consistency
Scalability
Predictability
Security
Developer Experience

When your API is clean and predictable…
developers love working with it.

Elvis (?:) vs Null Coalescing (??) in PHP: A Practical Guide for WordPress Developers

Abiodun Paul Ogunnaike — Wed, 11 Mar 2026 09:12:33 +0000

TL;DR

?? (Null Coalescing Operator) Only falls back if the variable is undefined or null.

$page = $_GET['page'] ?? 1;

Good for array keys, request data, and optional variables where values like 0 or "" might still be valid.

?: (Elvis Operator) Falls back for any falsy value (false, 0, "", null, etc.).

$per_page = get_option('posts_per_page') ?: 6;

Good for database values or WordPress options where empty or false values should trigger a default.

✅ Simple rule:

Use ?? when you only want to check for missing or null variables.

Use ?: when you want a fallback for anything falsy.

When writing PHP especially in a WordPress environment you’ll often need to provide fallback values when data isn’t available. PHP gives us two operators that look similar but behave very differently:

The Elvis operator ?:
The Null Coalescing operator ??

At first glance they seem interchangeable. In practice, they solve two completely different problems, and choosing the wrong one can lead to subtle bugs—particularly when dealing with WordPress functions like get_option().

Let’s break down how they differ and when you should use each one.

The Key Difference

The distinction comes down to what counts as “missing” data.

?? Only null or undefined variables
?: Any falsy value

In PHP, falsy values include:

null
false
0
"0"
"" (empty string)
Understanding this difference is critical when working with WordPress APIs.

The WordPress get_option() Example

WordPress functions don’t always behave the way you might expect.

For example:

get_option('posts_per_page')

This function can return:

false → if the option does not exist
"" (empty string) → if the option exists but has no value

Now consider this code:

$per_page = get_option('posts_per_page') ?? 6;

You might expect it to fall back to 6 when the option is empty.

But it won’t.

The ?? operator only checks for:

null
undefined variables

So if get_option() returns:

false

""

PHP will treat those as valid values and not use the fallback.

That means $per_page might end up being an empty string instead of 6.

Why the Elvis Operator Works Better Here

Now look at the Elvis operator:

$per_page = get_option('posts_per_page') ?: 6;

This behaves differently.

The Elvis operator checks for falsy values, which includes:

false
""
null

So if get_option() returns any of those, the fallback 6 is used.

This guarantees that $per_page always contains a usable value.

Does That Mean ?: Is Better Than ???

Not exactly.

They are not competing operators. They solve different problems.

The key is understanding what values you want to allow.

When to Use the Elvis Operator (?:)

Use ?: when you want to reject any falsy value.

Example Use Case

Reading settings from a database where empty or false values are not valid.

$per_page = get_option('posts_per_page') ?: 6;

If the database returns:

false
""
null

the code will fall back to 6.

This is very common when working with:

WordPress options
configuration values
settings panels

When to Use the Null Coalescing Operator (??)

Use ?? when you only want to handle undefined variables or null values, while preserving valid falsy values.

This is particularly useful for user input or array access.

Example Use Case

Reading query parameters:

$paged = max(1, intval($_GET['epage'] ?? 1));

If $_GET['epage'] does not exist, it falls back to 1.

But if it exists and contains something like:

 0
 ""

PHP will still attempt to parse it instead of replacing it with 1.

This is important in cases where 0 might be a valid value, such as:

pricing ($price = 0 meaning free)
counts
indexes
pagination offsets

Summary

The Elvis operator and the null coalescing operator look similar, but they solve different problems.

Elvis (?:)

Rejects any falsy value
Useful for database values and settings
Common in WordPress code

Null Coalescing (??)

Only checks for null or undefined variables
Preserves valid falsy values like 0
Ideal for array access and request data

Choosing the right one ensures your fallback logic behaves exactly as intended.

Final Takeaway

If you're working with WordPress options or database-driven values, the Elvis operator often gives you safer behavior:

$per_page = get_option('posts_per_page') ?: 6;

But when handling request data or optional variables, the null coalescing operator is usually the better fit:

$page = $_GET['page'] ?? 1;

Understanding the difference may seem small, but it can prevent subtle bugs that are frustrating to track down later.

And as always in PHP, the right operator depends on what counts as “missing” data in your application.

Unique Field Guard for ACF

Abiodun Paul Ogunnaike — Tue, 06 May 2025 12:30:27 +0000

I’m excited to share a project, I’ve been working on that solves a headache I’ve encountered way too often when building custom solutions with ACF.

🔒 Unique Field Guard is a lightweight plugin that prevents duplicate values from being saved in Advanced Custom Fields — perfect for use cases like:

💼 Unique employee IDs

📧 Preventing duplicate email or username fields

📁 Custom directories or member listings

⚙️ What It Offers:
Instant validation before saving

Works on posts, custom post types, and taxonomies

Easy to set up — plug and play

Filter hooks for developers needing deeper control

No bloat, just clean code built for speed and safety

Built it because I needed it. Sharing it because I know you probably do too.

📥 https://wordpress.org/plugins/unique-field-guard-for-acf/
📢 Feedback, suggestions, and collabs are welcome!

https://www.linkedin.com/in/abiodun-paul-ogunnaike/

Also, I’m open to remote dev opportunities – so if you know a team hiring passionate WordPress or PHP developers, I’d love to chat.

WordPress #AdvancedCustomFields #ACF #PluginDev #OpenSource #WordPressCommunity #DevLife #WPCustomFields #PHPDev #UniqueFieldValidation

Getting Started with HTML: A Beginner's Guide

Abiodun Paul Ogunnaike — Sun, 03 Dec 2023 19:51:54 +0000

HTML, or HyperText Markup Language, is the backbone of the World Wide Web. It is the standard markup language used to create and design web pages. Whether you're a complete beginner or someone with a bit of coding experience, learning HTML is an essential step toward understanding how websites are structured and developed. In this guide, we'll take you through the basics of HTML to help you get started on your journey to web development.

Understanding HTML
HTML is a markup language that uses a system of tags to structure content on the web. These tags are surrounded by angle brackets, and they define the elements on a web page. An HTML document consists of a series of nested elements that create the structure of a webpage. Each element serves a specific purpose and can contain text, images, links, and more.

Setting Up Your Environment
Before you start writing HTML code, you need a simple text editor to create and save your files. Popular choices include Notepad (Windows), TextEdit (Mac), or Visual Studio Code. Once you have your text editor ready, create a new file and save it with the ".html" extension.

Basic HTML Structure
Every HTML document follows a basic structure:

<!DOCTYPE html>
<html>
<head>
    <title>The Title</title>
</head>
<body>
    <!-- The content goes here -->
</body>
</html>

<!DOCTYPE html>: This declaration defines the document type and version of HTML being used. It should be placed at the beginning of every HTML document.

<html>: This is the root element that wraps all the content on the page.

<head>: Contains meta-information about the HTML document, such as the title, character set, and links to external stylesheets.

<title>: Sets the title of the web page, which appears in the browser tab.

<body>: Contains the actual content of the web page, such as text, images, links, and more.

HTML Elements and Tags
HTML elements are the building blocks of a web page, and they are defined by tags. Tags consist of an opening tag, content, and a closing tag. For example:

<p>This is a paragraph.</p>
<p> is the opening tag.
This is a paragraph. is the content.
</p> is the closing tag.

Here are some common HTML tags:

<h1> to <h6>: Headings of different levels.
<p>: Paragraph.
<a>: Anchor, used for links.
<img>: Image.
<ul>, <ol>, <li>: Unordered list, ordered list, list item.

Adding Text and Headings
To add text to your webpage, you can use the <p> tag for paragraphs and <h1> to <h6> tags for headings. For example:

<h1>This is a Heading</h1> <p>This is a paragraph of text.</p>

Adding Images

To add an image, use the <img> tag and specify the image source (src) and alternative text (alt). For example:

<img src="image.jpg" alt="A descriptive text about the image for screen readers">

Creating Links
To create a hyperlink, use the <a> tag and specify the destination URL in the href attribute.
For example:

<a href="https://www.example.com">Visit Example.com</a>

Saving and Previewing Your HTML File
Save your HTML file and open it in a web browser to see the results. Right-click on the file and choose "Open with" to select your preferred browser.

Conclusion
This basic guide should provide you with a solid foundation for creating simple web pages using HTML. As you progress in your web development journey, you'll explore more advanced features and learn how to integrate CSS (Cascading Style Sheets) and JavaScript to enhance the functionality and appearance of your websites. Keep practicing, refer to documentation, and don't hesitate to experiment with your code to deepen your understanding of HTML. Happy coding!

Feel Free to Connect On linkedIn
https://www.linkedin.com/in/abiodun-paul-ogunnaike/

Understanding Frontend vs. Backend Development

Abiodun Paul Ogunnaike — Sat, 18 Nov 2023 21:41:13 +0000

In the large and dynamic field of web development. These phrases designate several phases of the development process,Frontend and backend developers collaborate together to create websites and applications, each with its own duties, tools, and difficulties. Anyone wishing to pursue a career in web development or wants to effectively manage a development project must comprehend the distinctions between frontend and backend development.

Frontend Development:

The goal of frontend development, also known as client-side development, is to create a website's or application's user interface and user experience. This is the area of development where users have direct interaction. Frontend developers are in charge of putting the design into practice and making sure the application or website is aesthetically pleasing, responsive, and easy to use.

Key responsibilities of frontend developers include:

User Interface (UI) Design:
Designing and implementing the visual elements of the user interface, including layout, colors, typography, and interactive components.
User Experience (UX):
Ensuring a seamless and enjoyable experience for users by optimizing navigation, responsiveness, and overall usability.

Frontend Languages and Frameworks: Using languages such as HTML, CSS, and JavaScript, along with frameworks like React, Angular, or Vue.js, to build the frontend components and interactivity.

Cross-Browser Compatibility: Ensuring that the website or application works consistently across different web browsers.

Backend Development:

Backend development, sometimes referred to as server-side development, works on a website or application's internal workings. In addition to handling the logic that drives the frontend, it entails maintaining databases and server setup. The smooth operation of the program, the safe storage and retrieval of data, and the efficient frontend-server communication are all priorities for backend developers.

Key responsibilities of backend developers include:

Server Management:
Configuring and maintaining servers to handle requests from users, manage databases, and execute server-side code.
Database Management:
Designing and managing databases to store and retrieve data efficiently.Examples of common databases used are MySQL, MongoDB,PostgreSQL.
Server-Side Languages and Frameworks:
Using languages such as Python, Ruby, Java, or PHP, along with frameworks like Django, Ruby on Rails, or Express.js, to build the backend logic and handle server-side operations.
Security:
Implementing security measures to protect against vulnerabilities and unauthorized access to data.

Collaboration and Full-Stack Development:

While frontend and backend development are distinct, they often go hand-in-hand. Developers who have expertise in both frontend and backend development are known as full-stack developers. Full-stack developers have a comprehensive understanding of the entire development process, from designing user interfaces to managing server operations.

Conclusion:

Frontend and backend development are essential elements in the dynamic field of web development that collaborate to produce a smooth and useful user experience. Backend developers take care of the server-side processes and make sure that data is managed effectively and securely, while frontend developers concentrate on the interactive and visual elements that users interact with directly. Understanding the roles and duties of frontend and backend developers is crucial for success in the digital world, regardless of your interest in managing a development project or pursuing a career in web development.

Introduction to Programming Logic: Understanding the Basics of Coding

Abiodun Paul Ogunnaike — Sun, 29 Oct 2023 15:44:20 +0000

Essentially, programming is giving instructions to a machine on how to carry out particular tasks. Programming logic is something that must be understood and used in order to interact with computers. What enables developers to solve issues, make apps, and construct software systems is the basic organization and flow of operations.

What is Programming Logic?
The basic way programmers understand and organize their code to produce desired results is known as programming logic. Fundamentally, it involves decomposing issues into smaller, more manageable components and formulating a plan of action to address each one.

Key Elements of Programming Logic:
1. Sequence:
Programming logic involves arranging commands in a sequential order, allowing the computer to execute them one after another.

2. Selection (Conditional Statements):
Conditions or logical tests are used to direct the flow of a program. For instance, "if-else" statements allow the code to make decisions based on specific conditions.

3. Iteration (Loops):
Loops enable the repetition of certain tasks until a condition is met. This helps in automating repetitive tasks and managing data efficiently.

Why is Programming Logic Important?
Understanding programming logic is crucial for several reasons:

1. Problem Solving:
Programming logic helps in breaking down complex problems into smaller, manageable parts. This simplification enables developers to solve problems systematically.

2. Efficient Code Writing:
By using logical structures, programmers can write code that is not only understandable but also efficient. It helps in avoiding redundancy and streamlining the execution process.

3. Enhancing Debugging Skills:
Logical thinking assists in identifying errors within the code and debugging more effectively. It becomes easier to trace the flow of a program and identify where issues might occur.

Building Blocks of Programming Logic:
Variables:
Variables are used to store data within a program. They can be manipulated and used in logical operations.

Operators:
Operators perform specific operations on variables and values. For instance, arithmetic operators (+, -, *, /) are used for mathematical operations.

Control Structures:
Control structures like loops (for, while, do-while) and conditional statements (if, else if, else) control the flow of the program.

Examples of Programming Logic:
1. Conditional Statements:

$age = 25;

if ($age < 18) {
    echo "You are a minor.";
} else {
    echo "You are an adult.";
}

2. Looping:

for ($i = 0; $i < 9; $i++) {
    echo "Count: $i <br>";
}

How to Develop Strong Programming Logic?
Solving problems and practicing regularly are necessary to develop strong programming reasoning. Here are some actions you can take to sharpen your reasoning:

1. Start with Simple Problems:
Begin by solving simple problems using a structured approach. Break down tasks and analyze the steps to solve them.

2. Practice Regularly:
Regular practice and writing code help reinforce programming logic. Experiment with different problems to understand how logic applies to diverse scenarios.

3. Learn from Others’ Code:
Reviewing and understanding code written by experienced developers can provide insight into how logic is applied in different contexts.

Conclusion:
Programming logic forms the foundation of coding. It’s the systematic approach of thinking and organizing instructions to create functional software. Embracing logical thinking, breaking down problems, and applying structured solutions are key components for any budding programmer.

By grasping programming logic, beginners pave the way for a deeper understanding of programming languages and the ability to develop efficient and effective software solutions.

Understanding programming logic is just the first step in an exciting journey towards becoming a proficient developer!