The Serverless S3
Iceberg Lakehouse.

The Business Problem: Financial audit teams and compliance officers face a significant bottleneck when inspecting transaction ledgers (like SAP's BSEG general ledger table, BKPF headers, and sub-ledgers). In modern multi-entity corporations, identifying transaction anomalies—specifically **circular transaction loops** designed to inflate book revenues or hide embezzled payments—requires looking at relationships between thousands of accounts.

Using traditional relational SQL warehouses, searching for loops requires complex recursive Common Table Expressions (CTEs) or deep nested `JOIN` queries. As ledger sizes grow, these queries either run for hours on massive compute clusters or crash due to memory exhaustion. This makes real-time compliance checking impossible.

Autonomous Agentic Audit Protocols

Instead of relying on manual audit batches, an **Agentic Protocol** constantly monitors the incoming transaction stream. The compliance agent executes lightweight recursive Cypher queries on the Postgres graph to search for loops and reconcile double-entry paths automatically:

-- Query to detect circular financial loops (3 to 6 hops deep)
SELECT * FROM cypher('finance_graph', $$
  MATCH path = (a:Account)-[:TRANSFERS*3..6]->(a)
  WHERE a.status = 'active'
  RETURN path
$$) as (path gtype);

When a loop is detected, the agent immediately initiates an **A2A (Application-to-Application)** webhook, placing a temporary holds flag on the target accounts in the ERP ledger database and alerting the internal auditing team. This cuts audit latency from **30 days to sub-second real-time detection**.

The Business Problem: Modern supply chains suffer from disjointed operational data. Inbound logistics, warehouse inventory ledgers, and customer Order-to-Cash (O2C) records reside in completely separate databases.

When unexpected disruptions occur (e.g. stockouts, shipping delays, customs blocks), inventory planners are blind. Because joining these tables requires extracting data from legacy ERP logs, stockout alerts are usually delayed by **12 to 24 hours**, resulting in missed order deadlines, customer cancellations, and chargebacks.

Real-Time CDC Ingestion with Serverless Compiles

Meldra.ai implements lightweight Change Data Capture (CDC) pipelines. Instead of spinning up permanent Spark processing nodes to ingest stream partitions, we write transaction changes directly to S3. Meldra compiles these incremental logs on-the-fly using DuckDB:

-- Incremental Merge of warehouse stock changes into S3 Iceberg
MERGE INTO inventory_catalog.default.stock_levels t
USING (SELECT * FROM read_parquet('s3://warehouse-cdc/delta/*.parquet')) s
ON t.sku_id = s.sku_id
WHEN MATCHED THEN UPDATE SET t.quantity = s.quantity, t.last_updated = s.event_time
WHEN NOT MATCHED THEN INSERT (sku_id, quantity, last_updated) VALUES (s.sku_id, s.quantity, s.event_time);

Automated A2A Procurement Triggers

Our agentic protocol monitors these serverless merges. If an inventory merge indicates that stock levels for a critical part drop below safety limits, the agent runs a dependency scan on the S3 graph of suppliers.

It automatically invokes a secure **A2A API webhook** directly back into your ERP's procurement module (e.g., SAP Material Management), drafting a Purchase Requisition (PR) to replenish stock from the fastest supplier, completely bypassing manual procurement delays.

The Business Problem: Employee role changes and system onboarding represent a massive operational security risk. When an employee is hired, changes departments, or is terminated in **SAP SuccessFactors**, these changes must immediately propagate to downstream directories, financial ledgers, and identity access managers.

Typically, this synchronization is handled by manual spreadsheets or batch schedules that run overnight. During the latency window, former employees can retain access to sensitive financial environments (zombie accounts), representing a severe compliance breach under SOC2 and SOX.

Serverless IAM Audit Mappings

Meldra streams SuccessFactors event logs into the central `employees` Iceberg table on S3, mapping current role descriptors to organizational trees inside the Postgres graph database. This lets security agents execute instant graph sweeps:

-- Scan to identify access privileges mismatching the HR organizational tree
SELECT * FROM cypher('org_graph', $$
  MATCH (e:Employee)-[:ASSIGNED_TO]->(r:Role)
  MATCH (e)-[:MEMBER_OF]->(d:Department)
  WHERE r.tier > d.max_allowed_tier
  RETURN e.name, r.name, d.name
$$) as (emp_name gtype, role_name gtype, dept_name gtype);

Zero-Trust A2A Access Provisioning

The **Agentic Protocol** acts as an autonomous administrator. The moment a role change event updates S3, the agent detects department changes (e.g. Sales to Finance), maps the allowed system permissions, and executes automated **A2A API callbacks** to the IAM provider.

It immediately revokes the old tokens, provisions the new corporate credentials, and logs the entire action in the **Audit Timeline**, guaranteeing absolute security compliance in less than **2 seconds** from the initial HR action.

The MCP Design: Meldra exposes an MCP (Model Context Protocol) Server that declares a catalogue of structured tools (like create_table, query_data, ingest_csv, list_tables, drop_column). Claude — acting as the orchestrating AI — selects the right tool based on natural language intent.

MCP Tool Manifest

# mcp_server.py — Meldra Iceberg MCP Tool Declarations
tools = [
  MCPTool(
    name="create_iceberg_table",
    description="Create a new Apache Iceberg table on S3 with a given schema",
    input_schema={"namespace": "str", "table_name": "str", "schema_json": "list"}
  ),
  MCPTool(
    name="query_iceberg_data",
    description="Run a SQL SELECT query on an existing Iceberg table via DuckDB",
    input_schema={"namespace": "str", "table_name": "str", "sql_query": "str"}
  ),
  MCPTool(
    name="ingest_csv_to_iceberg",
    description="Parse and ingest a CSV file into an Iceberg table on S3",
    input_schema={"csv_path": "str", "namespace": "str", "table_name": "str"}
  ),
  MCPTool(
    name="list_iceberg_tables",
    description="List all Iceberg tables in a namespace from the Glue Catalog",
    input_schema={"namespace": "str"}
  )
]

User Interaction Flow

A business analyst types: "Show me all tables in the finance namespace and preview the first 5 rows of sap_bseg."

Claude invokes list_iceberg_tables({"namespace": "finance"}), receives the table catalog, then chains query_iceberg_data({..., "sql_query": "SELECT * FROM iceberg_table LIMIT 5"}) — entirely without the user touching SQL or knowing about S3 paths.

Why This Matters: Traditional ETL tools require dedicated data engineers to write bespoke pipelines for every new query or table evolution. This MCP server collapses the 3-day turnaround to a 3-second Claude conversation.

The MCP Design: A Meldra MCP Gateway wraps the SAP PyRFC Python library behind MCP tool declarations. Each tool maps a business intent to a specific BAPI call with pre-validated input schemas.

MCP Tool → SAP BAPI Mapping

# SAP MCP Tool Definitions
MCPTool(
  name="approve_purchase_requisition",
  description="Release a SAP Purchase Requisition (PR) for procurement approval",
  sap_bapi="BAPI_PR_CHANGE",
  input_schema={"pr_number": "str", "release_code": "str"}
)
MCPTool(
  name="release_billing_block",
  description="Remove a billing block from a SAP sales order",
  sap_bapi="BAPI_SALESORDER_CHANGE",
  input_schema={"sales_order": "str", "billing_block": "str"}
)
MCPTool(
  name="update_vendor_payment_term",
  description="Update the payment term for a SAP vendor in FI-AP",
  sap_bapi="BAPI_VENDOR_CHANGE",
  input_schema={"vendor_id": "str", "payment_term": "str", "company_code": "str"}
)

Business Impact

An AP clerk types: "Approve PR 4500012345 with release code A1 and update vendor V10001's payment term to NT60." The MCP agent sequences the two BAPI calls, validates the business key formats, executes on the SAP RFC layer, and returns structured confirmation — without the user touching SAP GUI once.

This eliminates the SAP training cost and reduces procurement cycle time from 2-3 days (waiting for an SAP-literate administrator) to under 10 seconds.

The MCP Design: The Meldra Snowflake MCP Server exposes tools that accept business-level parameters (not raw SQL). Claude translates the business intent into structured parameters, invokes the tool, and formats the results as rich summaries or tables for the user.

# Snowflake MCP Tool Examples
MCPTool(
  name="revenue_trend_by_period",
  description="Get monthly revenue totals grouped by cost centre",
  snowflake_table="finance.fact_revenue",
  input_schema={"period_from": "str", "period_to": "str", "cost_centre": "str"}
)
MCPTool(
  name="variance_analysis",
  description="Compare actual vs planned spend for a department",
  snowflake_tables=["finance.actuals", "finance.budget_plan"],
  input_schema={"department_id": "str", "fiscal_year": "int"}
)
MCPTool(
  name="top_vendors_by_spend",
  description="Rank vendors by total AP invoice spend in a fiscal period",
  snowflake_table="finance.ap_invoices",
  input_schema={"top_n": "int", "fiscal_quarter": "str"}
)

The Snowflake query results are cached in the S3 Iceberg layer as read-optimised snapshots using Meldra's serverless compile engine — so repeated questions resolve from warm S3 metadata reads rather than burning expensive Snowflake warehouse credits.

The MCP Design: Every tool invocation through the Meldra MCP server automatically fires a log_audit_event side-effect. This writes an immutable, append-only record to an S3 Iceberg partition with snapshot isolation — meaning the log itself can never be retroactively altered, deleted, or overwritten.

# Audit MCP interceptor — fires on every tool call
@mcp_tool_middleware
async def audit_interceptor(tool_name, args, user_id, result):
    await write_iceberg_audit(
        table="compliance.audit_log",
        record={
            "event_id":    str(uuid4()),
            "timestamp":   datetime.utcnow().isoformat(),
            "user_id":     user_id,
            "tool":        tool_name,
            "args_hash":   sha256(json.dumps(args)).hexdigest(),
            "result_hash": sha256(str(result)).hexdigest(),
            "outcome":     "success" if result else "failure"
        }
    )
    # Iceberg's snapshot isolation guarantees immutability

During a SOX audit, the compliance team runs a simple MCP query: "Show me all financial table modifications in Q3 by user svc-etl-agent." The agent scans the Iceberg audit partition and returns a structured, verifiable log — ready for the external auditor's review.

The MCP Orchestration Chain:

# 1. Stock Monitor Agent detects breach via Iceberg query
breach = mcp.invoke("query_iceberg_data", {
    "namespace": "supply_chain",
    "table_name": "stock_levels",
    "sql_query": "SELECT sku, qty, safety_stock FROM iceberg_table WHERE qty < safety_stock"
})

# 2. Supplier Ranking Agent selects fastest supplier via Graph query
best_supplier = mcp.invoke("query_supplier_graph", {
    "sku": breach["sku"],
    "strategy": "fastest_lead_time"
})

# 3. Procurement Agent raises PR in SAP MM via BAPI
pr_result = mcp.invoke("create_purchase_requisition", {
    "material": breach["sku"],
    "quantity": breach["reorder_qty"],
    "vendor": best_supplier["vendor_id"],
    "delivery_date": best_supplier["lead_time_days"]
})

# 4. Audit Agent logs the autonomous decision chain
mcp.invoke("log_audit_event", {"chain": [breach, best_supplier, pr_result]})

The entire 4-step chain — detect → rank → procure → audit — completes in under 8 seconds, compared to the standard 48-hour human procurement cycle.

The MCP Design: Meldra's IAM MCP Server listens to the SuccessFactors OData event stream (or polling the S3 employee Iceberg table for new snapshots). It exposes structured tools that map HR events to IAM API actions across Okta, Azure AD, and AWS IAM simultaneously.

# IAM MCP Tool Chain for Employee Termination

# Step 1: Detect termination event in Iceberg employee table
term_event = mcp.invoke("query_iceberg_data", {
    "sql_query": "SELECT * FROM iceberg_table WHERE event_type='TERMINATION' AND processed=false"
})

# Step 2: Revoke Okta SSO session tokens
mcp.invoke("okta_revoke_user_sessions", {"user_email": term_event["email"]})

# Step 3: Disable Azure AD account
mcp.invoke("azure_ad_disable_account", {"upn": term_event["email"]})

# Step 4: Remove from all AWS IAM groups
mcp.invoke("aws_iam_remove_all_groups", {"aws_username": term_event["aws_user"]})

# Step 5: Write immutable audit record
mcp.invoke("log_audit_event", {"action": "TERMINATION_SYNC", "user": term_event["email"], "status": "complete"})

Complete termination propagation — Okta, Azure AD, AWS IAM, and the audit trail — completes in under 5 seconds, eliminating the zombie account security window that SOC2 Type II auditors flag as a critical finding.

The MCP Design: Meldra's Fraud Detection MCP Server exposes a detect_payment_rings tool that triggers a recursive Cypher graph traversal in the Postgres AGE transaction graph. It checks every incoming payment batch for loops of 3–8 hops, flagging any cycle above a configurable velocity threshold.

-- Fraud Ring Detection Cypher Query (executed via MCP tool)
SELECT * FROM cypher('payments_graph', $$
  MATCH cycle = (a:Account)-[:SENT_TO*3..8]->(a)
  WHERE ALL(r IN relationships(cycle)
    WHERE r.amount > 10000
    AND r.timestamp > NOW() - INTERVAL '24 hours'
  )
  WITH a, cycle, length(cycle) AS hops
  WHERE hops >= 3
  RETURN a.account_id, hops, [n IN nodes(cycle) | n.account_id] AS ring_members
  ORDER BY hops DESC
$$) as (account_id gtype, hops gtype, ring_members gtype);

# When a ring is found, the MCP agent auto-escalates:
mcp.invoke("freeze_accounts",       {"account_ids": ring_members})
mcp.invoke("notify_fraud_team",      {"severity": "CRITICAL", "ring": ring_members})
mcp.invoke("log_sar_filing_request", {"ring": ring_members, "evidence": cycle})

The full detection-to-freeze pipeline runs in under 200ms per batch — making real-time payment block feasible at scale. Traditional BSS/OSS fraud systems running on nightly batch reports would have missed the same ring until the next business day.

The MCP Design: Meldra runs a central Orchestrator Agent that acts as the MCP client. It delegates each specialist task to a dedicated sub-agent via structured MCP tool calls. Each sub-agent is itself an MCP server exposing the domain expertise it owns.

# Month-End Close Orchestration via MCP
Orchestrator:
  ├── mcp.invoke("ledger_reconciliation_agent",      {"period": "2026-06", "company_codes": ["1000", "2000"]})
  │      └── Reads SAP BSEG from Iceberg, reconciles debits/credits, flags variance
  │
  ├── mcp.invoke("fx_revaluation_agent",             {"currencies": ["USD", "EUR", "GBP"], "rate_date": "2026-06-30"})
  │      └── Fetches ECB rates via MCP web-fetch tool, revalues open items
  │
  ├── mcp.invoke("intercompany_elimination_agent",   {"entity_graph": "corporate_structure"})
  │      └── Traverses org graph, eliminates IC transactions via Cypher
  │
  ├── mcp.invoke("tax_provision_agent",              {"jurisdiction": "all", "period": "2026-06"})
  │      └── Applies jurisdiction-specific tax rules, writes provision entries
  │
  ├── mcp.invoke("management_reporting_agent",       {"pack": "board_pack_june_2026"})
  │      └── Queries Snowflake, generates MD&A narrative using Claude, exports to PDF
  │
  └── mcp.invoke("audit_submission_agent",           {"trail_table": "compliance.audit_log"})
         └── Packages Iceberg audit snapshots, submits to external auditor portal

Each agent runs in parallel where dependencies allow. The orchestrator monitors completion, handles exceptions (e.g., retries a failed FX fetch with a fallback rate source), and assembles the final consolidated close package — reducing the 5-day process to under 4 hours of fully autonomous execution.

This is the core power of the A2A (Agent-to-Agent) Protocol combined with MCP: each specialist agent speaks a structured, verifiable tool language. No unstructured API calls, no brittle RPA scripts, no human handoffs for routine decisions.