WEBVTT

00:00.000 --> 00:12.000
For those who don't know me, let's get corrected and I work at Altinity as a Director

00:12.000 --> 00:20.000
of Services and we do support services and database of the service at Specializing Over

00:20.000 --> 00:21.000
Clickhouse.

00:21.000 --> 00:27.200
About myself, I've been working in open source for the last decade and a half and previously

00:27.200 --> 00:32.200
in life, I was an enterprise space doing enterprise databases.

00:32.200 --> 00:36.200
Most recently and within the last four or five years, I've called two books which I brought

00:36.200 --> 00:38.200
some over here.

00:38.200 --> 00:41.200
One of them is the MySQL cookbook over here.

00:41.200 --> 00:43.200
We have a few copies.

00:43.200 --> 00:48.200
This one should go to the best question and I'll say that one for the best question in the

00:48.200 --> 00:49.200
room.

00:49.200 --> 00:54.200
This one is the latest book on the database design modeling which we touch based on the new technologies

00:54.200 --> 00:59.200
and how it is scalable database operations and options to explore.

00:59.200 --> 01:02.200
This should go to the youngest in the room.

01:02.200 --> 01:03.200
I'll see.

01:03.200 --> 01:07.200
Okay.

01:07.200 --> 01:08.200
Sealing through you.

01:08.200 --> 01:09.200
That's my high-spraaker.

01:09.200 --> 01:13.200
I was going to skip that but I want to ask the question like, what's the one

01:13.200 --> 01:15.200
noticle mild equals two?

01:15.200 --> 01:17.200
How many kilometers?

01:17.200 --> 01:19.200
How do you measure that?

01:19.200 --> 01:20.200
Anyone?

01:20.200 --> 01:23.200
One point eight.

01:23.200 --> 01:24.200
One point eight.

01:24.200 --> 01:25.200
Okay.

01:25.200 --> 01:27.200
Because in land it's one point six.

01:27.200 --> 01:28.200
Thank you.

01:28.200 --> 01:29.200
All right.

01:29.200 --> 01:32.200
I'll go back.

01:32.200 --> 01:34.200
Not the embeddings.

01:34.200 --> 01:37.200
We can have two closer, I guess.

01:37.200 --> 01:39.200
Let me see.

01:39.200 --> 01:41.200
This clicker is not clicking.

01:41.200 --> 01:44.200
All right.

01:44.200 --> 01:47.200
I'll let chunker into this himself actually.

01:47.200 --> 01:48.200
That would be good.

01:48.200 --> 01:49.200
Hi.

01:49.200 --> 01:54.200
My name is Shankar and I've been an engineer throughout my life.

01:54.200 --> 01:59.200
And I was a long-term member of the Oracle Rack database development team, real application clusters.

01:59.200 --> 02:04.200
I was working in distributed logging, distributed recovery and stuff like that.

02:04.200 --> 02:11.200
After that, I have done some work in my SQL at Aurora and in Google.

02:11.200 --> 02:15.200
And yeah, my interests are of course vector search and AI.

02:15.200 --> 02:23.200
I also do a lot of work in my SQL and new recovery performance and really recovery performance improvements.

02:23.200 --> 02:24.200
Yeah.

02:24.200 --> 02:25.200
That's about me.

02:25.200 --> 02:26.200
Awesome.

02:26.200 --> 02:29.200
He's our developer on my vector project.

02:29.200 --> 02:33.200
And he's also the mastermind and architect of it.

02:33.200 --> 02:40.200
I'm with the vector space for the last six months not as experience as him.

02:40.200 --> 02:41.200
And we all learning.

02:41.200 --> 02:44.200
So let's learn that together today.

02:44.200 --> 02:45.200
Just a minute.

02:45.200 --> 02:47.200
Just use this one.

02:47.200 --> 02:49.200
Okay, vectors and dimensions.

02:49.200 --> 02:59.200
So vectors actually as much as also went through is a data point that represents what we point to.

02:59.200 --> 03:02.200
So what we can access to it can they can be in.

03:02.200 --> 03:07.200
We learned in our school systems in the earlier mat was two dimensional functions.

03:07.200 --> 03:11.200
And then there's a three dimensional space where you can actually have.

03:11.200 --> 03:18.200
And then the geo space and then there's also a data types that actually needs to be represented as vectors and within the dimensions.

03:18.200 --> 03:21.200
And.

03:21.200 --> 03:33.200
So vectors once the vectors are coupled and and collected they turn into an embedding and these embeddings can be represented as.

03:33.200 --> 03:42.200
The mathematical expressions and and those can be also processed using the functions that we will.

03:42.200 --> 03:44.200
Demo today.

03:44.200 --> 03:50.200
This is used in in like the AI as the previous talk mentioned and.

03:50.200 --> 04:00.200
It is popular with the AI but before even AI there it was already been used in some other places which I will also touch base on.

04:01.200 --> 04:03.200
So the vector embeddings.

04:03.200 --> 04:11.200
This is an example of an embedding that open AI uses and so this is a Wikipedia article.

04:11.200 --> 04:18.200
And there's a model called embedding ADA zero zero two with the dimensions one five three six.

04:18.200 --> 04:23.200
So there's what they do is they go and train on this using the L of M.

04:23.200 --> 04:30.200
And they have which is also open source and with these dimensions you get certain answer and like.

04:30.200 --> 04:34.200
Mathias said in the previous talk is is approximate.

04:34.200 --> 04:45.200
So the the higher dimensions the higher the data points are those embeddings you get a better result or a larger dataset the result that can be.

04:46.200 --> 04:49.200
The manipulated in the more meaningful.

04:49.200 --> 04:57.200
So also open AI has another model called text embedding three large model with with a higher dimension of 3000.

04:57.200 --> 05:03.200
So you can process that what that means is you need more GPU power which cost more money.

05:03.200 --> 05:12.200
But on the end deep seek popped up and they can also do embeddings up to 8k so 8000 dimensions embeddings are possible with deep seek.

05:12.200 --> 05:19.200
But to process that it will take more GPU power and of course space to do that.

05:19.200 --> 05:24.200
So I think we all are learning about more about embeddings what are the benefits.

05:24.200 --> 05:28.200
Exactly what we try to do in the databases is a search.

05:28.200 --> 05:38.200
So if you all remember in this room a use some sort of a full text search with you know like equals you know matching or other functions in in the.

05:38.200 --> 05:42.200
So basically most of them are covered in this book.

05:42.200 --> 05:48.200
It is very difficult and costly operation to do that within a database not scalable also.

05:48.200 --> 05:59.200
On the large scale eCommerce applications mobile applications you search for a keyword and then you can actually have an answer but it.

05:59.200 --> 06:05.200
You will get an exact answer from those or LTP databases but it will be costly and may not be very efficient.

06:05.200 --> 06:17.200
So the AI based applications use this technique and that is going to be supporting some of the application.

06:17.200 --> 06:31.200
So why do we need vector support in our databases because the traditional search is is not very efficient to get the results.

06:31.200 --> 06:41.200
And again the born of AI machine learning and all that new technology open source and have this.

06:41.200 --> 06:43.200
Need.

06:43.200 --> 06:46.200
So coming back to my SQL that is our subject.

06:46.200 --> 06:52.200
So you have my SQL implementation and you also do some sort of some of you will remember.

06:53.200 --> 07:00.200
Solar search you know doing full text indexing on a different we brand that for replicas for many many years.

07:00.200 --> 07:04.200
I don't know if it's still relevant but I think with this technology is not.

07:04.200 --> 07:07.200
And Phoenix was very popular at one point.

07:07.200 --> 07:15.200
We would run a replica of a replica so it's not impacted by something else run a job and then in the morning you would have an index that you could do a search.

07:15.200 --> 07:27.200
Keywords adapter you know plugs USB type C whatever and but with the support of existing ecosystem we can add some more functionality in my scan that's the idea behind.

07:27.200 --> 07:37.200
Why do we need my scan and my scan is also very popular and using places so it's it can be very good.

07:38.200 --> 07:47.200
The use cases are what he has already mentioned the NLP and LMs and other souls keep that okay.

07:47.200 --> 07:53.200
This is something when I was doing a little bit more deep research why.

07:53.200 --> 07:59.200
There are no vector dedicated databases that will do this job properly.

07:59.200 --> 08:04.200
There are actually they call a vector database.

08:04.200 --> 08:14.200
And some of these are listed I'm no in expert in these but what are the differences between the vector database or a vector store as a provider.

08:14.200 --> 08:28.200
In this case is my SQL MariaDB has tied DB has postgreses with also some of them are a little more specialized in this type of workflows like click house elastic search where you can actually have a more analytics.

08:28.200 --> 08:34.200
Targeted all updates as instead of having an within an all tb system.

08:34.200 --> 08:40.200
These databases if you do a little bit research on the vector database they're actually.

08:40.200 --> 08:48.200
Not a real database but it's a platform they provide an API and software development kit for the database behind it.

08:48.200 --> 09:00.200
You basically you code vector related or machine learning related or AI related application within the database.

09:00.200 --> 09:17.200
So they come with bunch of libraries you don't it's not like a SQL compatible database query and answer type of databases some of them they provided some of them are completely application based.

09:18.200 --> 09:29.200
Where as with the vector support comes to comes to existing databases database platforms is an extension to existing solution.

09:29.200 --> 09:43.200
So you already have your data in this case my SQL and you want to add a some sort of functionality within the my SQL you can get that with our subject of today is the plugin.

09:43.200 --> 09:57.200
So traditional databases use you know we are organized with schema and and we have tables columns data types we do.

09:57.200 --> 10:03.200
We get that result but vector databases is slightly different they go in.

10:03.200 --> 10:18.200
They go in in the data type which is in this case the embeddings are vector within the dimensions we get we get a different approach and we instead of versus rows and columns we have the embeddings in it.

10:18.200 --> 10:33.200
It's kind of a difference between we need to we must remember the difference and then that's how the compression and how we store the data how we index the data it's going to be different and traditional database on those.

10:33.200 --> 10:39.200
And again like if you're basically doing an AI based or or.

10:39.200 --> 10:50.200
This type of application it would be good to go into that direction as focusing on a vector database but if you have a database that has.

10:50.200 --> 11:05.200
Already in in progress and and you have it in production and one and add functionality you can do that and at that I'm going to the microphone to shankar for the vector plugin architecture.

11:06.200 --> 11:11.200
Yeah, you can often.

11:11.200 --> 11:24.200
Okay, thanks I'll can for laying the background and thanks Matthias for also laying the background earlier and let's get in how the my vector plugin is are.

11:24.200 --> 11:42.200
So let's look at the my vector plugin architecture so if you're aware of postgres rate postgres is very extensible you can add new data types you can add new access methods.

11:42.200 --> 11:51.200
So it's very extensible and that's how the PG vector was added in fact and but my sequel is not you can and we add a new storage engine to my sequel.

11:51.200 --> 11:59.200
You can't hack around with the optimizer or even data types and I worked in Oracle so adding a new data type is not easy job.

11:59.200 --> 12:09.200
So the plugin has three main components uses UDF's user defined functions in CNC++ every database provides that.

12:09.200 --> 12:20.200
It uses for the data type it for a type sorry for a to it uses wire binary that's basically a blob where you can just push those floats.

12:20.200 --> 12:33.200
And with nine we have the vector data type in my sequel so the plugin uses the vector data type and the third component for the indexing so it uses an hns w.

12:33.200 --> 12:46.200
vector index and the index supports both online and batch mode builds so online so the third piece of the design is it uses bin logs to update the vector index.

12:46.200 --> 12:54.200
So it's a plugin it's not inside the database it cannot intercept the emails but it uses the bin log as a wall.

12:55.200 --> 13:04.200
So post commit update of the vector index it came up earlier so it provides read committed consistency.

13:04.200 --> 13:17.200
All right and to tie all these things we have stored procedures so again we the plugin cannot change the my sequel syntax it doesn't touch the parser doesn't touch the grammar so it uses stored procedures.

13:17.200 --> 13:22.200
And stored procedures are in fact an easy way to extend the functionality of any database.

13:22.200 --> 13:34.200
Again, from coming from the Oracle day is right lot of Oracle supply thousands of stored procedures so things like queuing advanced queuing and stuff are implemented only using stored procedures.

13:34.200 --> 13:43.200
So for managing the database the plugin provides stored procedures.

13:43.200 --> 14:06.200
Okay so it's completely open source it's the get up repo is there and how do you build or get and build the plugin is straightforward you get clone the repo and like any other plugin my sequel plugin so you configure the make file for the plugin and then just make it.

14:06.200 --> 14:21.200
Output of this will be a shared object and then you take the shared object yes to file and copy it to the my sequel distribution my sequel installation directory and you run this single script SQL script.

14:21.200 --> 14:38.200
This will go and install the plugin and create the UDFs the the wrappers for the UDFs and also install these stored procedures that the plugin uses plugin provides.

14:38.200 --> 14:50.200
Yeah little more so the plugin is supported the same thing works for both my sequel ato if you have a production system currently in my sequel ato you can use it all the demos are on I know what I know.

14:50.200 --> 15:11.200
But it will work the same way for it and just going over this graphic here right so the index can be updated in the batch build or it can be updated online also both ways and batch is a very important use case models change frequently.

15:11.200 --> 15:24.200
So you have a million documents you have a hundred million documents you index it today the model LLM right it learns new things next month a new LLM the new version of the model could be released so you will have to reindex everything.

15:24.200 --> 15:30.200
So batch all the online is important batch is also more important.

15:30.200 --> 15:50.200
Okay and some of the other features of the plugin it uses the agonist w library from the original author thank you to your email code so it uses the same code as the original inventor of agonist w so high speed parallel build of index is supported.

15:50.200 --> 15:58.200
You can specify the recall and search parameters that the theories lays out.

15:58.200 --> 16:15.200
Agonist w is incrementally persistent so it's not a full versus full right on every update the agent is w is incrementally persistent so you have a hundred million documents today index and you add 10 more it is only incrementally persistent of 10 more index updates.

16:15.200 --> 16:28.200
As I mentioned the index is updated by reading the bin law it is crash slave index is crash slave so I have been working in recovery for in many multiple databases so it is crash slave.

16:28.200 --> 16:40.200
If the my SQL crashes comes back up it is recovered the next is recovered and why a plugin there is a theory behind if I can't I'm not listed the paper but.

16:40.200 --> 16:52.200
Domain indexes are better always as an external index things like spatial things like image index or stuff right this is not a relational databases for more structured data but.

16:52.200 --> 17:00.200
This kind of indexes are typically called as external domain indexes and they are better of stored outside the database and.

17:00.200 --> 17:04.200
That's why you are the plugin avoids right amplification.

17:04.200 --> 17:08.200
Okay, let's jump to the demo.

17:08.200 --> 17:12.200
Let me do that once again.

17:12.200 --> 17:16.200
Okay.

17:24.200 --> 17:28.200
Yeah, you will have to enable bin log on the primary and the replic also.

17:28.200 --> 17:34.200
Okay, you said that the index sets up after we don't make several individually because that's not set.

17:34.200 --> 17:36.200
Yeah.

17:36.200 --> 17:45.200
But the flexibility provided is there as I can mention about solar right so you can so you can have a production system which is the primary and.

17:45.200 --> 17:55.200
But you don't want vector search to impact that so you can have only this index set up on the replic also so you have a high memory and high CPU instance.

17:55.200 --> 17:59.200
So you can set it up on the replic also only on the replic.

17:59.200 --> 18:05.200
Okay, so let's look at a quick demo quick demo but I want to just remind.

18:05.200 --> 18:11.200
It's a plugin so it needs to be compiled so I think something need to keep in mind so you can just.

18:11.200 --> 18:22.200
If you have a like a binary that's running right now if you add the plugin to plugin directory if you restart it won't work so you still need to download the source.

18:22.200 --> 18:28.200
Add the plugin compile and then run it's basically just a kind of quick reminder.

18:28.200 --> 18:33.200
Okay, so let's look at the demo.

18:33.200 --> 18:36.200
So I'll stand here.

18:36.200 --> 18:50.200
So we have three demos the first demo is it has a bit of vectors where you see visually or in text one but beyond that as Mattias mentioned right you don't need to really see the vectors there like to high dimensions.

18:50.200 --> 18:54.200
So let's look at this demo.

18:54.200 --> 19:00.200
Okay, so this is kind of the data dictionary for the my vector and we are going to create a table.

19:00.200 --> 19:04.200
Which has words and their amenities.

19:04.200 --> 19:13.200
This is from this Stanford NLP data set so they publish a data set where 400k words and their 50 dimension vectors are published.

19:13.200 --> 19:19.200
So the demo is based on that.

19:19.200 --> 19:27.200
So the same set of files are part of the GitHub.

19:27.200 --> 19:31.200
So this is how you create a table with a vector column.

19:31.200 --> 19:33.200
So this is an annotation.

19:33.200 --> 19:38.200
Again, annotations are quite old in the database.

19:38.200 --> 19:42.200
And yeah, so you say my vector and a various parameters H&SW.

19:42.200 --> 19:52.200
So it also provides KNN index also if you want to do brute force search and the various H&SW related parameters.

19:52.200 --> 20:04.200
So in H&SW, this would translate into bar binary in I know it would translate to the Oracle vector tag.

20:04.200 --> 20:09.200
So I'm going to create the table.

20:09.200 --> 20:21.200
Yeah, just to show that this became the vector column and it uses the comments as data dictionary.

20:21.200 --> 20:24.200
So next is we will insert 400k.

20:24.200 --> 20:31.200
Yeah, this is where we see a vector actually beyond this demo there's no more seeing the vectors.

20:31.200 --> 20:33.200
So this is the Stanford NLP data set.

20:33.200 --> 20:38.200
You see the word secretary and that is the 50 dimension vector for secretary.

20:38.200 --> 20:40.200
And we use my vector construct.

20:40.200 --> 20:42.200
You can use the Oracle supplied function also.

20:42.200 --> 20:44.200
And there are 400k rows.

20:44.200 --> 20:49.200
It just shows a brief snippet.

20:49.200 --> 21:08.200
So we load this 400k rows.

21:08.200 --> 21:14.200
Yeah, this is how the vector for book looks and we use the Oracle function vector to string.

21:14.200 --> 21:15.200
So now let's do some distance.

21:15.200 --> 21:21.200
So distance came repeatedly today in our thing.

21:21.200 --> 21:23.200
Okay, the next is from using the same function.

21:23.200 --> 21:26.200
So the Oracle function is in scientific notation.

21:26.200 --> 21:30.200
Whereas the my vector function prints it in decimal.

21:30.200 --> 21:39.200
So let's do some distance.

21:39.200 --> 21:42.200
So this is the distance between book and paper.

21:42.200 --> 21:45.200
Again, absolute distance is not matter.

21:45.200 --> 21:46.200
It's all relative that matter.

21:46.200 --> 21:49.200
So this is the distance between book and novel.

21:49.200 --> 21:51.200
Eight.

21:51.200 --> 21:55.200
Because using the my vector distance function from the plugin.

21:55.200 --> 21:57.200
The distance between book and car.

21:57.200 --> 21:58.200
So we moved away.

21:58.200 --> 22:01.200
We went further away from book.

22:01.200 --> 22:03.200
This is the distance between book and library.

22:03.200 --> 22:07.200
So we come back.

22:07.200 --> 22:11.200
And these are the 20 words closest to book.

22:11.200 --> 22:14.200
And yeah, the SQL query went away.

22:14.200 --> 22:15.200
So it will come back.

22:15.200 --> 22:20.200
Yeah, so this is exactly brute force gain in search.

22:20.200 --> 22:27.200
So you use the SQL order by and compute the distance between each vector and your search vector.

22:27.200 --> 22:28.200
And you get this.

22:28.200 --> 22:31.200
So the key point to realize is it came up.

22:31.200 --> 22:36.200
It is brute force could be good if you have power and your data set is manageable.

22:36.200 --> 22:38.200
But my SQL does not have parallel query.

22:38.200 --> 22:41.200
So this has to be executed in this single thread.

22:41.200 --> 22:46.200
So this is how you build the vector index using the stored procedure.

22:46.200 --> 22:47.200
Done.

22:47.200 --> 22:51.200
Five seconds for 400k and 50 dimension.

22:51.200 --> 22:55.200
And this is how you search.

22:55.200 --> 22:59.200
Again, you can see the vector in this example, but beyond this point you.

22:59.200 --> 23:04.200
So select word from words where my vector is approximate number search.

23:04.200 --> 23:08.200
And you give the vector column and a couple of other parameters.

23:08.200 --> 23:09.200
And then the search vector.

23:09.200 --> 23:11.200
So this is the search vector.

23:11.200 --> 23:21.200
So this is the search vector for hardwood.

23:21.200 --> 23:25.200
So these are the 10 words related to hardwood.

23:25.200 --> 23:32.200
And yeah, the same one using brute force.

23:32.200 --> 23:42.200
So this completes one part of the demo.

23:42.200 --> 23:45.200
So let's look at a Wikipedia related one.

23:45.200 --> 23:46.200
Open AI stuff.

23:46.200 --> 23:56.200
So I'll just stand here.

23:56.200 --> 23:59.200
So we are using this as our demo.

23:59.200 --> 24:05.200
So the idea is a query created data set from Wikipedia.

24:05.200 --> 24:09.200
And I'm using two tables to store the data.

24:09.200 --> 24:11.200
So the data is stored in one table.

24:11.200 --> 24:14.200
So this is where you would document and stuff would be.

24:14.200 --> 24:18.200
So there is an ID column and a title column for the Wikipedia article.

24:18.200 --> 24:22.200
And the vector is stored separately in another table.

24:22.200 --> 24:25.200
And as I said, no point in seeing the vector.

24:25.200 --> 24:26.200
One, five, three, six.

24:26.200 --> 24:33.200
And it takes 6KB of this piece each vector.

24:33.200 --> 24:38.200
So 1 million documents or articles.

24:38.200 --> 24:41.200
And yeah.

24:41.200 --> 24:46.200
So on a 48 CPU, it's a green machine from OBS.

24:46.200 --> 24:48.200
And not nothing high powered.

24:48.200 --> 25:03.200
I took two minutes to index 1 million vectors of 15, 3, six-dimensional.

25:03.200 --> 25:04.200
Yeah.

25:04.200 --> 25:05.200
So how do you search?

25:05.200 --> 25:06.200
All right.

25:06.200 --> 25:07.200
It came up in the earlier talk.

25:07.200 --> 25:10.200
So you have your search vector as search query.

25:10.200 --> 25:12.200
Tell me some famous ancient structures.

25:12.200 --> 25:14.200
And then you contact Open AI.

25:15.200 --> 25:21.200
So you need to get the embedding for this query, search query,

25:21.200 --> 25:24.200
and then generate the SQL query.

25:24.200 --> 25:29.200
So the embedding goes here.

25:29.200 --> 25:34.200
So I run Python to get this SQL.

25:34.200 --> 25:38.200
So this is how the query looks like the final SQL query,

25:38.200 --> 25:39.200
just a snippet.

25:39.200 --> 25:42.200
Select article ID from DPIDware.

25:42.200 --> 25:52.200
This is the one, five, three, six-dimensional vector.

25:52.200 --> 25:53.200
Yeah.

25:53.200 --> 25:56.200
So we search for famous ancient structures.

25:56.200 --> 25:59.200
These are the top 10 matches.

25:59.200 --> 26:03.200
So now you'll have to visualize how this applies to your data set.

26:03.200 --> 26:05.200
Could be patent filings.

26:05.200 --> 26:08.200
Could be chat logs, personas.

26:08.200 --> 26:13.200
And the one more syntax is supported.

26:13.200 --> 26:26.200
So this time we will query some good marketing strategies.

26:26.200 --> 26:27.200
I have just a couple of minutes.

26:27.200 --> 26:28.200
So that's about it.

26:28.200 --> 26:30.200
There was a running one more demo.

26:30.200 --> 26:36.200
So this is about online update to the vector index.

26:37.200 --> 26:39.200
And this is a more business oriented thing.

26:39.200 --> 26:42.200
So we are going to search through a clinical trials dataset.

26:42.200 --> 26:45.200
Open, nothing, nothing private.

26:45.200 --> 26:47.200
And we're going to use the MP net model.

26:47.200 --> 26:51.200
So it is a sentence, transformer, free open source model.

26:51.200 --> 26:55.200
We are going to load around 283K documents,

26:55.200 --> 26:59.200
containing descriptions of clinical trials.

26:59.200 --> 27:06.200
Each divector is dimension 768.

27:06.200 --> 27:10.200
This is kind of the example table where I'm showing the how the role looks like.

27:10.200 --> 27:14.200
So there is a description of the study or the clinical trial.

27:14.200 --> 27:16.200
This is something about very close wings.

27:16.200 --> 27:19.200
And the vector is 768 dimension.

27:19.200 --> 27:22.200
On the part of the vector is shown.

27:22.200 --> 27:32.200
Just a couple of minutes.

27:32.200 --> 27:35.200
So I'm going to run.

27:35.200 --> 27:43.200
So insert 282606 rows once, first and then insert 1,000 rows.

27:43.200 --> 27:47.200
So the table is empty initially.

27:47.200 --> 27:57.200
And we build the index first time.

27:57.200 --> 28:00.200
So that's a table name, CL trials online.

28:00.200 --> 28:06.200
Nothing much, 0 rows.

28:06.200 --> 28:14.200
So load 400, sorry, 282, sorry, I think I forgot the script name.

28:14.200 --> 28:26.200
282606 rows.

28:26.200 --> 28:30.200
So the index is updated in the background from the binlogs.

28:30.200 --> 28:31.200
And this is life.

28:31.200 --> 28:34.200
So at this point right, within one second,

28:34.200 --> 28:38.200
243K rows have gone into the vector index.

28:38.200 --> 28:42.200
And by the next time I do that, the index is updated.

28:42.200 --> 28:46.200
282606 rows.

28:46.200 --> 28:54.200
Just one more minute.

28:54.200 --> 28:57.200
Yeah. And now I'll insert 1,000 individual rows.

28:57.200 --> 29:03.200
Just to prove that the vector index is incrementally updated.

29:03.200 --> 29:11.200
Sorry for that.

29:11.200 --> 29:14.200
Yeah. So we reached 283606.

29:14.200 --> 29:26.200
And just a couple of applications.

29:26.200 --> 29:29.200
Again, the same concept as the earlier one.

29:29.200 --> 29:33.200
Now we are using the MP net model from sentence transformers, all MP net base 2.

29:33.200 --> 29:35.200
This is the query.

29:35.200 --> 29:37.200
jogging after knee replacement surgery.

29:37.200 --> 29:39.200
Show me some effects of jogging.

29:39.200 --> 29:40.200
Can I jog after knee?

29:40.200 --> 29:46.200
This could be your application searching through your dataset.

29:46.200 --> 29:47.200
Yeah.

29:47.200 --> 29:50.200
9 number 10 is the query.

29:50.200 --> 29:53.200
So run the Python script.

30:05.200 --> 30:08.200
Yeah. So these are the top 10 matches from the dataset.

30:08.200 --> 30:11.200
So we were searching for knee surgery and jogging.

30:11.200 --> 30:14.200
Yeah. So return to physical activities after total soon.

30:14.200 --> 30:17.200
So.

30:17.200 --> 30:20.200
Yeah, that's all I had any questions.

30:20.200 --> 30:22.200
That's it.

30:22.200 --> 30:23.200
Yes.

30:23.200 --> 30:30.200
How do you generate the L1 answer for this one?

30:30.200 --> 30:32.200
Good question.

30:32.200 --> 30:35.200
So this what I showed is only vector search and similarity search.

30:35.200 --> 30:38.200
So RAD is built on top of that.

30:38.200 --> 30:43.200
So now you give these 10 articles and their contents to your LLM.

30:43.200 --> 30:47.200
And say can you answer as an healthcare expert?

30:47.200 --> 30:49.200
Can you please answer this question?

30:49.200 --> 30:54.200
How does knee surgery and jogging and you please use these?

30:54.200 --> 30:56.200
So you pass all these documents to them.

30:56.200 --> 30:57.200
The LLM will generate.

30:57.200 --> 31:00.200
So what I showed is only vector search, not rag.

31:00.200 --> 31:04.200
Do we have time for question?

31:04.200 --> 31:06.200
Yeah, how are we can take off layer?

31:06.200 --> 31:08.200
One more question.

31:08.200 --> 31:13.200
Is there any question that you have when you run the same query twice?

31:13.200 --> 31:15.200
Is there any question there?

31:15.200 --> 31:16.200
Yeah.

31:16.200 --> 31:19.200
The current implementation is a in memory vector index.

31:19.200 --> 31:21.200
And that is cash.

31:21.200 --> 31:25.200
And the other thing, yeah, based on the buffer pool, my SQL buffer pool being.

31:25.200 --> 31:26.200
Actual table rules, yeah.

31:26.200 --> 31:29.200
That would be based on the my SQL buffer pool.

31:29.200 --> 31:32.200
So when you run the first query, you have to take the same two seconds.

31:32.200 --> 31:35.200
And then you run the second query.

31:35.200 --> 31:37.200
You have to take rest.

31:37.200 --> 31:39.200
You have time to take the first query.

31:39.200 --> 31:42.200
The first query if the vector index is not been loaded in memory.

31:42.200 --> 31:43.200
Yeah, that query will take time.

31:43.200 --> 31:46.200
But the once the vector index is in memory.

31:46.200 --> 31:48.200
The next query is would be super first.

31:48.200 --> 31:49.200
Yeah.

31:49.200 --> 31:51.200
So it would not pass.

31:51.200 --> 31:53.200
That is the question.

31:53.200 --> 31:54.200
Oh, yeah.

31:54.200 --> 31:55.200
Thank you.

31:55.200 --> 31:57.200
I just want one quick thing.

31:57.200 --> 31:58.200
Thank you.

31:59.200 --> 32:01.200
Who wants to reveal his age?

32:01.200 --> 32:04.200
And who's the youngest in the room?

32:09.200 --> 32:10.200
Right, draw it.

32:10.200 --> 32:13.200
That one flight.

32:13.200 --> 32:14.200
Okay.

32:14.200 --> 32:17.200
You can come find me over here.

32:17.200 --> 32:18.200
Can you get it?

32:18.200 --> 32:20.200
Oh, yeah.

32:20.200 --> 32:22.200
It's not that too.

32:22.200 --> 32:24.200
It's a flight of books.

32:28.200 --> 32:29.200
Yeah.

32:29.200 --> 32:30.200
Yeah.

32:30.200 --> 32:31.200
Yeah.

32:31.200 --> 32:32.200
Yeah.

32:32.200 --> 32:33.200
Yeah.

32:33.200 --> 32:34.200
Yeah.

32:34.200 --> 32:36.200
Yeah.

32:36.200 --> 32:37.200
Yeah.

32:37.200 --> 32:38.200
Yeah.

32:38.200 --> 32:39.200
Yeah.

32:39.200 --> 32:40.200
Yeah.

32:40.200 --> 32:41.200
Yeah.

32:41.200 --> 32:42.200
Yeah.

32:42.200 --> 32:43.200
Yeah.

32:43.200 --> 32:44.200
Yeah.

32:44.200 --> 32:45.200
Yeah.

32:45.200 --> 32:46.200
Yeah.

32:46.200 --> 32:47.200
Yeah.

32:47.200 --> 32:48.200
Yeah.

32:48.200 --> 32:49.200
Yeah.

32:49.200 --> 32:50.200
Yeah.

32:50.200 --> 32:51.200
Yeah.

32:51.200 --> 32:52.200
Yeah.

32:52.200 --> 32:53.200
Yeah.

32:53.200 --> 32:54.200
Yeah.

32:54.200 --> 32:55.200
Yeah.

32:55.200 --> 32:56.200
Yeah.

32:56.200 --> 32:57.200
Yeah.

