Open Banking: Secure Data Sharing with MongoDB

Solution Overview

This solution presents an open banking ecosystem and demonstrates how to share financial data securely between institutions by using MongoDB Atlas and agentic AI.

Learn how to implement an agentic AI framework with LangGraph to streamline consent approval and give customers a consolidated, multi-bank view of their finances. MongoDB Atlas serves as the BIAN-aligned data layer that underpins these Open Banking architectures.

Reference Architectures

Figure 1. Open Banking Reference Architecture.

click to enlarge

As the diagram shows, the process begins when the customer logs into Leafy Bank (our fictional financial institution). The customer grants or denies consent to access external data—Third-Party Provider (TPP) data or other financial institution data (in this demo: MongoDB Bank, NeoFinance, and Green Bank).

A multi-agent workflow receives the customer request and performs the following tasks:

• Supervisor Agent: Reads the conversation and routes each request to the correct specialist.

• Consent Agent: Guides customers through secure data-sharing consent with external banks. It handles institution selection, consent creation, bank login, explicit customer approval, and revocation.

• Financial Advice Agent: Answers ad hoc questions about the customer's accounts, transactions, and products, and analyzes spending across internal and external banks by querying MongoDB directly through the MCP server.

from pymongo import MongoClient
from pymongo.encryption_options import AutoEncryptionOpts
class EncryptedMongoDBConnection(MongoDBConnection):
    """Subclasses the standard connection — services that type-hint
    MongoDBConnection accept it without modification."""
    def __init__(self, uri: str, auto_encryption_opts: AutoEncryptionOpts):
        self.uri = uri
        self.client = MongoClient(self.uri, auto_encryption_opts=auto_encryption_opts)

# Standard query on a plaintext field — works as usual
consent = consents_collection.find_one({"ConsentId": consent_id})
# Equality query on an encrypted field — same syntax, driver encrypts the filter value
consents = list(consents_collection.find({"Consumer.UserName": user_name}))

from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain_mcp_adapters.tools import load_mcp_tools
mcp_client = MultiServerMCPClient({
    "mongodb": {
        "command": "npx",
        "args": ["-y", "mongodb-mcp-server@latest"],
        "transport": "stdio",
        "env": {
            **os.environ,
            "MDB_MCP_CONNECTION_STRING": LEAFY_BANK_MONGODB_URI,
            "MDB_MCP_READ_ONLY": "true",
            "MDB_MCP_DISABLED_TOOLS": disabled_tools,
        },
    }
})
# Persistent session keeps MongoDB connection state across tool calls
async with mcp_client.session("mongodb") as session:
    all_mcp_tools = await load_mcp_tools(session)
    # Pre-connect so the agent never handles connection strings
    connect_tool = next((t for t in all_mcp_tools if t.name == "connect"), None)
    if connect_tool:
        await connect_tool.ainvoke({"connectionString": LEAFY_BANK_MONGODB_URI})
    # Only expose read/query tools to the agent
    allowed_tools = {"find", "aggregate", "count", "list-collections", "collection-schema"}
    mcp_tools = [t for t in all_mcp_tools if t.name in allowed_tools]

from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.mongodb import MongoDBSaver
# Each specialist is built from a factory that loads its system prompt
# from a Queryable-Encryption-backed MongoDB collection at startup.
consent_agent = create_consent_agent(prompts["consent_agent"])
financial_advice_agent = create_financial_advice_agent(
    prompts["financial_advice_agent"], mcp_tools
)
supervisor = create_supervisor_node(prompts["supervisor"])
def route_from_supervisor(state: AgentState) -> str:
    # The supervisor writes its routing decision to state["next"]
    return state.get("next", "FINISH")
workflow = StateGraph(AgentState)
workflow.add_node("supervisor", supervisor)
workflow.add_node("consent_agent", consent_agent)
workflow.add_node("financial_advice_agent", financial_advice_agent)
workflow.add_edge(START, "supervisor")
workflow.add_conditional_edges("supervisor", route_from_supervisor, {
    "consent_agent": "consent_agent",
    "financial_advice_agent": "financial_advice_agent",
    "FINISH": END,
})
workflow.add_edge("consent_agent", "supervisor")
workflow.add_edge("financial_advice_agent", "supervisor")
checkpointer = MongoDBSaver(
    client=db.client,
    db_name=DATABASE_NAME,
    checkpoint_collection_name=CHECKPOINTS_AIO_COLLECTION,
    writes_collection_name=CHECKPOINTS_WRITES_AIO_COLLECTION,
)
graph = workflow.compile(checkpointer=checkpointer)

from langgraph.types import interrupt, Command
# Agent pauses, returns review payload to the calling application
review = interrupt({
    "type": "APPROVAL_REQUIRED",
    "details": approval_details,
})
# Application resumes the workflow after the human decision
await agent.ainvoke(Command(resume=decision), config)

Data Model Approach

The demo uses two MongoDB Atlas databases:

• leafy_bank_bian: This database contains the shared, BIAN-aligned, operational model the demo runs on, such as customers (PartyReferenceDataDirectory), accounts (CurrentAccount), transactions, and products. This database also holds the consent records in the Queryable-Encrypted openbankingConsents collection, and the cachedExternalData collection that stores external data fetched under an approved consent.

• open_finance: This database contains the external institutions' source data—external_accounts and external_products from partner institutions—plus an institutions registry.

Leafy Bank owns and writes the leafy_bank_bian data. External data is borrowed through consent, not owned. The data is read from open_finance per approved consent, cached in cachedExternalData tagged with the granting ConsentId, and purged when the consent is revoked or expires. It is never merged into the institution's own account and transaction records.

The following are examples of documents in the collections:

• accounts (from leafy_bank_bian):

  {
    "accountId": "ACC-e0583b3b",
    "accountBank": "Leafy Bank",
    "accountNumber": "212100310",
    "currency": "USD",
    "balance": { "current": 315, "available": 315, "ledger": 315, "hold": 0, "overdraftLimit": 0 },
    "customerSnapshot": { "customerId": "CUST-00528224" },
    "gl": { "accountCode": "2121", "costCenter": "CC-RETAIL-DEFAULT" },
    "productId": "PROD-STD-SA-USD",
    "openedAt": "2024-12-07"
  }

• openbankingConsents (from leafy_bank_bian), a consent record with Queryable Encryption on the sensitive fields:

  {
    "ConsentId": "urn:greenbank:Cf5b9ff59e06f77",
    "Status": "AUTHORISED",
    "Consumer": { "UserName": "< encrypted >", "UserId": "< encrypted >" },
    "Permissions": "< encrypted >",
    "Purpose": "FINANCIAL_ADVICE",
    "SourceInstitution": { "InstitutionName": "< encrypted >", "InstitutionId": "679a1001a9711d00a3bb01a1" },
    "CreationDateTime": "2026-02-05T10:55:30Z",
    "ExpirationDateTime": "2026-08-04T10:55:30Z",
    "StatusHistory": [
      { "Status": "AWAITING_AUTHORISATION", "DateTime": "2026-02-05T10:55:30Z" },
      { "Status": "AUTHORISED", "DateTime": "2026-02-05T10:56:06Z" }
    ]
  }

External transactions use the same BIAN-aligned schema as Leafy Bank's own transactions—the account holder appears as payer on outgoing transactions and payee on incoming ones—so data from different institutions lands in a consistent shape.

Visit the GitHub repositories in the next section to explore sample data from all the collections in the solution.

Build the Solution

To build this solution, implement the following coordinated services: the Open Banking backend, the agentic chatbot backend, and the integrated UI.

For the complete implementation, follow the instructions in the corresponding GitHub repositories.

Part 1: Open Banking backend (GitHub repository)

Part 2: Agentic chatbot backend (GitHub repository)

Part 3: Integrated UI (GitHub repository)

For step-by-step setup commands, environment variables, and API details, follow the instructions in the README file of each repository mentioned above.

Key Learnings

• Unify open banking data on MongoDB Atlas: Unify internal and external datasets on MongoDB Atlas as your operational data layer to reduce integration complexity and duplication.

• Simplify analytics with aggregation pipelines: Use MongoDB aggregation pipelines to compute balances, debt totals, and spending scores across internal and external accounts in a single query path.

• Protect sensitive consent data with MongoDB queryable encryption: Apply Queryable Encryption to consent attributes so you can query on sensitive fields while maintaining strong privacy controls for regulated Open Banking workloads.

• Streamline consent journeys with agentic AI: Integrate a LangGraph-based multi-agent chatbot to explain consent scope, duration, and purpose in natural language, reducing abandonment across multibank flows and improving customer experience.

• Standardize data with a BIAN-aligned model: Model internal and external accounts, transactions, and consents on the BIAN service-domain standard so data from every institution lands in a consistent shape.

Authors

• Saul Calderon

• Kiran Tulsulkar

• Ainhoa Múgica

• Andrea Alaman Calderon

Learn More

• Agentic AI-Powered Payments Orchestration
• Financial Crime Mitigation with MongoDB Atlas