Today we're going to be taking a look at a really cool tool that's going to allow us to use local AI to basically perform rag on our documents. Or to
put it more simply, we're going to be able to use an AI to answer questions about PDFs or other types of unstructured data, even including images just
by using fully offline local AI models. This is enabled by an awesome tool called Unstract, who is
also the sponsor of today's video. So, thank you to Unstra for supporting the channel and allowing me to continue putting out videos at a high rate of
speed. But the really cool thing about this, and I know folks will be like, "Oh, a sponsor. I'm going to roll my eyes." And I want to cut in and
interject before that happens right here because this is something that is incredibly valuable for the
local AI enthusiast because everything we're going to see in the first part of this video is running completely on the local system. There's no
subscription fees. There's no API keys needed. There is literally nothing you need to kind of like go and click the link and buy. This is basically a
real cool all-in-one rag solution that is going to leverage entirely local stuff on a system in this case
the one running behind me just to actually be able to query our documents in natural language. Now, I have actually done a lot of stuff with Rag here
and I can kind of verify that it can be rather complicated depending on the type of system that you are attempting to build and this kind of
streamlines a lot of that sort of stuff and it really is quite cool. So, to begin, we're going to take a
quick peek at some of the cool features here, but really we're going to then just jump into actually showcasing a light installation tutorial with a
few prerequisites that will need to be met on the part of the viewer. Then, we're going to test this with a bunch of random documents. some with
images, some without. We're going to perhaps have some interesting queries, and we'll see how the local
system actually performs and handles this. So, to begin, we're essentially going to be replicating what we see right here in this little looped
animation for the key features with something called this prompt studio. Now again, I would like to reiterate that the entirety of what we're about to
do for this section is going to be using entirely local things on this system and we're going to
essentially be able to end up here, upload PDFs, have them parsed and then stored in a quadrant database, a vector database, and then we're going to
be able to ask our local Quen model questions about the uploaded documents and then we'll see it giving us answers and we'll learn a little about kind
of rag specific things like chunking and overlap and things like that. So to begin, we're just going
to jump into this right now. And I do want to start out first and foremost with the specific prerequisites that are going to be required to follow
basically step by step what is about to be shown here. The first of these is I am using an Ubuntu system which has Linux on it and I do have Docker
set up. The next is going to be having Olama set up with a specific model that you would like to use. So
in this case, if I type Olama list, we're going to see that this system has a Quen 3.635 635B model. Now, this is a 35 billion parameter mixture of
experts model with 3 billion active and it can run at decent speed even on computers that don't have huge beefy GPUs and it's a pretty modern and
potent option. Additionally, we see that we have this embedding model which we will get into a little
later, but know that is also kind of pertinent for what we're about to do. So, to begin, we're going to start by running the few commands here
outlined in the run locally section. Starting with the one right here, which is just going to clone this repository onto our local system. And once
that's done, we're going to type cd unstruct, which is just going to change our current working directory
into the newly cloned repository. Then once we're in the repository, we're going to do a dot /un-platform. I suppose you could also just copy paste
these. Um, sometimes I just like typing them manually. And this is going to go ahead. If you recall, I did mention that one of the prerequisites was
to have Docker installed on our system. So, this is basically going to go ahead and set everything up
to allow us to get to what is shown right here in this prompt studio UI. Now, you're going to notice there's also some additional feedback and output
right here. Things pertaining to the backup encryption key as well as some Docker logs and things like that for the purpose of a simple introductory
demo. I'm going to just opt to ignore those, but I do want to specifically mention what those are
with emphasis on the backup encryption key as that is something important that folks who are going to be processing sensitive data may be interested
in ensuring they kind of keep it safe. So once we've done this, our next step is just to click the URL right here, which is going to bring us to the
beginning steps to actually use the prompt studio. Now, the first thing we're going to see right here
when we click on this is that it is going to be prompting us to log in. But I know folks want to roll their eyes when they see that cuz I do as well.
But fortunately, this is all running locally on our system right now. And the actual login credentials, you don't need to sign up or anything like
that. They are just default. And they should actually be filled in already as unstracked and the
password is unstracted. And it's kind of funny. We notice we get like a password warning from Google saying this was in a data breach. But um we don't
really need to worry about that for the purpose of what we're doing right now. Now, there are a few different ways we can go about setting this up
initially. We can just go down here and click complete later and kind of ignore these things for now
and then set them up later once we're in the prompt studio. However, I find that for the purpose of setting this up for the first time, it's actually
easier to connect these all individually right now from this startup screen just to ensure that everything is going to go smoothly once we actually
try basically interacting and performing rag on our documents. Now, our first step is going to be
connecting an LLM that will power some of the intelligence and our ability to actually ask questions and receive answers for our documents. As you may
recall from the beginning, I did also mention that Olama was going to be a prerequisite, at least for this local demonstration. So, to just kind of
show this one more time, I am going to type Olama list. And we're going to see right here that we do
have a couple of things, namely the Quen 3635B model, which is the LLM that we're going to be using for this purpose. So to begin, we're just going to
hit connect right here. And this is going to give us the option to add an LLM from a variety of different providers. Some local, such as with Olama,
or some cloud, such as basically with a lot of the other ones we see right here. And there are going
to be some pros and cons to both options as we'll see later on in the video. But for now, because local is pretty cool, we're going to use Olama at
first. And we can see right here that we are getting some basically like things that because I always like to dry run stuff just to make sure that
everything goes smoothly. And we can see I'm going to repurpose or reuse some of these. So we're going to
name this specific Olama instance. And in the model field, we're going to type in the model that we have which is as shown in the terminal for Olama.
So just to do it one more time, if we type Olama list right here, we'll see that this model identifier is just named Quen 3.635B. So we can just paste
that in here right as well. Following this, we're going to need our base URL. Now this can be a
little confusing because Olama is running natively on this host system, but the unstructed front end right here and everything is running through
Docker. So we need to specifically enter the URL that will actually allow Docker to connect with the Olama server running on our host system. Now
there are some sample things right here, but for the purpose of this, we're actually going to kind of invert
what is listed right there. So we're going to add host.doccker.in internal at port 11434 which is the llama server port. And if we do lama serve on
our host system right here, we'll get a command like it's already being used. So port 11434 is already in use. So just to show that is the specific
Olama server port, I guess could be said. The next field here is maximum output tokens. I'm actually
going to leave that blank because that's not something we really need to worry about right now. We also have the temperature settings. And for this
specific Quen model, I do believe 7 is the correct temperature for precise coding or tasks such as that, which is very likely what's going to be
wanted for this specific use case. Following this, something I do want to change is the context window
right here. And this is going to be heavily dependent upon the specific model that you're using as well as the system that is running said model.
Because the context window being larger is good because it will allow us to basically process larger documents. The model will have more memory I
suppose could be thought of to put it simply. However, the downside of that is a larger context window will
utilize more resource on the host system. So, it is kind of a balancing act and there's a ton of online resource and documentation about learning the
best context window for a specific setup. for this specific setup right here in this model. This model does have a maximum context window of 262,144,
but I am just going to do 32,768 as it will allow us a bit of headroom, but it won't overwhelm this
system. Following that, we do have the option to enable JSON mode to constrain the outputs to valid JSON. For now, I'm going to pass on doing that
just for the introductory purpose of getting this set up. Everything else is all right there. So, the final thing we're going to do for this specific
LLM setup is click test connection. And fingers crossed, assuming everything did go to plan, we will
see in the top right here just a green checkbox with a connection test success. And once the connection has shown the green checkbox, our next step is
to just click submit. And we now see that we have configured the first of our four things, which is connecting the LLM. Our next step is going to be
connecting a vector database. And this is going to be very similar to what we did previously where
we had options to choose from and things like that. Now, in terms of what the vector database actually does right here, I think essentially without
this, we would have to just like feed the entirety of our document to the LLM every single time, which would not be very feasible for context length
limits and things like that. Again, that's a very simplified explanation, but they do also give a
couple of sentences here pertaining to what specifically this does in the scope of this process. But as we're more concerned with connecting it and
then using it, we're going to click the connect button. And for this, I am going to use the quadrant option, which is right down here. And if we
select this, it is also kind of just I find that this works pretty smoothly when actually running this and
testing it and setting it up. So, as before, we're going to fill in the things that we have right here. You may have guessed that this is the Quadrant
VDB1. Now, interestingly enough, we're actually going to just delete the things we see right here as we do need a different specific URL for this to
work just because of the way Docker and everything is set up. So in our URL text box, we're just
going to type in or paste not that we're going to type in http col/qudant and then this little symbol which denotes like the specific port that it
will be running on and then 6 3333. Okay. And I must have inevitably accidentally hit the enter key on the end of the keyboard. But the next thing I
was going to say is that we can leave the API key blank for what we're doing right here. We did see the
connection was successfully tested. So if we click submit, we now have that configured as well. Next up, we're going to choose an embedding model.
Now, you may have noticed that when we did run Olama list, there was an additional model here that was not quen. So this is an embedding model which
we also did pull. And this is just partially what's allowing this to run entirely with local AI models
and nothing connected to the cloud. And for the LLM or for the embedding model, I will just say they semantically map unstructured data for precise
retrieval impacting the quality of data organization and search relevance. Now, there are a lot of different embedding models out there with different
pros and cons almost kind of like with LLMs, how there's a wide variety of them. For the purpose of
this, we're just using one that's wellknown and fairly common and something that Olama has readily available just to showcase this actually working as
a workflow on our local system. So, as with the previous two setup sections, we're going to click connect. And once again, we're going to select O
Lama for this option. And we will just name this something. Now, we can see that I had named it Olama
embedding 1. And the model name is already filled in right here. But if it was not, we would just go back to the Olama list terminal right here. And
then we would copy paste the model identifier right there. We wouldn't need to include the latest portion of it. So you would just copy paste
everything right here if you did need to manually place it in. The base URL is going to be the same as what
we did previously where it is host.doccker.in and then port 11434. Being that this is being served by Olama, so we do need that same port number. And
we're going to leave the additional two options the same as they are listed right here, just in what they get filled in as by default. We can see now
we do have a successful connection test. Our final step here is to connect a text extractor. And as
it's listed right here, this will just basically help extract text from these documents to better allow our LLM to actually process them. Now, there
are a few options here to choose from. And I do want to make specific note that Unstact offers these LLM whisper options. And as we'll see later on in
the video in a different demonstration, the online stuff will be more potent and will really allow
us to go at and extract some pretty imageheavy and just very unstructured documents to then perform queries on. But for now, in keeping this fully
local for the initial setup, we are going to opt to use the unstructured IO community option. Now we see there is a URL prefilled right there and we
are just going to name it something related like unstructured-1. Finally, we will test our connection
here and submit. And once we do that, we are now brought into the prompt studio, which is what we got a look at in that little looped animation on the
GitHub a while ago before we actually set up. So, right now, this is actually mostly set up to allow us to drag in PDFs here and then have our
entirely local system actually perform analysis on them and answer questions for us, which is the next
thing we're going to do. So, our next step now that we're in the prompt studio is I probably am going to zoom in a little if I can figure out this
keyboard. Now, we're going to make a new project right here, which we're just going to do by the new project button. You can also hide the sidebar
here. For the time being, I will probably keep it open just to become a little more familiar with some of
these specific options right here. But, we're going to create a new project and we're going to name it something. You can see I have done a few tests.
So at this point let's do test five ben and then description. You can also choose an icon which is kind of fun. Good. So now that we have this project
right here we can see okay it was added successfully. So our next step is to add in a PDF that we
want to actually perform rag or just think of it as asking questions through our local AI that it will then reference this specific document to give
us the answer instead of its own internal knowledge that it contains. So that's kind of what's cool about Rag. So once we have this project set up,
we're not going to immediately go and add a document, which is what we're going to ultimately do. But
we see if we actually select that option right here, the ability to just drag and drop, say, a PDF is grayed out because we need to initially set a
default LLM profile for this project before we begin uploading our document. In order to do that, it is quite simple. We're just going to hit the
settings gear icon right here, and we're going to add a new LLM profile. And pretty much everything that
we choose here is going to mirror the initial setup that we did where we first logged in and then we selected the four specific things that were
linked. So we're going to see we can name it anything, but let's just name it Quen. I have that as A3B cuz that's an active 3 billion parameter
mixture of experts model for our LLM. We're going to choose the name that we created when we set up this
specific kind of user profile if you want to call it. Additionally to that, we're also going to select the same things for our vector database, our
embedding model, and then our text extractor as well. We can change the chunk size right here. Now, I do believe this specific embedding model that we
had chosen to use has a maximum chunk size of 512. They say right here, set it to zero if the
documents are small. And to begin, we're going to be giving it some relatively short documents. So, for now, I'm not going to touch anything about
that. But basically these just refer to like how the document that is going to be kind of processed and stored in the database will be sliced up. And
then the overlap is kind of if you were to just give it specific slices of the document, it wouldn't
necessarily have a reference of like which one goes where. So the overlap kind of includes some from like before and after unscientifically just to
give some better information about like specific location of different chunks or something of the sort. So with that done, we're going to then select
add. We have saved that successfully. So we can close that and close this. And now if we go into add
document, we see that we are now free to drag and upload a PDF. Now for our first simple example, I'm going to be giving this a research paper that is
quite popular in terms of like AI. This paper came out in 2017. It's called attention is all you need and it can be thought of as a very important
piece of like what powers the modern large language model like what we're going to be using Quen for
today to put it very simply. Now we're going to notice that it is uploaded but it currently is not indexed which means that we're not actually
utilizing any of the embeddings the vector database or anything like that will allow our language model to be able to search this very efficiently and
then provide answers to us based off of our inquiries. In order to index this, we're going to go over here
under actions and just select this button, which will index it. And once we click index, we're going to see we get a little progress bar right there.
But it happens very quickly. And then we get a popup saying basically everything worked. All right. Our next step is where things start to get a
little more exciting, I guess, at least in terms of some local AI things. So for this I do want to
quickly just showcase like let's actually ask something extremely simple that is not very difficult but just to showcase that our LLM as we see right
here Quen 3.635B is actually going to be responding to our query based off of the information that it gets from the whole pipeline here performing rag
on this specific PDF. So for something simple let's just start with what are the names of the
authors on this paper and this is a pretty simple one. So, we're going to just run it for the current document or we could also run it for all
documents. But because this is a simple example, we'll just do that. It won't take super long, but keep in mind this is using entirely a local stack
running only on our system, including this AI model. So, if I can catch it in time, if I do NVT, this will
show us our current GPU utilization. So, we can see right there that was using around 28 gigs of video memory on this system to actually kind of
handle and use that model to produce an answer, which is quite a decent amount. But this is a fairly heavy version of this model. Though, we can see
if I do not get distracted by getting excited by local AI. We do get the names of every single individual
who is listed as an author on this paper. 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8. And that's just pretty cool. And again, this is like a super simple example
of this. But the whole point of this is this is essentially a totally local rag workflow that is running using things that are entirely contained on
our system. And I would like to kind of highlight that a little further. So for our next demo, I
want to just showcase why this is cool to have this capability entirely on an offline system. And first and foremost, I'm going to completely disable
all network access on this system. So, the system only had internet access from Wi-Fi here. So, if we do ping and then 8.8.8.8, which is Google's DNS
server, we're going to see we don't have any internet access at all whatsoever. So, this system is
completely offline. Now, I have also at the same time generated a fictitious financial or business report, which seems to have just opened on the
wrong monitor. Let me drag this over for something called Steve's PC repair. So, if you do watch the channel, thank you. and you will be familiar with
the lore of Steve's PC repair. And there's just a bunch of different pertinent information right here
that we'll be able to give this. There's financial information, customer information, a bunch of fake like sensitive looking things, if you will. So
our next step is basically to showcase why something like this completely offline is actually quite useful to the point where I would I 100% guarantee
that there are businesses out there using things that are fully airgapped and offline that do not
have access to the internet as I have built some things like that. So let's start with a new project and this time we'll actually name it. So Steve's
financial sure that works. Author org name that can stay me. And then PC info. Now our next Oh, okay. We have to choose an icon too. I mean for this
we must. All right. I've chosen the bank icon. So now our next step is going to first and foremost
ensure that we do have the correct LLM profile selected which is going to be the one that we previously used for our initial demo. Keeping in mind
that now this computer has absolutely no internet access. And everything we see right here is running entirely locally offline on this system. So we
can close that now. And our next step is going to be to add our fictitious document for Steve's
financials. And we'll go into our documents demo financial records which is aptly named. And then of course we're going to need to index this so we
will actually be able to work with it. And that happens very quickly. Um, this is a pretty decent system, but even regardless of that, that should for
this PDF work pretty quickly on like any computer made in the last like 10 years, I would kind of
assess. So, our next step is to just add a prompt for our local model to do something. And prior to that, I would actually like to just quickly peek
at this just to see something where we can almost do like a little needle in a hay stack or something like that. I will also close the sidebar so we
have more room. So, let's do something that requires a little general knowledge as well on the part of
the model that we're going to be using. So, let's just ask it what graphics cards do we currently have in stock. I won't say we, I'll say, what GPUs
are currently in stock. And of course, this isn't necessarily a very like PII or private info query, but we'll run that following this. And we can see
that we have three units of the Nvidia RTX 580. So, if we scroll down here to our inventory, that is
in fact correct. And it's cool because we just asked it in a natural language thing and we got plain text back. We didn't have to really like do
anything complex or write any code or anything like that. And it's just cool to see. But next up, let's actually have this culminate in like accessing
some fake like PII or personal information. So I'm going to ask it what is the most common credit card
type from our recent credit card transactions and we'll see what we get for this. Now, in just looking at this row, it would be Visa because that
appears three times and the other ones don't. But it could get confusing because there's also a bunch of other stuff listed here in terms of like
paying for things and then rent and billing and things of that. So, that's cool. And it did properly answer
that and in all caps as well as it references here. Let's do like one more thing just to kind of check I guess a little more complicated of an
inquiry. So, for the final thing, I'm telling it, our two employees work 60 hours a week. What is the total payroll expenditure for a year, including
the owner, which is just a flat 75,000 a year? I did also mentioned that the hourly employees get two weeks
of unpaid vacation for themselves, which is probably pretty bad sounding, but we'll see what it comes up with. Now, off the top of my head, I don't
actually know. This math is a bit too intricate for me, but I'll fact check it following the result, but it's going to just look at everything right
here and then calculate the total payroll amount. Okay, so it's saying $253,500. I need a calculator
now. I can do this myself. I should be able to. Okay, so 35 an hour, 60 hours a week. That would be 2100 a week. 105,000 plus 75. So that would be 180
flat. And then we have 2450 an hour which would have to just make up 735. So this is spot on and that was correct. I'm happy to see that. And it's
just showing like imagine having even more sensitive data like this which of course in fact does exist
for various types of businesses. You can get data compliance and cloud services that will hypothetically like perform in a safe manner. But the
ability to actually do this entirely offline in an airgapped system is kind of cool and exciting and something that I've always found pretty useful as
a use case for AI and things like that. I know AI is making its way into so many things right now, but I
really do think like there is actually room for rag in like mom and pop's house. like, oh, okay, they can use this to like feed their bills to it and
be like, what are our expenses monthly and things like that, and they're less likely to get like, you know, I I digress. Now, it's useful to be able
to just query documents from within this web interface right here. But an additional feature that
this offers that's really quite cool is taking what we have here. So, we have our document that is uploaded and it is in our vector database and
everything like that. Additionally, we do have our prompt that we sent it, but I have gone and added another one here because we'll see why in a
second. So, one of the options we can perform here, and keep in mind this is still with everything entirely
locally, we can deploy this as an API, which will expose basically the entire process of this rag function in a way that can be used more
programmatically kind of. So essentially, if you wanted to pipe this into a different workflow or something like NAND, this would be the specific way
to do this because it will give us an API endpoint and then we can also get our specific API key to actually
access everything that's going on here. And really the way to show this is just very simply. So what I'm going to do right here is paste in a command,
which is going to look kind of a little complex at first glance, but it's actually quite simple. So basically what we're doing right here is from
within the terminal we're just sending a more kind of programmatic command to this while it is deployed
as an API so that we're actually hitting this and saying okay I want you to run both of these prompts that are outlined right here and then return the
information to me just through the terminal here. And keep in mind this could then be ascribed to basically any type of pipeline or program that you
could then use to incorporate this just through the API access. So, N8N would be something that
would be very useful in being able to do this. And we see right here, if we scroll up right now, we do have all of the answers specifically given to
us just in the terminal right here in more structured output showing the financial records for the specific payroll amount as well as all of the
specific inventory listed just like that. So this is something that's really cool because it opens up a
whole another path in how to actually use this or incorporate it into a larger workflow just from still like entirely local. So for the next
demonstration, we're going to be doing something that is a bit more involved and is going to really just need something that is at least online or
using a larger model through API access. So we're now just at unstrack.com and I am going to use the Unstrack
playground right here. So, if we go into the prompt studio, we can see that there is a demo playground. And the prompt studio feature is pretty cool
because we're going to be giving this the build manual for a Voron 3D printer. This is a very, very intricate 3D printer build. And if you do follow
3D printers, an open- source thing like the Voron is probably becoming more popular at this moment.
But it's like a 200 something page manual with a bunch of photo references, a bunch of specific information for building this relatively complex
device. So, I feel that will be a really awesome thing to actually test this with because it's really going to push it and showcase the power in
actually being able to just have a quick reference for a large verbose manual like that. So, let's test that.
So, I've created a new project and I'm basically just going to follow through like the tool tips that pop up and things like that because we're going
to need to figure that all out as well. being that this is not going to be using our local model anymore. We're going to use a cloud model and then
perhaps LLM whisperer that they have for OCR and things like that. So, we're now online and I am
uploading the Voron assembly manual. This is like 263 pages or something and it is incredibly dense with images and a lot of text interrelated. This
is something that is likely one going to take a little while to upload as it is around like I think a 75 megabyte PDF and it's also just fairly
complex and this is something that's actually really useful as someone who likes building like kits and
even like kit cars and things like that. They have these cool manuals but then you have to like flip through them. Having something that allows you to
actually ask an AI a question about the specific instruction manual for the thing you're working on is actually really quite like useful. So with
that, let's see what happens here as I try to now index this 263 page heavily image associated assembly
manual for the Voron. I would imagine this will take quite a little bit of time, but we'll see how it goes. So we can now see that this has changed to
indexed. So, I'm going to close out of this and then let's just add a prompt here. Now, we're going to see we're using GPT40, which is available to us
in the free trial. I do believe on page 53 of this instruction manual, there is some specific
mention of the proper orientation for the print bed, which way is up and which way is down? I think that may be a good question to ask just to get a
feel for performance here in this really dense and like image/textthe heavy document. So if we zoom in right here, this will be page 53. Which side is
which? So I want to just ask it. And then let's see what happens here. Now again, this is a the top
of the plate has mounting holes with bores that allow bold heads to sit flush below the surface. The top of the plate has mounting holes with bores
that allow bolt heads to sit flush slash below the surface. And the speed at which that happened as well as like essentially my point here is to
actually be able to reference an instruction manual like this by just asking an AI questions about it and
knowing the AI is actually specifically looking at the same manual. It's not just relying on its own training data or something like that. and it
being able to just spit the answer back out to you is quite quite useful. I really cannot overstate the usefulness of this. And we see right here the
cost for that specific query would have been around 2 cents. So I mean those would of course add up over
time, but again I mean 2 cents for saving the amount of time that it would take to look in the index and then look up the specific thing is a price
that I would be very willing to pay. Now, regrettably, I will likely have to end the web demo right now because we see you do get 100 max pages per
day for the free trial, which is quite good. The thing is, I gave it like the 260 plus page Voron
manual, which was perhaps a little excessive, but I really did want to just test the capabilities flat out, and I would say that was totally worth
doing e even if I can't necessarily showcase some additional things right here, but really just to kind of show some of the cool things. They also do
have the agentic prompt studio right here, which I'm regrettably not really going to be able to
showcase. But I do have an IKEA little document pasted in here because this is so imageheavy and it's kind of funny to see how IKEA things get
performed with Rag because of the way they're drawn and things of the sort. But this is a beta feature that just kind of augments like instead of
having to really do more manual work in crafting your prompt and things like this. This can automatically
generate like specific schemas using an AI to find specific data that one may be looking for and it just makes things a lot easier rather than having
to manually craft like an ultra specific prompt. If you're actually going through sorts of documentation that would require you to find very specific
pieces from a ton of different documents, this would just make it easier to actually have an AI
generate the query that would then go ahead and perform that action. So, it's kind of cool to have something that makes that simplified. I say from
experience, it is cool to have something that would just simplify that task because it can be quite a pain. So really additionally to that there's
also the LLM whisperer where if we go into connectors not connectors if we go into text extractor that is
their own piece here for OCR that is very good at just pulling things from um PDFs and images and things like that. But I I do find it kind of funny
how the Voron manual it did it found the build plate. it was word for word how the build plate would be instructed and it would do that for any page
of that document. So that's kind of cool. So overall that is going to conclude what is inevitably
going to be a more in-depth look at unstructed. And I really do just want to drive home the fact that a large portion of this video the beginning and
everything we did right here in this local web URL was run entirely offline utilizing things that lived on my own system. AI models, embedding models,
vector databases, everything like that. And it was really cool to see. This is a very, very useful
program, especially when considering that for the open-source enthusiasts or local AI enthusiasts among us, which I myself am one of, this is very
cool and useful to be able to have something for rag as opposed to I I understand like in GitHub they'll like current versus unstruct, oh well, of
course they would say that like the current state will make it look bad. I can personally kind of lend
I've had to do this stuff more manually and this is all kind of can be a big pain in the butt. So having something like this that's open source is
genuinely very very useful and it was cool to play with. I mean there's a bunch of other stuff you can do with rag um depending on how creative one is
but it's also very useful for like business use cases and financial stuff and personal stuff and
things like that. So really that is going to conclude our first look and test of Unstract. Again, thank you to Unstract for hooking me up with this
video cuz this was really a lot of fun to test and it's very cool to see Rag in action because it really showcases a very useful feature of local AI
or AI in general. And something else I kind of want to just point this out finally that I just think is
kind of cool is if we scroll all the way down here, we have some cookbooks as well for specifically setting this up. Kind of in the way that we
showcased, we could actually just call this or deploy it as an API. This specific section in the cookbooks will kind of give you some backend things
on what exactly you would then use that specific capability for, like NAD integration. But I also even like
they have right here prominently listed a note on analytics. It integrates post hog to track minimal usage analytics and then they give you the
specific thing to disable it by setting this just right here prominently in the actual GitHub readme. So that's something I see that just like I like
seeing stuff like that. So makes me feel comfortable. Make of that what you will. So that is going to
conclude today's video. If you have any questions, please feel free to leave them in the comments.