	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > Invoice Reconciliation Agent

Invoice Reconciliation Agent

Author: Venkata Sudhakar

ShopMax India processes hundreds of vendor invoices each month. Manually matching each invoice to the corresponding purchase order, checking quantities, unit prices, and GST amounts, takes the finance team days and is prone to error. An automated reconciliation agent that performs this matching in seconds and flags only the exceptions for human review transforms a week-long process into a daily automated workflow.

This tutorial builds an Invoice Reconciliation Agent using ADK and Gemini. The agent matches incoming invoices to purchase orders, validates line-item quantities and amounts, and produces a reconciliation report distinguishing clean matches from discrepancies that need finance team review.

The below example shows invoice reconciliation for ShopMax India vendor payments.

from google.adk.agents import LlmAgent
from google.adk.tools import FunctionTool
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService

# --- Purchase orders database ---
PURCHASE_ORDERS = {
    "PO-2025-001": {
        "vendor": "Samsung India Pvt Ltd",
        "items": [
            {"sku": "SKU-1001", "desc": "Samsung 55-inch 4K TV", "qty": 50, "unit_price": 45000},
            {"sku": "SKU-1010", "desc": "Samsung Remote Control", "qty": 50, "unit_price": 500},
        ],
        "total_before_gst": 2275000,
        "gst_rate_pct": 18,
    },
    "PO-2025-002": {
        "vendor": "Sony India Ltd",
        "items": [
            {"sku": "SKU-1002", "desc": "Sony WH-1000XM5 Headphones", "qty": 30, "unit_price": 20000},
        ],
        "total_before_gst": 600000,
        "gst_rate_pct": 18,
    },
}

# --- Incoming invoices ---
INVOICES = [
    {
        "invoice_id": "INV-SAM-4421",
        "po_reference": "PO-2025-001",
        "vendor": "Samsung India Pvt Ltd",
        "items": [
            {"sku": "SKU-1001", "qty": 50, "unit_price": 45000},
            {"sku": "SKU-1010", "qty": 50, "unit_price": 550},
        ],
        "total_before_gst": 2302500,
        "gst_charged": 414450,
    },
    {
        "invoice_id": "INV-SONY-9812",
        "po_reference": "PO-2025-002",
        "vendor": "Sony India Ltd",
        "items": [
            {"sku": "SKU-1002", "qty": 30, "unit_price": 20000},
        ],
        "total_before_gst": 600000,
        "gst_charged": 108000,
    },
]

# --- Tool: reconcile invoice against PO ---
def reconcile_invoice(invoice_id: str) -> dict:
    """Match an invoice to its purchase order and check for discrepancies.
    Args:
        invoice_id: Invoice identifier
    Returns:
        Reconciliation result with match status and discrepancy details
    """
    invoice = next((i for i in INVOICES if i["invoice_id"] == invoice_id), None)
    if not invoice:
        return {"error": f"Invoice not found: {invoice_id}"}
    po = PURCHASE_ORDERS.get(invoice["po_reference"])
    if not po:
        return {"error": f"PO not found: {invoice['po_reference']}", "invoice_id": invoice_id}
    discrepancies = []
    # Check vendor name
    if invoice["vendor"] != po["vendor"]:
        discrepancies.append(f"Vendor mismatch: PO={po['vendor']}, Invoice={invoice['vendor']}")
    # Check line items
    po_items = {item["sku"]: item for item in po["items"]}
    for inv_item in invoice["items"]:
        sku = inv_item["sku"]
        if sku not in po_items:
            discrepancies.append(f"SKU {sku} not in PO")
            continue
        po_item = po_items[sku]
        if inv_item["qty"] != po_item["qty"]:
            discrepancies.append(f"SKU {sku}: qty mismatch PO={po_item['qty']} Invoice={inv_item['qty']}")
        if inv_item["unit_price"] != po_item["unit_price"]:
            diff = inv_item["unit_price"] - po_item["unit_price"]
            discrepancies.append(f"SKU {sku}: price mismatch PO=Rs{po_item['unit_price']} Invoice=Rs{inv_item['unit_price']} (diff Rs{diff})")
    # Check GST
    expected_gst = round(invoice["total_before_gst"] * po["gst_rate_pct"] / 100)
    if invoice["gst_charged"] != expected_gst:
        discrepancies.append(f"GST mismatch: expected Rs{expected_gst} charged Rs{invoice['gst_charged']}")
    return {
        "invoice_id": invoice_id,
        "po_reference": invoice["po_reference"],
        "vendor": invoice["vendor"],
        "status": "DISCREPANCY" if discrepancies else "MATCHED",
        "discrepancies": discrepancies,
        "invoice_total": invoice["total_before_gst"] + invoice["gst_charged"],
    }

# --- Tool: run full reconciliation batch ---
def reconcile_all_invoices() -> dict:
    """Reconcile all pending invoices against purchase orders.
    Returns:
        Summary with matched and discrepancy counts
    """
    results = [reconcile_invoice(inv["invoice_id"]) for inv in INVOICES]
    matched = [r for r in results if r.get("status") == "MATCHED"]
    discrepant = [r for r in results if r.get("status") == "DISCREPANCY"]
    return {"total": len(results), "matched": len(matched), "discrepant": len(discrepant), "results": results}

# --- Agent setup ---
recon_tool = FunctionTool(func=reconcile_invoice)
batch_tool = FunctionTool(func=reconcile_all_invoices)

agent = LlmAgent(
    name="invoice_recon_agent",
    model="gemini-2.0-flash",
    instruction="""You are an invoice reconciliation agent for ShopMax India.
Call reconcile_all_invoices to process the full batch.
For MATCHED invoices: confirm they are clear for payment approval.
For DISCREPANCY invoices: list each discrepancy clearly and recommend holding payment
until the vendor provides a corrected invoice.
Present a clean summary table and total financial exposure from discrepancies.""",
    tools=[recon_tool, batch_tool],
)

session_service = InMemorySessionService()
runner = Runner(agent=agent, app_name="invoice_recon", session_service=session_service)

import asyncio

async def run_recon(query: str) -> str:
    session = await session_service.create_session(app_name="invoice_recon", user_id="finance")
    from google.genai.types import Content, Part
    msg = Content(role="user", parts=[Part(text=query)])
    result = ""
    async for event in runner.run_async(user_id="finance", session_id=session.id, new_message=msg):
        if event.is_final_response() and event.content:
            result = event.content.parts[0].text
    return result

response = asyncio.run(run_recon("Reconcile all pending invoices and flag anything that needs to be held."))
print(response)

It gives the following output,

Invoice Reconciliation Report - ShopMax India
2 invoices processed  |  1 matched  |  1 discrepancy

CLEAR FOR PAYMENT:
  INV-SONY-9812  |  PO-2025-002  |  Sony India Ltd  |  Rs 7,08,000
  -> All quantities, prices, and GST verified. Approve payment.

HOLD - DISCREPANCY FOUND:
  INV-SAM-4421  |  PO-2025-001  |  Samsung India Pvt Ltd
  Invoice total: Rs 27,16,950

  Discrepancies:
  1. SKU-1010 (Samsung Remote): PO price Rs 500, Invoice price Rs 550
     Overcharge: Rs 50 x 50 units = Rs 2,500
  2. GST mismatch: expected Rs 4,09,500, charged Rs 4,14,450
     Excess GST: Rs 4,950

  Total financial exposure: Rs 7,450
  Action: Request corrected invoice from Samsung India before releasing payment.

In production, connect this agent to your ERP system via Cloud Functions - new invoices arriving in Cloud Storage trigger the reconciliation automatically. Matched invoices get routed to payment approval workflow; discrepancies trigger an email to the vendor via SendGrid with the specific line items to correct.

Send your comments, suggestions or queries regarding this site to [email protected].