00:14:25.000 –> 00:14:34.000
Hello, everybody! Welcome to this webinar. I’m Mahashree, Product Marketing Specialist at Unstract, and also your host for this session today.
00:14:34.000 –> 00:14:43.000
So, with the growing volumes of documents businesses handle daily, document extraction is only the first step in gaining true value from your document data.
00:14:43.000 –> 00:14:49.000
To drive true efficiency at scale, end-to-end document process automation also becomes an imperative.
00:14:49.000 –> 00:14:57.000
So that will be the primary focus of this webinar. We’ll see how we can bring together document extraction and process automation.
00:14:57.000 –> 00:15:14.000
Using Unstract and an agentic automation platform like n8n. Now, this is a beginner-friendly webinar, so if you are new to either of these platforms, not to worry, we will be introducing them to you, and we’ll help you understand how you can set up seamless document workflows.
00:15:14.000 –> 00:15:19.000
So that said, let’s move on to covering a few housekeeping points before I get started.
00:15:19.000 –> 00:15:25.000
So firstly, all attendees in this webinar will automatically be on mute throughout the course of this session.
00:15:25.000 –> 00:15:34.000
In case you have any questions, please do drop them in the Q&A tab, and one of us from the team will be able to get back to you with the answers via text.
00:15:34.000 –> 00:15:42.000
Now, you can also interact with fellow attendees using the chat tab. This is where you’ll also let us know in case you run into any technical difficulties during this session.
00:15:42.000 –> 00:15:53.000
Now, as a final point, when you exit this session, you’ll be redirected to a feedback form, where I request you to leave a review on so that we can improve our webinar experience going forward.
00:15:53.000 –> 00:15:59.000
So that said, here’s the agenda for today. We’ll start off by laying out the problem statement.
00:15:59.000 –> 00:16:05.000
We’ll start discussing the challenges in both document extraction as well as process automation.
00:16:05.000 –> 00:16:12.000
Moving on from there, we’ll cover what the Unstract-n8n integration brings in order to solve these challenges.
00:16:12.000 –> 00:16:18.000
The impact it has on businesses, and we’ll understand this better with the relevant business use case.
00:16:18.000 –> 00:16:24.000
Moving on from there, we have a rather interesting segment, which is our core chunk of the webinar.
00:16:24.000 –> 00:16:30.000
We’ll be diving deep into a demo segment on both Unstract and n8n in action, and we’ll see how.
00:16:30.000 –> 00:16:36.000
This integration can, again, be implemented in real time for the discussed use case.
00:16:36.000 –> 00:16:42.000
And finally, in case we have any questions remaining, we’ll also venture into a Q&A, where one of our experts will be on air.
00:16:42.000 –> 00:16:51.000
To answer your questions live. So that said, here’s the first discussion of the day, document extraction challenges.
00:16:51.000 –> 00:16:56.000
Now, these are usually challenges that stem from within the documents themselves.
00:16:56.000 –> 00:17:08.000
And first up, we have complex formatting. Now, documents come in varied formats, and they are usually designed keeping in mind the format that is best understandable by a human reader.
00:17:08.000 –> 00:17:19.000
Now, this format may not always be the best way for a machine to interpret the same document, and that is the exact challenge we’ve been facing with previous gen tools when it comes to document extraction.
00:17:19.000 –> 00:17:28.000
But what we are seeing, however, with today’s LLNs is that they understand information or read documents very much similar to how a human would.
00:17:28.000 –> 00:17:37.000
So they’re actually able to overcome this hurdle, and they are able to retrieve data pretty accurately from even complex formats of documents.
00:17:37.000 –> 00:17:50.000
Moving on from there, we have document variants. Now, a typical business would be dealing with various document types. It could be invoices, legal papers, supply chain records, or just about anything.
00:17:50.000 –> 00:17:57.000
And traditionally, for each of these types, we’d have to create predefined templates to extract data.
00:17:57.000 –> 00:18:02.000
Now, this is what we’re seeing, uh, being overcome with a platform like Unstract that is powered by LLMs.
00:18:02.000 –> 00:18:13.000
As the platform acts as a one-stop destination for processing any document type and variant, and it requires no prior training or predefining of any template, and you can simply upload a document.
00:18:13.000 –> 00:18:21.000
And get, uh, started with data extraction. So thirdly, we have scans and handwritten text.
00:18:21.000 –> 00:18:27.000
Now, both of these are, uh, pretty much big components of business documents today.
00:18:27.000 –> 00:18:34.000
And when we are dealing with scans, they may not always be of good quality. We may incur scans with low resolution, skewed scans, or scans with bad.
00:18:34.000 –> 00:18:43.000
Lighting. So all of these factors play a role in how difficult it becomes for the document extraction system to retrieve any data from the document.
00:18:43.000 –> 00:18:51.000
But this is, again, a challenge that we see Unstract overcome, especially with its in-house text extraction tool called LLM Whisperer.
00:18:51.000 –> 00:19:03.000
Which is observed to be a pretty powerful pre-processor of documents, and is able to work on even difficult scans and still be able to accurately extract text from these kind of documents.
00:19:03.000 –> 00:19:08.000
Now, we’ll… we will go over how this works in the upcoming demo segments of our webinar.
00:19:08.000 –> 00:19:14.000
And finally, we have extraction accuracy as the final challenge in document extraction.
00:19:14.000 –> 00:19:21.000
Now, when we are working with LLMs, while they do overcome various hurdles faced by traditional systems.
00:19:21.000 –> 00:19:32.000
They still have one limitation, that is that LLMs today still cannot validate whether or not their output is valid. So this is where we’ll have to bring in capability.
00:19:32.000 –> 00:19:43.000
Capabilities powered by a platform like Unstract, where it addresses this problem head-on with capabilities like LLM Challenge and Human in the Loop that we’ll see later on in the demo segments.
00:19:43.000 –> 00:19:48.000
So I think that sums up our challenges in document extraction, and let’s move on to.
00:19:48.000 –> 00:19:58.000
The challenges we face when it comes to process automation. Now, process automation, again, is when we deal with how you basically route the data.
00:19:58.000 –> 00:20:03.000
Post-extracting it from your document, or how you even connect it with the sources.
00:20:03.000 –> 00:20:09.000
Where the document comes in. So this is the first challenge that we see, which is fragmented data sources.
00:20:09.000 –> 00:20:18.000
Now, most businesses have documents coming in from. Emails, cloud drives, internal tools, ERPs, and a lot more sources.
00:20:18.000 –> 00:20:26.000
So the real challenge here is, does your current document extraction system support all these places from which you’re getting your documents?
00:20:26.000 –> 00:20:30.000
And more importantly, can it scale as you, um, as you may add more.
00:20:30.000 –> 00:20:40.000
Sources going forward. So this is where the Unstract-n8n integration makes a big difference, because while Unstract acts as the powerhouse for document extraction.
00:20:40.000 –> 00:20:50.000
n8n orchestrates this entire flow by connecting with more than 300 apps and tools, and automatically pulling in documents from relevant sources.
00:20:50.000 –> 00:20:54.000
Performing the extraction and routing it to the destinations that you want.
00:20:54.000 –> 00:20:59.000
So you basically get the best of both worlds when you’re working with this integration.
00:20:59.000 –> 00:21:04.000
So moving on from that, we have another challenge that is manual handoffs or delays.
00:21:04.000 –> 00:21:14.000
Now, while it may be great to want to automate the entire process when it comes to document workflows, and which is actually possible with the Unstract-n8n and integration.
00:21:14.000 –> 00:21:21.000
Currently, there are still certain industry requirements where you might have certain compliances that you’ll need to adhere to.
00:21:21.000 –> 00:21:26.000
For, uh, implementing manual reviews of the data extracted from your documents.
00:21:26.000 –> 00:21:35.000
So, to support this, Unstract supports a native feature called Human-In-The-Loop, which will enable users to route their documents.
00:21:35.000 –> 00:21:47.000
Relevant documents which need to be undergone through the manual check, and they’re able to check whether the data extracted is accurate or not. So we will take a look at this in our demo segment as well.
00:21:47.000 –> 00:22:01.000
So thirdly, we have inability to implement complex business logic. Now, if we are dealing with a simple use case, the native automation capabilities supported by Unstract alone or any document extraction platform might be sufficient.
00:22:01.000 –> 00:22:08.000
To complete the entire, uh, process automation. However, in case we are dealing with complex use cases.
00:22:08.000 –> 00:22:17.000
You might want to implement context-aware decisions. So, you might, uh, want to implement decisions like, let’s say, if an invoice amount exceeds.
00:22:17.000 –> 00:22:32.000
A certain value, then you might want to route it to a different manager. So, such use cases will need complex tools, and with the NAT and integration, you get access to if blocks, switch nodes, as well as AI agents that can help you route your processes accurately.
00:22:32.000 –> 00:22:39.000
So, we will see how this works. And finally, we have scalability without coding expertise.
00:22:39.000 –> 00:22:47.000
Now, again, this is an age-old problem we’ve been dealing with, where teams are heavily dependent on developers for setting up document workflows.
00:22:47.000 –> 00:22:55.000
So this is, again, time-consuming, it can become unproductive, and you will need to regularly reach out to the developer to maintain the workflow itself.
00:22:55.000 –> 00:23:09.000
So, with the rise of low-code, no-code platforms like Unstract-n8n in both, we are seeing this challenge being rapidly overcome, and these kind of platforms also democratize the process to a very large extent among teams.
00:23:09.000 –> 00:23:15.000
So, with that, we have concluded the challenges that, uh, we wanted to cover in process automation.
00:23:15.000 –> 00:23:23.000
And let’s move on to seeing how the Unstract-n8n integration helps overcome all the challenges that we just looked at.
00:23:23.000 –> 00:23:31.000
Now, as I mentioned earlier, for simple use cases, the native automation capabilities within the document extraction platform itself may be sufficient.
00:23:31.000 –> 00:23:39.000
However, there are more advanced business use cases where you might need a more elaborate document workflow.
00:23:39.000 –> 00:23:46.000
So, to understand what these use cases might look like, we will be taking up a relevant business use case that will, uh.
00:23:46.000 –> 00:23:51.000
That will, uh, aim to solve a real-world problem. So let me move on to the next slide.
00:23:51.000 –> 00:23:57.000
So, in this webinar, we’ll predominantly cover the invoice document extraction use case.
00:23:57.000 –> 00:24:05.000
So, in this use case, we’re basically seeing how we’re going to deal with a newly raised invoice, and how you’re going to extract data from this invoice, process.
00:24:05.000 –> 00:24:09.000
This particular document, and also send it to the relevant destination.
00:24:09.000 –> 00:24:17.000
So, to lay out the problem statement. Let’s say that finance teams often receive invoices via email in unstructured formats.
00:24:17.000 –> 00:24:25.000
Now, if we were not to implement any automation of the workflows, or if we were to work on this manually, this process would be.
00:24:25.000 –> 00:24:30.000
Heavily time-consuming, it would be difficult to prioritize urgent or high-value invoices.
00:24:30.000 –> 00:24:41.000
And this would most definitely lead to delayed approvals and missed due dates, and also the risk of dealing with fake invoices, which may just slip through the workflow, and which, again, contributes to unproductivity.
00:24:41.000 –> 00:24:48.000
So this, again, has critical business impact, where without automations, uh, automation, companies.
00:24:48.000 –> 00:24:54.000
Could face delayed vendor payments, finance teams could face burnouts from repetitive manual tasks.
00:24:54.000 –> 00:25:01.000
There could be a lack of visibility into high priority or time-sensitive invoices, and also inaccurate financial reporting.
00:25:01.000 –> 00:25:10.000
So, in order to combat all these implications that we would have, we might need to set up a relevant workflow for this use case.
00:25:10.000 –> 00:25:14.000
So, in the upcoming slide, you will see how we have set up this workflow.
00:25:14.000 –> 00:25:21.000
But before I moved on to that, I just wanted to give you a quick idea of what are the tools that we are using in this particular workflow.
00:25:21.000 –> 00:25:30.000
So, we are, of course, using Unstract and LLM Whisperer for document extraction, n8n in to orchestrate the entire process automation end-to-end.
00:25:30.000 –> 00:25:37.000
Quickbooks, because in this particular use case, we are dealing with invoices, and it would be relevant to store such data in a platform like Pickbooks.
00:25:37.000 –> 00:25:44.000
We’d be using Google Sheet to maintain a consolidated report of all the invoices that we get.
00:25:44.000 –> 00:25:55.000
And also Slack, where we’ll be intimating the relevant teams upon a newly raised invoice. And finally, Gmail, where we would be getting the newly raised invoice as an email trigger.
00:25:55.000 –> 00:26:02.000
So let me move on to the workflow, so you can get a better idea of how this has been implemented.
00:26:02.000 –> 00:26:10.000
So, if I had to explain this workflow. What happens is, at the beginning, we get an email trigger with a newly raised invoice.
00:26:10.000 –> 00:26:16.000
And then in this workflow, we’ve designed it to go through a check to check whether it is a junk email or, in fact.
00:26:16.000 –> 00:26:28.000
A new invoice which can be sent for further processing. So this would be sent to an Unstract API, which would work on the email content, or the body of the email, and check whether or not this is a newly raised invoice.
00:26:28.000 –> 00:26:33.000
And if yes, it would be passed to the next steps in the process.
00:26:33.000 –> 00:26:39.000
Or it would be sent to a relevant error message channel on Slack in case this isn’t a newly raised invoice.
00:26:39.000 –> 00:26:50.000
So let’s say it is… so it goes on, uh, through the process, it gets passed to another Unstract API, where we extract relevant invoice data, which would be used for further processing.
00:26:50.000 –> 00:26:58.000
So this could be data like vendor details, it could be the amount, the due date, and such details which we are looking to extract over here.
00:26:58.000 –> 00:27:05.000
And post this data extraction, we move on to a validation stage, where we check whether or not this invoice is valid.
00:27:05.000 –> 00:27:14.000
So, how we do this is we bounce the vendor details, like the vendor name, against QuickBooks to see whether or not it’s already present in the application.
00:27:14.000 –> 00:27:17.000
So this checks for vendor validation, and we also check whether.
00:27:17.000 –> 00:27:24.000
The dates are valid. For instance, your invoice due date should be greater than the date in which the invoice was raised on.
00:27:24.000 –> 00:27:32.000
So these are the kind of checks we do in the validation stage, and if they pass through this, it would move on to the next step in the process.
00:27:32.000 –> 00:27:44.000
Otherwise, it would be routed to another error message channel. So, post the validation, if it is passing through this stage, we would then classify the invoice based on various conditions that we have over here.
00:27:44.000 –> 00:27:52.000
So if the invoice is less, uh, is due in less than 3 days, we’d want to mark it as urgent and intimate the finance team.
00:27:52.000 –> 00:28:02.000
If the amount mentioned in the invoice is greater than $100K, then this would be marked as high value, and it would be routed to a relevant manager who can take this up.
00:28:02.000 –> 00:28:14.000
If it satisfies both these conditions, then we would mark it as critical, and if it satisfies neither of these conditions, it would be marked as normal. So this is the classification logic that we’ll be implementing.
00:28:14.000 –> 00:28:28.000
And finally, post that all these details along with the vendor details, the invoice amount, as well as what is the category it’s been classified into, all of these details get updated on Google Sheets, where we have a consolidated invoice report.
00:28:28.000 –> 00:28:34.000
And finally, the relevant teams are also notified on Slack and intimated upon the newly raised invoice.
00:28:34.000 –> 00:28:45.000
And this detail also gets updated on QuickBooks. And if this is an invoice being raised by a new customer, we also create a new customer within the application before updating the invoice.
00:28:45.000 –> 00:28:52.000
So I think this is, um… I’ve explained this use case, and as you can see, this is pretty extensive.
00:28:52.000 –> 00:28:58.000
And, uh, let’s see how this can be implemented. But before I move on into the n8n implementation.
00:28:58.000 –> 00:29:02.000
One, uh, point to note is that the process is heavy.
00:29:02.000 –> 00:29:08.000
Points in this workflow would be the processing that is done using the unstructed nodes.
00:29:08.000 –> 00:29:13.000
So, the nodes that you see over here for data, extracting data from the invoice, these.
00:29:13.000 –> 00:29:19.000
Are the ones that take up most of the time and perform most of the heavy lifting in this particular workflow.
00:29:19.000 –> 00:29:29.000
So, especially for those of you that are new to Unstract and might want to get a better understanding of the platform, I thought it would be good to take a quick detour from this place and, uh.
00:29:29.000 –> 00:29:41.000
Just go over the platform very briefly, show you how it works, so that when we cover the workflow and its implementation on n8n, you would have a better understanding of what is going on in the backend.
00:29:41.000 –> 00:29:47.000
So, Unstract, as I mentioned, is an LLM-powered data extraction platform.
00:29:47.000 –> 00:29:57.000
Now, if I had to talk about the platform briefly, I might want to put the capabilities under two buckets, that is, the development phase and the deployment phase.
00:29:57.000 –> 00:30:06.000
So in the development phase is where you upload your documents into the system, and you do this in the prompt engineering environment that the platform provides called Prompt Studio.
00:30:06.000 –> 00:30:17.000
Where you will also be specifying prompts that will mention what is the data that you’re looking to extract from this, uh, from your documents, and what schema are you, uh, looking to extract your data in.
00:30:17.000 –> 00:30:23.000
Now, the first step that is done in the Prom Studio is to extract the text.
00:30:23.000 –> 00:30:37.000
From the original document. So you extract this text using LLM Whisperer, and you also pre-process it into a format that is LLM-ready. So this, as I mentioned earlier, LLMs consume information from documents very much similar to how a human would.
00:30:37.000 –> 00:30:45.000
So, maintaining the original format or the original layout of the document is key when it comes to ensuring accurate LLM output.
00:30:45.000 –> 00:30:52.000
So, we’ll see how LLM whisperer preprocesses documents and also ensures that it maintains the layout.
00:30:52.000 –> 00:30:56.000
And in the Prom Studio, you can test your prompts across various document variants.
00:30:56.000 –> 00:31:04.000
And, uh, this is also where you get access to various accuracy-enabling capabilities, like LLM Challenge, and you can see how it is working on your prompts.
00:31:04.000 –> 00:31:24.000
So, uh, once you have set up all the prompts and you’re getting the data extracted from your prompt studio project, you are ready to deploy this in your existing system. So the platform currently offers four major ways of doing this. So we have API deployment, where you get an incoming document from an application, you would want to process it using one of the Prom Studio projects.
00:31:24.000 –> 00:31:32.000
And, uh, route the extracted output, or the data, to a relevant… to another application. So that is when you would use the API deployment.
00:31:32.000 –> 00:31:41.000
Etl pipeline is used when the incoming document is from a file system, and post-processing, you’re sending the output data to a data warehouse or a database.
00:31:41.000 –> 00:32:01.000
Task pipeline is when you get the document from a file system, you process it, and send it back to another file system, and human in the loop, as I had mentioned earlier, is where it allows you to perform manual checks, so you get the document from a file system, you process the document, you get the output data, and you route it to a manual review, where you can check.
00:32:01.000 –> 00:32:18.000
Whether or not the data extracted is correct for yourself. So, we will be briefly going over these capabilities in the demo, and a few numbers that would probably describe the platform today is that Unstract currently has 5K plus stars on GitHub. We have an 850 plus member Slack community.
00:32:18.000 –> 00:32:25.000
And today, we’re processing over 8 million plus pages per month by paid users alone.
00:32:25.000 –> 00:32:34.000
So let me move on into the demo. And I’ll take you through the platform. So, as you can see over here, this is the Unstract interface.
00:32:34.000 –> 00:32:44.000
Now, the first step you would probably have to do as a new user would be to set up your connectors. So these are certain prerequisite connectors that you will need in order to perform data extraction.
00:32:44.000 –> 00:32:51.000
So, um, Unstract is a platform that is powered by LLM, so you can integrate with all the prominent LLMs over here.
00:32:51.000 –> 00:33:03.000
And you have VectorDBs, embedding models, and text extractors. So, under text extractor is where you can also integrate with LLM Whisperer, and we also support other text extractors in the market as well.
00:33:03.000 –> 00:33:11.000
So once you perform this integration, you would want to create your prompts to your project, upload your documents, and get started.
00:33:11.000 –> 00:33:21.000
But for the want of time, I would venture into an existing Prom Studio project that I have over here to help you understand how this works before we move on into the NAT and demo.
00:33:21.000 –> 00:33:24.000
So let me just open one of the projects that I have.
00:33:24.000 –> 00:33:30.000
So, as you can see, this is a credit card parser, so in this project, the aim is to parse.
00:33:30.000 –> 00:33:35.000
Credit card statements and extract data from them, like the customer name, customer address, and so on.
00:33:35.000 –> 00:33:40.000
So, as you can see, in this case, I have uploaded an American Express credit card statement.
00:33:40.000 –> 00:33:47.000
And it is in a particular format, and I can also test these prompts across various different documents of.
00:33:47.000 –> 00:33:57.000
So, of different variants. So, as you can see over here, not only have we uploaded the American Express credit card statement, we also have other statements over here, like the Bank of America.
00:33:57.000 –> 00:34:04.000
So, for instance, if I have to open this, you can see that it has a completely different format, but the prompts over here remain the same.
00:34:04.000 –> 00:34:12.000
So this is how we can efficiently overcome the challenge of complex formatting, because that really doesn’t have to be a hindrance when we are deploying LLMs over documents.
00:34:12.000 –> 00:34:20.000
So, once you upload the documents, the first step that the platform would perform would be to extract the text from the original document.
00:34:20.000 –> 00:34:29.000
So this is done, as I mentioned earlier, using LLM Whisperer, and you can see how the layout is being preserved. So even something as small as the logo you see over here is.
00:34:29.000 –> 00:34:44.000
Extracted, keeping in mind the spacing that it was given in. So this is the powerful pre-processing stage, which could also be considered as a secret sauce behind LLM Whisperer, because of this powerful layout preservation.
00:34:44.000 –> 00:34:50.000
Llms are able to understand the context of your documents completely, and they’re able to extract accurate results.
00:34:50.000 –> 00:35:02.000
So, after, uh, you extract the text, you can run your prompts on your document. So, as you can see, in each of these prompts, I’m mentioning what is the data that I want to retrieve along with the format I want this to be done in.
00:35:02.000 –> 00:35:09.000
And, uh, over here, I can also mention that, uh. The output data type that I want.
00:35:09.000 –> 00:35:17.000
And under coverage, you can see how the different documents… what are… what is the output for this particular prompt across the different documents.
00:35:17.000 –> 00:35:30.000
So these are the capabilities that you have over here, and you can see whether or not the output you’re receiving from each of your prompts is what you’re looking for, and whether it’s good enough for you to route this to the destination.
00:35:30.000 –> 00:35:41.000
So this sums up the capabilities of Prom Studio very briefly. Of course, there are more capabilities. For instance, if I go into the settings, you can see a bunch of capabilities over here.
00:35:41.000 –> 00:35:51.000
So for the want of time, I wouldn’t be going into all of these. Let me just delve into LLM Challenge, as we had spoken about this earlier, this is one of Unstract’s differentiating capabilities in the market as well.
00:35:51.000 –> 00:35:58.000
So, when you enable LLM Challenge, you basically enable two LLMs to work on each of your prompts.
00:35:58.000 –> 00:36:03.000
So, as you can see in the LLM Challenge log, you would define an extraction LLM as well as a challenger LLM.
00:36:03.000 –> 00:36:16.000
And only if these two models arrive at a consensus on the output is it given to the user. So this is how you can powerfully prevent hallucinations of LLNs, and you can also prevent inaccurate data from being extracted.
00:36:16.000 –> 00:36:22.000
So, with LLM Challenge logged, you can also inspect the conversation between the extraction run and the challenger run.
00:36:22.000 –> 00:36:30.000
So, as you can see, the extraction run brings out, uh, brings the output that it has got from the prompt. The challenger run gives you a score and a feedback.
00:36:30.000 –> 00:36:42.000
As to how far it agrees with the output brought forward by the extraction run. And finally, the output is given to the user. So this is, again, one of the accuracy-enabling capabilities of Unstract.
00:36:42.000 –> 00:36:49.000
And once you are happy with all your prompts, and you’ve set everything in place, you can export this project as a tool.
00:36:49.000 –> 00:36:57.000
And this tool will then be deployed in your workflows when you want to deploy it either as an API deployment, an ETL pipeline, and so on.
00:36:57.000 –> 00:37:06.000
So in this case, I’ve deployed this credit card parser as an API, so we’ve defined the input configuration as an API, the output configuration as an API.
00:37:06.000 –> 00:37:09.000
And you can choose from the various tools on the right-hand side.
00:37:09.000 –> 00:37:19.000
From the tools pane, and you can also create complex workflows over here using the different tools, but in this case, I’ve just dragged and dropped a single tool that is the credit card parser.
00:37:19.000 –> 00:37:28.000
So this API can then be deployed, and you would get access to the API endpoint along with a downloadable Postman collection that you can use to make the request.
00:37:28.000 –> 00:37:34.000
So similarly, we have ETL pipelines, task pipelines, and also human quality, uh, human-in-the-loop review.
00:37:34.000 –> 00:37:46.000
So, let me move on to this capability where, uh, since we’ve spoken about manual review and that being a compliance requirement for many industries, I just wanted to show you how this works within the platform.
00:37:46.000 –> 00:37:52.000
So when you deploy this as a human review, you have this, uh, the review interface over here.
00:37:52.000 –> 00:37:57.000
So, as you can see, we have a relevant document on the left, and you have all the output.
00:37:57.000 –> 00:38:08.000
Brought from this particular document on the right. So, upon clicking on any of this output, the system automatically highlights the corresponding place from the original document.
00:38:08.000 –> 00:38:16.000
So, as you can see, when I click on New Balance, we have all the different locations from the original document where this particular value was extracted from.
00:38:16.000 –> 00:38:28.000
And we do not need to stop at this. For instance, if I click on one of the spend items, and you can see that it’s been highlighted, and let’s say I want to change this data, and I want it to be stored as a different value when I send it to my database.
00:38:28.000 –> 00:38:35.000
So I can just double-click on this, and I can easily edit the value to what I want, and when I click on save.
00:38:35.000 –> 00:38:45.000
The new value will be saved in the database. So that is also another capability that I have over here. And this sums up what we had to see in the Unstract demo.
00:38:45.000 –> 00:38:49.000
So let me, uh, let me go back to my slideshow.
00:38:49.000 –> 00:38:59.000
So, in this demo, uh, I just wanted to give you a context of what you can perform within the platform, and how it really powers data extraction.
00:38:59.000 –> 00:39:14.000
Now, for the want of time, I’ve been moving on in this session, but if you do want to explore this platform in more detail, we have done extensive webinars on these capabilities itself before, so I’ll ask my team to drop the link in chat. You can always go through them at any time.
00:39:14.000 –> 00:39:21.000
Now, let me move back, and we’ll see how, basically, Unstract plays a role in the workflow that we had looked at.
00:39:21.000 –> 00:39:28.000
So, to give you a quick recap of the workflow, we basically get a new invoice, we are checking whether it is, in fact, a new invoice.
00:39:28.000 –> 00:39:34.000
We’re extracting the required data from the document, we’re validating whether it is.
00:39:34.000 –> 00:39:48.000
Good to go, and then we perform the classification logic where we are classifying it as urgent, high-value, critical, or normal. And finally, we update Google Sheets, QuickBooks, as well as the relevant Slack channels on the newly raised invoice.
00:39:48.000 –> 00:39:53.000
So, let me move on to show you how this actually works.
00:39:53.000 –> 00:40:02.000
So, as you can see, this is the n8n interface that I have over here. You can integrate Unstract by checking out Unstract in the community node.
00:40:02.000 –> 00:40:13.000
So, n8n is a powerful open-source automation tool that helps you connect with over 300 plus apps and services, as I mentioned before.
00:40:13.000 –> 00:40:15.000
And you can do this without having to write a ton of code.
00:40:15.000 –> 00:40:22.000
So, and as you can see, you can also visually lay out the connection and route the processes in the way that you want.
00:40:22.000 –> 00:40:27.000
It’s actually a simple drag-and-drop interface that allows you to set up and automate business workflows.
00:40:27.000 –> 00:40:35.000
And in this particular workflow, we have set up the invoice processing and routing according to the flow that I’d explained in the diagram earlier.
00:40:35.000 –> 00:40:40.000
So we will be testing two sample emails through this workflow to see how it works.
00:40:40.000 –> 00:40:47.000
And, uh, before I start this test, let me just jump to my inbox to show you what is the email that we’re actually.
00:40:47.000 –> 00:40:53.000
Dealing with. So, we have a couple of test emails over here, uh, for you to understand this workflow better.
00:40:53.000 –> 00:41:04.000
Now, um, as you can see in this particular, uh, invoice, this is due in 2 days, and the amount that this invoice mentions is also greater than $100K.
00:41:04.000 –> 00:41:11.000
So, as you can see, this is both urgent and high value, so this particular invoice would be classified as critical.
00:41:11.000 –> 00:41:15.000
So let’s see how the workflow is able to do that.
00:41:15.000 –> 00:41:35.000
And post… after this workflow, uh, works on this particular document, it should be updated as the 11th row in this Google Sheet that you see. So as you can see, we’ve already run this particular workflow on a couple of invoices, and we’re extracting, we’re basically updating data, like the invoice number, the due amount, vendor details, and so on.
00:41:35.000 –> 00:41:38.000
So you would have to see another row appended over here.
00:41:38.000 –> 00:41:42.000
And also on QuickBooks. Just a minute, um….
00:41:42.000 –> 00:41:55.000
I think I’ll just have to log in.
00:41:55.000 –> 00:42:25.000
Just give me a second, folks, I’ll…. Get back in a while.
00:42:25.000 –> 00:42:35.000
Alright, uh, let me just share my screen. You’ve logged in.
00:42:35.000 –> 00:42:41.000
So, as you can see on QuickBooks, we have two invoices updated over here, so we will be, uh, expecting a third invoice to be updated as well.
00:42:41.000 –> 00:42:45.000
So this is what we’ll be expecting out of this particular run.
00:42:45.000 –> 00:42:55.000
So, let me move back to my, um, email, and the… basically, the workflow checks for any unread emails so that it can trigger this workflow. So let me first mark this.
00:42:55.000 –> 00:43:01.000
Email as unread. And once I trigger this workflow, you will see how this performs.
00:43:01.000 –> 00:43:08.000
So, because, as I mentioned earlier, the Unstract APIs are quite… they do the heavy lifting, and you might spend some time over here, so….
00:43:08.000 –> 00:43:15.000
I will first trigger this workflow, and then I’ll take you through how this works, and I’ll explain the process in more detail.
00:43:15.000 –> 00:43:23.000
So, as you can see, once I click on Test Workflow, the email gets triggered, so we’re getting a new… it checks for new, uh, unread emails.
00:43:23.000 –> 00:43:28.000
And once it detects one, it sends it to the Unstract API, which basically, um.
00:43:28.000 –> 00:43:34.000
Checks the body content of the email, and decides whether or not this is a newly raised invoice.
00:43:34.000 –> 00:43:45.000
And if it is a newly raised invoice, it would go forward in the workflow. Otherwise, it would be routed to a relevant Slack channel, and the email would be marked as read, and the loop will be closed.
00:43:45.000 –> 00:43:53.000
So in this case, as you can see, it has detected that it is a new invoice, so we then extract the attachments from this email.
00:43:53.000 –> 00:44:05.000
And we would send these attachments as a file to LLM Whisperer API, which would then pre-process these attachments, it would extract the text from both the email body as well as the attachments that come with it.
00:44:05.000 –> 00:44:13.000
And it would then send this format, the pre-processed format, as a file to the Unstract API, which would then extract details from the.
00:44:13.000 –> 00:44:27.000
It would extract the relevant data that you’re looking for. So you can even inspect the nodes by opening it up, and you can see what are the conditions that I’ve set over here, what was the input that you have got, and how the output looks.
00:44:27.000 –> 00:44:34.000
So, as you can see in this particular node, we are extracting data like the buyer name, the due amount, the due date, and so on.
00:44:34.000 –> 00:44:43.000
And we have vendor details, payment method, and all of these, uh, all of this information is basically being extracted, along with some metadata that you have over here.
00:44:43.000 –> 00:44:51.000
So for each of these nodes on n8n, you can actually open it up and see what is the logic and what is going on in the backend.
00:44:51.000 –> 00:45:03.000
So, to actually show you what are the API, what is this particular API, let me just open up the Prom Studio project, and we’ll see what is actually happening in both these nodes, the first one as well as the second one.
00:45:03.000 –> 00:45:10.000
So, in the first Unstract node, we are actually looking to extract, uh, I mean, check whether or not it is a newly raised invoice.
00:45:10.000 –> 00:45:13.000
So this is basically the project that we’ve deployed over here.
00:45:13.000 –> 00:45:20.000
So, uh, we have a simple code which says that based on the email content, I want, uh, the code… I mean, I want the, um.
00:45:20.000 –> 00:45:24.000
Platform to answer whether or not it is a newly raised invoice.
00:45:24.000 –> 00:45:28.000
And it only has to return whether it’s true or false. So, with this prompt in natural language.
00:45:28.000 –> 00:45:35.000
Uh, we’re deploying this as an API in the workflow over there, what you had seen.
00:45:35.000 –> 00:45:43.000
And the second, um…. Note that you had seen in the workflow was where the Unstract API was deployed to extract the relevant data from the invoice.
00:45:43.000 –> 00:45:50.000
So let me open up that project as well, so you understand what’s going on in the backend.
00:45:50.000 –> 00:45:59.000
So, in the invoice data extraction project over here, you can see how we have defined a prompt that is, um.
00:45:59.000 –> 00:46:07.000
And we’ve mentioned to extract details like the invoice number, invoice date, buyer name, and all that data that you’d seen earlier in the node.
00:46:07.000 –> 00:46:11.000
And we’ve also given the schema for extraction. For instance, the dates have to be given in a particular format.
00:46:11.000 –> 00:46:26.000
So once I run this particular prompt, you can see that the data has been extracted over here, and it is this data that will then be used in the processes further, like for classification purposes and routing purposes.
00:46:26.000 –> 00:46:39.000
So, moving back to the workflow, you can see that it has already deployed this API, the data has been extracted, and then we performed the QuickBooks validation to check whether or not the vendor detail extracted from the invoice is present in QuickBooks.
00:46:39.000 –> 00:46:52.000
So, upon checking the QuickBooks classification, I can open this node, and as you can see, we have the input data over here, we have the condition, as well as the output, which is found to be true. So in this case, the vendor is present in QuickBooks.
00:46:52.000 –> 00:47:06.000
So, it passes on to the document process further, and in case it’s not, it would be routed to another relevant error channel on Slack, and the email would be marked as red, and the loop will be closed.
00:47:06.000 –> 00:47:12.000
So, after this QuickBooks validation in the if state, we’re also checking whether the due dates are valid.
00:47:12.000 –> 00:47:22.000
And post that, we check the classification, so if I just had to open it, you can see that with some code, we are classifying whether or not the, um, document received is urgent, high value.
00:47:22.000 –> 00:47:27.000
Normal or critical. And based on the value that we have.
00:47:27.000 –> 00:47:32.000
We have a switch node over here, which will route it to different destinations. So, as you can see.
00:47:32.000 –> 00:47:39.000
If it is urgent, which means that if the invoice is due in less than 3 days, it is being routed to the invoice.
00:47:39.000 –> 00:47:43.000
Finance, uh, Slack channel, where the team can take a look at it.
00:47:43.000 –> 00:47:56.000
If it is of high value, it would be routed to the invoice manager’s Slack channel, and if this is both high value and urgent, it is again routed to the manager’s Slack channel. And in spite of what classification the document falls under.
00:47:56.000 –> 00:48:01.000
All the documents are updated on Google Sheets. And on QuickBooks as well.
00:48:01.000 –> 00:48:12.000
So, in QuickBooks, you can see that if the customer is already present, it would… the invoice would just be added. Otherwise, we would be creating a new customer, and then adding the invoice to the platform.
00:48:12.000 –> 00:48:22.000
So, to check, as you can see, this has already been run, and you have the process, uh, over here, so let me just go and we’ll cross-check how this actually reflects.
00:48:22.000 –> 00:48:29.000
In the, uh, platforms. So, as you can see, firstly, the email has been marked as unread, intimating that, um.
00:48:29.000 –> 00:48:39.000
The loop has been closed. And in the Google Sheets, you can see that there is a new 11th row with the details of the newly processed invoice.
00:48:39.000 –> 00:48:46.000
You can see that it is both, uh, it’s critical, it’s been marked as critical, and we have all the details over here.
00:48:46.000 –> 00:48:56.000
In the QuickBooks platform, let me just refresh the application so we get the invoice details.
00:48:56.000 –> 00:48:59.000
So, as you can see, a third invoice has been appended.
00:48:59.000 –> 00:49:07.000
And we have the details over here as well. And finally, we’ll need to see this, um, invoice being raised in the relevant manager’s.
00:49:07.000 –> 00:49:14.000
Slack channel, so as you can see, we have a newly… new message over here. So in this message, we have.
00:49:14.000 –> 00:49:24.000
The details of the invoice with the extracted data, along with when it is due, and this will basically help the manager take this up and prioritize this invoice further.
00:49:24.000 –> 00:49:31.000
So, similarly, you can see that we have other channels over here for invoice… the invoice finance team, so all the urgent.
00:49:31.000 –> 00:49:37.000
Invoices would be dropped over here, so you can see that this is an urgent invoice alert with the relevant details.
00:49:37.000 –> 00:49:47.000
This was a previous early-run invoice document. And we also have two error channels, which will basically catch junk emails as well as invoices that fail at the.
00:49:47.000 –> 00:49:57.000
Validation stage. So, uh, depending on, uh, how your document is and what your data is, it would be routed to any of these Slack channels.
00:49:57.000 –> 00:50:03.000
So let me move back to the demo, and we will just test the workflow again with another.
00:50:03.000 –> 00:50:13.000
Use case before I conclude this segment of the webinar. So we have another simple use case over here. This is actually a junk email, so let’s say that this, um.
00:50:13.000 –> 00:50:20.000
Falls into this email, but this is actually not a newly raised invoice. So let’s see how the error workflow would run.
00:50:20.000 –> 00:50:29.000
So I’ve marked that email as unread, and let me trigger this workflow again.
00:50:29.000 –> 00:50:35.000
So, as you can see, the, uh…. Unread email is detected.
00:50:35.000 –> 00:50:48.000
And then we get the message, the email body, and. The API over here is basically checking whether or not this is a newly raised invoice.
00:50:48.000 –> 00:50:51.000
So let’s just wait for a couple of seconds. This should ideally fall into this.
00:50:51.000 –> 00:50:55.000
Workflow over here, since this was a junk email that we had.
00:50:55.000 –> 00:51:03.000
Triggered. So, as you can see, this has been, um, routed to the relevant workflow, and let’s just cross-check this using the Slack channel.
00:51:03.000 –> 00:51:10.000
So, you can see that we have a new message over here in the invalid email channel, and we have the details of the email along with the sender.
00:51:10.000 –> 00:51:25.000
Details that we have over here. So this…. Sums up what you can perform with the Unstract-n8n integration folks, so you can see this is actually one of the real-world use cases that we have picked up on. However, this.
00:51:25.000 –> 00:51:32.000
Can also find widespread application in insurance use cases and loan processing or banking use cases as well.
00:51:32.000 –> 00:51:37.000
So let me move back to the presentation. And that brings us to the wrap-up.
00:51:37.000 –> 00:51:44.000
So, uh, from the start of this webinar, we covered challenges in both document extraction and process automation.
00:51:44.000 –> 00:51:52.000
We saw how it can be overcome using the Unstract-n8n integration, and we also looked at a relevant use case that would be, uh.
00:51:52.000 –> 00:51:56.000
That would make the integration relevant, and how it could be used.
00:51:56.000 –> 00:52:07.000
So, we also saw how this use case can be implemented using the n8n platform, and we also took a detour to check out how Unstract works in the backend, in case you are new to the platform.
00:52:07.000 –> 00:52:11.000
So that brings me to the end of this session. Now, uh, this….
00:52:11.000 –> 00:52:24.000
Integration might find… might be useful for many of you, so if you want to understand this better, you can always sign up for Unstract at any time, and also n8n, and you can set this up and try it up for your own.
00:52:24.000 –> 00:52:32.000
Or you can also book a free demo with us, where one of our experts will be there with you to understand your unique business needs.
00:52:32.000 –> 00:52:36.000
We’ll see how you can customize both these platforms and help you forward with this.
00:52:36.000 –> 00:52:46.000
So, in case you are interested in this demo, I would suggest that you drop your email ID in the chat, and we’ll be able to proactively reach out to you.
00:52:46.000 –> 00:52:59.000
So, with that, uh, we’ll be moving on to the Q&A in case we have any questions left.
00:52:59.000 –> 00:53:06.000
Just a minute.
00:53:06.000 –> 00:53:12.000
Okay, so it looks like most of the questions… okay, we do have a new question, um….
00:53:12.000 –> 00:53:19.000
Nareen, would you be able to take this up?
00:53:19.000 –> 00:53:32.000
Uh, yeah. So, yeah, it can take, uh, any source, like email, uh, yeah, API, database, like, whatever, like, n8n is available. If you’re just doing, uh, API-type integration, you could do it directly using, uh, Unstract, or you may not even need….
00:53:32.000 –> 00:53:43.000
A separate, uh, I mean, innate in itself. It depends on what you want, because database is also, like, we have, like, ETL pipelines where the databases are available as part of the Unstract, uh.
00:53:43.000 –> 00:53:51.000
Like, destinations. So that’s also there. But, uh, yeah, uh, here we wanted to show how both can work together.
00:53:51.000 –> 00:54:07.000
Abstract and NATN, and I would, uh, in the chat, the blog, right, that is a very detailed blog on how this whole thing works, and you might want to check it out, that blog.
00:54:07.000 –> 00:54:13.000
With the title from inbox to database, automating document extraction with Unstruct, and I would highly encourage you to.
00:54:13.000 –> 00:54:16.000
Uh, check it out. Yeah.
00:54:16.000 –> 00:54:24.000
Alright, uh, thank you, Naveen. Um, I don’t think we have any further questions.
00:54:24.000 –> 00:54:28.000
Okay, we do have another question, uh, Nareem.
00:54:28.000 –> 00:54:48.000
Uh, LLM within OneStrak can be hosted in local? Yeah, so we… yes, Badri, like, we have, uh, Olama integration, so you can connect any locally self-hosted model, uh, and you can connect it, uh, using OLAMA. Yes, that answer is, yes.
00:54:48.000 –> 00:55:02.000
All right, so we’ll just wait another minute in case anybody has any other questions, and then we can conclude this session, folks.
00:55:02.000 –> 00:55:23.000
Will it support Docker, um…. Yeah, I mean, so the… we do have, like, a option to install this on-prem, where the Unstract plus LLM Whisperer can be, like, installed using Kubernetes and, um.
00:55:23.000 –> 00:55:27.000
Hand chat. So, we do have that. So, yes, it can be deployed on-prem.
00:55:27.000 –> 00:55:41.000
Or in a VPC. Yeah, I mean, I think Bombadu is often a similar question. Yes, so we have an open source edition where, yes, you can run it, uh….
00:55:41.000 –> 00:55:59.000
In your, uh. Local mission, and same way, N8 and both, NADEN is also available as an open source edition, and same way An instruct is also available as OpenSource Edition, which you can run it locally, yes.
00:55:59.000 –> 00:56:12.000
Can Instruct also, uh…. Lines of table, yes, so we have, like, table extraction. Again, there is a detailed blog on how you can extract, uh, tables. We do have.
00:56:12.000 –> 00:56:21.000
Table extraction as a mode within Prompt Studio as well, so you might want to try that, uh, it’s a yes.
00:56:21.000 –> 00:56:32.000
Uh… yeah, pricing… yeah, pricing, uh, question, yeah, pricing is published on the website, you can check it out, there’s a pricing page. Please, uh, from the home page, you can see that it’s, uh.
00:56:32.000 –> 00:56:39.000
You can check the pricing, yeah, and I think Sandaryak will… from our team, will drop a link to the pricing.
00:56:39.000 –> 00:56:51.000
On-premise on Windows systems? No, I think it’s only a Linux. We don’t support Windows systems, or it has not been tested on Windows systems to be, uh, precise.
00:56:51.000 –> 00:56:56.000
So you might want to try it on Windows systems, yeah.
00:56:56.000 –> 00:57:12.000
Difference between open source versus pricing version. Yeah, I think all this information is available on the pricing page. Please check it, and you can see the difference between open source. Mainly, like, premium features, like, of course, LLM Expirator is not open source, so that is not there, and uh….
00:57:12.000 –> 00:57:20.000
Also, a couple of other things, like, um, uh, open source was, uh, versus the enterprise, like, the LLM Challenge.
00:57:20.000 –> 00:57:33.000
A single-pass extraction, summarized extraction, those things are not available, but otherwise, like, everything else is part of the open source edition as well. And also, human in the Loop is also an enterprise feature.
00:57:33.000 –> 00:57:46.000
Uh, how about self-learning from past actions for LLM in case of on-prem installation? Uh, it’s technically possible, uh, Badri, but the data is the main thing, right? Because we need.
00:57:46.000 –> 00:58:01.000
Uh, like, uh, like…. Annotated data, if that’s available in large… if large enough dataset is available, it can be done. However, we have not seen a much need for fine-tuning unless you have, like, very… something very domain-specific you are doing.
00:58:01.000 –> 00:58:11.000
If not, you don’t need to do any, uh, specific… I mean, fine-tuning may not be… is not, like, uh, we have not seen that as a requirement.
00:58:11.000 –> 00:58:40.000
Because, uh, the LLMs are really smart, right? Today, with, uh, I mean, the latest models, like, uh, 4.0 and Cloud Sonnet 4, like, it’s, it’s, like, really powerful, and there may not be a need for fine-tuning at all.
00:58:40.000 –> 00:58:47.000
Um, anything else?
00:58:47.000 –> 00:58:51.000
Okay, um, so I think we can close this session, folks.
00:58:51.000 –> 00:59:01.000
Um, thank you so much for joining this session today. And, uh, you can always, uh, uh, book a free demo with us. We also have the link dropped in chat.
00:59:01.000 –> 00:59:06.000
So, looking forward to seeing you at our upcoming events. So, thank you, Naren. Thank you, everybody.
00:59:06.000 –> 00:59:09.000
Thank you.
00:59:09.000 –> 00:59:12.000
Well, we have one last question, I think. Okay, okay, it was just a thank you message. Thank you.
00:59:12.000 –> 00:59:21.000
Yeah, thank you, thank you. Thank you, everyone.
Open-sourced ETL Platform for Unstructured Data
Privacy policy | Terms of service | DPA | 2025 Zipstack.Inc. All rights reserved.