Amazon S3 から PDF テキストを抽出するインタラクティブな仕組みの構築

Picture this: a compliance officer needs a specific clause during an audit, an attorney needs contract terms while a client waits on the phone, or a finance analyst needs numbers from last quarter’s report before a meeting that starts in 10 minutes. In each case, waiting for a scheduled job to finish is not practical. You need on-demand access to the text inside your PDFs.

In this post, you’ll build a server that extracts text from PDF files in Amazon S3 in real time. This protocol-based approach provides programmatic document access. You’ll walk through the architecture, set up the server, and run interactive document queries. Along the way, you’ll compare this approach with Amazon Textract so you can decide which tool fits your workload.

We built this solution after working with several teams who shared the same frustration: their documents lived in Amazon S3, but getting text out of them on demand meant either writing custom scripts or waiting on batch pipelines. This MCP server approach sits in between, giving you interactive access with minimal setup. Interactive PDF text extraction from Amazon S3 gives you real-time answers from your documents without batch pipelines or heavy infrastructure.

This MCP-based option works well for text-based PDFs in development and proof of concept settings. For complex document processing like optical character recognition (OCR), form extraction, and layout analysis, Amazon Textract remains the recommended choice.

Who benefits from this approach

This solution fits several common roles. If these scenarios sound like your day-to-day, read on.

Compliance and legal teams: During a time-sensitive review, you need to locate a specific clause buried in a 200-page policy document or contract. Searching manually takes too long. With this solution, you ask a question in natural language and get the relevant passage back in seconds.

Financial services teams: During an audit session, you need immediate access to the exact wording of an internal risk policy or regulatory filing. This solution lets you pull that information directly from your Amazon S3 document repository without leaving your terminal.

Executive teams: During strategic planning meetings, you can query a PDF on the spot when someone asks about a data point from last quarter’s earnings report. No flipping through printed copies or waiting for someone to look it up after the meeting.

These scenarios share a few common traits: they involve real-time information needs where batch processing is too slow, text-based PDF documents with standard formatting, cost sensitivity in development and proof of concept environments, and integration requirements with existing AWS workflows and tooling.

Where this approach fits alongside Amazon Textract

Amazon Textract is a fully managed AWS AI service purpose-built for document processing at scale. It handles scanned pages, handwriting, and multi-column layouts. Choose Amazon Textract when you need OCR for scanned documents, advanced form and table extraction, complex layout analysis, production-scale batch processing with service level agreement (SLA) requirements, or compliance features and enterprise support.

The MCP-based approach addresses a complementary scenario: giving an AI assistant interactive, on-demand access to text already encoded inside PDFs. Choose this pattern when your documents are text-based PDFs (no OCR required), your workflow is interactive rather than batch, you are working in development or proof of concept environments, and you want minimal infrastructure between the AI assistant and the source document. For everything else, including any document processing that benefits from OCR or structured extraction, route the work to Amazon Textract.

How the solution works

With this solution, you connect your AI assistant directly to your PDF documents in Amazon S3 and can get answers quickly. Under the hood, the solution uses the Model Context Protocol (MCP), an open standard that provides a structured way to access external data sources. MCP acts as a communication layer between your application and your data. The architecture has four components: a command-line interface as the user interface, the MCP layer for communication, a custom MCP server for PDF processing, and Amazon S3 for document storage, secured by AWS Identity and Access Management (AWS IAM).

Cost comparison

Choose the approach that fits your budget and requirements. For approximately 10,000 text-based PDF pages per month in a proof of concept environment, here is how the two approaches compare:

These two figures are price points for different feature sets and should not be read as a head-to-head price comparison. Use them to pick the right tool for the workload, not to optimize purely on dollars. If your workload involves scanned documents, forms, tables, complex layouts, or production SLAs, Amazon Textract is the appropriate choice and the additional capabilities are reflected in its price.

Amazon Textract scope: page-level processing, OCR-ready, form and table extraction, layout understanding, enterprise SLAs

Indicative monthly cost: Amazon Textract processing approximately $15, Amazon S3 storage $2, AWS Lambda compute $1, and large language model (LLM) token processing approximately $5 to $10, for a total of approximately $23 to $28.

MCP server scope: direct text extraction from PDFs whose text is already encoded; no managed processing service involved

Indicative monthly cost: Amazon S3 storage $2 and data transfer $0.50, for a total of approximately $2.50.

*All cost figures are illustrative and may change. Refer to the official AWS pricing pages for current rates.*

Architecture overview

The following sequence diagram illustrates the end-to-end workflow for extracting text from a PDF stored in Amazon S3. The process begins when the AI client initiates a request for PDF extraction through the CLI. The system forwards this request to the MCP server, which retrieves the PDF file from Amazon S3 using the provided bucket and object key.

After the MCP server fetches the PDF, it passes the file to a PDF parsing component. The component processes the document and extracts the textual content. The MCP server then returns the extracted text to the client, and the client displays it to the user.

Step-by-step implementation

Follow these steps to set up and configure the PDF text extraction solution. Begin by confirming you have the required prerequisites in place.

Prerequisites

Before you begin, confirm that you have the following items ready. You’ll also need basic familiarity with Python programming and AWS services.

• An AWS account with Amazon S3 read permissions.

• Python 3.10 or later installed.

• AWS Command Line Interface (AWS CLI) configured with valid credentials.

• Kiro CLI installed.

• `

pip install boto3 PyPDF2 mcp

### Installation

This section guides you through installing the MCP server and its dependencies. The process involves creating a Python virtual environment, installing the required packages, and creating the server file. Follow these steps in order. Run each command in your terminal.

**Before you start, you need:**

- Python 3.10 or newer installed on your machine.

- The Kiro CLI installed and logged in.

- AWS credentials set up on your machine (run aws configure if you haven’t).

- An S3 bucket that contains at least one PDF file.

**Step 1 — Create a folder for the project**

Run these two commands in your terminal:

mkdir ~/s3-pdf-extractor

**Step 2 — Navigate to the project folder**

Run this command:

cd ~/s3-pdf-extractor

**Step 3 — Create a Python virtual environment**

Run this command:

python3 -m venv venv

**Step 4 — Activate the virtual environment**

Run this command:

source venv/bin/activate

After this, your terminal prompt will show `(venv)` at the start. Keep this terminal open. You need to stay in this virtual environment for the next steps.

**Step 5 — Install the required Python packages**

Run this one command:

pip install mcp boto3 PyPDF2

Wait for it to finish. It should end with “Successfully installed…”.

**Step 6 — Create the server file**

Inside the `~/s3-pdf-extractor` folder, create a new file named **exactly:**

s3_pdf_extractor.py

Paste the following code into that file and save it:

**Step 7 — Test that the server starts**

In your terminal (still inside the `s3-pdf-extractor` folder with the venv active), run:

python s3_pdf_extractor.py

The terminal will appear to “pause” with no output. That is correct. It means the server is running and waiting for requests. Press `Ctrl+C` to stop it.

If you see an error instead, re-check Steps 2 and 3.

from mcp.server import Server
from mcp.types import Tool, TextContent
import boto3
from PyPDF2 import PdfReader
import tempfile
import os
import logging

# Configure logging for production use
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

server = Server("s3-pdf-extractor")

@server.list_tools()
async def list_tools():
return [
Tool(
name="extract_s3_pdf_text",
description="Extract text content from a PDF stored in Amazon S3",
inputSchema={
"type": "object",
"properties": {
"bucket": {"type": "string", "description": "S3 bucket name"},
"key": {"type": "string", "description": "S3 object key"}
},
"required": ["bucket", "key"]
}
)
]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
if name == "extract_s3_pdf_text":
bucket = arguments["bucket"]
key = arguments["key"]

try:
# Use existing AWS credentials and IAM permissions
s3_client = boto3.client('s3')

with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
s3_client.download_file(bucket, key, tmp_file.name)
tmp_path = tmp_file.name

# Extract text using PyPDF2
reader = PdfReader(tmp_path)
text = ""
for page in reader.pages:
text += page.extract_text()