RPA and AI in Action: Build Enterprise AI Workflows from Scratch with Code and Config Examples

Introduction: When RPA Meets AI, Your Workflows Begin to "Self-Evolve"

Folks, have you ever had that feeling? Every day you sit down at your computer, facing a mountain of repetitive tasks—logging into systems, copy-pasting, filling out forms, sending emails, organizing Excel sheets... You're busy non-stop, but when you look back, it feels like you've just been doing "pure grunt work"?

I used to be in the same boat, until I seriously delved into the combination of RPA and AI, and it was like a lightbulb went off. Simply put, RPA is the "hands," responsible for executing those mechanical mouse and keyboard actions; AI is the "brain," responsible for understanding, judging, and generating content. When these two join forces, you can build truly enterprise-grade AI workflows, letting robots do the heavy lifting while you clock out on time.

In this AI tutorial, I'm not going to talk abstract theory. I'll take you from 0 to 1, guiding you step-by-step through building a complete workflow. This article will include core concepts, environment setup, real, actionable code examples, as well as the pitfalls I've encountered and optimization tips. If you're looking to get into this field, or searching for efficiency solutions for your team, this article is definitely worth ten minutes of your time.

1. Understanding the Concepts: How Do RPA and AI Divide the Work?

Many people new to this area fall into a common misconception, thinking RPA is AI, or AI is RPA. Let's clarify the relationship between these two "brothers" first.

1. What is RPA (Robotic Process Automation)?

RPA is more like an advanced version of "screen recording playback." It operates on multiple software applications at the GUI (Graphical User Interface) level by simulating human actions. What it excels at are "deterministic" processes: for example, downloading reports from an ERP system at a scheduled time and then filling them into an Excel template. Its strength is its stability; its weakness is its rigidity—if a button moves on the page, or the data format changes, it gets confused.

2. What Problems Does AI (Artificial Intelligence) Solve?

AI, especially Large Language Models (LLMs), excels at handling "non-deterministic" tasks. For instance, reading a customer complaint email and extracting the core issue, or generating an analysis report from a pile of scattered data. AI can understand context, reason, and generate content. However, it can't directly click a button on a webpage for you.

So, the relationship between RPA and AI is like "hands" and "brain." RPA is responsible for "feeding" data to AI, and after AI processes it, RPA "transports" the results back to the business system. In my experience, learning only RPA has a low ceiling; learning only AI makes it hard to implement. Combining the two is the winning formula.

2. Core Components Breakdown: What "Parts" Do You Need to Build a Workflow?

Since we're building an enterprise-grade AI workflow, we need to see what building blocks we have, just like assembling LEGOs. I categorize the core components into three main parts, all of which are essential.

• Orchestration and Scheduling Engine: This is the "central brain" of the workflow. I recommend UiPath, Yingdao (YinDao), or Power Automate. If you prefer a lightweight solution and know how to code, you can also use Python's Schedule library or Prefect. Personally, I like Yingdao because its Chinese support and community ecosystem are very friendly for beginners.
• AI Model Service: This is the "source of intelligence." You can call the OpenAI API, or use domestic models like Zhipu AI (智谱), ERNIE Bot (文心一言), or Tongyi Qianwen (通义千问). For private deployment, consider running Llama 3 with Ollama. In this AI tutorial, I'll use the OpenAI API as an example because its interface is the most universal and its ecosystem is the most mature.
• Connectors and Data Storage: Workflows need to interact with the outside world, such as reading databases, uploading files to FTP, or sending WeChat Work notifications. This requires various ready-made connectors. For data storage, I recommend SQLite (lightweight) or MySQL (enterprise-level).

Just a side note: if you want to stay updated on daily changes in the AI world, pay attention to some latest AI daily news columns. They can quickly inform you about model upgrades or tool discounts. In tech, information asymmetry is also productivity.

3. From 0 to 1 Hands-On: Building an "Automated Invoice Verification and Archiving" Workflow

All talk and no action is useless. Below, I'll use the high-frequency scenario of "Automated Invoice Verification and Archiving for the Finance Department" to walk you through the complete setup process. I've personally run this case in my company; it went live in less than a week and saves our finance colleagues about 3 hours daily.

Step 1: Define Requirements and Feasibility Analysis

Don't jump straight into coding. First, draw a simple flowchart: Receive PDF invoice → Recognize invoice information → Call API for verification → Update ledger → Archive to network drive. Then, assess which steps are repetitive (for RPA) and which require intelligent judgment (for AI). In this case, "recognizing invoice information" (OCR + field extraction) is AI's strength, while "downloading email attachments" and "updating the ledger" are RPA's specialties.

Step 2: Environment Configuration and Dependency Installation

Let's assume we use Python for the core logic (Yingdao handles the RPA orchestration, but Python is more flexible for core logic). You'll need to install the following libraries:

# Basic operation library
pip install pillow
# For PDF parsing
pip install pdfplumber
# For calling OpenAI API (or other LLMs)
pip install openai
# For Excel operations
pip install openpyxl
# For HTTP requests (calling verification API)
pip install requests

Note here that crafting the AI Prompt is the soul of the entire AI component. When writing the prompt for extracting invoice information, I recommend using structured instructions, like: "Please extract the invoice code, invoice number, issue date, and total amount (including tax) from the following OCR text, and output it in JSON format. If information is missing, mark it as null."

Step 3: Write the AI Recognition and Extraction Function

This is the core logic of the entire workflow. We'll first use pdfplumber to convert the PDF to text, then send it to the LLM.

import openai
import pdfplumber
import json

# Configure your API Key (recommend using environment variables, don't hardcode)
openai.api_key = "sk-YourKey"

def extract_invoice_info_from_pdf(pdf_path):
    # 1. Extract PDF text
    with pdfplumber.open(pdf_path) as pdf:
        page = pdf.pages[0]
        raw_text = page.extract_text()
    
    # 2. Build the AI prompt
    prompt = f"""
    You are a precise OCR information extraction assistant.
    Please extract the following information from the invoice OCR text below:
    - invoice_code
    - invoice_number
    - invoice_date
    - total_amount (including tax)
    - seller_name
    
    Rules: Output only JSON, no explanations.
    Text content:
    \"\"\"
    {raw_text}
    \"\"\"
    """
    
    # 3. Call the LLM
    response = openai.ChatCompletion.create(
        model="gpt-4o-mini",  # Using the mini version for cost-effectiveness
        messages=[
            {"role": "system", "content": "You are a meticulous data extraction expert."},
            {"role": "user", "content": prompt}
        ],
        temperature=0  # Set to 0 for deterministic output
    )
    
    # 4. Parse the returned JSON
    reply_content = response.choices[0].message.content.strip()
    try:
        # Sometimes the model adds markdown code block markers, need to clean up
        if reply_content.startswith("```json"):
            reply_content = reply_content[7:]
        if reply_content.endswith("```"):
            reply_content = reply_content[:-3]
        return json.loads(reply_content)
    except Exception as e:
        print(f"Failed to parse JSON: {e}, raw content: {reply_content}")
        return None

See? This is the embodiment of AI skills. Traditional OCR tools (like Tesseract) output a bunch of garbled text, and you have to write your own regex to match fields. But with an LLM, just a prompt gives you clean, structured data. It's like switching from a manual transmission to an automatic one—it feels a bit strange at first, but you get used to it quickly.

Step 4: Write the RPA Orchestration Script (Simulating Form Filling and Archiving)

Once the structured data is extracted, RPA takes over. The following code simulates writing the extracted data into an Excel ledger and moving the original PDF file to a designated folder.

import os
import shutil
from openpyxl import load_workbook
from datetime import datetime

def rpa_archive_invoice(invoice_data: dict, source_pdf_path: str):
    # 1. Simulate adding a new record in Excel
    excel_path = "C:/invoices/ledger.xlsx"
    wb = load_workbook(excel_path)
    ws = wb.active
    next_row = ws.max_row + 1
    ws.cell(row=next_row, column=1, value=invoice_data.get("invoice_code"))
    ws.cell(row=next_row, column=2, value=invoice_data.get("invoice_number"))
    ws.cell(row=next_row, column=3, value=invoice_data.get("invoice_date"))
    ws.cell(row=next_row, column=4, value=invoice_data.get("total_amount"))
    ws.cell(row=next_row, column=5, value=invoice_data.get("seller_name"))
    ws.cell(row=next_row, column=6, value=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
    wb.save(excel_path)
    print(f"✅ Ledger updated, current row {next_row}")
    
    # 2. Simulate moving the file to the archive directory
    archive_dir = "C:/invoices/archived/"
    if not os.path.exists(archive_dir):
        os.makedirs(archive_dir)
    new_pdf_path = archive_dir + os.path.basename(source_pdf_path)
    shutil.move(source_pdf_path, new_pdf_path)
    print(f"📁 File archived to: {new_pdf_path}")

# Assuming this is the data obtained from Step 3
if __name__ == "__main__":
    sample_data = {
        "invoice_code": "031002200211",
        "invoice_number": "12345678",
        "invoice_date": "2025-03-10",
        "total_amount": "1234.56",
        "seller_name": "Example Tech Co., Ltd."
    }
    rpa_archive_invoice(sample_data, "C:/downloads/invoice_from_mail.pdf")

See how clear the process is? In actual Yingdao or UiPath, you don't need to write such low-level code; you can just drag and drop the ready-made "Excel Write" and "File Move" components. But understanding the underlying