How to Integrate Anthropic for investment banking with Cloudflare Workers for AI agents

Combining Anthropic for investment banking with Cloudflare Workers gives you a low-latency agent layer that can sit close to users, route requests, and call the model only when needed. For investment banking workflows, that means faster deal-room Q&A, document triage, and policy-aware analysis without standing up a heavy backend.

Prerequisites

• •Python 3.10+
• •pip installed
• •An Anthropic API key
• •A Cloudflare account with Workers enabled
• •Wrangler CLI installed and authenticated
• •Basic familiarity with HTTP requests and JSON payloads
• •A clear use case, such as:
  • •deal memo summarization
  • •earnings-call extraction
  • •compliance-sensitive Q&A over internal docs

Install the Python dependencies:

pip install anthropic requests python-dotenv

Set your environment variables:

export ANTHROPIC_API_KEY="your_anthropic_key"
export CLOUDFLARE_WORKER_URL="https://your-worker.your-subdomain.workers.dev"

Integration Steps

1. •Create the Anthropic client in Python and verify model access.

Use the official Anthropic SDK. For investment banking agents, keep prompts tight and structured so outputs are easy to validate downstream.

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

response = client.messages.create(
    model="claude-3-5-sonnet-latest",
    max_tokens=300,
    temperature=0,
    messages=[
        {
            "role": "user",
            "content": (
                "Summarize this investment banking note in 3 bullets: "
                "Company has strong revenue growth, margin compression from expansion spend, "
                "and management expects EBITDA recovery next quarter."
            ),
        }
    ],
)

print(response.content[0].text)

2. •Build a Cloudflare Worker endpoint that acts as the agent gateway.

The Worker should accept requests from your app, enforce lightweight auth, and forward only approved tasks to your Python service or directly to Anthropic if you’re using Workers AI routing logic. In practice, many teams keep the Worker as the edge entry point and let Python handle orchestration.

Example Worker fetch handler:

export default {
  async fetch(request) {
    if (request.method !== "POST") {
      return new Response("Method not allowed", { status: 405 });
    }

    const body = await request.json();

    return new Response(JSON.stringify({
      ok: true,
      task: body.task,
      payload: body.payload,
    }), {
      headers: { "Content-Type": "application/json" },
    });
  }
}

Deploy it with Wrangler:

wrangler deploy

3. •Call the Cloudflare Worker from Python before invoking Anthropic.

This pattern is useful when the Worker performs request validation, tenant routing, or prompt classification. Your Python service sends the user request to the edge first, then uses the returned metadata to shape the Anthropic call.

import os
import requests
from anthropic import Anthropic

worker_url = os.environ["CLOUDFLARE_WORKER_URL"]
client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

payload = {
    "task": "investment_banking_summary",
    "payload": {
        "company": "Acme Corp",
        "notes": "Revenue up 18%, EBITDA margin down 2 pts due to sales hiring."
    }
}

worker_resp = requests.post(worker_url, json=payload, timeout=10)
worker_resp.raise_for_status()
route_info = worker_resp.json()

prompt = f"""
You are an investment banking analyst.
Task: {route_info['task']}
Input: {route_info['payload']}
Return:
- Summary
- Key risks
- Follow-up questions
"""

response = client.messages.create(
    model="claude-3-5-sonnet-latest",
    max_tokens=400,
    temperature=0,
    messages=[{"role": "user", "content": prompt}],
)

print(response.content[0].text)

4. •Add structured output so your agent can feed downstream systems.

For banking workflows, free-form text is not enough. You want JSON that can be stored in a case management system or passed into another agent step.

import json
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

response = client.messages.create(
    model="claude-3-5-sonnet-latest",
    max_tokens=300,
    temperature=0,
    messages=[
        {
            "role": "user",
            "content": (
                'Return valid JSON with keys: summary, risks, questions. '
                'Analyze: Margin pressure from hiring and capex expansion.'
            ),
        }
    ],
)

result_text = response.content[0].text
data = json.loads(result_text)
print(data["summary"])

If you expect occasional formatting drift, wrap this with a validator and retry once with a stricter prompt.

5. •Wire Cloudflare Workers into an agent loop for approvals or routing.

A common pattern is:

• •Worker receives user request at the edge
• •Python service calls Anthropic for analysis
• •Worker returns policy flags or tenant context
• •Agent decides whether to answer directly or escalate

Python example with both calls:

import os
import requests
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
worker_url = os.environ["CLOUDFLARE_WORKER_URL"]

context_resp = requests.post(
    worker_url,
    json={"task": "policy_check", "payload": {"request_type": "deal_summary"}},
    timeout=10,
)
context_resp.raise_for_status()
context = context_resp.json()

messages = [
    {
        "role": "user",
        "content": f"""
Policy context: {context}
Write a concise deal summary for an internal banking user.
Do not include unsupported claims.
""",
    }
]

response = client.messages.create(
    model="claude-3-5-sonnet-latest",
    max_tokens=250,
    temperature=0,
    messages=messages,
)

print(response.content[0].text)

Testing the Integration

Run this end-to-end test to confirm both sides are working:

import os
import requests
from anthropic import Anthropic

worker_url = os.environ["CLOUDFLARE_WORKER_URL"]
client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

test_payload = {
    "task": "earnings_call_extraction",
    "payload": {
        "transcript_snippet": (
            "Revenue grew 12% year over year. Management expects stronger "
            "free cash flow in H2."
        )
    }
}

r = requests.post(worker_url, json=test_payload, timeout=10)
r.raise_for_status()
ctx = r.json()

resp = client.messages.create(
    model="claude-3-5-sonnet-latest",
    max_tokens=200,
    temperature=0,
    messages=[{
        "role": "user",
        "content": f"Using this context {ctx}, extract 2 key points from the transcript."
    }],
)

print(resp.content[0].text)

Expected output:

1. Revenue increased 12% YoY.
2. Management expects stronger free cash flow in H2.

Real-World Use Cases

• •

  Deal team assistant

  • •Summarizes CIMs, management presentations, and diligence notes behind a Cloudflare Worker gateway.
  • •Keeps request routing close to users while Anthropic handles language-heavy analysis.
• •

  Compliance-aware research copilot

  • •Uses Workers for tenant checks and prompt gating.
  • •Uses Anthropic to draft responses only when policy allows it.
• •

  Investment memo generator

  • •Takes raw notes from analysts.
  • •Produces structured outputs for IC decks, CRM systems, or approval workflows.

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.