Open Banking: compartilhamento seguro de dados com o MongoDB

Visão Geral da Solução

Esta solução apresenta um ecossistema de open banking e demonstra como compartilhar dados financeiros de forma segura entre instituições usando o MongoDB Atlas e a IA agêntica.

Aprenda a implementar um framework de IA agêntica com LangGraph para agilizar a aprovação de consentimento e dar aos clientes uma visão consolidada e multibancária de suas finanças. O MongoDB Atlas funciona como a camada de dados alinhada ao BIAN que sustenta essas arquiteturas de Open Banking.

Arquiteturas de referência

Figura 1. Arquitetura de referência de Open Banking.

clique para ampliar

Como mostra o diagrama, o processo começa quando o cliente se conecta ao Leafy Banco (nossa instituição financeira fictícia). O cliente concede ou nega o autorização para acessar dados externos — dados de fornecedores terceirizados (TPP) ou outros dados de bancos e bancos (nesta demonstração: Banco MongoDB , GeoFinance e Banco verde).

Um fluxo de trabalho de vários agentes recebe a solicitação do cliente e executa as seguintes tarefas:

• Agente Supervisor: Lê a conversa e encaminha cada solicitação para o especialista correto.

• Agente de anuência: Guia os clientes sobre o consenso seguro do compartilhamento de dados com bancos externos. Ele lida com a seleção da instituição, a criação do autorização, o login no banco, a aprovação explícita do cliente e a revogação.

• Agente de consultoria financeira: responde a perguntas ad hoc sobre contas, transações e produtos do cliente e analisa os gastos em bancos internos e externos fazendo consultas diretamente ao MongoDB por meio do servidor MCP.

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)

Abordagem do modelo de dados

A demonstração utiliza dois bancos de dados MongoDB Atlas :

• leafy_bank_bian: Este banco de dados contém o modelo operacional compartilhado e alinhado ao BIAN no qual a demonstração é executada, como clientes (PartyReferenceDataDirectory), contas (CurrentAccount), transações e produtos. Este banco de dados também contém os registros de consentimento na coleção openbankingConsents com criptografia de query e na coleção cachedExternalData que armazena dados externos obtidos mediante um consentimento aprovado.

• open_finance: Este banco de dados contém os dados de origem das instituições externas—external_accounts e external_products de instituições parceiras—além de um registro de instituições.

O Leafy Bank possui e grava os dados leafy_bank_bian. Dados externos são concedidos mediante consentimento, não adquiridos. Os dados são lidos de open_finance conforme o consentimento aprovado, armazenados em cache em cachedExternalData com a tag do ConsentId concedente e eliminados quando o consentimento é revogado ou expira. Eles nunca são mesclados aos registros de conta e transações da própria instituição.

Veja a seguir exemplos de documentos nas coleções:

• accounts (de 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 (de leafy_bank_bian), um registro de consentimento com Queryable Encryption nos campos confidenciais:

  {
    "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" }
    ]
  }

As transações externas usam o mesmo esquema alinhado ao BIAN que as próprias transações do Leafy Bank — o titular da conta aparece como pagador nas transações de saída e como beneficiário nas de entrada — portanto, os dados de diferentes instituições chegam em um formato consistente.

Visite os repositórios do GitHub na próxima seção para explorar dados de amostra de todas as coleções na solução.

Construir a solução

Para criar essa solução, implemente os seguintes serviços coordenados: o backend de Open Banking, o backend de chatbot de agentes e a IU integrada.

Para a implementação completa, siga as instruções nos repositórios GitHub correspondentes.

Parte 1: backend de Open Banking (repositório GitHub)

Parte 2: backend do chatbot agente (repositório do GitHub)

Parte 3: IU integrada (repositório do GitHub)

Para obter comandos de configuração passo a passo, variáveis de ambiente e detalhes da API, siga as instruções no arquivo README de cada repositório mencionado acima.

Principais Aprendizados

• Unifique os dados do open banking no MongoDB Atlas: unifique conjuntos de dados internos e externos no MongoDB Atlas como sua camada de dados operacionais para reduzir a complexidade e a duplicação da integração.

• Simplifique a análise com pipelines de agregação: use pipelines de agregação do MongoDB para calcular saldos, totais de dívidas e pontuações de gastos em contas internas e externas em um único caminho de query.

• Proteja dados confidenciais de consentimento com a criptografia de query do MongoDB: aplique a Queryable Encryption aos atributos de consentimento para que você possa executar a query em campos confidenciais mantendo controles de privacidade rigorosos para cargas de trabalho regulamentadas de Open Banking.

• Simplifique as viagens de consenso com a IA de agentes: integre um chatbot multiagente baseado em LangGraph para explicar o escopo, a duração e a finalidade do consenso em linguagem natural, reduzindo o abandono nos fluxos multibancos e melhorando a experiência do cliente.

• Padronize dados com um modelo alinhado ao BIAN: modele contas internas e externas, transações e consentimentos no padrão de domínio de serviço BIAN para que os dados de cada instituição cheguem em um formato consistente.

Autores

• Saul Calderon

• Kiran Tulsulkar

• Ainhoa Múgica

• Andrea Alaman Calderon

Saiba mais

• Orquestração de pagamentos com IA agêntica
• Mitigação de Crimes Financeiros com o MongoDB Atlas