We built some great AI power chat

interfaces together. The models know

about programming languages, historical

events, scientific concepts, and

millions of other topics to respond to

user questions. Let's say you want to

create an AI chat interface as an

internal tool where anyone can ask

questions about your company. For

example, developers need to know about

architecture decisions. Designers want

to look up brand guidelines and user

research findings. Product managers need

roadmap information and customer

feedback. Support teams need to quickly

find solutions to customer issues and

product documentation. The AI model has

no information about any of this. It

doesn't know your tech stack, your

design system, your product strategy, or

your customer history. And even for

public information, there's always a

cutoff date. The model doesn't know

about yesterday's product launch or this

morning's incident resolution. Now, you

might think, well, I'll just store all

my data in a database and search when

needed. Let me tell you, traditional

search has a huge problem. Imagine

you're on Netflix trying to find

something to watch. You remember

watching this great movie about AI

taking over the world, but you can't

remember the title. So, you search for

AI Apocalypse or Robots Destroying

Humanity. If the movie's title and

description don't have those exact

words, you get nothing. Zero results.

Maybe the movie description says

"Machines gain consciousness and

threaten mankind." Totally different

words, but similar meaning. Traditional

keyword search just doesn't work here.

This is exactly what Netflix, Spotify

YouTube, basically every content

platform has to deal with. How do you

help users find content based on

meaning, not just matching keywords?

This is where embeddings come in.

Embeddings are a way to turn text into

numbers that capture what the text

actually means. When you give text to an

embedding model, it gives you back a

list of numbers. We call this a vector.

These numbers represent what your text

means in mathematical terms. And here's

the cool part. Similar meanings end up

close together in this mathematical

space even if they use completely

different words. So AI apocalypse and

machines gain consciousness would be

really close in this embedding space

even though they don't share a single

word. And this is how Netflix can show

you the matrix when you search for

reality simulation, even though the

movie description might never use those

words. Now, let's talk about what these

vectors actually are. A vector is just a

list of decimal numbers. For OpenAI's

text embedding 3 small model, you

get,536

numbers. We call that,536

dimensions. Even the simplest text like

the matrix will give you an array of,536

dimensions. Of course, we can't

visualize thousands of dimensions. Our

brains max out at 3D, but the idea is

the same. Imagine a simple 2D graph

where we plot movies. On the x-axis

maybe we measure action versus drama

and on the y-axis, realistic versus

sci-fi. The Matrix would be high on

sci-fi and high on action. The Godfather

would be high on drama and high on

realistic. With,500

plus dimensions, the model can capture

superdetailed aspects of meaning, which

means similar content naturally groups

together. All sci-fi movies about AI

would be in one area. Romantic comedies

would be grouped in another area.

Historical documentaries would be

somewhere else entirely. But it is

smarter than just genre. The Matrix

Inception, and Blade Runner, for

example, would be super close together

because they're all philosophical sci-fi

that explores reality. Meanwhile, Star

Wars would be further away because it's

sci-fi, but more adventure than

philosophy. When Netflix wants to

recommend movies, they find the movies

closest to what you just watched in this

embedding space. When you search, they

convert your search into an embedding

and find the closest content. No keyword

matching is needed. But how do we

measure closeness in this space? The

most common way is called cosine

similarity. Without getting too deep

into the math, cosine similarity

measures the angle between two vectors.

It gives us a score from minus1 to one

where one means identical meaning, zero

means unrelated and minus one means

opposite meaning. So for example, the

matrix versus inception could be.92 very

similar. The matrix versus godfather

could be 31 pretty different. and matrix

versus the matrix reloaded could be.98

almost identical. Of course, these

numbers are hypothetical and will depend

on the model you use. Embeddings and

similarity search actually have many use

cases. In customer support, when a

customer says, "My internet is slow,"

you can find similar resolve tickets

even if they said connection lagging

pages loading forever, or bandwidth

issues. In content moderation, you can

detect harmful content even when people

use creative spelling or code words to

avoid keyword filters. In duplicate

detection, you can find similar bug

reports or support tickets even when

people describe the same problem

differently. In retrieval augmented

generation or rag for short, which is

what we are building toward, you can

store your documents as embeddings, find

the most relevant ones for a user's

question, and give them to the AI as

context to generate an accurate answer.

All right,, now, that, we, understand, the

theory, let's see how to actually

implement this in code. In the next

lesson, we will use OpenAI's embedding

models to convert text into vectors.