00:00A lot has been going on with AI over the past few years

00:02Prompt engineering, context, windows, tokens, embeddings, rag, vector DB, MCPS, agents, lang chain, langraph, claude, Gemini, and more

00:12If you felt left out, this is the only video you'll need to watch to catch up

00:16In this video, we assume you know absolutely nothing and try to explain all of these concept through a single project so that by the end of it, you go from zero to gaining an overall understanding of everything that's going on with AI

00:28We'll start with AI fundamentals, then move on to rag, vector DB, lang chain, langraph, MCP, prompt engineering, and finally put it all together with a complete system

00:39Let's start with the basics

00:39When you ask an AI model a question, it's typically answered by a subset of AI called large language models

00:44Large language models have gotten popular right around when Chachib was released in late 2022 when we started to see language models get larger in size because of their obvious benefits in performance

00:56So let's dig a bit deeper to understand how large language models are able to process requests that we send

01:02Popular LLMs like OpenASGPT, Enthropics Claude, and Google's Gemini are all transformer models that are trained on large sets of data

01:10The size of training tokens can go up to tens of trillions of tokens that are used to train these models

01:17And the training data includes data from thousands of different domains like healthcare, law, coding, science, and more

01:23But when we work in TechCorb, the 500 GB of data that we have aren't part of the training data that was used to train the model, which means that in order for us to use the LLMs to ask questions about the TechCorp's internal documents, we need the ability to pass in data to the LLM

01:41One of the ways that we can pass the data into the model is by adding them to the conversation history functions like a short-term memory where during the duration of the conversation, all of this context is kept in memory

01:51And this memory is called the context window

01:56Context windows are measured in tokens which is roughly 3/4 of a word for English text

02:01The context window is typically limited in size and the upper limit varies depending on the model

02:07Some models like XAI GO 4 have 256,000 tokens whereas Enthropics Cloud Opus 4 has 200,000 tokens and Google's Gemini 2.5 Pro has 1 million tokens

02:16So as you can see the total upper bound for how much context can be stored for each model can vary

02:24While the context window plays an important role in storing them in memory, there are practical limitations in how LLM treats what's inside the context window

02:32For example, if I asked you to memorize the pi digits 3.141592653589791 and asked you to recite it, some of you might have a hard time committing that many numbers all at once, which is similar to how LLM's context window works

02:49So therein lies the current limitations in LLM

02:52How much context can it hold in a given time? This can vary depending on model to model

02:57For example, a lot of nano, mini, and flash models can have very small context windows in the size of 2,000 to 4,000 tokens, which amounts to about 1,500 to 3,000 words

03:09Conversely, bigger models like GPT4.1 and Gemini 2.5 Pro offer context windows up to 1 million tokens, which is equivalent to roughly 7,500 words or 50,000 lines of code

03:21So, as you can see, choosing the right model for the task can be very important

03:26For example, if you downloaded a novel in a txt format and you wanted to change the script, choosing a model that offers a large context window would be best

03:38Conversely, if you are working on a small document and require very low latency, meaning faster responses, using flash and nano variants would be best

03:47Here's another angle to look at when it comes to memory in LLMs

03:49Let's say I ask you this question

03:52Sally and Bob own an apple farm

03:54Sally has 14 apples

03:54Apples are often red

03:5812 is a nice number

03:58Bob has no red apple, but he has two green apples

04:03Green apples often taste bad

04:06How many apples do they all have? This might require you to think about the problem a little bit to get to the final answer, which is 16

04:12That's because the context here includes information that is completely irrelevant to the question, which is to count how many apples they have in total

04:20The fact that apples are red or green or how it tastes have nothing to do with the total number of apples that they have because they either have the apple or they don't

04:29Now that we have a grasp on what context window provides, Techorp's 500 GB of documents, this creates an immediate problem

04:38Even the largest context window, like Gemini 2.5 Pro's 1 million tokens, can hold only about 50 files of typical business documents all at once

04:48We need our AI model to understand all 500 gigabytes, but it can only see a tiny fraction at a given moment

04:54This is where embedding comes in, and they're absolutely crucial to understand

05:00Embeddings transform the way we think about information

05:02Instead of storing text as words, we convert meaning into numbers

05:07The sentence employee vacation policy and staff time off guidelines use completely different words, but they mean essentially the same thing

05:17Embeddings capture that semantic similarity

05:18And here's how it works

05:18An embedding model takes a text and converts it into a vector

05:23Typically, 1536 numbers that represent the meaning

05:29Similar concepts end up with similar number patterns like vacation and holiday will have vectors that are mathematically close to each other

05:35For TechCorb, this means that we can find relevant documents based on what someone means, not just the exact word that they've used

05:44When an employee asks, "Can I wear jeans to work?" Our system will find the dress code policy, even if it never mentions the word jeans specifically

05:54Now that we understand how LLMs and embeddings work, we will need a system that ties everything together

05:59In our case, Tech Cororb needs a chatbot where customers can ask questions about the company policy, product information, and support issues

06:07The chatbot needs to remember conversation history, access the company knowledge base, and handle complex multi-step interactions

06:14Your first instinct might be to use OpenAI's SDK to build a quick chat interface

06:19But you quickly realize that there are massive missing pieces

06:23Storing chat messages, maintaining conversation context, connecting to Tech Corp's internal knowledge base, and handling the possibility that the company might switch from OpenAI to Anthropic or Google in the future

06:35And now what seemed like a simple project becomes a massive undertaking

06:39While you can write your own implementation to connect them, there's already a wellestablished abstraction layer called langchain

06:47Langchain is an abstraction layer that helps you build AI agents with minimal code

06:52It addresses all those pain points using pre-built components and standardized interfaces

06:56But first, let's understand the crucial difference between an LLM and an agent

07:00When you use large language models like GBT, Claude and Gemini directly, you're using them as static brain that can answer question based on their training data

07:11An agent on the other hand has autonomy, memory, and tools to perform whatever task it thinks that is necessary to complete your request

07:18For TechCorp's customer support scenario, imagine a customer asks, "What's your company's policy on refunding my product that arrived damaged?" An agent will self-determine how it should answer that request based autonomously instead of traditional software that requires conditional statement that determines how a program should execute

07:36Langchain comes with extensive pre-built components that handle the heavy lifting for Techorp Chatbot

07:42Langchain chat models provide direct access to LLM providers

07:48Instead of writing custom API integration code, you can set up OpenAI with open bracket model equals GPT3 turbo

07:55So if the requirements change to use enthropic instead, you simply change one line LLM equals chat enthropic open bracket model equals claw 3 sonnet

08:02This same pattern applies to every other capability techp needs

08:07Memory management uses memory saver to automatically store and retrieve chat history, which means there's no need to build your own database schema or session management

08:17Vector database integration works through standardized interfaces

08:21Whether you choose Pine Cone or Chroma DB, Langchain provides consistent APIs and we'll go through what a vector database is in the next couple chapters

08:29For text embedding, it uses OpenAI embeddings or similar components to convert Tech Corp's document into vector representation

08:36The embedding process becomes a single function call instead of managing API connections and data transformations manually

08:44Finally, tool integration allows the agent to access external system

08:48So if you need to query Tech Corp's customer database, you can simply create a tool that the agent can call when it determines customer specific information is needed

08:57Without lang chain, you would need to build all of this infrastructure yourself

09:01API management for multiple LLM providers, vector databases, SDKs, embedding pipelines, semantic search logic, state management, memory system, and tool routing

09:12The complexity grows exponentially

09:14Lang chain's component library includes modules like chat anthropic API connections

09:18Chromad vector database operations, OpenAI embeddings for texttoveector conversion, memory saver for chat history management, custom tool definitions for external system integrations

09:29The agent orchestrates these components based on the conversation context

09:34So as we're talking about tech corp depending on what the question is asked the agent will now use the given tools like vector databases as well as the context it built from conversation memory and the system prompt written in API layer autonomously handle your request and you can extend the agents abilities beyond this example by using other pre-built tools that lang chain offers like custom database access web search local file system access and more

10:00Now that we covered the conceptual elements of lang chain, let's look at how it looks like on a practical level

10:06We can look over at this lab specifically geared towards how to use lang chain

10:10All right, let's start with the labs

10:12In this lab, we're going to explore how to make your very first AI API calls

10:16The mission here is to take you from absolute zero to being able to connect, call, and understand responses from OpenAI's APIs in just a few progressive steps

10:26We begin by verifying our environment

10:28In this step, we're asked to activate the virtual environment

10:32Check that Python is installed

10:34Ensure the OpenAI library is available and confirm that our API keys are set

10:39This is important because without this foundation, nothing else will work

10:43Once the verification runs successfully, the lab will confirm that the environment is ready

10:47Next, we take a moment to understand what OpenAI is

10:52Here we're introduced to the company behind chatbt and their family of AI models including GBT4, GBT4.1 Mini and GBT 3.5

11:00The narration highlights that we'll be working with the Python OpenAI library which acts as a bridge between our code and OpenAI server

11:07With that context set, we move into task one

11:09In this task, we're asked to open up a Python script and complete the missing imports

11:16Specifically, we need to import the OpenAI library and the OS library

11:21After completing these lines, we run the script to make sure that the libraries are properly installed and ready to use

11:27If everything is correct, the program confirms that the import worked

11:29From here, we transition into authentication and client setup

11:33Here, the lab explains the importance of an API client, an API key, and the base URL

11:38The API key works like a password that identifies us and grants access, while the base URL defines the server location where requests are sent

11:47This prepares us for task two

11:49In task two, we open another Python script and are asked to initialize the client by plugging in the correct environment variables

11:56This involves making sure we pass the OpenAI API key and OpenAI API base

12:00Once those values are filled in, we run the script to verify the client has been properly initialized

12:08If done correctly, the script confirms the connection to OpenAIS servers

12:11Once the setup is complete, we move on to the heart of the lab, making an API call

12:15Before jumping into it, we learn what chat completions are

12:20This is OpenAI's conversational API where we send messages and receive messages just like a chat

12:24Lab explains the three roles in a conversation

12:29System, user, and assistant, and how the request format looks like in Python

12:33That takes us into task three

12:33Here we open the script, uncomment the lines that define the model, role, and content, and then configure it

12:40So the AI introduces itself

12:42Once we run the script, if all is correct, the AI should respond back with an introduction

12:47This is the first live call to the model

12:51Next, we're guided into understanding the structure of the response object

12:54The lab breaks down the response path, showing how we drill down into the response, choices, message content to extract the actual text returned by the AI

13:02Although the response object contains other fields like usage, statistics, and timestamps, most of the time what we really need is the content field

13:11That brings us to task four, where we're asked to update the script to extract the AI's response using the exact path

13:17Running the script here confirms that we can successfully capture and display the text that the AI returns

13:23Once we've mastered making calls and extracting responses, the lab shifts gears to tokens and costs

13:28We learned that tokens are the pieces of text used by the model that every request consumes tokens

13:34Prom tokens are what we send in

13:37Completion tokens are what the AI sends back and total tokens are the sums of both

13:41Importantly, output tokens are more expensive than input tokens

13:45So being concise can save money

13:48Finally, in task five, we're asked to extract the token usage values, prompt completion, and total tokens from the response

13:55The script is already set up to calculate costs

13:57So once we complete the extraction and run it, we can see exactly how much the API call costs

14:03The lab wraps up by congratulating us

14:05At this point, we verified our environment, connected to OpenAI, made real API calls, extracted responses, and calculated costs

14:12The key takeaway is remembering how to navigate the response object with response.content

14:21Some of the finer points and details like exploring usage fields or playing with different models are left for you to explore yourself

14:27But by now, you should have a solid foundation for working with AI APIs and be ready for what comes next in the upcoming labs

14:36All right, let's start with the labs

14:36In this lab, we're going to explore Lang Chain and understand how it makes working with multiple AI provider simpler and faster

14:44The key idea here is that instead of being locked into one provider's SDK and rewriting code whenever you switch, Langchain offers one interface that works everywhere

14:55With it, you can move from OpenAI to Google's Gemini or XAI's Gro by changing just a single word

15:00We begin the environment verification

15:02In this step, we're asked to run a script that checks whether Langchain and its dependencies are installed, validates our API keys and our base URL, and confirms that we have access to different model providers

15:15Once this check passes, we're ready to start experimenting

15:17The first test compares the traditional OpenAI SDK approach with Lang

15:22We have to write 10 or more lines of boilerplate code just to make an API call

15:27If we want to switch to another provider, we'd have to rewrite all of it

15:31With Langchain, the same logic is cut down to just three lines

15:35And switching providers is as simple as changing the model name

15:37In this task, we're asked to complete both versions in a script and then run them side by side

15:46This is where we really see the 70% reduction in code

15:48The second task demonstrates multimodel support

15:51Here we're asked to configure three providers

15:55Open GPT4, Google's Gemini, and XAS Gro, all with the same class and structure

16:00Once configured, we can run the exact same prompt through all of them and compare their responses

16:05This is especially powerful when you need to do AB test or balance cost because you can evaluate multiple models instantly without changing your code structure

16:14In the third task, we're introduced to prompt templates

16:17Instead of writing separate hard-coded prompts for every variations, we create one reusable template with placeholders

16:23Then we can fill in the variables dynamically just like fstrings in Python

16:28This eliminates the nightmare of maintaining hundreds of slightly different prompt files

16:33After completing the template, we test it with multiple inputs to see how the same structure generates varied responses

16:41The fourth task takes a step further by introducing output parsers

16:44Often AI responses are just free text, but what our code really needs are structured objects

16:51Here we're asked to add parsers that can transform responses into lists or JSON objects

16:56In this way, instead of dealing with unstructured sentences, we can access clean Python lists or dictionaries that our application can use directly

17:07Finally, we reach task five, which is all about chain composition

17:09Langchain allows us to connect components together with pipe operator

17:13Just like Unix pipes, instead of writing multiple variables for each step, creating a prompt, sending it to the model, getting a response, and parsing the result, we simply chain everything together

17:24With one line, we can link prompts, models, and parsers, and then invoke the chain to get the structure output

17:31It's a much cleaner and more scalable way to build AI pipelines

17:35By the end of this lab, we've learned how a lane chain reduces boiler plate, enables multimodel flexibility, creates reusable templates, parses structured outputs, and ties everything together with elegant chaining

17:47Some of the finer details like experimenting with more complex parser setups or chaining additional steps are left for you to explore on your own

17:57Now, we come to the technique, but it's not a technique in the sense of building lane chain application like we just did

18:03No, we're talking about a technique that involves how you send your prompt to the agent that we just built

18:07In other words, prompt engineering

18:09When you send a prompt as an input to TechCorps AI document assistant that we just built, the quality of your prompt directly impacts the quality of responses you receive

18:21While AI agents can certainly handle wide range of prompts, understanding prompt techniques help you communicate more effectively with TechCorp system

18:29For example, if you prompt the agent with this question, "What is the policy?" It can pull a lot of details that are irrelevant

18:35Sending a more specific prompt like, "What's the company's remote work policy for international employees?" will lead to a more accurate result from the agent

18:43And the same thing applies to role definition when you're describing the role of the agent

18:49For example, you might descriptively write out a detailed prompt like, "You are a tech customer support expert." When you are asked about the company's policy, you are to always respond with bullet points for easier readability

19:01As you can see, being able to control the agents behavior can directly benefit from a well-written prompt

19:07This type of technique is referred to as prompt engineering

19:11And there are different prompt techniques like zeroot, oneshot, fshot, and chain of thought prompting have its own use case for the task

19:17For example, zerootshot prompting means that we are asking AI to perform a task without providing any examples

19:24So if you send a prompt, write a data privacy policy for our European customers, you're essentially relying entirely on the AI's existing knowledge base to write the data policy document

19:36Since within the prompt, we're not giving any examples of what they are

19:40Oneshot and few shot prompting is similar to zerootshot but in this case we're providing examples of how the agent should respond directly within the prompt

19:50For example, you might say here's how we format our policy documents

19:54Now write a data privacy policy following the same structure because you provided a template

19:59The AI follows your specific formatting and style preferences more consistently

20:03And conversely, fusart learning is the act of learning from the LLM side where even though the LLM might not have seen the exact training data for how to process your unique request, it's able to demonstrate the ability to fulfill your request from similar examples provided

20:21And finally, chain of thought prompting is a style of prompting where you provide the model with a trail of steps to think through how to solve specific problems

20:30For example, instead of prompting the AI agent with fix our data retention policy, you might instead use chain of thought prompting to say here's how you fix data retention policy

20:41Review current GDPR requirements for data retention periods

20:43Then analyze our existing policy for specific gaps

20:46Then research industry best practices for similar companies

20:51And finally, draft specific recommendations within implementation steps

20:55Now fix our customer policy

20:57As you can see, providing how LLM should go through in breaking down a specific request for how data retention policy should be fixed gives an exact blueprint for how the LLM should then go and fix the customer policy, which in this case, we're not explicitly telling the agent how to fix the policy for that, but it gives the reasoning steps for the model to fix accordingly

21:19So, in this lab, we're going to master prompt engineering using lane chain

21:24The main problem being addressed here is that AI can sometimes give vague or inconsistent responses or not follow instructions properly

21:32The solution is to use structured prompting techniques, zero shot, one shot, viewshot, and chain of thought

21:38Each of which controls the AI's behavior in a different way

21:42We begin by verifying the environment

21:44The provided script checks that lang chain and its OpenAI integrations are installed, confirms that the API key and base URL are set and ensures that prompt template utilities are available

21:54Once this verification passes, we're ready to move into tasks

21:58The first task introduces zero prompting

22:01In this exercise, we're asked to compare what happens when we provide a vague instruction versus when we write a very specific prompt

22:08For example, simply asking the AI to write a policy results in a long generic essay

22:16But when we specify write a 200word GDPR compliant privacy policy for European customer with 30-day retention period, the response is focused, useful, and aligned to the constraints

22:26This demonstrates why being specific is crucial in zero shot prompts

22:30The second task moves us to oneot prompting

22:32Here we provide one example for the AI to follow almost like showing a single template

22:39For example, if we gave the AI one refund policy example with five structured sections, we can then ask it to produce a remote work policy and it will replicate the same style in structure

22:50This shows how one example can set the tone and ensure consistency across many outputs

22:55Next, in task three, we expand on this with few shop prompting

23:00Instead of one example, we provide multiple examples so the AI can learn not only the format but also the tone, patterns, and style

23:08For example, giving three examples of emphatic support replies teaches the model how to handle customer support issues consistently

23:17Once the examples are in place, the AI can generate new responses that follow the same tone and structure, making it especially powerful for use cases like customer service

23:26In task 4, we're introduced to chain of thought prompting

23:31This technique encourages the AI to show its reasoning step by step

23:36Instead of vague oneline answer, the AI breaks a problem into steps and works through it systematically

23:41This results in clear or more reliable and more accurate outputs, particularly for complex reasoning tasks

23:48Finally, task 5 brings all of these techniques together in a head-to-head comparison

23:53We run the same problem through zero shot, one shot, few shot and chain of thought prompts to see the difference

23:58Each approach has its strength

24:01Zero shot is quick

24:03One shot ensures formatting

24:03Few shot enforces tone and consistency and chain of thought excels at detailed reasoning

24:10The outcome shows that choosing the right technique can dramatically improve results depending on the task

24:16By end of this lab, we not only learned what each prompt method is, but we've also seen them in action

24:20The key takeaway is that the right technique can make your prompts 10 times more effective

24:26Some of these exercises are left for you to explore and refine

24:28But now you have the foundation to decide whether you need speed, structure, style, or reasoning in your AI responses

24:36That wraps up this narration

24:39And with it, you're now ready to move on to the next lab onto vector databases and semantic search

24:45Let's do a quick recap of what we just built

24:47We learned about what LLM is and how LLMs use what's inside the context window

24:52After learning about LLMs, we wanted to solve Tech Corp's business requirements of searching for 500 GB worth of data

24:59In order to do that, we determined that embedding is a good way to search a massive set of documents

25:06After that, we went over Langchain and what functions they serve, which is that they allow us to easily build Gentic application like Tech Corps chatbot

25:12So now that we have the lang chain application, we need to be able to search through these large sets of documents

25:19Let's say inside the 500 GB of documents, your company has a document called employee handbook that covers policies like time off, dress code, and equipment use

25:28Employees might ask terms like vacation policy, but miss time off guidelines

25:34While these are common questions that people would typically ask, building a database around this requirement can be tricky

25:42In a conventional approach where data is stored in a structured database like SQL, you typically need to do some amount of similarity search like select all from documents content like vacation or vacation policy with a wild card before and after to look for details about questions on holiday

25:58To expand your result set, you might increase the scope by adding VA or VAC space P

26:05However, the drawback to this approach is that it puts the onus on the person searching for the data to get the search term formatted correctly

26:12But what if there was a different way to store the data? What if instead of storing them by the value, we store the meaning of those words? This way, when you search the database by sending the question itself of can I request time off on a holiday based on the meaning of those words contained in the question, the database returns only relevant data back

26:30This is a spirit of what vector databases tries to address storing data by the embedding

26:37So essentially instead of searching by value, we can now search by meaning

26:42Popular implementation of vector databases include pine cone and chroma

26:47These platforms are designed to handle embeddings at scale and provide efficient retrieval based on semantic similarity

26:54And these are also great use cases for prototyping something quick

26:58While conceptually this seems straightforward, there's a bit of an overhead in setting this up

27:02And you might be asking, well, can we just throw the employee handbook into the database like we just did for SQL database? Not quite

27:10And here's why

27:10With SQL database, the burden is put on the user searching to structure the database

27:15But with vector databases, the burden is put on you who is setting up the database since you are trying to make it easier for someone searching for the data

27:23And you can imagine why a method like this is becoming extremely popular when paired with large language models in AI since you don't have to train separately on how LLM should search your database

27:36Instead, the LLM can freely search based on meaning and have the confidence that your database will return relevant data it needs

27:43So let's explore some of the key concepts behind what goes into setting up a basic vector database

27:50Let's start with embedding

27:50Embedding is really the key concept that makes the medium go from value to meaning

27:54In SQL, we store the values contained in the employee handbook as a straightup value

28:01But in a vector database, you need to do some extra work up front to convert the value into semantic meanings

28:06And these meanings are stored in what's called embeddings

28:09For example, the words holiday and vacation should semantically share a similar space since the meaning of those words are close to each other

28:18So before the sentence employee shall not request time off on holidays in the document is added to the database

28:23The system runs through an embedding model and the embedding model converts that sentence into a long vector of numbers and when you search the database you are actually comparing this exact vector

28:36That way when someone later asks can I take vacation during a holiday even though the phrasing is a little bit different the database can still service the request

28:44And this is the fundamental shift

28:46Instead of searching by exact wording, we're now searching by meaning

28:50Another important concept is dimensionality

28:52And you might be asking, why do I have to worry about dimensionality? Can't I just throw the words into embedding and store it into the database? There's one more aspect in embedding that you need to think about, and that's dimensionality

29:03Typically, a word doesn't just have one meaning to learn from

29:08For example, the word vacation can have different semantics depending on the context that is used in

29:14and capturing all those intricacies like tone, formality, and other features can give richness to those words

29:21Typically, dimensions we use today are 1536 dimensions, which is a good mix of not having too much burden in size, but also giving enough context to allow for depth in each search

29:31Once the embedding is stored with proper dimension, there are two other major angles that we need to consider when we're working with vector databases

29:40And this is the retrieval side

29:42Meaning now that we store the meaning of those words, we have to take on the burden of the retrieval side of embeddings

29:48Since we are not doing searches like we did in SQL with a wear query, we need to make a decision on what would technically be counted as a much and by how much

29:57This is done by looking at scoring and chunk overlap

30:02And if you're at this point wondering, this seems like a lot of tweaking just to use vector database

30:07And that's the serious trade-off you ought to consider when using a vector database, which is that while a properly set up vector database makes searching so much more flexible, getting the vector database properly configured often adds complexity up front

30:19So with that in mind, scoring is a threshold you set to how similar the results need to be to be considered a proper match

30:26For example, the word Florida might have some similarity to the word vacation since it's often where people go for vacation

30:34But asking the question, can I take my company laptop to Florida is very different than does my company allow vacation to Florida? Since one is asking about a policy in IT jurisdiction and the other is about vacation policy

30:50So setting up a score threshold based on the question can help you limit those low similarities to count as a match

30:57Okay, there's one final angle which is chunk overlap

30:59So in SQL, we're used to storing things rowby row, but in vector databases, things look a little bit different

31:06When we're storing values in vector databases, they're often chunked going into the database

31:10So when we chunk down an entire employee handbook into chunks, it's possible that the meaning gets chunked with it

31:16That's why we allow chunk overlap so that the context spills over to leave enough margin for the search to work properly

31:26In this app, we're going to build a semantic search engine step by step

31:28The story begins with TechDoc Inc

31:30where users search through documentation 10,000 times a day

31:34But more than half of those searches fail

31:36Why? Because traditional keyword search can't connect reset password with password recovery process

31:44Our mission is to fix that by building a search system that understands meaning, not just words

31:48We begin with the environment setup

31:51In this step, we're asked to install the libraries that make vector search possible

31:56Sentence transformers for embeddings

31:58lang chain for orchestration, chromadb for vector database and few utility libraries like numpy

32:04Once installed, we verify the setup using a provided script

32:07If everything checks out, we're ready to move forward

32:10Next, we take a moment to understand embeddings

32:13These are the backbone of semantic search

32:14Instead of treating texts as words, embedding converts text into numerical vectors

32:21Similar meanings end up close to each other in this mathematical space

32:23That means forgot my password in account recovery looks very different in words but almost identical in vector 4

32:30This is a magic that allows our search engine to succeed where keyword search fails

32:38That takes us into task number one where we put embedding into action

32:40We open the script, initialize the mini LM model, encode both queries and documents and then calculate similarity using cosign similarity

32:49Running the script demonstrates how a search for forgot password successfully matches password recovery, showing semantic understanding in real time

32:58Once we understand embeddings, we move to document chunking

33:01Large documents can't be embedded all at once

33:04So, we need to split them into smaller chunks, but if we cut too bluntly, we lose context

33:11That's why overlapping chunks are important

33:12They preserve meanings across boundaries

33:15For example, setting a chunk size of 500 characters with 100 characters overlap can improve retrieval accuracy by almost 40%

33:22Lang chain helps us do this intelligently

33:25In task number two, we put this into practice by editing a script to import lane chain's recursive characters text splitter and set the chunking parameters

33:33Running the script confirms that our documents are now split into overlapping pieces ready for storage

33:40The next concept we explore is vector stores

33:42Embeddings alones are just numbers

33:45We need a system to store and search through them efficiently

33:49That's where Chromma comes in

33:49It's a production ready vector database that can handle millions of embeddings, perform similarity search in milliseconds, and support metadata filtering

33:58In task number three, we're asked to create a vector store using Chroma DB

34:02We import the necessary classes, configure the embedding model, and then run the script

34:07Once confirmed, we have a working vector store that can accept documents and retrieve them semantically

34:13Finally, we bring everything together with semantic search

34:16Here we implement the full pipeline, convert the user query into an embedding, search the Chromma store, retrieve the most relevant document chunks, and return them to the user

34:25For example, a query like work from home policy will now correctly surface remote work guidelines

34:33In task 4, we configure the query, set the number of top results to return, and establish a threshold for similarity scores

34:41Running the script validates our search engine end to end

34:45The lab closes with a recap

34:45We started with a broken keyword search system where 60% of the search failed

34:50Along the way, we learned about embeddings, smart document chunking, vector stores, and semantic search

34:56By the end, we built a productionready search engine with 95% success rate

35:01Some of the deeper experiments like adjusting chunk sizes, testing different embedding models and or adding metadata filters are left for you to explore on your own

35:14So is it possible that instead of searching through the entire 500 GB of documents, AI assistant can fit them into their context window and generate output

35:22This is called rag or retrieval augmented generation

35:25Let's say your company used the AI assistant to ask this question

35:30What's our remote work policy for international employees? In order to understand how rag works, we need to break them into three simple steps

35:38Retrieval, augmented, and generation

35:40Starting with retrieval, just like how we convert the document into vector embeddings to store them inside the database, we do the exact same step for the question that reads, "What's our remote work policy for international employees?" Once the word embedding for this question is generated, the embedding for that question is compared against embeddings of the documents

36:00This type of search is called semantic search where instead of searching by the static keywords to find relevant contents, the meaning and the context of the query is used to match against the existing data set

36:12Moving on to augmentation in rag refers to the process where the retrieved data is injected into the prompt at runtime

36:18And you might think why is this all that special? Typically, AI assistants rely on what they learned during pre-training, which is static knowledge that can become outdated

36:28Instead, our goal here is to have the AI assistant rely on up-to-date information stored in the vector database

36:36In the case of RAG, the semantic search result pends to the prompt that essentially serves as an augmented knowledge

36:42So, for your company, the AI assistant is given details from company's documents that are real, up-to-date, and private data set

36:51And all this can occur without needing to fine-tune or modify the large language model with custom data

36:56The final step of rag is generation

36:58This is a step where AI assistant generates the response given the semantic relevant data retrieved from the vector database

37:08So the initial prompt that says what's our remote work policy for international employees? The AI assistant will now demonstrate its understanding of your company's knowledge base by using the documents that relate to remote work and policy

37:20And since the initial prompt specifies a criteria of international employees, the generation step will use its own reasoning to wrestle with the data provided to best answer the question

37:32Now, RAG is a very powerful system that can instantly improve the depth of knowledge beyond its training data

37:39But just like any other system, learning how to calibrate is an acquired skill that needs to be learned to get the best results

37:45Setting up a rag system will look different from one system to another because it heavily depends on the data set that you're trying to store

37:53For example, legal documents will require different chunking strategies than a customer support transcript document

37:58This is because legal documents often have long structured paragraph that need to be preserved and intact

38:05While conversational transcript can be just fine with sentence level chunking with high overlap to preserve context

38:10In this lab, we're taking our semantic search system to the next level by adding AI power generation

38:17Up until now, we've been able to find relevant documents with high accuracy

38:22For example, matching remote work policy when someone searches work from home

38:29But the CEO wants more

38:29Instead of retrieving a document, the system should actually answer the user's questions directly

38:35something like yes, you can work three days from home, not just showing a PDF

38:39We begin the environment setup

38:42In this step, we're asked to activate the Python environment and install the key libraries

38:45These include Chroma DB for vector storage, sentence transformers for embeddings within lane chain with integrations for OpenAI and hugging face

38:54Once installed, we verify everything using the provided script to ensure the rack framework is ready

39:01Next, we move into task number one, setting up the vector store

39:03Here we initialize a chromabb client

39:05Create our get collection named tech corp brag and configure the embedding model all mini6v2

39:15This is where we get our system of memory

39:17A place where all of our company documents will be stored as vectors so that we can search them semantically

39:22In task number two, the focus shifts to document processing and chunking

39:28Unlike our earlier lab where we split text into fixed-size character chunks, here we upgrade to paragraph-based chunking with smart overlaps

39:37The goal is to preserve meaning so that each chunk contains complete thoughts

39:42This is crucial for RAG because when AI generates answers, the quality depends on having coherent chunks of context

39:51From there, we go to task number three, LLM integration

39:54This is where we connect OpenA model GPD4.1 Mini

39:56The API key and base are already preconfigured for us

40:02We just need to set the generation parameters like temperature, max tokens, and top P values

40:06Once integrated, we can test simple text generation before layering on retrieval and augmented steps

40:12Task number four introduces prompt engineering for rag

40:17We're asked to build a structured prompt template that always ensures context is included

40:21The system prompt makes it clear that answers must come only from the retrieved documents

40:25If the information isn't in context, the AI must respond with, "I don't have that information in the provided documents." This keeps our answers factual and prevents hallucinations

40:35Finally, we reach task number five, the complete rag pipeline

40:41Here we wire everything together

40:43The flow is embed the user query, search Chromad, retrieve the top three chunks, build a contextaware prompt, and generate an answer using LLM

40:53The final touch is a source attribution

40:55Every answer points back to the document it was derived from

40:58This transforms the system into a full production ready Q&A engine

41:03At the end, we celebrate rag mastery

41:06What started as simple document search has evolved into a powerful system that retrieves, augments, and generates answers

41:13This is the same architecture that powers tools like catchupt, claude, and gemini

41:18Some parts like experimenting with different trunk strategy, refining prompts are left for you to explore yourself

41:25But by now you've built a complete RAG system that answers questions with context, accuracy, and confidence

41:35Now that we covered the conceptual elements of RAG, let's look at how it looks on a practical level

41:39To better understand this, we can look over at this lab specifically geared towards how to use Rag

41:45Now we covered the basic concepts of simple chat application that allows us to chat with documents using vector databases and rag

41:52Most business cases in the real world may be slightly more complicated

41:58For example, in tech corp's case, the business requirement might extend to more complex requirements like being able to connect the agent to human resource management system to pull employee documents to cross reference and make personalized responses

42:13However, lang chain has limitations

42:15When business requirements become more complex like multi-step workflows, conditional branching or iterative processes, you need something more sophisticated for better orchestration

42:25That's where langraph becomes essential

42:27Langraph extends lane chain to handle more complex multi-step workflows that go beyond simple question and answer interactions

42:34For example, if a customer asks, I need to understand our data privacy policy for EU customers

42:41Since we assume that inside the 500 GB of database, it contains details about EU specific regulations, we need to create a system that can analyze Tech Corp's data privacy policies for EU customers, ensuring compliance with GDPR, local regulations, and company standards

42:57While in a traditional software development, you need to write code that can sequentially and conditionally call different sections of the code to process this request

43:07With lang graph, this becomes a graph where each node handles a specific responsibility

43:12For example, node one, search and gather privacy policy documents

43:17Node two, extract and clean document content

43:19Node three, evaluate GDPR compliance using LLM analysis

43:22Node four, cross reference the local EU regulations

43:28And node five, identify compliance gaps and generate recommendation

43:32A node is an individual unit of computation

43:34So think of a function that you can call

43:36Once you have all the nodes created in langraph, you will then need to connect them and this connection is called an edge

43:43Edges in langraph define execution flow

43:45For example, after node one gathers documents, the edge routes to node two for content extraction

43:53And after node 3 evaluates compliance, a conditional edge either routes to node four for additional analysis or jumps to node five for report generation

44:03And one final concept to keep in mind beyond nodes and edges is shared state between each node

44:10This is possible by using state graph that essentially stores information throughout the entire workflow

44:17For example, class compliance state type dictionary topic string documents list of string current documents optional string compliance score optional integer gaps list of string recommendation list of string can be used for nodes we identified before

44:34As the workflow progresses, each node updates relevant state variables

44:37Node one populates documents with found policy files

44:42Node two processes individual documents and updates current document

44:46Node 3 calculates compliance score

44:49Node 4 identifies gaps

44:49Node 5 generates recommendation

44:52The state graph orchestrates execution based on configured flow

44:56If node 3 determines compliance score is below 75% the conditional edge routes back to node one to gather additional documents

45:04If the score exceeds 75% execution proceeds to node 5 for final report generation

45:10As you can see this creates powerful capabilities loops for iterative analysis conditional branching on intermediate results persistent state that maintains context across the entire workflow

45:23So for Tech Corps compliance assistant, Langraph is an essential tool for workflow automation

45:28All right, let's start with the labs

45:31In this lab, we're diving into Langraph, a framework designed for building stateful multi-step AI workflows

45:37Unlike simple chains, Langraph gives us specific control over how data moves, letting us create branching logic, loops, and decision points

45:46By the end of this journey, we'll have built a complete research assistant that can use multiple tools intelligently

45:53We begin with environment setup

45:55In this setup, we activate the Python virtual environment and install the required libraries

46:01Langraph itself, Langchain, and OpenAI integration

46:04Once everything is installed, we run a verification script to make sure our setup is ready

46:08With the environment ready, we start small

46:12Task number one introduces us to essential import

46:14We bring in state graph end and type dict to define the data that flows through the workflow

46:21Then we add a simple state field for messages

46:24This is the foundation

46:24State graph holds the workflow and marks completion and the state holds shared data

46:31In task number two, we create our first nodes

46:34Nodes are just Python functions that take state as inputs and return partial updates

46:39In this case, we define a greeting node and an enhancement node

46:44Once connected, one node outputs a basic greeting and the next node improves it with a bit of a flare

46:50This demonstrates how state accumulates step by step

46:52Pass number three is about edges

46:54The connections between nodes

46:56Here we use add nodes and add edges to wire greeting nodes to the enhancement node

47:01With that, we built our first mini workflow

47:04Data flows from one function to another

47:06The state updates along the way

47:08In task number four, we take it further with a multi-step flow

47:13We add new nodes like a draft step and a review step

47:15Connect them and see how the data moves through multiple stages

47:19Each step preserves states, adds detail and passes it on

47:25This mimics real world pipelines where content is outlined, drafted and polished

47:30Pass number five introduces conditional routing

47:32Instead of a fixed flow, the system now decides dynamically

47:36For example, if the query is short, it routes one way

47:39If detailed, it routes another

47:41The router inspects the state and returns the next node name, making workflows flexible and adaptive

47:48Then comes task number six, tool integration

47:51Here we add a calculator tool

47:53The router checks if the query is math related

47:55If so, it routes to the calculator node which computes the answer

48:00This is our first glimpse at how Langraph lets us integrate specialized tools directly into workflows

48:06Finally, task number seven puts everything together into research agent

48:11We combine the calculator with a web search tool like duck.go

48:15Depending on the query, the system decides whether to perform a calculation, run a web search, or handle a text normally

48:22This is a dynamic tool orchestration, the foundation of modern AI agents

48:28By the end of this lab, we've gone from simple imports to a fully functional research assistant

48:32We've seen how to build nodes, connect them, design multi-step flows, and add routing logic and integrate tools

48:39Some of the deeper experiments like chaining more advanced tools or refining the router logic are left for you to explore on your own

48:51Now that we covered lang chain and langraph and understood how techp business requirements can be met by leveraging pre-built tools that it offers, there's one final piece that's been popular since Anthropics released back in November 2022 called MCP or model context protocol

49:06Techorps AI document assistant is working well for internal knowledge base, but employees might now need to access external systems like customer database, support systems, inventory management software, and other thirdparty APIs

49:21And writing custom integrations to all these API connections will take a huge amount of time

49:28MCP functions like an API, but with crucial differences that make it perfect for AI agents

49:32Traditional APIs expose endpoints that require you to understand implementation details leading to rigid integrations tied to specific systems

49:42MCP doesn't just expose tools

49:45It provides self-describing interfaces that AI agents can understand and use autonomously

49:51The key advantage here is that unlike traditional APIs, MCP puts the burden on the AI agent rather than the developer

49:59So when you start an MCP server, an instance starts and establish a connection with your AI agent

50:04For example, the Techorps document assistant might easily have these MCP servers to enable powerful integration

50:11Let's say customer database MCP

50:14When someone asks, "What's the status of the order 1 2 3 4?" The AI uses an MCP to query TechCorb's order management system, retrieves the current status, and provides a complete response

50:25The same logic applies for support tickets, inventory databases and notification system mentioned earlier where we can simply plug into existing integrations of MCP servers to allow the agent to now extend its capabilities

50:40For example, we can create a very simple MCP server code that looks something like this

50:45Here we have fast MCP customer DB that starts the MCP server with the name customer DB at MCB tool that exposes a function to MCP clients

50:56the AI can call like an API function parameters and return types that tells the MCP client what inputs are required and what type of output to expect

51:06Finally, customers variable that is a fake database in this case stored in memory, but in your company's case, you can connect this to a SQL database or MongoDB or any other custom database you might hold customer information on

51:19Now, looking at this code might confuse you on what MCP really is, since it's typically being talked about as a simple plugand play, and you're right to think that way

51:28The difference here is that this MCP server code that's written only needs to be written once, and it doesn't necessarily have to be you

51:35In other words, a community of MCP developers might have written custom MCP servers for other popular tools like GitHub, GitLabs, or SQL databases, and you can simply use them directly on your agent without having to write the code yourself

51:50That's where the power of MCP really comes from

51:53In this lab, we're going deeper into MCP, model context protocol, and learning how to extend Langraph with external tools

52:00Think of MCP as a universal port like USB that allows AI system to connect to any tool, database or API in a standardized way

52:11With it, our langraph agents can go beyond built-in logic and integrate external services seamlessly

52:16We begin with the environment step

52:18In this step, we activate our virtual environment and install the key packages

52:23Lang graph for the workflow framework, Langchain for the core abstractions, and Langchain OpenAI for the model integration

52:30The setup also prepares for fast MCP, the framework we'll use to build MCP servers

52:37Once installed, we verify by learning the provided script, ensuring everything is ready for MCP development

52:44Next, we get a conceptual overview of the MCP architecture

52:46Here the lab explains that the MCP protocol acts as a bridge between an AI assistant built with Langraph and external tools

52:54The flow works like this

52:57The MCP server exposes tools and schemas

52:59Langraph integrates with them and queries are routed intelligently

53:04The naming convention MCP server tool ensures clarity when multiple tools are involved

53:12A helpful analogy is comparing MCP to USB devices

53:14A protocol is a port

53:17The server is a device

53:17The tools are its functions

53:20And Langraph is a computer that uses them

53:22That brings us to task number one, MCP basics

53:24Here we're asked to create our very first MCP server

53:30The task involves initializing a server called calculator, defining a function as a tool with at MCP.tool decorator and running it with the SCDIO transport

53:40This shows how simple it is to expose a structured function as an external tool

53:45that langraph can later consume

53:47In task number two, we integrate MCP with langraph

53:49The challenge here is to connect the calculator server to an agent

53:53This involves configuring the client fetching tools from the server create react agent that can decide when to call the calculator selected when needed

54:02Next, task number three scales things up with multiple MCP servers

54:08Instead of just a calculator, we add another server, in this case, a weather service

54:13Now, Langraph orchestrates between both

54:15The system retrieves available tools, creates an agent with access to both servers, and intelligently routes queries

54:23If a user asks a math question, the calculator responds

54:26If they ask about the weather, the weather tool responds

54:30This is where we see the true power of MCP

54:32Multiple servers are working together under a unified AI agent

54:37The lab wraps up by celebrating MCP mastery

54:39By now, we've created MCP servers, integrated them with ElangRaph, and orchestrated multiple tools

54:45The key takeaways are that MCP is universal

54:47It can connect any tool to any AI

54:50Routing is what gives it power

54:53The design is extendable, so we can add servers anytime

54:57Some deeper explorations like exposing databases, APIs or file systems through MCP are left for you to explore on your own

55:05That concludes this narration

55:07Next, we'll continue the journey by experimenting with resource exposure, human in the loop approval flows, and eventually deploying production ready MCP packages

55:19Now that we have put all these pieces together like context windows, vector databases, lang chain, langraph, MCP, and prompt engineering, Techorp is now able to do complex document search that went from manual searching that could have taken up to 30 minutes to now less than 30 seconds using our AI agent

55:35And we also have a higher accuracy using contextaware semantic search like using rag

55:42And finally, the chat application UI allows users to have more satisfaction in working with a tool that can help keep track of conversation history and better intuition overall

55:54And the availability for this is 24/7 as long as the application is running

55:57And this is just the beginning

55:59Imagine layering on predictive analytics, proactive compliance agents, and workflow automation that doesn't just answer questions, but actively solves problems before employees can even ask

56:12The shift from static documents to living intelligent system marks a turning point not just for Tech Corp, but for how every other business can unlock a full value of its knowledge using agents.