Build a Human-Reviewed Invoice Flow Without Code (Full Transcript)

[00:00:00] Speaker 1: If you've ever had to open a document like an invoice, for example, and then manually retype the important parts into some other system, like the vendor, the date, the total, and so on, you know how tedious that gets. It's the kind of task that starts to feel like busywork when you could be doing other things. So what if you could build an orchestration that does the reading and the typing for you? Hi, I'm Garak. And today, in partnership with UiPath, we're taking a look at UiPath Maestro Flow, a new way to build orchestrations that doesn't require writing a single line of code. By the end of this video, you'll have watched an entire orchestration built from scratch, something that reads a document, pulls out the details that matter, and lets a human double-check everything before it's saved. So first, a bit of context. UiPath Maestro Flow, I'm just going to call it Flow from here on out, is a canvas inside UiPath where you build an orchestration by connecting a few steps together. Those steps are called nodes. And each one does something specific, like bring information in, do something with it, hand it to a person to check, and send it somewhere once you're done. The great thing is you don't need to be a developer to use it. You're basically describing, step by step, what should happen and in what order. Now, Flow can do a ton of things. But I want to keep the example in this video focused. We're going to build this orchestration for a scenario where a document comes in. And we'll use a hotel invoice for this example. And an agent reads it and pulls out the details that matter, checks in with a person before anything is finalized, and then the clean information gets saved somewhere useful, like a spreadsheet. So there are just four steps in this orchestration. And again, it doesn't have to be an invoice. The same Flow works just as well for a receipt, a form, pretty much any document with a few consistent fields. And while I'm building this in Studio Web today, Flow is also available in Studio Desktop, VS Code, and coding agent-friendly forks like Cursor, Windsurf, and Quero. So you can build these wherever you already work. So let's build a Flow from scratch, start to finish, so you can see exactly how it comes together. To get started, I'll go to cloud.uipath.com and sign into my account. And from here, I'll head into Studio to create my Flow. From here, I'll click the menu next to Create New. And I'll choose Maestro Flow. That takes us to a new Flow canvas. And here, I'll right-click on the Flow's name and choose Rename. And I'll give it something more descriptive so I can find it more easily later. I'll call this one Invoice Reader. Okay, so now we have a new blank Flow. This workspace area is where we're gonna build the entire orchestration. Now, a quick note before we get started. Everything I'm about to build here by hand, you can also build by simply describing it to a coding agent, which is an AI assistant like Cloud Code that writes and wires up the Flow for you inside your own editor based on plain language instructions instead of clicks. I'm building this one manually today so you can see exactly how each piece works. But if you wanna see the coding agent approach in action, I have a whole video of that here on the Kevin Stratford channel. So when we created this Flow just now, a manual trigger node was already added to our canvas. That's the starting point that kicks off the orchestration. Right now though, it doesn't have anything to receive. So the first thing we need is to give it an input to work with, a place to attach the document I want it to read. So with it selected, I'll click the Edit button above it to open its properties. You can also double-click the node to open its properties. And from here, I'll make sure Parameters is selected and click Add Input Argument. I'll name this Document and set its type to File. This is what allows me to attach a real file to this trigger when I actually run the Flow. You can leave the description file as is or type a description of what this node represents. Then click Add, and then I'll close the manual trigger's properties to go back to the canvas. Now that our trigger can accept a document, we need something to actually read it and pull out the details that we care about. That's the job of an AI agent. I'll click the plus button here next to the manual trigger to add a new node. Notice we can add a wide variety of nodes here. You can browse through the types by clicking Connector or Data and so on. Or if you know the name of the node you want, you can actually type it here in the Search Nodes field. In this case, we want to add an AI agent node. So I'll click Agent, and here I'll select Autonomous Agent. And now we have this Autonomous Agent node on our canvas connected to the manual trigger node. Notice it has these categories of points we can add to it, including escalations, context, and tools. This is how you specify what the agent does, what it knows, and so on. Now, the agent can't read a file on its own, so I need to give it a tool for that. So I'll click the plus button here on the Tools point, and in this case, I know I want to add the Analyze Files node. So I'll search for Analyze Files. There it is. And you can see that connects it directly to the Autonomous Agent node. Now, Analyze Files needs to know what to actually look at and what to do with it. So I'll click its Edit button, which opens up the Properties panel with the two fields I need to fill in, Attachments and Analysis Task. Attachments is where I tell it which file to actually look at. Now, if you know how to parse variables, you can manually type in the reference to the document in the manual trigger node, but you can also click this sparkly icon here and choose Variable. A searchable dropdown appears with the flows variables listed here. I'll expand Manual Trigger 1, and then its output, and then I'll select Document. That's the whole file coming in from our trigger, and the field now shows the vars.manualtrigger1.output.document confirming it's pointed at the right place. Now, for Analysis Task, I'll click into the field, which opens a text box for me to type the instructions directly. We can use plain language here to tell the agent what we want it to do with the info in the document. So I'll say, extract the vendor invoice date and the total amount due from this invoice, and then click Save. And now we can close the Analyze Files properties. Then back on the agent itself, I'll click its pencil icon to open its properties. Notice the system prompt field with the generic placeholder, you are an agentic assistant. So the system prompt sets the agent's persistent instructions, its role, the rules it should follow, how to handle edge cases, and so on. I could type directly into this field myself, but I'm gonna click the sparkle button here instead, which opens a field to describe what I want this agent to do. And I'll say, read this invoice and pull out the vendor, the date, and the total. And I'll click Generate, and watch what happens. Flow turns that single sentence into a full, highly detailed system prompt on its own. Basically, I'm letting the UiPath AI compose what it thinks will be the best prompt based on the single sentence that I typed. Now you can, of course, and should read through this to make sure it's doing what you want it to do, and you can edit it as you like, but this is a great way to get started rather than typing everything yourself. Now below that, we have the user prompt field with the placeholder, what is the current date? So while the system prompt sets the agent's persistent instructions, the user prompt is the actual message or request for a given run, kind of like what you would type into a chat window to kick things off. Now in a normal chat, that distinction matters a lot. But here, our flow doesn't have a person typing anything. It's gonna be triggered automatically by a file coming in. So there's no real user message to provide. Now flow still requires something in this field, so instead of leaving the default text sitting here of what's the current date, which has nothing to do with what we're building, I'll replace that with a simple instruction that just kicks off the task. Process the attached invoice and return the requested fields. Now below that, we have outputs. So the system prompt tells the agent what to look for, but it still needs somewhere to put what it finds. I see that there's already a default field here called content, and I'll delete that using the trash icon. Then I'm gonna click add output variable three times to add our own fields. First, vendor, with its data type set to string. Then date, also set to string. And then total, and we'll set that data type as a number. All right, and lastly, I'm gonna double-click autonomous agent up here and type in a new name, so it's easy to spot on the canvas and know what it's doing. Then I'll close its properties, and there it is. All right, so now that the agent can read the invoice and pull out the details, I want a real person to double-check that before anything gets saved. Even a sophisticated agent can misread something or hit an unusual document, so having a human confirm the result before its final is what actually makes this trustworthy enough to rely on. Now, in Flow, that human check happens through something called an escalation. So I'll click the plus button on the agent's escalation point and select quick form escalation. And you can see that's added as its own separate node on the canvas, connected directly to the agent's escalation point. So it's nice that it's not buried inside the agent's own properties, and it's a distinct step you can see and configure on its own. So I'll click edit to open its properties. Now here you can configure a few things. There's an editable default approval form reviewers will see, some additional properties like the task titles, priority, and so on. We have an assignment section, which is who actually receives the review request. So for example, I could choose email address and type in my own address here. Now we also have the outcome behavior section, which is where we define what happens depending on how it's resolved. So just having the node connected on the canvas doesn't guarantee anyone actually sees it. It's important to know that the agent only sends something here if it's told to. An escalation is basically an optional action available to the agent and not an automatic checkpoint that the flow always passes through. Now this form doesn't come with any outcomes built in, so I need to add them myself. Now below this form field here, there's a small plus icon. I'll click that, and it adds a button called untitled. I'm gonna click on that and rename this approve. Then I'll click on this plus icon again and add a second outcome and rename that one reject. Now behind the scenes, each of these picks up its own behavior automatically. Approve is set to continue, which lets the flow pick up right where it left off, and reject defaults to end, which stops the flow right there before anything gets saved. Notice if I switch to the JSON view and scroll down, we can see that approve has the action of continue and reject has the action of end. So that's exactly what I want. If I reject the data, the flow should just stop. All right, I'll close the quick form escalation nodes properties, and now I need to go back to the invoice reader agent's instructions and edit the system prompt. And here I wanna add an explicit line telling it to always send its extracted result here for approval before finishing. I'll just scroll down to the bottom of the prompt, and we'll add a line that says, before finishing, always send your extractor result to the escalation for human review and approval. Do not skip this step, complete the task, or return a final answer without first sending the result for review, even if you are confident that the extracted data is correct. So notice how explicit this instruction is. I want it to be completely unambiguous and unconditional to guarantee that a person checks this every time before it moves on. Okay, so now that the extracted details have been set up to be checked by a person, we need somewhere for that clean approved information to actually land. I'm gonna connect this to a Google Sheet I already created that stores the information from invoices. So for this example, this is an easy visual way to see the results end up somewhere real, but this same connection point works just as well for a database or some other system downstream. So back here on the Flow Canvas, I'll click the plus button on the agent's main output point, and here I'm gonna search for Google Sheets. And here I'll select the write row action, since we want the orchestration to write the extracted information to a row of that sheet we just saw. Then I'll click its edit button to open its properties, and here I need to configure a few things. Now I've already connected my Google account to UiPath. If you haven't done so yet, you will just enter your Gmail address here, and you'll be walked through the steps to connect to your account. When you're done, you should see your address listed here where mine is. Once your account is connected, you'll be able to browse the documents stored on your Google Drive. So I'll navigate to my drive and to the sheet which is called invoice reader test, and click apply. So do note that the document has to already exist since write row can only write into a sheet that's already there, and it won't create one for you. I'll set the range to the sheet that I want it to write to. It only has one in this case. And I'll keep how to write set to append so that each new result adds a new row instead of overwriting what's already there. Now, last for the actual data, I want to write the vendor, date, and total information that's extracted by the agent from the invoice and place that into the spreadsheet. Now, if we only needed to write in a single value, I could just come up here and click insert, select it from autonomous agent one, output, and select, for example, vendor. And we get something clean like this, vars.autonomousagent1.output.vendor. But I wanted to write the vendor, date, and total together as one array. And there really isn't an easy way to just select all of those from a menu and have it parse everything correctly. So instead, I'll just type the whole thing out directly. Notice that all three of these are essentially the same other than having the variations of vendor, date, and total. And we'll close the properties. And that's it. We now have four nodes connected start to finish. We have a trigger that accepts a document, an agent that reads the data, a human who will check it, and a sheet where the clean results get saved. Okay, so now that all four nodes are connected, I want to actually run this thing end to end and confirm that it works the way we just built it and make sure the data actually flows all the way from the trigger through to the saved row. I'll come up here and click debug in the top toolbar. So a debug configuration dialog appears with two tabs. We have solution resources and entry point arguments. I'll make sure entry port arguments is selected. And this is where the input we set up back in step one actually shows up as a real field. Since we made it a file type, it renders as an upload box right here. And I actually have a couple of sample invoices here on my desktop. And you can see we can either select the files or just drag them right in. And once we've uploaded that document, we can click save and debug. And now we can watch this run in real time. Notice we got the green check mark on manual trigger. So it was successfully triggered with the file we uploaded. Now the invoice reader agent is doing its part. And again, we can watch what it's doing in real time in the execution trace panel. Now notice that action needed has appeared next to the quick escalation form node. That's where we requested human approval. I'm gonna leave this running, but I'm gonna open a new tab and go to cloud.uipath.com again. And here at the bottom of the home portal, we have my actions and here I'm gonna click see all actions. And if I come over here to the unassigned tab, here's the approval that's waiting for human interaction. So in order to approve it, I'm gonna click assign to self, which moves it over to the pending tab. And here it is. And here I can see the data that's been extracted from the invoice. So we can give that a look. And if it all looks good, we can click approve. So notice these are the two buttons that we created. So clicking approve is what allows the flow to continue to that last saved step. So if I switch back to the workflow tab, we see the quick form escalation now has a green check mark and things are moving over to the right row node. And before I even finished saying that sentence, we see the successful notification appear. So now if I switch back to my Google Sheet, notice this new row has been added to the bottom with the data from the invoice. Now let's just confirm this isn't a fluke. So I'm gonna run this again with a different invoice. So we can just click debug again. It's gonna prompt me to select a file, delete the one that's currently in there. And this time I'll click the select button, go into invoices and I'll select the second invoice and click save and debug. And now we can watch it start to finish again. We'll just jump ahead. So again, we see action needed for the quick form escalation. We'll go over to the action center, look at unassigned. There it is, assigned to self. Find it here again in pending and click approve. And then I can go back to the workflow and hopefully it'll finish the orchestration. And there we have the successful notification. And if I look at the sheet, there's that next entry. So that's it. Two different documents, same flow, no code, no training and a person still checking the results both times before anything's final. Now, everything you've seen so far has been running in debug mode, just to build and test the flow. To actually put this to work, you would click the deploy button here in the toolbar, which publishes it as a live active process in your UiPath tenant. From there, whenever you have a new invoice to process, you would go to that deployment and click start job, attach the file and run it. And you'll run through the same document upload and approval steps you just watched just outside of debug. Now, since this flow starts with a manual trigger, it won't run itself automatically. So a person or another system has to kick off each run. But if you wanted it to pick up new invoices on its own, say from an email inbox or a shared folder, you would just have to swap in a different trigger node instead of the manual one we use today. And that's UiPath Maestro Flow. A canvas, a few nodes, some plain language instruction and a document that used to mean a bunch of manual retyping that's now handled automatically with a person still in the loop the whole way through. Now it's worth noting that the same canvas can also power something lighter. If your process is quick, finishing in minutes rather than involving an extended human review like ours did, that's what Maestro Automate is built for. It's the same flow canvas, just tuned for short, fast agent and API workflows instead of longer orchestrations like the one we just built. If you wanna try building an orchestration yourself, check out the link in the description to get started. And if this was helpful, hit subscribe and I'll see you in the next one.