Build an Enterprise LLM Assistant with AWS Lambda, API Gateway and Amazon Bedrock

Generative AI applications are often introduced with a simple example: send a prompt to an LLM and display the response. A real application usually needs more. A user may ask a question without context, paste an email and summarize it, provide text and ask the model to draft a response, or upload a PDF and ask questions about it.

This article builds a simple Enterprise LLM Assistant using HTML/JavaScript, Amazon API Gateway, AWS Lambda, Amazon Bedrock, Amazon Nova Micro, and pypdf.

1. What Are We Building?

+------------------------------------------------+
|              Enterprise LLM Assistant          |
+------------------------------------------------+
| Prompt / Question                              |
| +--------------------------------------------+ |
| | Ask anything...                            | |
| +--------------------------------------------+ |
|                                                |
| Context (Optional)                             |
| +--------------------------------------------+ |
| | Paste email or other context here...       | |
| +--------------------------------------------+ |
|                                                |
| PDF Context (Optional)                         |
| [ Choose PDF ]                                 |
|                                                |
|              [ Send to LLM ]                   |
+------------------------------------------------+
| LLM Response                                   |
+------------------------------------------------+

The user does not need to select a mode. The application determines what to send based on the information provided.

2. Three Supported Scenarios

Prompt only

Prompt → API Gateway → Lambda → Amazon Nova Micro → Response

Prompt + text context

Lambda receives the context and prompt, combines them into an instruction, and sends the request to Nova Micro.

Prompt + PDF

Browser
   |
   | PDF + Prompt
   v
API Gateway
   |
   v
Lambda
   |
   | Extract PDF text
   v
pypdf
   |
   v
Build LLM prompt
   |
   v
Amazon Nova Micro
   |
   v
Answer

In this initial implementation, the PDF is converted to text and included directly in the prompt. We are not using a vector database or RAG yet.

3. High-Level Architecture

The solution uses a lightweight serverless architecture to connect the web client with Amazon Bedrock while supporting optional text and PDF context.

Figure 1: End-to-end architecture of the Enterprise LLM Assistant.

4. Lambda Logic

The Lambda function acts as the orchestration layer and determines how the request should be processed based on the context supplied by the user.

The Lambda performs these steps:

Receive Event
      |
      v
Validate Request
      |
      v
Identify Context Type
      |
      +-------------+-------------+
      |             |             |
     none          text          pdf
      |             |             |
      |             |        Extract PDF text
      |             |             |
      +-------------+-------------+
                    |
                    v
              Build Prompt
                    |
                    v
             Bedrock Converse
                    |
                    v
             Nova Micro
                    |
                    v
             JSON Response

5. Lambda Function

The Lambda receives the API Gateway request, determines the context type, optionally extracts PDF text, builds the prompt, calls Bedrock Converse, and returns JSON.

import json
import boto3
import base64
import io
from pypdf import PdfReader

MODEL_ID = "amazon.nova-micro-v1:0"
REGION = "us-east-1"

bedrock = boto3.client(
    "bedrock-runtime",
    region_name=REGION
)

def response(status_code, body):
    return {
        "statusCode": status_code,
        "headers": {
            "Content-Type": "application/json",
            "Access-Control-Allow-Origin": "*",
            "Access-Control-Allow-Headers": "*",
            "Access-Control-Allow-Methods": "POST,OPTIONS"
        },
        "body": json.dumps(body, ensure_ascii=False)
    }

def extract_pdf_text(pdf_bytes):
    reader = PdfReader(io.BytesIO(pdf_bytes))
    text = ""

    for page in reader.pages:
        page_text = page.extract_text()
        if page_text:
            text += page_text + "\n"

    return text

def lambda_handler(event, context):

    try:

        http_method = event.get(
            "requestContext", {}
        ).get(
            "http", {}
        ).get(
            "method", ""
        )

        if http_method == "OPTIONS":
            return response(200, {"success": True})

        headers = event.get("headers", {}) or {}

        query = (
            headers.get("x-query")
            or headers.get("X-Query")
        )

        body = event.get("body")

        if not body:
            return response(400, {
                "success": False,
                "error": "Request body is empty"
            })

        context_type = (
            headers.get("x-context-type")
            or headers.get("X-Context-Type")
            or "none"
        )

        if context_type == "text":

            request = json.loads(body)
            query = request.get("query")
            context_text = request.get("context", "")

        elif context_type == "none":

            request = json.loads(body)
            query = request.get("query")
            context_text = ""

        elif context_type == "pdf":

            if not query:
                return response(400, {
                    "success": False,
                    "error": "x-query header is required"
                })

            if event.get("isBase64Encoded", False):
                pdf_bytes = base64.b64decode(body)
            else:
                pdf_bytes = body.encode("latin1")

            context_text = extract_pdf_text(pdf_bytes)

        else:

            return response(400, {
                "success": False,
                "error": "Invalid context type"
            })

        if not query:
            return response(400, {
                "success": False,
                "error": "Query is required"
            })

        if context_text:

            prompt = (
                "You are an enterprise AI assistant.\n\n"
                "Answer the user's request using the supplied context.\n\n"
                "IMPORTANT:\n"
                "- Use the context as the primary source.\n"
                "- Do not invent information that is not present.\n"
                "- If the requested information cannot be found, "
                "clearly say that it is not available in the supplied context.\n\n"
                "CONTEXT:\n"
                "-------------------------\n"
                f"{context_text}\n"
                "-------------------------\n\n"
                "USER REQUEST:\n"
                f"{query}\n\n"
                "Provide a clear and useful response."
            )

        else:

            prompt = (
                "You are an enterprise AI assistant.\n\n"
                "USER REQUEST:\n"
                f"{query}\n\n"
                "Provide a clear, accurate and useful response."
            )

        result = bedrock.converse(
            modelId=MODEL_ID,
            messages=[
                {
                    "role": "user",
                    "content": [
                        {"text": prompt}
                    ]
                }
            ],
            inferenceConfig={
                "maxTokens": 2000,
                "temperature": 0.2
            }
        )

        answer = (
            result["output"]
            ["message"]
            ["content"][0]
            ["text"]
        )

        return response(200, {
            "success": True,
            "query": query,
            "contextType": context_type,
            "answer": answer
        })

    except Exception as e:

        print("ERROR:", str(e))

        return response(500, {
            "success": False,
            "error": str(e)
        })

6. How the Lambda Decision Works

For no context:

if context_type == "none":

Only the user prompt is sent.

For text:

context_type == "text"

Lambda combines:

context + query

For PDF:

context_type == "pdf"

The flow is:

PDF
 ↓
Binary/Base64 payload
 ↓
pypdf
 ↓
Extracted text
 ↓
Prompt
 ↓
Amazon Nova Micro

7. Calling Amazon Nova Micro

The Lambda uses the AWS SDK for Python:

import boto3

The Bedrock Runtime client is created with:

bedrock = boto3.client(
    "bedrock-runtime",
    region_name="us-east-1"
)

The model ID is:

MODEL_ID = "amazon.nova-micro-v1:0"

The request is sent through:

bedrock.converse()

The Converse API provides a consistent message-based interface for supported Bedrock models.

8. HTML Request Patterns

Prompt only

fetch(API_URL, {
    method: "POST",
    headers: {
        "Content-Type": "application/json",
        "x-context-type": "none"
    },
    body: JSON.stringify({
        query: prompt
    })
});

Prompt + text

fetch(API_URL, {
    method: "POST",
    headers: {
        "Content-Type": "application/json",
        "x-context-type": "text"
    },
    body: JSON.stringify({
        query: prompt,
        context: context
    })
});

Prompt + PDF

fetch(API_URL, {
    method: "POST",
    headers: {
        "Content-Type": "application/pdf",
        "x-context-type": "pdf",
        "x-query": prompt
    },
    body: pdfBytes
});

9. Example: Email Summarization

Context:

Hi John,

The project deployment has been delayed because
the security review is still pending.

We expect the deployment to happen next Friday.

Regards,
David

Prompt:

Summarize this email in three bullet points.

Possible response:

• Project deployment has been delayed.
• Security review is still pending.
• Deployment is expected next Friday.

10. Example: PDF Question Answering

Suppose the user uploads an insurance claim PDF.

Prompt:

What is the claim number and approved amount?

Example response:

The claim number is CLM-2026-004817,
and the approved amount is ₹72,500.

11. API Response

{
  "success": true,
  "query": "What is the approved amount?",
  "contextType": "pdf",
  "answer": "The approved amount is ₹72,500."
}

The frontend reads data.answer and displays the response.

12. CORS

During development, the Lambda response includes:

Access-Control-Allow-Origin: *
Access-Control-Allow-Headers: *
Access-Control-Allow-Methods: POST, OPTIONS

For production, replace * with the specific application origin.

13. Lambda Layer for PDF Processing

The Lambda uses:

from pypdf import PdfReader

The pypdf package can be provided through a Lambda Layer:

pypdf-layer.zip

└── python/
    ├── pypdf/
    └── pypdf-*.dist-info/

14. Testing the API Before the UI

Prompt only

curl -X POST \
"https://YOUR_API_ID.execute-api.us-east-1.amazonaws.com/llm" \
-H "Content-Type: application/json" \
-H "x-context-type: none" \
-d '{"query":"What is Amazon Bedrock?"}'

Text context

curl -X POST \
"https://YOUR_API_ID.execute-api.us-east-1.amazonaws.com/llm" \
-H "Content-Type: application/json" \
-H "x-context-type: text" \
-d '{
  "context":"The project deployment is scheduled for next Friday.",
  "query":"When is the project deployment scheduled?"
}'

PDF

curl -X POST \
"https://YOUR_API_ID.execute-api.us-east-1.amazonaws.com/llm" \
-H "Content-Type: application/pdf" \
-H "x-context-type: pdf" \
-H "x-query: What is the claim number and approved amount?" \
--data-binary "@sample_claim.pdf"

15. End-to-End Request Flow

User enters prompt + uploads PDF
              |
              v
          HTML / JS
              |
              v
       API Gateway POST /llm
              |
              v
            Lambda
              |
              v
       Identify PDF context
              |
              v
        Extract PDF text
              |
              v
          Build prompt
              |
              v
      Bedrock Converse API
              |
              v
        Amazon Nova Micro
              |
              v
       Extract model answer
              |
              v
         JSON response
              |
              v
          HTML displays

16. Current Architecture vs Future Architecture

Current architecture:

HTML
 |
API Gateway
 |
Lambda
 |
PDF text extraction
 |
Nova Micro

This is suitable for small PDFs, emails, short documents, document Q&A, summarization, rewriting, classification and information extraction.

17. Future S3 + RAG Architecture

                  +----------------+
                  |   Web UI       |
                  +-------+--------+
                          |
                          v
                  +----------------+
                  | API Gateway    |
                  +-------+--------+
                          |
                          v
                  +----------------+
                  | Lambda         |
                  +-------+--------+
                          |
             +------------+-------------+
             |                          |
             v                          v
       +-----------+             +-------------+
       | Amazon S3 |             | User Query  |
       | Documents |             +------+------+
       +-----+-----+                    |
             |                          |
             v                          v
       +----------------+       +----------------+
       | Knowledge Base |<------| Semantic Search|
       | / RAG          |       +----------------+
       +-------+--------+
               |
               v
       Relevant document chunks
               |
               v
       +----------------+
       | Amazon Nova    |
       | Micro          |
       +-------+--------+
               |
               v
            Response

Instead of sending an entire document to the model, the application retrieves only the relevant pieces.

18. Security Considerations

The proof of concept uses:

Access-Control-Allow-Origin: *

For production, consider:

• Authentication
• Authorization
• Restricted CORS origins
• API throttling
• Input validation
• File size limits
• File type validation
• CloudWatch monitoring
• IAM least-privilege policies
• Encryption
• Audit logging
• Prompt-injection protection
• Sensitive-data handling policies

19. Key Learning

An LLM application is not simply:

Prompt → LLM

A production-oriented application looks more like:

User
 |
 v
Frontend
 |
 v
API
 |
 v
Application Logic
 |
 +---- Context processing
 +---- Validation
 +---- Prompt construction
 +---- Model orchestration
 |
 v
LLM
 |
 v
Response processing
 |
 v
User

The LLM is one component of the application. The surrounding architecture turns the model into a usable product.

20. Conclusion

We built an enterprise-style LLM assistant using AWS managed services.

The application supports:

• Direct LLM questions
• Text and email context
• PDF-based question answering
• A simple browser interface
• API-based integration
• Serverless backend processing
• Amazon Bedrock
• Amazon Nova Micro

The next step is to evolve the application into a more enterprise-ready GenAI platform using S3, RAG, vector search, conversation history, authentication, guardrails, observability, streaming responses, multi-model support and agentic workflows.

This provides a path from a simple LLM proof of concept to a production-grade enterprise GenAI application.

References

• Amazon Bedrock Converse API
• Boto3 Bedrock Runtime converse API
• Amazon Nova documentation
• AWS Lambda documentation
• Amazon API Gateway documentation