How to Integrate OpenAI for investment banking with AWS Lambda for AI agents

Combining OpenAI with AWS Lambda gives you a clean pattern for building investment banking AI agents that can react to events, summarize documents, and generate analyst-ready outputs without running a permanent service. Lambda handles the event-driven execution layer, while OpenAI handles language-heavy tasks like deal memo drafting, earnings call extraction, and client Q&A.

For banking workflows, this matters because most tasks are bursty and compliance-sensitive. You want short-lived compute, tight IAM control, and a model layer that can turn raw financial data into usable actions.

Prerequisites

• •An AWS account with permission to create:
  • •Lambda functions
  • •IAM roles
  • •CloudWatch logs
• •AWS CLI configured locally:
  • •aws configure
• •Python 3.11 or later
• •boto3 installed for AWS SDK access
• •openai Python SDK installed
• •An OpenAI API key stored as an environment variable:
  • •OPENAI_API_KEY
• •Basic familiarity with:
  • •AWS Lambda handler functions
  • •JSON event payloads
  • •Python packaging for deployment

Integration Steps

1. •Set up your local project and install dependencies.

You want a small Lambda package that can call OpenAI directly from the handler. Keep the dependency surface minimal so cold starts stay predictable.

mkdir ib-openai-lambda
cd ib-openai-lambda
python -m venv .venv
source .venv/bin/activate

pip install openai boto3

2. •Create the OpenAI client and a reusable prompt function.

For investment banking use cases, keep prompts structured. In practice, you’ll pass in deal notes, company context, or transcript excerpts and ask for a constrained output like bullets or JSON.

import os
from openai import OpenAI

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

def analyze_investment_banking_text(text: str) -> str:
    response = client.responses.create(
        model="gpt-4.1-mini",
        input=[
            {
                "role": "system",
                "content": (
                    "You are an investment banking analyst assistant. "
                    "Summarize clearly, use concise language, and avoid speculation."
                ),
            },
            {
                "role": "user",
                "content": f"Summarize this banking content into 5 bullets:\n\n{text}",
            },
        ],
    )
    return response.output_text

This uses the real OpenAI SDK method client.responses.create(). That’s the right entry point for agent-style workflows because it returns structured response objects instead of forcing you into chat-only patterns.

3. •Wrap the model call inside an AWS Lambda handler.

Lambda should be the orchestration layer: receive an event, validate input, call OpenAI, return JSON. Don’t let business logic sprawl across multiple handlers.

import json
import os
from openai import OpenAI

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

def lambda_handler(event, context):
    body = event.get("body", {})
    if isinstance(body, str):
        body = json.loads(body)

    text = body.get("text", "")
    if not text:
        return {
            "statusCode": 400,
            "body": json.dumps({"error": "Missing 'text' field"}),
        }

    response = client.responses.create(
        model="gpt-4.1-mini",
        input=[
            {
                "role": "system",
                "content": (
                    "You are an investment banking assistant. "
                    "Return concise output suitable for internal review."
                ),
            },
            {
                "role": "user",
                "content": text,
            },
        ],
    )

    return {
        "statusCode": 200,
        "body": json.dumps({
            "summary": response.output_text,
        }),
    }

In production, set OPENAI_API_KEY as a Lambda environment variable or pull it from AWS Secrets Manager before calling the model.

4. •Add AWS SDK logic when your agent needs to fetch or store banking data.

A real agent usually does more than one model call. It may load documents from S3, write outputs to DynamoDB, or publish results to SNS for downstream review.

import json
import os
import boto3
from openai import OpenAI

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

def lambda_handler(event, context):
    bucket = event["bucket"]
    key = event["key"]

    obj = s3.get_object(Bucket=bucket, Key=key)
    text = obj["Body"].read().decode("utf-8")

    response = client.responses.create(
        model="gpt-4.1-mini",
        input=f"Extract key risks and valuation points from this document:\n\n{text}",
    )

    return {
        "statusCode": 200,
        "body": json.dumps({
            "source": f"s3://{bucket}/{key}",
            "analysis": response.output_text,
        }),
    }

Here you’re using boto3.client("s3").get_object(...) alongside OpenAI in the same execution path. That’s the common pattern for AI agents in regulated environments: retrieve controlled inputs from AWS storage, then send only what’s needed to the model.

5. •Package and deploy the Lambda function.

Zip your code with dependencies or use a Lambda layer/container image if your dependency tree grows. For a simple first pass:

zip -r function.zip .
aws lambda create-function \
  --function-name ib-openai-agent \
  --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=$OPENAI_API_KEY}"

If you update code later:

aws lambda update-function-code \
  --function-name ib-openai-agent \
  --zip-file fileb://function.zip

Testing the Integration

Invoke the function with a sample investment banking prompt and inspect the returned summary.

import json
import boto3

lambda_client = boto3.client("lambda")

payload = {
    "body": json.dumps({
        "text": (
            "Company A is considering acquiring Company B for $2.4B. "
            "Revenue growth is strong but margins are compressing due to integration costs."
        )
    })
}

response = lambda_client.invoke(
    FunctionName="ib-openai-agent",
    InvocationType="RequestResponse",
    Payload=json.dumps(payload).encode("utf-8"),
)

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

Expected output:

{
  "statusCode": 200,
  "body": "{\"summary\": \"...5 concise bullets...\"}"
}

If you get a 200, your Lambda can reach OpenAI and return model output successfully.

Real-World Use Cases

• •

  Deal team memo generation

  • •Feed management discussion notes or CIM excerpts into Lambda.
  • •Return a standardized summary with risks, catalysts, and follow-up questions.
• •

  Earnings call monitoring

  • •Trigger on new transcript uploads to S3.
  • •Have the agent extract guidance changes, margin commentary, and notable Q&A.
• •

  Client briefing automation

  • •Pull market data snapshots from internal systems.
  • •Generate banker-ready talking points before meetings or roadshows.

The pattern is simple: AWS Lambda gives you controlled execution and event triggers, while OpenAI provides reasoning over messy financial text. For investment banking AI agents, that combination is usually enough to ship something useful without standing up a full orchestration service on day one.

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.