From Data to Knowledge: The Power of Vector Databases​

In a world flooded with unstructured data, how can we store not just information, but knowledge itself?

This article explores the rise of vector databases — a revolutionary technology that enables similarity-based search and semantic understanding. We'll break down what vectors are, how they're used in Natural Language Processing (NLP) and how embeddings allow for efficient, contextualized representations of information. Finally, we’ll explore real-world applications and why vector databases are becoming essential in modern AI systems.

The Rise of Unstructured Data​

With the advance of Big Data, billions of connected devices generate real-time information in the form of text, images, videos, and more. These unstructured formats don't fit well into traditional SQL tables and demand more sophisticated storage solutions. This is where vector databases emerge as a game-changing approach, enabling similarity-based searches and unlocking knowledge from complex data.

Before we dive into how vector databases work, let’s first recapitulate the fundamentals of databases.

What Is a Database?​

A database is, simply put, an organized collection of information that can be efficiently accessed, managed and updated. It acts as a structure that stores and organizes data, making it easy to query and manipulate using specialized software.

Relational Databases​

Relational databases are the most commonly used type. They store data in tables organized into rows and columns — where each row represents a record and each column represents a field or attribute. This model is ideal for structured data such as customer records, bank transactions, or product inventories.

A classic example is a customer database with columns for name, address, phone number and email. Relational databases enable fast and precise queries like “find all customers who made a purchase in the last 30 days,” using a language known as SQL (Structured Query Language).

Non-Relational Databases (NoSQL)​

Unlike relational databases, NoSQL databases are designed to handle unstructured or semi-structured data, offering more flexibility and scalability. They store information in diverse formats such as JSON documents, key-value pairs or graphs. This makes them better suited for modern applications like social-media platforms or streaming services.

For instance, a document-oriented NoSQL database might store data in JSON format, allowing for more complex and nested data structures — without requiring a rigid schema.

Among the categories of non-relational databases, vector databases stand out for their ability to store contextualized data — also known as knowledge.

Vector Databases​

Vector databases introduce a transformative approach tailored to store and retrieve data as vectors — mathematical structures that represent information in multiple dimensions. Unlike traditional databases that rely on exact matching, vector databases enable similarity searches, which are ideal for retrieving content like texts, images or sounds based on their characteristics.

This brings us to a key question: what is a vector?

What Is a Vector?​

A vector is a structure that stores information across multiple dimensions. In the case of a three-dimensional vector, it has three coordinates — (x, y, z) — that define its position or direction in a 3-D space.

A real-world example is how colors are represented in the RGB model (Red, Green, Blue). A color is described by three values, each representing the intensity of red, green and blue. For instance, white is [255, 255, 255], while black is [0, 0, 0].

This concept extends to 4-D vectors, such as RGBA, where the fourth component “A” stands for alpha (transparência). A semi-transparent red poderia ser [255, 0, 0, 0.5].

Just as colors can be represented by vectors in three or four dimensions, vector databases use vectors to organize items such as words, images and sounds in multidimensional spaces, where the distance between vectors indicates similarity.

Representing Words with Vectors​

Vectors are widely used to represent more abstract information, such as words. In NLP, converting words into numbers is essential for machines to understand and manipulate them. One of the simplest techniques is One-Hot Encoding.

One-Hot Encoding​

One-Hot Encoding is a technique in which each word is transformed into a vector of zeros and ones. In this vector, each position corresponds to a specific word in the vocabulary, and only one position holds the value "1" — all the others are set to "0".

Let’s consider a set of four words: dog, cat, bird, and fish. Using One-Hot Encoding, these words would be represented as follows:

• dog: [1, 0, 0, 0]
• cat: [0, 1, 0, 0]
• bird: [0, 0, 1, 0]
• fish: [0, 0, 0, 1]

Each vector contains only one "1", indicating the corresponding word, while the "0s" indicate that the other words are not present. Although this approach is simple and easy to implement, it comes with some limitations — especially as the vocabulary begins to grow.

The Limitations of One-Hot Encoding​

Although simple, One-Hot Encoding doesn't capture semantic relationships between words. In the example above, "dog" and "cat" are treated as completely different, even though both are household pets, have four legs, two ears, and a tail. Another drawback appears in scenarios with large vocabularies — say, 10,000 words. In such cases, each word would be represented by a very long vector with a single "1" among 10,000 positions, offering no indication of how the words relate to one another. This inefficiency and lack of semantic information highlight the need for more advanced techniques to represent words as vectors in a meaningful way.

Advanced Representations: Embeddings​

To overcome these limitations, embeddings were introduced — dense and continuous vector representations of words, where words with similar meanings are placed close to each other in the vector space. Unlike One-Hot Encoding, embeddings capture the meaning of words, positioning related terms — like “dog” and “cat” — near each other in the vector space, since they share common features.

What Are Embeddings?​

Embeddings are a way to represent data as vectors, where similar items are positioned close to one another in a multidimensional space. They are widely used in areas like NLP to capture relationships between words, images, or sounds more effectively than simpler methods like One-Hot Encoding.

These embeddings allow data with similar characteristics to cluster together, which makes similarity search and grouping of related information much more efficient.

A Simple Analogy: Colors in a 3-D Vector Space​

To make this easier to understand, let’s consider a familiar example: colors in the RGBA model. Each color is represented by four values — the intensities of red, green, and blue, plus an alpha channel that controls transparency — placing it in a four-dimensional (4D) space.

Since we can’t visualize four dimensions directly, we simplify by plotting just the RGB components in a 3D space. The alpha value still exists, but isn't represented visually in this view.

For example:

• Red: [255, 0, 0, 1]
• Light Red: [255, 0, 0, 0.5]
• Green: [0, 255, 0, 1]
• Blue: [0, 0, 255, 1]

When we plot these colors in a 3D space using only the RGB components, we can clearly see that Red and Light Red appear close to each other, while Green and Blue are located farther away. This spatial proximity reflects how similar the colors are — in this case, due to their shared red intensity.

Representing Words with Embeddings​

Now, let’s apply this idea to how we represent words. Instead of using three or four dimensions like in the RGB color model, words are typically represented in vector spaces with hundreds or even thousands of dimensions. Each dimension captures some aspect or feature of the word — such as its meaning, context, or relationships with other words.

For example:

In the example above, "dog" and "cat" appear close to each other in the vector space, because both are pets and share contextual similarities. On the other hand, "car" and "forest" are positioned farther away due to their very different meanings and usage patterns.

Illustrative only — no actual model was used to generate this plot.

These high-dimensional vector spaces are generated by embedding models, which analyze large volumes of text and learn to position words based on the contexts in which they appear. The closer two words are in the space, the more semantically similar they are likely to be.

This representation makes it possible for machines to reason about meaning — not just recognize exact matches, but understand relatedness. That’s a key foundation for modern AI tasks like question answering, translation, and semantic search.

Explore a Real Embedding Representation​

If you’d like to see what embeddings look like in practice, you can explore a live, interactive visualization using the TensorFlow Embedding Projector. This tool allows you to navigate through high-dimensional vector spaces and observe how words, images, or other data points are organized based on their semantic relationships.

You'll see something similar to the example below, where each word is plotted in a space with up to 200 dimensions, reduced visually to 2D or 3D using dimensionality reduction techniques like PCA ou t-SNE.

In this visualization, each dot represents a word, and the proximity between them reflects how similar their meanings are according to the embedding model. For example, the word “store” is surrounded by words like “shop,” “market,” and “retail”, indicating that the model has learned their contextual similarity from large-scale text data.

This type of embedding space enables machines not only to recognize individual terms, but also to understand relationships between them — a powerful capability for tasks like semantic search, where the goal is to find relevant information based on meaning rather than exact matches.

How Does a Vector Database Work?​

Now that we’ve covered the basic concepts, we can better understand how vector databases operate. A vector database organizes data in the form of vectors, which occupy positions in multidimensional space. The main goal is to enable semantic search — that is, finding similar items based on their vector proximity, rather than exact matches like in traditional databases.

For example, imagine a database of images where each image is represented as a vector that captures its visual characteristics — such as color, shape, and texture. If you want to find images similar to a specific picture of a cat, the vector database will compute the distance between the query image's vector and the vectors of other stored images. Those with the shortest distance will be returned as results, since they share similar characteristics.

A common real-world application of this is facial recognition, where the similarity between the vector of a captured face and that of a registered face can indicate a potential match.

But how exactly is similarity between vectors measured?

Vector Distance and Similarity Search​

In a vector database, items with similar features are clustered close to each other in a multidimensional space. The "closeness" — or similarity — between items is determined by specific distance metrics, such as Euclidean distance or cosine similarity.

In the case of word searches, like in our earlier embeddings example, a vector database can return words that are semantically close to the query. For instance, if you search for the word "feline", the database might return "cat," "tiger," or "leopard", based on how near their vectors are in the semantic space.

This kind of vector-based matching allows systems to go beyond surface-level keywords and find results that are meaningfully related, even when the exact words don’t match — a major advantage in modern AI applications.

Applications of Vector Databases​

Vector databases are already being widely used to solve challenges related to unstructured data across various domains. Here are some practical examples:

• Image Search: Medical systems and platforms like Google Images use vector databases to find visually similar images based on features like color, shape, and texture — which helps with diagnoses and content discovery.

• Product Recommendations: In e-commerce, vector databases suggest products based on past searches or user purchase history, enabling a more personalized shopping experience.

• Facial Recognition: Security systems use vector databases to compare facial images, identifying matches with high precision — making authentication and surveillance more effective.

• RAG (Retrieval-Augmented Generation): This technique combines document retrieval from vector databases with the response generation capabilities of large language models (LLMs). It allows these models to specialize in specific topics without requiring retraining.

In my undergraduate thesis, I used RAG to build a chatbot focused on mental health. The system retrieves relevant information and provides more accurate and contextualized responses.

Conclusion​

As unstructured data continues to grow exponentially, vector databases are becoming essential for retrieving information efficiently and meaningfully. By enabling similarity-based search rather than relying on exact matches, they open up new possibilities for interacting with complex data in more intuitive and intelligent ways.

From applications like image search, product recommendations, and facial recognition, to powering advanced techniques such as RAG, vector databases are poised to play a foundational role in the future of artificial intelligence. They help bridge the gap between raw data and actionable knowledge — fueling innovation across industries.

In a world where context and meaning matter more than ever, vector databases offer a paradigm shift. By interpreting data semantically, they have the potential to revolutionize the way we store, retrieve, and understand information — connecting today’s digital systems with the knowledge-driven technologies of tomorrow.

References​

This article was originally published on LinkedIn.

Do you know what magic methods are in Python? Hint: You use them every day!​

A few years ago, when I was learning to use the Django framework (the first framework I ever learned), I came across a peculiar characteristic of Python classes: the constructor method has to follow a specific pattern — it must be identified by double underscores (__) before and after the word init. That struck me as odd; why this specific structure?

class MyClass:
    def __init__(self): # This is the constructor method
        ...

Trying to understand where these 'different' functions came from, I found out that in the world of Python, there are several methods that follow this 'dunder' pattern (a nickname derived from Double UNDERscore). These methods aren’t just common — they’re special and fundamental to the language, known as dunder methods or magic methods.

OK, but what do these methods actually do? What makes them 'magic'?

Those were some of the questions that led me to study them more deeply and write this article. Hope you enjoy it :)

What are dunder methods?​

In the world of programming, we often come across concepts that seem complex at first, but once understood, make perfect sense. A great example of this in Python is dunder methods.

So, what exactly are these methods? As mentioned earlier, the word 'dunder' refers to the double underscore notation at the beginning and end of the names of these special methods. For instance, __init__ for a class constructor, or __str__ for the string representation of an object.

P.S. Some Python purists don’t like calling the __init__ method a constructor, since technically it’s an initializer. However, for the sake of simplicity, we’ll refer to it as a constructor throughout this article.

These methods aren’t called directly by name. Instead, Python calls them internally when certain actions are performed. For example, when we add two objects using the + operator, Python internally calls the __add__ method, which handles the logic of adding one value to another.

Still a bit confusing? Let me give you some examples to make it clearer!

Imagine you're building a class to represent a book in a library. To do that, you’ll need to implement the __init__ method, which acts as a constructor, setting up initial attributes like title, author, and page count:

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

What happens when you try to add two Book objects together? You might expect them to combine in some way, but Python doesn't know how to handle that operation by default:

book1 = Book("First Book", "Author A", 100)
book2 = Book("Second Book", "Author B", 200)

print(book1 + book2)

This will raise a TypeError because Python doesn't know how to add two Book objects together. This code will output:

>>> TypeError: unsupported operand type(s) for +: 'Book' and 'Book'

To make this operation work, you can define the __add__ method in your Book class. This method will specify how two Book objects should be added together. For example, you might want to add their page counts:

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

    def __add__(self, other):
        return self.pages + other.pages

Now, when you try to add two Book objects, Python will call the __add__ method, in this case, summing their page counts. This is how you can customize the behavior of operators for your own classes.

book1 = Book("First Book", "Author A", 100)
book2 = Book("Second Book", "Author B", 200)

print(book1 + book2) # This will output: 300

This behavior isn't limited to just the addition operator!

Actually, the most operators in Python can be customized using dunder methods. For example, you can define how your class behaves with the == operator by implementing the __eq__ method, or with the - operator by implementing the __sub__ method. A good example of this is the in operator, when we verify if some value is in a list, behind the scenes, Python is calling the __contains__ method of the list class, passing the value as an argument. See the example below:

my_list = [1, 2, 3, 4, 5]

print(3 in my_list)  # This will output: True
print(my_list.__contains__(3))  # This will also output: True

print(6 in my_list)  # This will output: False
print(my_list.__contains__(6))  # This will also output: False

More examples of dunder methods​

Now that you have a basic understanding of what dunder methods are and how they work, let's see some more examples of their usage, still applied to the Book class:

__str__: Customizing prints​

Following the previous example, what happens when you try to print a Book object? By default, Python will show something like <__main__.Book object at 0x...>, which isn't very informative:

book1 = Book("First Book", "Author A", 100)
print(book1)

This will output something like:

>>> <__main__.Book object at 0x7f8c1b0d0>

If you're wondering whether it's possible to customize this output, making the representation more user-friendly, yes, it is! You just need to implement the magic method called __str__ in your class. This method allows you to define how your object should be represented as a string. So, let's go ahead and implement it:

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

    def __str__(self):
        return f"{self.title} by {self.author}, {self.pages} pages"

Now, when you print a Book object, it will display the title, author, and page count in a more readable format:

book1 = Book("First Book", "Author A", 100)
print(book1) # This will output: First Book by Author A, 100 pages

__eq__: Customizing equality checks​

What if you want to check if two Book objects are considered equal? By default, Python checks if they are the same object in memory, which might not be what you want. To customize this behavior, you can implement the __eq__ method:

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

    def __eq__(self, other):
        return (self.title == other.title and
                self.author == other.author and
                self.pages == other.pages)

Now, you can compare two Book objects for equality based on their attributes:

book1 = Book("First Book", "Author A", 100)
book2 = Book("Second Book", "Author B", 200)
book3 = Book("First Book", "Author A", 100)

print(book1 == book2)  # This will output: False
print(book1 == book3)  # This will output: True
print(book3.__eq__(book1))  # This will output: True

__len__: Customizing length checks​

What if you want to check how many pages a book has? You can manually check the pages attribute, but you can also implement the __len__ method to allow the use of the built-in len() function:

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

    def __len__(self):
        return self.pages

Now, you can use the len() function on a Book object:

book1 = Book("First Book", "Author A", 100)
print(len(book1))  # This will output: 100

__getitem__: Customizing item access​

Lastly, what if you want to access a specific attribute of a Book object using indexing, like book[0] for the title? You can implement the __getitem__ method:

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

    def __getitem__(self, index):
        if index == 0:
            return self.title
        elif index == 1:
            return self.author
        elif index == 2:
            return self.pages
        else:
            raise IndexError("Index out of range")

Now, you can access the title, author, and pages of a Book object using indexing:

book1 = Book("First Book", "Author A", 100)
print(book1[0])  # This will output: First Book
print(book1[1])  # This will output: Author A
print(book1[2])  # This will output: 100

Conclusion​

These were just a few examples that highlight the power and flexibility of dunder methods in Python. With them, you can shape the behavior of your classes and objects in ways that align with the language's syntax and paradigms, making your code more intuitive and 'Pythonic'.

So, next time you're designing a Python class, remember the magic of dunder methods and how they can enrich your abstractions!

Bellow, I'll leave a list of some of the most commonly used dunder methods in Python, each linked to the official documentation for further reading:

• __init__: The constructor method, called when an object is created.
• __add__: Defines the behavior of the addition operator (+).
• __contains__: Defines the behavior of the in operator for an object.
• __str__: Defines the string representation of an object, used by the print() function.
• __eq__: Defines the behavior of the equality operator (==).
• __len__: Defines the behavior of the len() function for an object.
• __getitem__: Defines the behavior of indexing an object (e.g., obj[key]).
• __setitem__: Defines the behavior of setting an item in an object (e.g., obj[key] = value).
• __delitem__: Defines the behavior of deleting an item from an object (e.g., del obj[key]).
• __repr__: Defines the official string representation of an object, used by the repr() function.
• __ne__: Defines the behavior of the inequality operator (!=).
• __lt__: Defines the behavior of the less than operator (<).
• __le__: Defines the behavior of the less than or equal to operator (<=).
• __gt__: Defines the behavior of the greater than operator (>).
• __ge__: Defines the behavior of the greater than or equal to operator (>=).
• __sub__: Defines the behavior of the subtraction operator (-).
• __mul__: Defines the behavior of the multiplication operator (*).
• __truediv__: Defines the behavior of the true division operator (/).
• __bool__: Defines the truth value of an object, used by the bool() function.
• __iter__: Defines the behavior of an object when used in a loop or with the iter() function.
• __next__: Defines the behavior of the next() function for an object, allowing it to be iterable.
• __enter__: Defines the behavior of an object when used in a with statement, allowing it to set up a context.
• __exit__: Defines the behavior of an object when exiting a with statement, allowing it to clean up resources.
• __hash__: Defines the behavior of the hash() function for an object, allowing it to be used in hash-based collections like sets and dictionaries.
• __del__: Defines the behavior of an object when it is about to be destroyed, allowing for cleanup actions.

I hope this article has shed some light on the fascinating world of dunder methods in Python. If you have any questions or want to share your experiences with dunder methods, feel free to get in touch! Happy coding!

References​

Hello, world! 👋

I’m Marco Antônio and this is my Brain Blog.

This first post is a quick tour of what you’ll find here.

Why “Brain Blog”?​

“Those who teach learn while teaching, and those who learn teach while learning.” — Paulo Freire (Translated from Portuguese)

Brain Blog is a public backup of my brain where I capture study notes, organize references and document learning journeys.

Content structure​

My personal stream of ideas and experience.

You’ll read articles, tutorials and reflections on topics that excite me, plus lessons learned from real‑world projects.