Forem: An Vo

be-confused.com

An Vo — Sun, 12 Apr 2026 14:13:56 +0000

This is a submission for the DEV April Fools Challenge

What I Built

I built be-confused.com, a deliberately useless local web app powered by Teapot Intelligence and fully compliant with HTTP 418.

At first glance, it looks like a polished chat product. In reality, it is a teapot-themed nonsense machine called Teabot 418 that confidently delivers:

surreal breaking news
absurd quizzes with ceremonial grading
fake serious explanations of 418 I'm a teapot
harmless nonsense about capybaras, turtles, crocodiles, kettles, and beverage protocol

The whole joke is that it has the interface and confidence of a serious software product, but none of the usefulness. Sometimes it even has a tiny tea hiccup in the middle of a reply, says something ridiculous like it briefly became a pancake wizard, apologizes, and then continues as if nothing happened.

I wanted it to feel like an internet protocol joke that accidentally became a startup.

Demo

https://youtu.be/Jo9CcmoHSkc

Code

https://github.com/anvo0000/April-Fools-Challenge

How I Built It

I built this with a very small stack on purpose:

Python
FastAPI
Jinja2
vanilla HTML, CSS, and JavaScript

The app has a single page and a single chat endpoint. On the backend, I used lightweight keyword routing to classify prompts into modes like news, quiz, teapot refusal, info, or general confusion. Responses are generated from template banks with randomized phrases, so the app feels playful and a little unpredictable without needing a real model.

On the frontend, I added fake streaming text, fake model labels, a polished teapot-themed interface, and quick prompt cards so it feels like a serious Teapot Intelligence product for about three seconds before the nonsense begins.

One of my favorite additions was the tea hiccup flow. Occasionally the bot interrupts itself with a harmless absurd sentence, apologizes, and goes back to the original answer. That tiny glitch made the experience feel much sillier and more alive.

This project was intentionally scoped to stay local, simple, and fast to build while still feeling polished enough to sell the joke.

Prize Category

I am submitting this for Best Ode to Larry Masinter.

The core concept is built around the HTCPCP joke and the legacy of 418 I'm a teapot. Instead of using the teapot reference as a one-line easter egg, I made it the entire product identity. The chatbot is literally framed as a beverage-protocol-compliant assistant that refuses coffee requests, explains 418 with fake authority, and turns protocol absurdity into the whole user experience.

This project is basically my attempt to take an internet joke RFC far too seriously and turn it into a useless product demo.

GenAI #2: What are Vector Databases?

An Vo — Tue, 27 Jan 2026 15:39:21 +0000

What is a Vector?

A vector is a list of numbers that represents something (text, image, audio, user, product, etc.) in a way computers can compare.

Think of a vector as a “numerical fingerprint.”
A vector might look like: [0.48, -0.87, 1.04, 0.33, ...]
Each number captures some aspect of meaning or features.

Why vectors matter in GenAI

AI models can’t directly understand words or images — they understand numbers. So we convert things into vectors using embedding models.

Example:

"I love dogs" → vector A

"I like puppies" → vector B

Those vectors will be close together in vector space because they mean similar things.

What are Vector Databases?

A vector database stores vectors and lets you quickly find the most similar ones.

Why regular databases aren’t enough

Traditional databases are great for:

Exact matches (id = 123)
Filters (price > 50)

But GenAI needs:

“Find text similar to this”

“Find documents that mean the same thing”

“Find images that look alike”

That’s where vector databases come in.

What does a Vector Database do?

A vector database:

Stores vectors (embeddings)
Indexes them efficiently
Performs similarity search (usually cosine similarity or distance)

Typical GenAI Workflow (RAG-style)

You start with data such as PDFs, notes, system logs, customer support chat logs, etc.
These documents are split into smaller chunks and converted into vectors (embeddings) using an embedding model.
The vectors are stored in a Vector Database.
A user asks a question.
The question is converted into a query vector using the same embedding model.
The Vector Database performs a similarity search to find the vectors (document chunks) most relevant to the query vector.
The retrieved text chunks are fed into an LLM as context.
The LLM uses this context to understand, summarize, and synthesize the information—following the system prompt—and returns a natural-language response to the end user.

Popular Vector Databases:

Pinecone
Weaviate
Milvus
Chroma
FAISS (library, not a DB)
PostgreSQL + pgvector (Relational database with vector support)
Qdrant
AWS:
- Individual Vector DB: Amazon Kendra, OpenSearch Service, and RDS for PostgreSQL with pgvector.
- Managed service via Amazon Bedrock Knowledge Bases: Aurora PostgreSQL, Neptune Analytics, OpenSearch Serverless, Pinecone, and Redis Enterprise Cloud.

Vector Index Optimization:

In a Vector Store, there can be millions or even billions of vectors.
To retrieve relevant information efficiently, these vectors cannot be stored as a simple flat list, which would require brute-force comparison against every vector.

Vector index optimization refers to selecting and configuring specialized algorithms that organize vectors into efficient data structures, enabling fast approximate similarity search while maintaining acceptable accuracy.

Brute-Force Comparison: means comparing a query vector against every single vector in the vector store to find the most similar ones. It's guaranteeing accuracy but killing performance at scale.

Assume:

- You have 1,000,000 vectors
- Each vector has 1,536 dimensions (typical OpenAI embedding size)
- When a user asks a question:
    - Convert the question into a vector
    - Compute similarity between the question vector and:
Vector 1
Vector 2
Vector 3
…
Vector 1,000,000

    - Sort the results
    - Return the top-K most similar vectors

That’s brute force.

Hierarchical Navigable Small World (HNSW): It builds a graph structure connecting similar vectors. High-speed (low latency and high recall), consumes RAM, and is the best fit for RAG chatbots with end users.
Below is an intuitive sample:

Layer 3 (top, very sparse)
    o -------- o
       \
        o

Layer 2
  o ---- o ---- o
    \      \
     o      o

Layer 1
 o -- o -- o -- o
 |    |    |    |
 o -- o -- o -- o

- Each `o` is a vector (a data point)
- Lines are connections to nearby vectors
- Higher layers have fewer nodes and longer jumps

** Step 1: Start at the top layer

Begin from a random entry point
This layer helps you make big jumps across the space
Goal: get close to the target region Like using Google Maps zoomed out at the continent level

** Step 2: Move down layer by layer

At each layer:
Look at neighboring nodes
Move to the neighbor that’s closer to your query
Repeat until you can’t get closer
Drop down to the next layer Like zooming from continent → country → city → street

** Step 3: Final search at the bottom layer

Bottom layer is dense
You now explore the local neighborhood
Retrieve the nearest vectors
This is where accuracy comes from.

Inverted File Index (IVF): IVF does not create paths or layers like HNSW. Instead, it:
Partitions space into regions
Stores vectors in buckets
Searches only the most relevant buckets
Imagine the entire vector space as a world map:

+-------------------+-------------------+
|     Region A      |     Region B      |
|   (Cluster C1)    |   (Cluster C2)    |
|   ● ● ● ● ●       |   ● ● ● ●         |
|                   |                   |
+-------------------+-------------------+
|     Region C      |     Region D      |
|   (Cluster C3)    |   (Cluster C4)    |
|   ● ● ●           |   ● ● ● ● ● ●     |
+-------------------+-------------------+
- Each region is a cluster
- Each ● is a vector (document chunk)
- Each region has a centroid (not shown yet)

** Step 1: Zoom In to the Centroids (Region Representatives)
Now imagine flags planted at the center of each region:

      🚩C1                🚩C2

      ● ● ● ●            ● ● ●

      🚩C3                🚩C4

      ● ● ●              ● ● ● ● ●

These flags (centroids) act like: “If your query is close to me, search my region.”

** Step 2: A user question becomes a vector

          🔎 Query
              ●

** Step 3: Compare ONLY with centroids
Instead of checking every ●, you check:

Distance(Query, 🚩C1)
Distance(Query, 🚩C2)
Distance(Query, 🚩C3)
Distance(Query, 🚩C4)

This is cheap and fast.

** Step 4: Pick nearest regions (nprobe)
Say the closest centroids are C2 and C1:

Search these regions only:
✅ Region B (C2)
✅ Region A (C1)

Ignore:
❌ Region C
❌ Region D

** Step 5: Search inside selected buckets
Now you finally compare the query with vectors:

Region B: ● ● ● ●
Region A: ● ● ● ● ●

But only those — not the entire world.

Curious Why It’s Called “Inverted File”??
Instead of: “Which cluster does this vector belong to?”
You store: “Here are all vectors belonging to this cluster.”
==> That’s the inversion.

This series will build toward the goal of preparing for the AWS Certified Generative AI Developer – Professional (AIP-C01) certification
https://docs.aws.amazon.com/aws-certification/latest/examguides/ai-professional-01.html

Ref:

https://docs.aws.amazon.com/prescriptive-guidance/latest/choosing-an-aws-vector-database-for-rag-use-cases/introduction.html

GenAI #1: What Is AI?

An Vo — Mon, 05 Jan 2026 16:20:54 +0000

AI often feels mysterious, but it starts with a simple idea: machines learning from data.

What is AI?

Humans learn from experiences, and AI learns by processing vast amounts of data to make informed decisions.
Data is indispensable for AI as it aids in learning, pattern recognition, and making informed decisions or predictions.

Foundational AI Concepts and Terminology

Artificial Intelligence (AI): The field of building machines that can make decisions or perform tasks in ways that resemble human intelligence.
Machine Learning (ML): a subset of AI, uses data to train the computer. The computer will learn and improve over time.
Supervised Learning: A learning process where models are trained on labeled data (data with correct answers). For example, a model can learn to classify cats and dogs after being trained on labeled images.
Unsupervised Learning: is the process that uses big data without labels to train the model, it will learn and find patterns by itself. For example, Unsupervised methods can analyze physiological and behavioral data to identify mental health conditions, especially when labeled data is in short supply.
Reinforcement Learning: if the model returns a correct answer, then send a reward to it. If the answer is incorrect, it receives a penalty.
Deep Learning A subset of machine learning based on neural networks. Common architectures include:
- Artificial Neural Networks - Inspired by the human brain, they can process massive datasets and learn patterns from them.
- Convolutional Neural Networks (CNNs): used in vision tasks, can extract context from images.
- Recurrent Neural Networks (RNNs): Efficient for sequential data and are often used for predicting text. RNNs are adept at handling time-series predictions in stock prices.
Generative Models: Models that learn from existing data and generate new, similar data samples, making them useful for creating content like text, images, or music.
Transformer Architecture: Consisting of encoders and decoders, crucial in language translation and code generation tasks.

This post lays the foundation for my AI learning journey. In the next post, I’ll dive deeper into GenAI #2: What are Vector Database?

This series will build toward the goal of preparing for AWS Certified Generative AI Developer – Professional (AIP-C01) certification

https://docs.aws.amazon.com/aws-certification/latest/examguides/ai-professional-01.html

Conda Environment Setup Guide for MacOS and Pycharm

An Vo — Sun, 25 May 2025 07:12:57 +0000

Conda Environment Setup Guide

This guide helps you set up and use a Conda environment named myenv3.12 with Python 3.12.

1. Install Miniconda

Download the Miniconda installer for your platform from:

https://docs.conda.io/en/latest/miniconda.html

Install via Terminal (macOS, Apple Silicon example):

curl -O https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh
bash Miniconda3-latest-MacOSX-arm64.sh

Follow the prompts and restart your terminal after installation.

source ~/.zshrc

2. Create a New Environment

Create an environment named myenv3.12 with Python 3.12:

conda create -n myenv3.12 python=3.12

3. Activate the Environment

conda activate myenv3.12

4. Install Packages

Example: Install numpy and pandas

conda install numpy pandas

5. List Your Environments

conda env list

6. Deactivate the Environment

conda deactivate

7. Remove the Environment (if needed)

conda env remove -n myenv3.12

8. Useful Tips

Always activate your environment before working on your project.
Install packages only after activating the desired environment.
To update conda itself:

  conda update conda

9. List out packages in a specific environment

conda activate myenv3.12
conda list

10. Using Conda Environment in PyCharm

In PyCharm, go to Preferences > Project > Python Interpreter.
Click Add Interpreter > Conda Environment > Existing environment.
Browse to: ~/miniconda3/envs/myenv3.12/bin/python
Click OK to set it as your project interpreter.

11. Create or Update the current environment with an environment.yml file

name: myenv3.12
dependencies:
  - python=3.12
  - pandas
  - numpy
  - matplotlib
  - seaborn
  - scikit-learn
  - tensorflow

conda env create -f backend/environment.yml

conda env update --file environment.yml --prune

Happy coding anvo0000!

Python's walrus operator ' := '

An Vo — Sat, 12 Apr 2025 08:01:47 +0000

I have just found that Python has a new operator named "Walrus", it's so interesting to deep dive and worth writing down:

Codeblock Description:

Prompts the user to enter 0, 1, or 2.
If the user enters something else, it keeps asking.
As soon as the input is valid, the loop ends.

The original code:

list_embedding_models = [
        "0-Ollama-Nomic Embedded", 
        "1-OpenAI Embedding", 
        "2-Chroma DefaultEmbeddingFunction"
    ]
print(f"====Select an Embedding model:")
    print(*list_embedding_models, sep="\n")

while True:
    embedding_model_choice = input("Please enter 0,1, or 2: ")
    if embedding_model_choice in {"0", "1", "2"}:
        break
    else:
        print("Try again!")

Then we can apply Walrus Operator ':='

list_embedding_models = [
        "0-Ollama-Nomic Embedded",
        "1-OpenAI Embedding",
        "2-Chroma DefaultEmbeddingFunction"
    ]
print(f"====Select an Embedding model:")
    print(*list_embedding_models, sep="\n")
    while (embedding_model_choice := input("Please enter 0,1, or 2: ")) not in {"0", "1", "2"}: print("Try again!")
    print(embedding_model_choice)
    print(f"==> User choose {list_embedding_models[int(embedding_model_choice)]}")

What's happening?

embedding_model_choice := input(...) this assigns the result of input() to embedding_model_choice, inside the condition of the while loop.
not in {"0", "1", "2"}: then checks whether the user's input is one of the allowed choices. If not, it loops again.
print("Try again!"): if the user's input is invalid, it will print a message Try again! and ask for input again. In this step, you can either print a message or pass it.

while (embedding_model_choice := input("Please enter 0,1, or 2: ")) not in {"0", "1", "2"}: pass

Use case:

Cleaner, shorter loops when you want to assign and check a value in the same place.
Useful in input loops, file reading, etc.

Risk:

The walrus operator is a new syntax that is available from Python 3.8 and later.
If your code needs to support legacy systems, then it will be broken, so it's better to use the classic while ... if ... break.

Python Decorator

An Vo — Sun, 23 Mar 2025 09:39:51 +0000

SIMPLE DECORATOR SYNTAX

1- Define a decorator

def decorator_function(function):
    def wrapper_function():
        # Do something before the function
        function()
        # Do something after the function
    return wrapper_function

Python Decorator Function (4 lines of code)

1- Create a normal function.
2- Input is another normal function, the function in this case doesn't have parentheses ().
3- Inside the decorator_function, create a wrapper_function
The wrapper_function() will trigger the actual input "function()" that was passed into the decorator_function().
4- Return the wrapper_function without parentheses ().

Key takeaways:

  + Decorator function is just a function that wraps another function,
  + And GIVE that function some ADDITIONAL FUNCTIONALITY

2.1 - Using a decorator function by @ sign -> RECOMMENDED way.

@decorator_function #this line will trigger the decorator function for a_normal_function
def a_normal_function():
    pass

2.2 - Using a decorator function by input function -> NOT RECOMMENDED way.

decorated_func = decorator_function(a_normal_function)
decorated_func() # remember to add parentheses ()

EXAMPLES

Requirements:

All functions should be delayed by 5 seconds.
Avoid adding time.sleep(5) to each function.
Add time.sleep(5) once.

Implementation:

We can modify delay_decorator to delay the execution of the wrapped function by 5 seconds.

import time

def delay_decorator(function):
    def wrapper_function():
        time.sleep(5) # wait 5 seconds before executing the next function
        function()
    return wrapper_function


@delay_decorator
def say_hello():
    print("Hello!")

@delay_decorator
def say_bye():
    print("GoodBye!")

def say_greeting():
    print("How are you?")

Now we will define a main_flow:

def main_flow():
    say_hello() # no delay because we don't add @delay_decorator to it
    say_greeting() # delay 5s before executing greeting
    say_bye() # delay 5s before executing GoodBye

main_flow()

Result:

Hello!
wait 5s
How are you?
wait 5s
GoodBye!

ADVANCE DECORATOR SYNTAX

Class and Adv Python Decorator

1. Requirements:

Users have to provide their name, and is_logged_in = True
Create a decorator to ensure users log in by using the "is_authenticated_decorator()"

2. Define a class name User:

class User:
    def __init__(self, name):
        self.name = name
        self.is_logged_in = False

2. The function to create a new blog post:

def create_blog_post(user):
    print(f"This is {user.name}'s new blog post.")

3. Define a decorator:

To check whether users log in or not
Remember the create_blog_post function requires a param name user.
With Decorator, we cannot send param directly, in this case, we can use *args and **kwars.
args[0] means the first argument input.

def is_authenticated_decorator(function):
    def wrapper(*args, **kwargs):
        user = args[0]
        if user.is_logged_in:
            function(user)
        else:
            print("Please log in!")
    return wrapper

4. Main Flow:

# If is_logged_in = True, a new blog post will be created.
new_user = User("Anvo0000")
new_user.is_logged_in = True
create_blog_post(new_user)
# --> This is Anvo0000's new blog post.

# If no log-in:
new_user.is_logged_in = False
create_blog_post(new_user)
# --> Please log in!

P/S: if the function has a return value, remember to return that result in a wrapper.

def logging_decorator(function):
    def wrapper(*args):
        result = function(*args)
        print(f"You called {function.__name__}{args}")
        print(f"It returned: {result}")
        return result # IMPORTANT: remember to return a result for the follower function.
    return wrapper

@logging_decorator
def sum_function(*args):
    return sum(args)

sum_function(1,2,3)

HTTP Requests

An Vo — Sat, 22 Mar 2025 09:05:18 +0000

HTTP Requests have some common request types:

/GET: request.get(): is used to retrieve data from a server.

GET https://api.user.org/users/?id=AAA

/POST: request.post(): is used when sending data to the server to create new resources.

POST /api/users
Content-Type: application/json
{
  "id": "AAA",
  "name": "John Doe",
  "email": "john@testmail.com"
}

/PUT: request.put(): is used to update or replace a resource on the server.

PUT /api/users/AAA
Content-Type: application/json

{
  "name": "AAA Smith",
  "email": "aaa@testmail.com"
}

/DELETE: request.delete(): is used to remove or delete a resource on the server.

DELETE /api/users/AAA

Sample Python code: Remember to create a .env file with TOKE, USERNAME, and ENDPOINT.

import os
import dotenv
import requests

PIXELA_TOKEN = os.getenv("PIXELA_TOKEN")
PIXELA_USERNAME = os.getenv("PIXELA_USERNAME")
PIXELA_ENDPOINT = os.getenv("PIXELA_ENDPOINT")
headers = {
    "X-USER-TOKEN": PIXELA_TOKEN
}

user_param = {
    "token": PIXELA_TOKEN,
    "username": PIXELA_USERNAME,
    "agreeTermsOfService": "yes",
    "notMinor": "yes"
}
response = requests.post(url=PIXELA_ENDPOINT, json=user_param)
print(response.text)

### {"message":"Success. Let's visit  ...

Python - Small Notes

An Vo — Wed, 19 Feb 2025 09:14:16 +0000

1. Python allows you to change the datatype of a variable. int -> string -> float -> int

a = 1 # int  
a = "testing" # string

2. To prevent the datatype change in the future, apply "Type Hint" when defining a variable:

a: int
a = 1  # accepted

a = "testing" # Python will reject this assigning

3. Apply function Arrow to force the return datatype

def hello(name: str) -> str:
    return f"Hello {name}" # this only accept return a string.


def greeting(name: str) -> str:
    return True # this boolean will be rejected by Python

It's different from other languages such as C#, Java, and Swift.

Create a Python environment.

pip install pipenv
pipenv shell #create a new environment
pip i

# create a new virtual environment
python3 -m venv .venv

#activate environment
source .venv/bin/activate

Python OOP

An Vo — Mon, 17 Feb 2025 09:23:08 +0000

I. What is Python OOP?

OOP = Object Oriented Programming.

Python fully supports OOP with Class and Class Inheritance. A Python class is a blueprint for creating from 1 to many objects. It can have:
Attributes are attached to it to maintain its state. They may be read-only or writeable.
Methods to modify its state. Syntax to define a class name "Animal":

class Animal:
    def __init__(self, secret_attribute="Suyt"):
        # __init__: constructor that runs when an object is created.
        # self: refers to the current instance of the class
        self.num_eyes = 2
        self.__secret_attribute = secret_attribute # Private variable

    def breathe(self):
        print("Inhale, exhale.")

    def get_secret_attribute(self):
        return self.__secret_attribute

    def make_sound(self):
        pass  # To be implemented by subclasses

II. What are the core concepts or elements of OOPs?

Class: a blueprint for creating objects class Animal
Object: an instance of a class. Instantiation is an action that creates an instance from the class nemo_fish = Fish().
Encapsulation: restricted direct access to attributes or from the outside self.__secret_attribute
Inheritance: Allows a child class to use methods and properties from parents' classes.

class Fish(Animal):
    """Fish class is an inheritance from Animal"""
    def __init__(self):
        super().__init__() # call Animal init

    def breathe(self):
        super().breathe() #call the Animal breathe function, then modify it.
        print("doing this underwater.")

    def swim(self):
        print("moving in the water")

Polymorphism: allows different classes to use the same method name but different implementations.

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

animals = [Dog(), Cat()]
for animal in animals:
    print(animal.make_sound())  # Calls the correct method based on the object type

Abstraction: hiding implementation details and only exposing essential functionalities. For example: we have many 2 kinds of animals: cats, dogs, and fish. We know they care how they make the sound, only care that they can make a sound.

from abc import ABC, abstractmethod # import abstract base class module

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

# Getting error if instantiate an abstract class
# dog = Animal()
# TypeError: Can't instantiate abstract class Animal
# without an implementation for abstract method 'make_sound'

# Dog class inherits from Animal so it has to implement method make_sound
class Dog(Animal):
    def make_sound(self):
        return "Woof! Woof!"

perfect_dog = Dog()
print(perfect_dog.make_sound())
# Woof! Woof!