How to Integrate OpenAI for retail banking with AWS Lambda for RAG

Combining OpenAI for retail banking with AWS Lambda gives you a clean way to run retrieval-augmented generation inside a bank-grade serverless boundary. The common pattern is simple: Lambda handles ingestion, retrieval, and orchestration; OpenAI handles answer generation against approved internal knowledge. That gets you low-ops deployment, controlled access to data, and a path to production RAG without standing up a full application server.

Prerequisites

• •An AWS account with:
  • •Lambda enabled
  • •IAM permissions for lambda:CreateFunction, lambda:InvokeFunction, logs:*, and access to your vector store or document source
• •Python 3.11 locally
• •AWS CLI configured:
  • •aws configure
• •An OpenAI API key set as an environment variable:
  • •export OPENAI_API_KEY="..."
• •A retrieval backend ready for RAG:
  • •Amazon Bedrock Knowledge Bases, OpenSearch Serverless, Pinecone, or pgvector in Aurora/Postgres
• •A Lambda execution role with:
  • •CloudWatch Logs permissions
  • •Network access to your retrieval backend if it sits in a VPC
• •The OpenAI Python SDK installed locally:
  • •pip install openai boto3

Integration Steps

1) Create the Lambda handler that orchestrates retrieval and generation

Your Lambda should accept a user question, fetch relevant context from your retriever, then call OpenAI with that context. Keep the handler thin; all business logic should sit in helper functions so you can test them locally.

import os
import json
import boto3
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
lambda_client = boto3.client("lambda")

def retrieve_context(query: str) -> str:
    # Replace this with your real retriever call:
    # Bedrock KB, OpenSearch kNN, pgvector query, etc.
    return (
        "Policy excerpt: Retail banking customers can dispute card transactions "
        "within 60 days of statement date. Mortgage prepayment penalties apply "
        "only to fixed-rate products."
    )

def generate_answer(question: str, context: str) -> str:
    response = client.responses.create(
        model="gpt-4.1-mini",
        input=[
            {
                "role": "system",
                "content": "You are a retail banking assistant. Answer only from provided context."
            },
            {
                "role": "user",
                "content": f"Question: {question}\n\nContext:\n{context}"
            }
        ]
    )
    return response.output_text

def lambda_handler(event, context):
    question = event.get("question", "")
    retrieved_context = retrieve_context(question)
    answer = generate_answer(question, retrieved_context)

    return {
        "statusCode": 200,
        "body": json.dumps({
            "question": question,
            "answer": answer
        })
    }

2) Package dependencies and deploy the Lambda function

For production, use a deployment package or container image. If you’re starting with a zip-based function, keep dependencies minimal and pin versions.

mkdir rag-lambda && cd rag-lambda
python -m venv .venv
source .venv/bin/activate
pip install openai boto3 -t .
zip -r function.zip .

Then create the function with the AWS CLI:

aws lambda create-function \
  --function-name retail-banking-rag \
  --runtime python3.11 \
  --handler app.lambda_handler \
  --role arn:aws:iam::123456789012:role/lambda-execution-role \
  --zip-file fileb://function.zip \
  --environment Variables="{OPENAI_API_KEY=your-openai-key}"

3) Connect Lambda to your real retrieval layer

In a bank environment, hardcoded policy text is not enough. Replace the stub with an actual retrieval call. If you use OpenSearch Serverless or Aurora pgvector, this is where you fetch top-k chunks and pass them into the model.

import os
import json
import boto3

opensearch = boto3.client("opensearchserverless")

def retrieve_context(query: str) -> str:
    # Example placeholder for your vector search layer.
    # In practice you'd query OpenSearch/Aurora/Pinecone here.
    hits = [
        {
            "text": "Customers may request chargeback investigations within 60 days."
        },
        {
            "text": "Debit card replacements are issued within 5 business days."
        }
    ]

    return "\n".join([h["text"] for h in hits])

def lambda_handler(event, context):
    question = event["question"]
    context_text = retrieve_context(question)

    return {
        "statusCode": 200,
        "body": json.dumps({
            "context": context_text,
            "question": question
        })
    }

The important part is the contract:

• •input: user query
• •output: ranked snippets with provenance
• •downstream: OpenAI receives only approved snippets

4) Call OpenAI from inside Lambda using structured prompts

For retail banking use cases, don’t let the model freewheel. Force it to answer from retrieved evidence and return concise output suitable for downstream channels like chat widgets or CRM notes.

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

def generate_answer(question: str, context: str) -> str:
    resp = client.responses.create(
        model="gpt-4.1-mini",
        input=[
            {
                "role": "system",
                "content": (
                    "You are a retail banking assistant. "
                    "Use only the provided context. If missing, say you don't know."
                )
            },
            {
                "role": "user",
                "content": f"Question:\n{question}\n\nContext:\n{context}"
            }
        ],
        temperature=0.2
    )
    return resp.output_text

If you need stricter outputs for compliance workflows, add JSON schema validation on top of this response before returning it to callers.

5) Invoke the Lambda function from another service or agent

In an AI agent system, another service often triggers the RAG Lambda rather than calling OpenAI directly. That keeps orchestration centralized and auditable.

import json
import boto3

lambda_client = boto3.client("lambda")

payload = {
    "question": "Can a customer dispute a debit card charge after two months?"
}

response = lambda_client.invoke(
    FunctionName="retail-banking-rag",
    InvocationType="RequestResponse",
    Payload=json.dumps(payload).encode("utf-8")
)

result = json.loads(response["Payload"].read())
print(result["body"])

Testing the Integration

Run a local smoke test first by invoking the handler directly.

from app import lambda_handler

event = {
    "question": "What is the window for disputing a card transaction?"
}

result = lambda_handler(event, None)
print(result["statusCode"])
print(result["body"])

Expected output:

{
  "statusCode": 200,
  "body": "{\"question\": \"What is the window for disputing a card transaction?\", \"answer\": \"Customers can dispute card transactions within 60 days of statement date.\"}"
}

If you see empty answers or generic responses:

• •check that OPENAI_API_KEY is set in Lambda environment variables
• •verify your retriever returns non-empty chunks
• •confirm the prompt says “use only provided context”
• •inspect CloudWatch logs for serialization or permission errors

Real-World Use Cases

• •Customer support copilot
  • •Answer balance transfer rules, fee questions, dispute timelines, and mortgage policy questions from approved internal docs.
• •Branch employee assistant
  • •Let bankers query product policies during customer calls without searching multiple systems.
• •Case summarization pipeline
  • •Pull account notes and policy snippets into Lambda, then have OpenAI generate concise summaries for CRM handoff.

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.