In this lesson, we are going to talk about the proof of content.
A proof of concept.
Of concept.
The.
About the proof of concept phase.
So let's talk first about the main process to develop an app a.
Curiously, we don't start programming.
When we start a new project, a new application, the first thing we do is drawing.
So we need to have a graphic representation of the application we are going to build before starting
to code.
It's important for us to understand the different parts of our application and the different connections
or integrations between among these different parts.
So the first thing we do is we create a graphic with the applications structure.
Once we have that clear, we build what we call the proof of concept.
The proof of concept is just a prototype of the application A.
Once we have this prototype, we try the prototype, ideally with some test users, and we confirm that
this proof of concept meets the expectations of the project.
Usually when we try the proof of concept, the user is going to find, you know, some, uh, mistakes
or some missing parts or some problems in the process.
And we will have to reevaluate our app and structure, you know, and the and the and to, to, to to
improve the project definition.
Once we have this prototype, uh, completely tested and approved, then we can go ahead with the next
stage.
That would be to build the, uh, production level, uh, application.
So usually the person in charge of the proof of concept is the LM app developer or the LM app engineer.
But when we go to the production phase, usually, uh, you will have a team of people working around
that.
In some cases, it will be the, the same LM app engineer, uh, that would be in charge of the whole
process, even the production level application.
But usually when you reach the production phase, you are going to find a that in most companies you
have a multi a multi person team with, you know, front end engineers, back end engineers, database
engineers, LM engineers etc..
So it depends of the project.
It depends of the company, it depends of the team.
But usually the LM app developer is going to build the proof of concept.
And once this proof of concept has been approved and goes into production, usually you have a software
developer team.
So what about the process to build the proof of concept itself?
So this stage that, as I was telling you, is usually in charge of the LM App developer or LM app engineer,
whatever you want to call it.
Usually this process has four main stages.
The first stage is the data capturing stage or the well.
The data of an LM application can come from different sources.
It can come from files, from databases, from the web, whatever.
If if it comes from the web.
For example, we will use a technique to grab the data that is called web scraping.
If the data comes from databases or files or whatever, we will use different techniques.
So the first step, when you are building a proof of concept application usually is getting the data
in a proper way.
The second step step would be to a to design the main logic of the proof of concept application with
the orchestration framework.
So you would use long chain or lambda index in most cases, but in some cases you would use directly
the API of OpenAI etc..
Right.
So second step orchestration framework.
Third stage in most cases would be to introduce the vector database.
When you are in the proof of concept stage, usually you are going to use a very simple vector database,
for example files, which is a very, very simple version of vector databases.
When you move into a production stage, usually you are going to use a more robust, more serious vector
databases like like Postgres for example, or pinecone, etc..
And finally, the fourth step in the proof of concept stage is the a user interface.
In this case, in the in the proof of concept stage, we are going to use a very simple user interface.
Like Streamlit, Streamlit is the most popular.
A interface for temporary user interface.
The most popular framework that we see to create temporary user interfaces.
Okay.
So remember.
One thing is the process to develop an application.
The other thing is the process to build a proof of concept.
Excuse me, which is just one phase of the whole process of developing an application.
And remember the four stages of a.
The proof of concept stage of proof of concept process would be.
First, get the data.
Second, a write the main logic with an orchestration framework.
Third.
Use a simple vector database.
Fourth, use a simple user interface.
In the next.
In the next lesson, we are going to see some basic concepts around Streamlit.