DEV Community: John Otienoh

My AI habit Tracker

John Otienoh — Mon, 03 Nov 2025 12:12:55 +0000

Build an intelligent agent, connect it to Telex.im, and make it do something genuinely useful.

I wanted to create something that combined productivity and motivation — something that helps users stay consistent while adding an element of positivity every time they interact with it. That’s how I came up with the Motivational Habit Tracker AI Agent.

💡 Concept

The idea is simple but meaningful:
Users can create and manage habits (like “read 10 pages” or “exercise daily”), and each time they check their progress, they receive a motivational quote fetched from the ZenQuotes API.

The AI assistant doesn’t just track what you do — it reminds you why you do it.

🧩 Architecture Overview

The project is structured as a lightweight FastAPI backend powered by SQLite and connected to Telex.im via a JSON-RPC (A2A) API.

FastAPI App
 ┣━━ ai_helper.py         → Fetches motivational quotes (AI agent logic)
 ┣━━ database.py          → Handles SQLite database (habits, timestamps)
 ┣━━ habit_manager.py     → Business logic layer for CRUD + quotes
 ┗━━ main.py              → REST and JSON-RPC endpoints for Telex integration

Each component has a focused responsibility — helping keep the project simple, modular, and easy to maintain.

⚙️ Why I Chose FastAPI

The original version of this project was written in Flask, but I decided to refactor it into FastAPI for several reasons:

Asynchronous Support – Perfect for APIs that fetch external data like quotes.
Automatic Documentation – FastAPI generates Swagger and ReDoc docs instantly.
Modern Syntax – Type hints, Pydantic validation, and async endpoints make the code cleaner and more reliable.
Better Performance – FastAPI is built on Starlette and Uvicorn, which are lightweight and fast.

🧠 AI Integration (ZenQuotes API)

For motivation, I integrated the ZenQuotes API, which provides a random inspirational quote on each call.

Here’s the core logic from ai_helper.py:

def get_motivational_quote():
    try:
        response = requests.get("https://zenquotes.io/api/random", timeout=5)
        if response.status_code == 200:
            data = response.json()[0]
            return f'"{data["q"]}" - {data["a"]}'
    except Exception:
        return "💡 Keep going — small, consistent steps lead to big change!"

If the API is unreachable, the system gracefully falls back to a default motivational message.

🗃️ Data Model

SQLite was a natural choice for simplicity.
Each user has multiple habits stored in a table with frequency and timestamps:

id	username	habit	frequency	created_at	last_done

The backend automatically determines when a habit is due based on frequency (daily, weekly, etc.) and adds reminders accordingly.

🧩 Telex Integration (A2A JSON-RPC)

Telex.im uses a JSON-RPC 2.0 protocol for agents.
I implemented an /a2a/habits endpoint that accepts structured messages like this:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "habits/get",
  "params": { "username": "john" }
}

The agent responds with:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "habits": [...],
    "motivational_quote": "\"Action is the foundational key to all success.\" - Pablo Picasso"
  }
}

It supports:

habits/get → View habits
habits/add → Add a new habit
habits/mark_done → Mark a habit as complete

This makes the agent easy to integrate with Telex.im or any client that supports JSON-RPC.

🧭 Thought Process & Design Decisions

Here’s how I approached the project step by step:

1️⃣ Simplicity First

I started with a small, clear goal — track habits and return motivational quotes. The simpler the core logic, the easier it is to expand later.

2️⃣ Separation of Concerns

I divided the code into modules:

database.py for persistence
habit_manager.py for core logic
ai_helper.py for AI tasks
main.py for API routes

This made debugging and testing straightforward.

3️⃣ User Experience as a Priority

Each API response includes a motivational quote, even when users just check their habits.
This transforms the backend into something encouraging — not just functional.

4️⃣ Error Handling and Validation

All endpoints validate JSON-RPC format, parameters, and catch exceptions gracefully.
Invalid requests return clear error messages instead of crashing the service.

⚡ Example Usage

POST /habits/john

{
  "habit": "Exercise",
  "frequency": "daily"
}

GET /habits/john
Returns all habits with reminders and a motivational quote.

POST /a2a/habits

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "habits/mark_done",
  "params": {"username": "john", "habit": "Exercise"}
}

🌍 Deployment

The app runs seamlessly on Railway, Render, or Fly.io using:

web: uvicorn main:app --host 0.0.0.0 --port $PORT

💭 Key Takeaways

Building an “AI Agent” isn’t just about complex models — even a motivational quote generator can add emotional intelligence.
FastAPI made development fast, intuitive, and well-documented.
Clean architecture (small, focused modules) saved time debugging and made testing easier.
Integrating JSON-RPC taught me how structured communication between agents works.

🚀 What’s Next

Future improvements could include:

User authentication (JWT)
Tracking streaks or progress percentage
A web dashboard built with Vue or React
Integration with a real AI model for personalized motivational feedback

🏁 Final Thoughts

This project was a great exercise in combining backend logic, AI integration, and human-centered design.
It reminded me that small touches — like a random quote — can make digital tools feel alive and supportive.

If you’d like to try it or explore the source, check out the GitHub repo and connect with me on Telex.im!

“Discipline is choosing between what you want now and what you want most.”
— Abraham Lincoln

Me-API

John Otienoh — Fri, 17 Oct 2025 13:04:10 +0000

Simple RESTful API endpoint that returns your profile information along with a dynamic cat fact fetched from an external API.

Introduction

As part of the HNG Internship Backend track Stage 0 Task, I was challenged to build a simple yet dynamic RESTful API that returns my profile details along with a live cat fact fetched from the Cat Facts API.
This task has helped me sharpen key backend development concepts — from API integration, response structuring, time formatting, to error handling and deployment.

Task Requirements

The goal was to create a GET /me endpoint that returns:

{
  "status": "success",
  "user": {
    "email": "johndoe@gmail.com",
    "name": "John Doe",
    "stack": "Python/FastAPI"
  },
  "timestamp": "2025-10-17T12:34:56.789Z",
  "fact": "Cats sleep for 70% of their lives."
}

The cat fact must come dynamically from the public API

Tools & Technologies

Framework: FastAPI
Language: Python 3
Deployment Platform: Railway

My Implementation Process

- Project Setup
I created a new FastAPI project and installed dependencies:

pip install fastapi uvicorn requests python-dotenv

- Defined Schema with Pydantic.
To maintain clean and validated responses, I created a schema.py:

from datetime import datetime
from pydantic import BaseModel, EmailStr

class User(BaseModel):
    """Model for the response"""
    email: EmailStr
    name:str
    stack: str

class Profile(BaseModel):
    status: str
    user: User
    timestamp: datetime
    fact: str

- Get cat facts
To get the cat facts from the Cat Fact API, i created the catfact.py

import requests

def cat_fact(url: str) -> str:
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        response_dict = response.json()
        fact = response_dict["fact"]
    except Exception:
        fact = "Could not fetch cat fact at this time."

    return fact

- Built the /me Endpoint

from datetime import datetime, timezone
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware 

from app.schema import Profile
from app.catfact import cat_fact

app = FastAPI()
URL = "https://catfact.ninja/fact"

origins = ["*"]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)



my_info = {
    "status": "Success",
    "user": {
        "email": "johnteclaire@gmail.com",
        "name": "John Charles Otienoh",
        "stack": "Python/fastAPI"
    },
    "timestamp": datetime.now(timezone.utc).isoformat(),
    "fact": ""
}

@app.get("/me", response_model=Profile)
async def get_my_info():
    "Retreive Basic information"
    my_info['fact'] = cat_fact(URL)
    return my_info

- Tested the API
I used cURL to test:

curl http://localhost:8000/me

The API returned a live cat fact and a real-time timestamp every request!

What I Learned

How to consume external APIs safely using requests
How to handle timeouts, errors, and fallbacks
How to return structured JSON with Pydantic models
The importance of clean documentation and response validation
How to think about API reliability and best practices (timeouts, CORS, content-type headers, etc.)

Project Links

GitHub Repo: https://github.com/john-otienoh/Me_API
Live API: https://meapi-production.up.railway.app/me
Contact: johnteclaire@gmail.com

Recursion

John Otienoh — Fri, 17 Oct 2025 12:37:13 +0000

What is Recursion?
Any function which calls itself is called recursive. A recursive method solves a problem by calling a copy of itself to work on a smaller problem. This is called the recursion step.The recursion step can result in many more such recursive calls.
It is useful in sort, search, and traversal problems that often have simple recursive solutions.

Syntax

A beginner's guide to data engineering concepts, tools, and responsibilities.

John Otienoh — Mon, 05 Aug 2024 11:34:31 +0000

Data Engineering Concepts

Data engineering is the process of designing, building, and maintaining the infrastructure for storing, processing, and retrieving large datasets. It involves creating systems that efficiently collect, transform, and store data, making it usable for analysis and decision-making.

Tools for data engineers.

Scripting and programming language: python is the commonly used language in data engineering due to its simplicity and extensive libraries , which is used in transformation and data cleaning. There are other languages that are used such as ruby, Scala among others.
Databases: data engineers use various databases like MySQL to store and manage structured data for analytics and reporting.
Data visualization tools: to gain insights and patterns from data, a data engineer should be familiar with various tools used in visualization such as tableau and Power BI.
Data warehousing and storage tools: the commonly used tool in managing data is snowflake, snowflake is a cloud data warehouse that allow one to store and manage data, snowflake is very flexible since it works with some programming languages such as python

Responsibilities:

Designing data pipelines to collect and process data from various sources
Developing data warehouses and lakes to store structured and unstructured data.
Ensuring data quality, integrity, and security.
Building scalable and high-performance data processing systems.
Collaborating with data scientists and analysts to understand their data needs.
Implementing data governance policies and metadata management.

POST-MORTEM

John Otienoh — Fri, 28 Jun 2024 20:05:58 +0000

Database Connection

Issue Summary

Duration: 2 hours 55 minutes (14:55 UTC - 17:50 UTC).
The affected service was the website's search functionality leading to 20% of users experienced slow load times, with average page load times increasing by 7 seconds.
The root Cause was a misconfigured database connection pooling leading to connection timeouts.

Timeline

14:55 UTC: Monitoring alerts triggered for high response times on the search functionality.
15:00 UTC: Engineer on call investigates and notices high CPU usage on the database server.
15:10 UTC: Initial assumption is that the issue is related to a recent code deployment, and the team begins reviewing code changes.
15:20 UTC: Investigation reveals no issues with the code deployment, and attention turns to the database server.
15:40 UTC: Misleading investigation path: The team explores the possibility of a database query optimization issue.
16:00 UTC: Escalation to the database administration team.
16:20 UTC: Root cause identified: misconfigured database connection pooling.
16:55 UTC: Configuration changes made to the database connection pooling.
17:50 UTC: Issue resolved, page load times return to normal.

Root Cause and Resolution

The root cause of the issue was a misconfigured database connection pooling setting, which led to connection timeouts and increased CPU usage on the database server. This caused slow load times for 20% of users, affecting the website's search functionality.
The issue was resolved by adjusting the database connection pooling settings to optimize connection reuse and reduce timeouts. This change was made in collaboration with the database administration team.

Corrective and Preventative Measures

Improve database connection pooling configuration and monitoring.
Implement automated testing for database connection pooling settings.
Enhance monitoring for CPU usage on the database server.
Conduct regular reviews of database server performance and configuration.

TODO List

Patch database connection pooling configuration to optimize connection reuse.
Add monitoring for database connection timeouts.
Implement automated testing for database connection pooling settings.
Schedule regular database server performance reviews.
Develop a playbook for troubleshooting database connection issues.

This postmortem highlights the importance of thorough investigation and collaboration between teams to resolve complex issues. By identifying and addressing the root cause of the problem, we can prevent similar issues from occurring in the future and improve the overall reliability of our services.

0x00. Shell, navigation

John Otienoh — Sat, 08 Jun 2024 22:42:29 +0000

File System Organization

Like Windows, the files on a Linux system are arranged in what is called a hierarchical directory structure. This means that they are organized in a tree-like pattern of directories (called folders in other systems), which may contain files and subdirectories. The first directory in the file system is called the root directory. The root directory contains files and subdirectories, which contain more files and subdirectories and so on and so on.
The basic three commands include:

pwd (print working directory)
cd (change directory)
ls (list files and directories).

pwd

The directory we are standing in is called the working directory. To see the name of the working directory, we use the pwd command.

[me@linuxbox me]$ pwd
/home/me

When we first log on to our Linux system, the working directory is set to our home directory.

cd

To change the working directory (where we are standing in the maze) we use the cd command. To do this, we type cd followed by the pathname of the desired working directory. A pathname is the route we take along the branches of the tree to get to the directory we want.

me@linuxbox me]$ cd /usr/bin
me@linuxbox bin]$ pwd
/usr/bin

If we type cd followed by nothing, cd will change the working directory to our home directory.

me@linuxbox me]$ cd
me@linuxbox bin]$ pwd
/home/me

A related shortcut is to type cd ~user_name. In this case, cd will change the working directory to the home directory of the specified user.

me@linuxbox me]$ cd ~me
me@linuxbox bin]$ pwd
/home/me

Typing cd - or cd .. changes the working directory to the previous one.

me@linuxbox me]$ cd /usr/bin
me@linuxbox bin]$ pwd
/usr/bin
me@linuxbox me]$ cd ..
me@linuxbox bin]$ pwd
/usr

ls

It is used to list the files in the current working directory.

[me@linuxbox me]$ ls
Desktop   Download  Pictures  Music  Templates  Documents examples.desktop    Public  Videos

File names that begin with a period character are hidden. This only means that ls will not list them unless we say ls -a.

[me@linuxbox me]$ ls -la
.git/    .ssh/   .ipython/ Desktop   Download  Pictures  Music  Templates

ls -lList the files in the working directory in long format

[me@linuxbox me]$ ls -l
drwxr-xr-x 1 me 197121  0 Oct 17  2023  OneDrive/
drwxr-xr-x 1 me 197121  0 Jan 17  2023  Pictures/
drwxr-xr-x 1 me 197121  0 Mar  3  2023  Saved Games/
drwxr-xr-x 1 me 197121  0 Apr 27  2023  Searches/

Displaying file contents

There are several commands to display the content of a file in Linux.

Using cat command

$ cat filename

Using head and tail commands

The head command displays the first 10 lines of a file, while the tail command displays the last 10 lines of a file.

$ head filename   # displays the first 10 lines of a file
$ tail filename   # displays the last 10 lines of a file

You can modify the number of lines displayed by using the -n option, for example:

$ head -n 5 filename   # displays the first 5 lines of a file
$ tail -n 5 filename   # displays the last 5 lines of a file

Using less command

The less command allows you to view a file one page at a time. It allows you navigate through the file using the arrow keys or page up/down keys.

$ less filename

Using awk command

This command uses awk to print each line of the file.

$ awk '1' filename

Creating files and directories

Create a file:

Using the touch command:

$ touch filename

This will create a new empty file with the specified name.

Using a text editor:

$ nano filename # using the nano editor.
$ vi filename # using vim editor.
$ code filename # using vscode editor.

This will open a text editor where you can create and edit the file. Once you're done, save and exit the editor.

Using the echo command:

$ echo "Hello World!" > filename

This will create a new file with the specified name and add the text "Hello World!" to it.
Create a directory:

Using the mkdir command:

$ mkdir directoryname

This will create a new directory with the specified name.

Removing a file or directory

Removing a file:
To remove a file, use the rm command followed by the name of the file you want to remove:

$ rm filename

If the file is write-protected, rm will ask you to confirm the deletion. To remove the file without prompting, use the -f option:

$ rm -f filename

Removing a directory:
To remove an empty directory, use the rmdir command followed by the name of the directory:

$ rmdir directoryname

If the directory is not empty, you will get an error message. To remove a non-empty directory and all its contents, use the rm command with the -r option:

$ rm -r directoryname

Moving or Copying a file or directory

Moving a file or directory:
To move a file or directory, use the mv command followed by the source file or directory and the destination:

$ mv source destination

Renaming a file or directory:
To rename a file or directory, use the mv command with the source file or directory and the new name:

$ mv oldname newname

Copying a file or directory:
To copy a file or directory, use the cp command followed by the source file or directory and the destination:

$ cp source destination

To copy a directory and all its contents, use the -r option with the cp command:

$ cp -r source destination

This will copy the entire directory source and all its contents to destination.
Using rsync command:
The rsync command is a powerful tool for copying and synchronizing files and directories. It can be used to copy files and directories while preserving permissions, timestamps, and other attributes:

$ rsync -avz sourceDir destinationDir

This will copy the entire directory sourceDir and all its contents to the specified destination, preserving permissions, timestamps, and other attributes.

Thanks for your time! Please leave a comment and any suggestions are welcome. Follow me to get updates.

Variables in Python

John Otienoh — Mon, 01 Jan 2024 20:04:50 +0000

Variables

I have a value where do i store it in my computer?
Well that's where variables come handy.
Variables refer to

A location in the memory that are reserved to store the values of my code
A container that holds one value and has a label on it. From our definition we can visualise a variable as a gift box with similar characteristics like a container-like, has a label, stores something etc.

Syntax for declaring a variable in python is:
'variable_name' 'assignment operator' 'value'

    name = 'john'
    age = 20
    option = True

Variables in python have a specific naming convention.

Use snake_case or CamelCase naming convention. e.g my_name, MyName.
Variable name can only contain alphanumeric character and underscores [A - Z, 0 - 9 and _].
Variable name starts with a letter or the underscore character. e.g _name = 'john' or name = 'john'
Variable name should not be a keyword. e.g in, for, while etc.
Variable names should meaningful.

If a variable is defined(assigned a value) , trying to use it will give us specifically a NameError.

Multiple assignment in a single line

Supposed we want to define numerous variables using single line of code, we can do it by separating variable names and values with commas.

    a, b, c = 1, "alphabet", True

The line above is similar to

    a = 1
    b = "alphabet"
    c = True

Variables are key components for any programming language.