00:03:11.000 –> 00:03:41.000
Hi folks, we’ll be starting the session in another two, three minutes, which is waiting for everybody to join.
00:05:17.000 –> 00:05:24.000
So hi, everybody. Thank you so much for joining the webinar today. I’m really glad that all of you could make it.
00:05:24.000 –> 00:05:29.000
I’m Mahashree, product marketing specialist at Unstract and also your host for this session today.
00:05:29.000 –> 00:05:42.000
So in this webinar, we’ll cover what Unstract is all about. So for those of you that are new, Unstract is a purpose-built platform that is LLM powered for document data extraction.
00:05:42.000 –> 00:05:54.000
So we look at the end-to-end capabilities of the platform in this session, and we’ll see how it is really at the forefront of modern document processing and automation.
00:05:54.000 –> 00:06:08.000
So moving on, this is what we have in store for you today. We’ll kickstart this session with a brief discussion on the challenges faced in document data extraction. And this will be followed by an in-depth demo of Unstract as a solution.
00:06:08.000 –> 00:06:19.000
So over here, we’ll cover the capabilities in detail and you’ll see how they are actually able to cope up with the challenges and also cater to modern document processing needs.
00:06:19.000 –> 00:06:26.000
Following this would be a quick overview of LLM Whisperer, which is Unstract’s in-house text extraction tool.
00:06:26.000 –> 00:06:41.000
While we wouldn’t get into a very in-depth discussion on LLM Whisperer, we wouldn’t be getting into a detailed demo, but we will be getting an overview of the platform so that you can also see how it is able to complement Unstract.
00:06:41.000 –> 00:06:51.000
And finally, in case you have any questions, we will be taking up a live Q&A segment at the end in case there are a lot of questions that need to be answered.
00:06:51.000 –> 00:07:05.000
So moving on to the housekeeping, as you can see, all attendees will automatically be on mute throughout the course of this webinar. You can start posting your questions in the Q&A tab that you’d find at the bottom of your screen at any time during the session.
00:07:05.000 –> 00:07:11.000
Our team is working in the backend and will be able to get back to you with the answers via text.
00:07:11.000 –> 00:07:26.000
Now, you’d also find a chat tab in the panel below. So this is where you can post in case you’re running into any technical difficulties during the session and we’ll be able to help you out. And you can also interact with fellow attendees in this webinar today.
00:07:26.000 –> 00:07:38.000
Now, as a final point before you exit the session, you would be redirected to a feedback form where I request you to leave a rating and a review on for us so that we can continue to improve our webinar experience for you.
00:07:38.000 –> 00:07:49.000
So with that said, and without any further ado, let me jump into the first discussion that we have planned out for today, which is the challenges that are commonly faced in document data processing.
00:07:49.000 –> 00:08:06.000
So over here, we’ve outlined six common challenges and some of you may already be facing these in your businesses. So firstly, we have complex formatting So documents come with various components in them. This could be tables, forms.
00:08:06.000 –> 00:08:19.000
Scanned images, handwritten notes, and just about anything. So how well is your document processing system actually able to process this information and extract the correct data that you’re looking for?
00:08:19.000 –> 00:08:30.000
Now, traditionally, this was done either manually or through certain predefined templates, which have not been very sustainable in the long run and have also been prone to human error.
00:08:30.000 –> 00:08:42.000
So in this session, we’ll see how LLMs are able to comfortably overcome these challenges and can actually process documents no matter their formatting.
00:08:42.000 –> 00:08:53.000
So the next challenge is document variance. So typically a business would incur documents from various sources and this could be invoices, bank statements, purchase orders.
00:08:53.000 –> 00:09:00.000
And a lot more. So how well is your system actually able to handle the variety of documents that you incur?
00:09:00.000 –> 00:09:13.000
So we’ll also see how LLMs can be deployed over a variety of documents and they can handle any use case, no matter the layout or design.
00:09:13.000 –> 00:09:31.000
Moving on, we have handwritten text. So handwritten text or users filling in details by hand is still a common process that a lot of businesses have. As you can see on the screenshot on your right, we have a form with certain details filled out by hand. Or you could actually have documents, entire documents written by hand.
00:09:31.000 –> 00:09:44.000
So these would obviously contain different handwritings and styles. So how well is your system actually able to detect that and get the accurate data that you’re looking to extract? So we will take a look at that as well.
00:09:44.000 –> 00:10:06.000
And to quickly wrap up the last three challenges, we have extraction accuracy. So typically in a document, when you’re looking to extract data on a certain topic, it wouldn’t all be in a certain space. It can be spread out across different locations in the document. So how well is your system able to get all of this information together and bring the accurate answer to you?
00:10:06.000 –> 00:10:20.000
Next, we have security and privacy, which is again an age-old challenge that businesses often face when adopting digital platforms. So we’ll also take a look at how Unstract is able to ensure security and privacy of your data.
00:10:20.000 –> 00:10:37.000
And finally, we have integration. So how well are your document data extraction workflows able to sit in with the existing systems that you have in your business? So this is ultimately what will enable your teams to adapt these processes in their day-to-day operations.
00:10:37.000 –> 00:10:51.000
So we’ve covered quickly a brief on all the challenges that people usually face when it comes to document data extraction. And you might have one or more solutions dealing with these challenges in your businesses.
00:10:51.000 –> 00:11:05.000
But in this webinar, you’ll see how Unstract can actually pose as a single stop solution for all these challenges. And you’d also see various other capabilities that could be useful for you when it comes to document processing.
00:11:05.000 –> 00:11:26.000
Now to quickly give an overview of how you can actually use the platform, Unstract comes in three different editions. We have an open source edition with certain limited features that you can set up and actually get started and explore the platform and its capabilities on your own. We also support cloud and on-prem additions as well.
00:11:26.000 –> 00:11:39.000
And when it comes to LLM Whisperer, there are, again, three different ways in which you can use it. Firstly, you have a LLM Whisperer playground, which generously offers around 100 pages that you can process on a daily basis for free.
00:11:39.000 –> 00:11:50.000
But in case your requirement for this exceeds the limit, then you can always go and opt for the LLM Whisperer Cloud version or the on-prem version as well.
00:11:50.000 –> 00:11:58.000
And finally, our platforms, our ISO, GDPR, and HIPAA compliant to ensure the security and privacy of your data.
00:11:58.000 –> 00:12:07.000
So with that, I’ll move on to a brief overview of Unstract and all of its capabilities before jumping into the core demo section.
00:12:07.000 –> 00:12:18.000
So if I had to loosely bucket the different capabilities that the platform supports, I can put it under the development phase and the deployment phase.
00:12:18.000 –> 00:12:31.000
So in the development phase is where you would be creating your prompts or you would be specifying what data to extract from your documents. So this is done in a no code prompt engineering environment called Prompt Studio.
00:12:31.000 –> 00:12:43.000
So the first thing, the environment does is that you first extract the text from your original documents. So this is where you would be deploying a text extraction tool like LLM Whisperer.
00:12:43.000 –> 00:13:13.000
And then you can actually specify generic prompts that would be given in natural language and can run across various documents that you can upload in a single project. So in these prompts, you would be defining one, what data to extract and two, what is the schema that you’re looking for extracting? So how do you want the result to be structured? And you can test this across various document variants as well. So for instance, if you’re looking at extracting information from bank statements, and let’s say I have 100 different bank statements.
00:13:15.000 –> 00:13:27.000
Then I can actually specify a generic prompt across these different statements, even if they are from different vendors, because ultimately they are going to contain the same field. They’d probably have the customer name.
00:13:27.000 –> 00:13:45.000
Customer address and probably what they spent their card on or such details. So you can specify a generic prompt for all of your documents and it would be able to extract the results for you. So this is what we’ll be looking at in the development phase.
00:13:45.000 –> 00:13:57.000
And once you develop your workflow, you know what you’re going to extract and your processes are set, the next phase is to actually deploy this particular project in your business.
00:13:57.000 –> 00:14:15.000
Now, not all businesses are going to be deploying it in the same way. So we have different workflows or different ways in which you can actually deploy your project. So you might want to get your document from an application, perform the process and store the data that you receive after extraction into another application.
00:14:15.000 –> 00:14:25.000
That is when an API deployment would be useful for you. So similarly, you’d have documents in file systems that you may want to store in DBs and data warehouses.
00:14:25.000 –> 00:14:42.000
So depending on your use case you have for different deployment options, that is your API deployment, ETL pipeline, task pipeline, and human in the loop. So I will be getting into more detail on these different deployment options later on in this demo.
00:14:42.000 –> 00:15:02.000
And just a few numbers to sum up where Unstract is today is that we have over 5,000 plus stars on GitHub and a 650 plus member Slack community where you can interact with other users using the platform. And today we are processing over 7 million pages per month by paid users alone.
00:15:02.000 –> 00:15:14.000
So here are a few highlights that I thought I should mention before I jump into the demo section, which is what are the few capabilities that actually help us stand out in the market and what you should be looking for in this demo.
00:15:14.000 –> 00:15:28.000
So for those of you that have worked with LLMs before, you know that LLMs are capable of hallucinating. So how is the platform able to overcome this obstacle? So we do have a feature to support that called LLM Challenge that you’ll be seeing in this demo.
00:15:28.000 –> 00:15:42.000
And there are also cost optimizing capabilities like single pass extraction and summarized extraction. And we’ll again take a look at how layout preserved text extraction works with LLM Whisperer.
00:15:42.000 –> 00:15:54.000
And finally, certain industries might require a human in the loop when it comes to document data processing. So we do have a capability to support that called the human in the loop, and we’ll take a look at that as well.
00:15:54.000 –> 00:16:00.000
With that said, I think we’ve arrived at the most awaited portion of this webinar that is the demo section.
00:16:00.000 –> 00:16:05.000
So let me hop on to the platform. Hope you can see my screen.
00:16:05.000 –> 00:16:15.000
All right. So this is the Unstract interface that you see over here. Now, I am a returning user, but if you were to sign up and were logging in for the first time.
00:16:15.000 –> 00:16:30.000
The platform would intuitively guide you to set up certain connectors that you have over here on the left hand side panel under settings. So these can be considered as certain prerequisites that you will require in order to get started with document data extraction.
00:16:30.000 –> 00:16:42.000
So as you know, the platform deploys LLMs to extract the data. So we have a couple of elements that you can integrate with and set up connections with.
00:16:42.000 –> 00:16:51.000
So it’s pretty simple. I just have to enter the mandatory fields over here, like the API key, the name and a few more. And once I test the connection, I can get started with it.
00:16:51.000 –> 00:17:05.000
So similarly, we have vector DBs embedding models and a text extractor and setting up the connection in these different connectors is also pretty simple and very similar to what you looked at under LLMs.
00:17:05.000 –> 00:17:13.000
So under text extractor, this is where you will find LLM Whisperer along with other text extractor tools that the platform supports.
00:17:13.000 –> 00:17:32.000
And one important thing to note over here is that When it comes to LLMs, they process information very similar to how a human would. So if I were to look at a document, I can look at how the layout is and you would intuitively be able to understand what it’s trying to communicate.
00:17:32.000 –> 00:17:52.000
So the best way to actually feed the raw text from your documents to an LLM is to basically preserve the layout of your original document. And this is something that the LLM Whisperer is known to do. It does it wonderfully and we will see certain examples of how this works later on in this demo.
00:17:52.000 –> 00:18:05.000
So in this case, I have set up my connectors. So I think I’m good to go. Let me quickly open a Prompt Studio project over here and we’ll see how we can actually deploy the prompts over our documents.
00:18:05.000 –> 00:18:11.000
So if I were to create a new project, I would click on new project, enter the details and get started.
00:18:11.000 –> 00:18:20.000
But for the want of time in this demo, I will be going into an existing project that I have over here called the credit card passer.
00:18:20.000 –> 00:18:33.000
All right. So you can see in this project that we have credit card statement over here on the right hand side And we also have a few prompts that we have deployed over this particular statement on the left.
00:18:33.000 –> 00:18:39.000
So the first step, as I mentioned earlier, is to extract the text from your original document.
00:18:39.000 –> 00:18:47.000
And in order to make it better consumable by LLMs, the best way to do it is to actually preserve the layout of your original document.
00:18:47.000 –> 00:18:55.000
So we’ll see how this is done in this particular project, I have deployed LLM Whisperer as the text extractor.
00:18:55.000 –> 00:19:02.000
And you can see over here under raw view how LLM Whisperer is actually able to preserve the layout of the original document.
00:19:02.000 –> 00:19:10.000
And even something as small as a logo that you see over here is retained under the raw view as well.
00:19:10.000 –> 00:19:16.000
All right. So just to show you how in other contexts in which LLM Whisperer works.
00:19:16.000 –> 00:19:29.000
I think I’ll just take a quick detour from here and we’ll take a look at a couple of other documents where you can see how LLM Whisperer has been able to extract the raw text, maintaining the layout.
00:19:29.000 –> 00:19:34.000
So for that, I’ll just go into a few other Prompt Studio projects that I have.
00:19:34.000 –> 00:19:47.000
So in this case, let’s see how the document turns out. We have a document with details that is filled in by hand. So we have the name over here and also the social security number.
00:19:47.000 –> 00:20:02.000
So if I go into raw view, you can see how the name is actually retrieved, even though it is filled by hand. And we also have the social security number over here. And all of this is done retaining the original layout of your document.
00:20:02.000 –> 00:20:08.000
So looking at one last example before we go back to credit card passer.
00:20:08.000 –> 00:20:16.000
So as you can see, this particular document has a table that is very condensed and it’s pretty text heavy.
00:20:16.000 –> 00:20:33.000
So LN Whisperer is still able to retrieve the text and you can see that it’s actually spaced out in a way that gives space for the different cells in the table. And this is what really helps the LLMs actually understand the document and retrieve the information that you’re looking for.
00:20:33.000 –> 00:20:40.000
All right, so this brings me back to the credit card password project that we’ll be looking at in more detail today.
00:20:40.000 –> 00:21:03.000
So once I have extracted the raw text or the text from my original document, I can start creating prompts and running them over the documents. So over here, we’ll cover the few capabilities that we have in uh if you take any single prompt. So we have a couple of prompts over here. So from this particular credit card statement.
00:21:03.000 –> 00:21:17.000
When extracting the customer name, the customer address. What are the spend line items that this particular card has been spent on and also certain payment information that I have over here.
00:21:17.000 –> 00:21:25.000
So let me just take the customer name prompt for starters. So you would be defining the prompt name, which is in a JSON compatible format.
00:21:25.000 –> 00:21:42.000
And you’d also, this is where you would be giving your prompt in natural language. So as I mentioned earlier, you would be specifying what is the data that you’re looking to extract. So in this case, it is the customer name to whom this credit card belongs to and also in what schema you want the extraction to be done.
00:21:42.000 –> 00:21:48.000
So we’ve given format the name of the customer with the first letter of each name capitalized.
00:21:48.000 –> 00:21:54.000
So once I give these a detailed prompt of how I want the extraction to be done.
00:21:54.000 –> 00:22:05.000
I can go ahead and specify the data, the output data type. So the platform supports you with the range of data types that you can choose from. In this case, I’m going to retain it as text because we’re just extracting the name.
00:22:05.000 –> 00:22:20.000
And you also have the different LLM models that you have deployed for this particular extraction given over here. So you have the details of the LLM, the embedding model, vector, DB, as well as the text extractor used.
00:22:20.000 –> 00:22:30.000
And as you can see, you can also deploy more than one LLM to perform the extraction. So over here, we do have two different LLMs working for the same prompt.
00:22:30.000 –> 00:22:44.000
And you also have metadata details over here. So what was the number of tokens that it took for the extraction for this particular prompt alone? What was the time taken for completion as well as the costs incurred?
00:22:44.000 –> 00:22:48.000
And what you see over here is the chunk used in this particular extraction.
00:22:48.000 –> 00:22:58.000
So what is exactly a chunk? So in this case, if you take a look at the document, it’s just a few pages long, but this wouldn’t always be the case.
00:22:58.000 –> 00:23:08.000
Because you might have to process documents that are hundreds of pages long. And sometimes LLNs wouldn’t be able to handle the entire context of the document in one go.
00:23:08.000 –> 00:23:19.000
So this is when you can enable chunking as a feature, which would be able to break down the document and feed specific chunks to your prompts from which your data will be extracted.
00:23:19.000 –> 00:23:24.000
And finally, we have LLM Challenge Log. This is something that I’ll come back to in a little while.
00:23:24.000 –> 00:23:35.000
And you also have the output over here. So these are the basic capabilities that you have in any given prompt.
00:23:35.000 –> 00:23:51.000
And you see over here that we’ve already run these prompts against this document and they are working pretty well. So if I were to take an example of another prompt over here, you can see that we are retrieving the spend line items from this credit card statement.
00:23:51.000 –> 00:24:07.000
And I’ve also given the exact details of how I want my output to be structured, like the spend date, the spend description, as well as the amount and the output data type is given as JSON. And you can actually compare the extraction done by both these LLMs over here.
00:24:07.000 –> 00:24:31.000
So these are working pretty well and I’m good to go. But one common challenge that you might face with LLMs As I’d spoken earlier is the L&M hallucinating. So how do you overcome this challenge? So is something that Unstract deals with pretty well. We have a powerful capability called the LLM Challenge right here.
00:24:31.000 –> 00:25:01.000
So to explain how this works, so you have an extractor LLM which would be running on your document. So what you can do to overcome hallucinations is to actually define another alternative LLM, also known as a challenger LLM, which would also run on this particular document And only if the result from the extraction LLM and the challenger LLM are same or they arrive at a consensus, will it be given to the user? Because Unstract’s philosophy is that a null value is still better than a wrong value.
00:25:03.000 –> 00:25:13.000
So we would be ensuring that they arrive at a consensus and a best practice when it comes to choosing the challenger LLM is to go for a flagship model from a completely different vendor.
00:25:13.000 –> 00:25:17.000
So I can enable it over here under Prompt Studio Settings.
00:25:17.000 –> 00:25:25.000
And to briefly go over the other settings that I have over here, you have the LLM profile.
00:25:25.000 –> 00:25:35.000
So you saw how you can integrate with various connectors, whether it’s your LLMs, vector DVs, and so on. So if you have set up different connectors under LLMs or under any particular category.
00:25:35.000 –> 00:25:40.000
You can choose what is the combination you’re looking to work with in this particular project.
00:25:40.000 –> 00:25:44.000
And we have summarized extraction, which again, I’ll come to in a little while.
00:25:44.000 –> 00:25:55.000
We looked at the LLM challenge. So grammar is where you would be defining certain words and synonyms that you want the system to pick up on from your documents.
00:25:55.000 –> 00:26:15.000
And then we have the preamble and post amble. So these are basically prompts The preamble is a prompt that is common and it would be added at the beginning of all your prompts in your project. So this is already pre-populated by the system. However, you can go through it and change it according to your needs.
00:26:15.000 –> 00:26:23.000
Very similarly, a post amble is a prompt that is appended at the end of all your prompts. And this is also editable over here.
00:26:23.000 –> 00:26:51.000
Finally, we have highlighting, which is a capability that is supported only when you have LLM Whisperer as your text extraction service. So this basically helps you highlight your, it lets you choose your output and highlights the corresponding portion from the document from which this particular output was extracted. So this lets you basically see how the extraction is being done and verify that it is working perfectly well for you.
00:26:51.000 –> 00:27:06.000
So just to see how highlighting works. In this case, if I select the name over here, you can see how the name has been highlighted in the document. So I have I might have different portions where it has retrieved the name from.
00:27:06.000 –> 00:27:20.000
So once I select the name, you can see how it is being highlighted. So it’s been highlighted on the top over here as well as the bottom. So this is how you can basically verify if the extraction is working well.
00:27:20.000 –> 00:27:25.000
So we looked at how you can also overcome LLM challenge, I mean, hallucinations using LLM challenge.
00:27:25.000 –> 00:27:38.000
And you can actually check out how it’s working using the LLM challenge log that you have over here. So we have the extraction LLMs result, the challenger LLMs result. And you can see that the result is a five on five pass.
00:27:38.000 –> 00:27:46.000
So only when it has arrived at a consensus am I able to see the actual output.
00:27:46.000 –> 00:28:04.000
So now we know how to overcome hallucinations. But another important aspect that you should be considering when you’re using LLMs are the costs involved. Because depending on your LLM And the model that you’re choosing, your cost may vary based on the number of tokens that you use.
00:28:04.000 –> 00:28:11.000
So ideally, we should be looking at optimizing the costs while still maximizing the results that we get.
00:28:11.000 –> 00:28:17.000
And the platform supports two powerful capabilities that can be deployed separately for this.
00:28:17.000 –> 00:28:22.000
Which are known to bring down your costs by 8 to 10x.
00:28:22.000 –> 00:28:26.000
So that is nothing but your single pass extraction and summarized extraction.
00:28:26.000 –> 00:28:50.000
So as you can see over here on the top right hand side, we have the single pass extraction. It’s a simple toggle that I have over here. Now, what this capability does basically is that if you take any particular prompt, ideally it runs across the entire context of your document. So each of these prompts are running against the entire document every time they are run.
00:28:50.000 –> 00:29:07.000
So just imagine the number of tokens that you would be spending for each of these extractions. So what you can do with single pass extraction is combine all of these prompts into one single large prompt And that large prompt would be run against the context of your document just once.
00:29:07.000 –> 00:29:15.000
And it would be able to retrieve the information that you’re looking for while still keeping the atomic prompts maintainable separately.
00:29:15.000 –> 00:29:22.000
So this is single pass extraction. The other capability that I spoke about was summarized extraction that you see over here.
00:29:22.000 –> 00:29:28.000
So the way this works is that you specify, again, another LLM for you to use.
00:29:28.000 –> 00:29:37.000
And this basically looks at all your prompts and it identifies the portions from your original document where you might require information to be extracted from.
00:29:37.000 –> 00:29:49.000
And it then creates a summarized view of your original document and your LLMs would basically then be run over the summarized view and results would be acquired from there.
00:29:49.000 –> 00:30:03.000
So you can see over here under summary view So this is the summarized context that this system has been able to create for this particular document.
00:30:03.000 –> 00:30:16.000
And one more feature actually that I missed to cover is that I had mentioned earlier that you can run your prompts across various different documents. So these are generic prompts.
00:30:16.000 –> 00:30:29.000
So over here, you can see that we have the American Express credit card statement that is visible, but I can also upload other credit card statements that you can see over here. So I have already uploaded it and I can upload new files as well.
00:30:29.000 –> 00:30:36.000
And each of your prompts are run over these different documents and you can view them under coverage.
00:30:36.000 –> 00:30:52.000
Where for each of your prompts, the customer name has been retrieved from all the documents that I have uploaded as well. So this is how you can also test how your prompts are working across different documents depending on their layout or design.
00:30:52.000 –> 00:31:17.000
So with that said, I think we’ve wrapped up the portion in the prompt studio. So finally, if you want to deploy single pass extraction, I can just switch on this toggle and you can see how the individual run buttons across your different prompts are combined into one single pass extraction button over here. And then your entire document, I mean, all your prompts would be run once against the entire context of your document.
00:31:17.000 –> 00:31:32.000
So that wraps up what we’re looking at in Prompt Studio. And the final step in the development phase before you move on to deploying your project in your existing system or workflows is to export this particular project as a tool.
00:31:32.000 –> 00:31:41.000
So you can also define certain share settings over here for added privacy. In this case, I’ve already exported this particular project, so I wouldn’t be doing this.
00:31:41.000 –> 00:31:49.000
And let me quickly move on to the deployment phase where you would be basically deploying it according to your use case.
00:31:49.000 –> 00:31:56.000
So for that, I will be creating workflows So let me create a new workflow over here.
00:31:56.000 –> 00:32:08.000
I would be creating a credit card API workflow.
00:32:08.000 –> 00:32:15.000
So let me quickly define these. Fields and we have the interface over here where you can get started.
00:32:15.000 –> 00:32:31.000
So in this case, you have the input configuration over here on top, the output configuration over here in the bottom, and you have the various tools that I’ve exported in my account over here. So you would also have the credit card password tool when I search for it.
00:32:31.000 –> 00:32:44.000
So you can see that the credit card passer tool also appears over here. So I can use any of my tools in my workflows And so in this case, I would be creating a workflow for API deployment. So let me
00:32:44.000 –> 00:32:57.000
Select my input configuration as API since I want my document coming in from an application. I want to perform this process and send out the output to another application. So I would be selecting API.
00:32:57.000 –> 00:33:06.000
And I can simply drag and drop the process or the tool that I’m looking to perform for this particular workflow.
00:33:06.000 –> 00:33:15.000
So in this case, I have dropped just one tool, but you can create a chain of different tools depending on how you want to work with your document.
00:33:15.000 –> 00:33:21.000
And you can also then define the output configuration, which would again be an API in this case.
00:33:21.000 –> 00:33:35.000
So we looked at various capabilities like LLM challenge, summarized extraction, highlighting, and single pass extraction in the Prompt Studio. So that is where you would develop the prompts and test how they are working across different documents.
00:33:35.000 –> 00:33:40.000
But in the workflow is where you actually deploy these capabilities.
00:33:40.000 –> 00:33:53.000
So I can choose to enable any one of these capabilities that I want in this particular workflow.
00:33:53.000 –> 00:34:00.000
Alright, so once this is done, I can then deploy this workflow as an API.
00:34:00.000 –> 00:34:11.000
So let me give it a name.
00:34:11.000 –> 00:34:25.000
So once I do this, my API is created And you can see this under API deployments on the left hand side panel and we have our API deployment right here.
00:34:25.000 –> 00:34:36.000
That you can see. So this also comes with an API endpoint and you can download this as a Postman collection for you to be able to call this particular workflow.
00:34:36.000 –> 00:34:43.000
So moving on, the next deployment option that we have is an ETL pipeline.
00:34:43.000 –> 00:34:52.000
So we looked at API deployments, which basically gets in documents from an application and then it does the processing and then sends out the output to another application.
00:34:52.000 –> 00:35:07.000
So you might have a use case where you have your documents coming in from a file system and you might want to process it and send it back to a database or a data warehouse. So this is where the ETL workflow or the ETL pipeline comes in.
00:35:07.000 –> 00:35:09.000
So I’ve already created one over here for the want of time.
00:35:09.000 –> 00:35:20.000
So under input configuration, you can choose which of your file systems you want to get your document from. So in this case, I’ve connected my Google Drive.
00:35:20.000 –> 00:35:26.000
So I will be getting a certain document from my Google Drive and running this particular tool on that document, processing it accordingly.
00:35:26.000 –> 00:35:34.000
And I would be storing this in a database. So you have the various other databases that the platform supports.
00:35:34.000 –> 00:35:50.000
And just to show you how this works in action, let me quickly open my database over here and you can see how I’ve actually uploaded the same credit card statement. And you can see that the output is stored in my database.
00:35:50.000 –> 00:35:57.000
Over here, it’s been able to extract the details and it’s also available with some metadata like the time taken for extraction.
00:35:57.000 –> 00:36:13.000
So over here is where you can see the customer address, the customer name, the payment information and the spend line items. So these were all the different prompts that you had seen earlier that I had specified in my Chrom Studio. And you can see the same over here.
00:36:13.000 –> 00:36:25.000
So this is similarly how your API calls would look as well. And you would have these different fields extracted and given to you as in a JSON format.
00:36:25.000 –> 00:36:35.000
So going back to my platform. We looked at ETL workflow Next, let’s take a look at the task pipeline.
00:36:35.000 –> 00:36:41.000
In the ETL pipeline, you basically get documents from a file system and you store the result or the output after processing in a DB.
00:36:41.000 –> 00:36:49.000
With a task pipeline, you basically get the document from a file system. You would want to process it and store the output back in the file system.
00:36:49.000 –> 00:36:57.000
So as you can see, I’ve specified my input and output configuration as Google Drive. You also have the other file systems that you can choose from.
00:36:57.000 –> 00:37:06.000
And just to show you again how this works in action. So I have the output stored in my Google Drive over here. And when I open it.
00:37:06.000 –> 00:37:18.000
This is how it opens up. So I have a JSON file. So again, we have some metadata and then we have the fields that we’re actually looking to extract, like the customer name, payment info.
00:37:18.000 –> 00:37:28.000
Customer address and the spend line items. So this is what that particular JSON file contains and this entire process can be automated as well.
00:37:28.000 –> 00:37:48.000
So finally, we looked at three different deployment capabilities. The final capability would be the human in the loop deployment. So as I mentioned earlier, certain industries might require a human in the loop to view the different documents and how the output is actually being extracted from them.
00:37:48.000 –> 00:38:04.000
And this is also supported in the platform. But for the want of time, let me not cover this in the demo. I’d be going back to my slideshow and you would have relevant screenshots over there from which you can get an idea of how this works.
00:38:04.000 –> 00:38:13.000
So as you can see in the human in the loop feature, we have the original document on the left-hand side, along with all of the output on the right.
00:38:13.000 –> 00:38:39.000
So it’s pretty simple. I can select any one of my output and the system would be able to highlight the corresponding area from which this particular output was extracted. So this lets me verify that my documents are working well. And another capability is that I can also further define what are the kind of documents I want to send for the human in the loop or the human quality review.
00:38:39.000 –> 00:38:49.000
So I can define that based on certain parameters that I can set when you’re creating the workflow for this particular deployment. So once the human reviews this.
00:38:49.000 –> 00:38:58.000
And it’s not just limited to this. You can also double click on the output and edit the output accordingly before you send it to a DV or a file system or wherever.
00:38:58.000 –> 00:39:13.000
So you can do that as well depending on the access permissions that you have. So this is where you have the human in the loop and this also lets you ensure that you are in fact extracting the right data from your document.
00:39:13.000 –> 00:39:26.000
So with that, we have covered the deployment phase as well. We looked at API deployments, ETL pipeline, task pipeline, and finally the human in the loop deployment So with that.
00:39:26.000 –> 00:39:54.000
I think we’ve concluded the demo section of this webinar. So just to briefly go over the various aspects that we covered today, we saw how text extraction works, how it’s important to preserve the layout of your original document and how LLM Whisperer is also able to perform this pretty well and you saw how it’s performed across different document types as well. And then we moved on to the prompt engineering environment, Prompt Studio.
00:39:54.000 –> 00:39:59.000
Where we saw how you would create a prompt and test it across different documents.
00:39:59.000 –> 00:40:19.000
And we also saw how you can overcome hallucinations by LLNs using LLM challenge, optimize costs using single pass extraction or summarized extraction. And finally, how do you deploy this particular project in a way that is best useful for your particular business use case?
00:40:19.000 –> 00:40:25.000
So we had API deployments, ETL pipeline, task pipeline, and the human in the loop.
00:40:25.000 –> 00:40:46.000
Deployment as well. So we’ve covered, I’ve tried my best to cover as many capabilities as I can in the short span of time that we have. However, there are a lot more things that you can learn about the platform. And in case you want to sit and understand how this can be adopted for your particular business.
00:40:46.000 –> 00:40:57.000
Then you can always schedule a free personalized demo with one of our experts and we will be able to reach out to you and understand your business use case and see how you can customize the platform to your particular needs.
00:40:57.000 –> 00:41:05.000
So in case you are interested in this, please drop your email ID in the chat and we will be able to reach out to you proactively.
00:41:05.000 –> 00:41:20.000
And you also have the option of trying out a free trial for both Unstract and LLM Whisperer. I’ll ask my team to drop in the links for the free trial. And there’s also extensive documentation that is available for you to learn more about the platform.
00:41:20.000 –> 00:41:37.000
And understand how it works. So with that, I think we’ve concluded the session. And in case there are any questions, we can take up the live Q&A segment.
00:41:37.000 –> 00:41:45.000
Gokul, do we have any questions?
00:41:45.000 –> 00:41:46.000
Okay.
00:41:46.000 –> 00:41:57.000
Yeah, I think I’ve answered a couple of them. Yeah, so Dario, I mean, you can, of course, reach out to us. You know, we’ll share the links and uh You can also sign up through the website for a quick demo. Of course, you can get help from the team.
00:41:57.000 –> 00:42:05.000
And I believe we are also recording the session and we might send it to you over an email after the session.
00:42:05.000 –> 00:42:21.000
All right. So thank you everybody for joining this session. And please do leave us your feedback and we hope you have a great day. Thank you so much.
Open-sourced ETL Platform for Unstructured Data
Privacy policy | Terms of service | 2025 Zipstack.Inc. All rights reserved.