FROM python:3.10-slim-bookworm

ENV PYTHONDONTWRITEBYTECODE=1

ENV PYTHONUNBUFFERED=1

WORKDIR /app

RUN apt-get update \

&& apt-get install -y --no-install-recommends libglib2.0-0 libgomp1 \

&& rm -rf /var/lib/apt/lists/*

COPY requirements.txt .

RUN pip install --no-cache-dir --upgrade pip \

&& pip install --no-cache-dir -r requirements.txt \

&& pip uninstall -y opencv-python \

&& pip install --no-cache-dir opencv-python-headless

COPY app.py .

EXPOSE 8001

CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8001"]

This service provides the OCR endpoint used by the `local_file` tool.

- `GET /health`

- `POST /ocr/pdf`

- `multipart/form-data`

- file field: `file`

- response: `{"text":"recognized text"}`

When an active store enables the `local_file` tool and the tool Provider URL is empty, OpenAgent warms up the managed OCR service in the background during startup. If the first `local_pdf_ocr_read` call arrives before warmup finishes, that call waits for the same managed OCR startup instead of starting a second service.

The managed Python environment is created under:

If the `local_file` tool Provider URL is empty, OpenAgent uses the managed endpoint by default:

Python 3.10+ must already be installed on the machine. OpenAgent installs the Python package dependencies into the managed virtual environment during the first managed OCR startup or background warmup.

From the OpenAgent repository root:

docker compose -f docker-compose.ocr.yml up --build

To force OpenAgent to use the Docker service instead of the managed service, set the `local_file` tool Provider URL to:

curl http://127.0.0.1:8001/health

curl -F "file=@/absolute/path/to/scanned.pdf" http://127.0.0.1:8001/ocr/pdf

import os

import tempfile

from threading import Lock

import pypdfium2 as pdfium

from fastapi import FastAPI, File, HTTPException, UploadFile

from rapidocr import RapidOCR

app = FastAPI(title="OpenAgent OCR Service")

ocr_engine = RapidOCR()

ocr_lock = Lock()

def health():

return {"status": "ok"}

async def ocr_pdf(file: UploadFile = File(...)):

content = await file.read()

if not content.startswith(b"%PDF"):

raise HTTPException(status_code=400, detail="file must be a PDF")

try:

text = read_pdf_text(content)

except Exception as err:

raise HTTPException(status_code=500, detail=f"failed to OCR PDF: {err}") from err

return {"text": text}

def read_pdf_text(content: bytes) -> str:

temp_path = write_temp_pdf(content)

try:

pdf = pdfium.PdfDocument(temp_path)

try:

page_texts = [read_page_text(pdf[index], index + 1) for index in range(len(pdf))]

finally:

pdf.close()

finally:

os.remove(temp_path)

return "\n\n".join(text for text in page_texts if text)

def write_temp_pdf(content: bytes) -> str:

with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as temp_file:

temp_file.write(content)

return temp_file.name

def read_page_text(page, page_number: int) -> str:

try:

bitmap = page.render(scale=2.0)

try:

image = bitmap.to_pil().convert("RGB")

finally:

bitmap.close()

finally:

page.close()

with ocr_lock:

result = ocr_engine(image)

if result is None or result.txts is None:

return ""

text = "\n".join(item for item in result.txts if item)

if text == "":

return ""

return f"Page {page_number}\n{text}"

uvicorn[standard]

services:

openagent-ocr:

restart: unless-stopped

build:

context: ./deploy/ocr-service

dockerfile: Dockerfile

ports:

- "8001:8001"

var _embeddedOcrService embed.FS

ocrServiceFS, _ := fs.Sub(_embeddedOcrService, "deploy/ocr-service")

embedsupport.Setup(confFS, webFS, skillsFS, ocrServiceFS)

webFS fs.FS

skillsFS fs.FS

ocrServiceFS fs.FS

func Setup(conf, web, skills, ocrService fs.FS) {

ocrServiceFS = ocrService

func OcrServiceFS() fs.FS { return ocrServiceFS }