Summarize Documents Locally: PDF, Word, Excel & PowerPoint

Published on April 11, 2026 · 24 min read

Last month a lawyer asked me to build a summarization tool for case files. The catch: nothing could leave the firm's network. Not a single byte. No ChatGPT, no Claude API, no cloud anything.

So I built a local pipeline with Ollama and about 200 lines of Python. It processes PDF, Word, Excel, and PowerPoint files, chunks them intelligently, and produces structured summaries — entirely offline.

This article is that pipeline, cleaned up and documented. You can have it running in 15 minutes.

---

Why Summarize Documents Locally {#why-summarize-documents-locally}

Three reasons, in order of importance:

1. Confidentiality. Financial reports, medical records, legal briefs, HR documents, M&A due diligence. These cannot go to a third-party API. Period. When you paste a confidential document into ChatGPT, OpenAI's servers process it. When you use the API, it still traverses the internet. Local inference means the data never leaves your machine.

2. Cost. Summarizing a 100-page document with GPT-4o costs roughly $0.30-0.50 per document (depending on output length). That adds up fast for firms processing hundreds of documents daily. Local inference costs nothing per document after the hardware investment.

3. Speed and availability. No rate limits, no API outages, no internet requirement. Process documents on a plane, in a SCIF, or in a data center with no internet access.

---

Pipeline Architecture {#pipeline-architecture}

  ┌──────────────────────────────────────────────────┐
  │                 Input Documents                   │
  │  .pdf  .docx  .xlsx  .pptx  .txt  .csv  .md     │
  └─────────────────────┬────────────────────────────┘
                        │
                        ▼
  ┌──────────────────────────────────────────────────┐
  │            Text Extraction Layer                  │
  │                                                  │
  │  PDF → PyMuPDF (fitz)                            │
  │  DOCX → python-docx                              │
  │  XLSX → openpyxl                                 │
  │  PPTX → python-pptx                              │
  │  TXT/CSV/MD → built-in open()                    │
  └─────────────────────┬────────────────────────────┘
                        │
                        ▼
  ┌──────────────────────────────────────────────────┐
  │           Recursive Text Splitter                 │
  │                                                  │
  │  Chunk size: 500 tokens                          │
  │  Overlap: 50 tokens                              │
  │  Split on: paragraphs → sentences → words        │
  └─────────────────────┬────────────────────────────┘
                        │
                        ▼
  ┌──────────────────────────────────────────────────┐
  │         Summarization Strategy                    │
  │                                                  │
  │  < 5 chunks  → Stuff (single pass)               │
  │  5-50 chunks → Map-Reduce (parallel + combine)   │
  │  50+ chunks  → Map-Reduce with hierarchical      │
  │                reduce (multiple levels)           │
  └─────────────────────┬────────────────────────────┘
                        │
                        ▼
  ┌──────────────────────────────────────────────────┐
  │              Ollama Inference                      │
  │                                                  │
  │  Model: Llama 3.3 70B / Qwen 2.5 14B            │
  │  API: http://localhost:11434                      │
  └─────────────────────┬────────────────────────────┘
                        │
                        ▼
  ┌──────────────────────────────────────────────────┐
  │              Output Formatter                     │
  │                                                  │
  │  → Markdown summary                              │
  │  → Key points extraction                         │
  │  → Executive brief (1 paragraph)                 │
  └──────────────────────────────────────────────────┘

---

Setup and Dependencies {#setup-and-dependencies}

Install Ollama and Pull a Model

# Install Ollama (if not already installed)
curl -fsSL https://ollama.com/install.sh | sh

# Pull your summarization model
# For best quality (needs 42GB VRAM):
ollama pull llama3.3:70b-instruct-q4_K_M

# For good quality on consumer GPUs (needs 10GB VRAM):
ollama pull qwen2.5:14b

# For speed on 8GB GPUs:
ollama pull llama3.2

# Verify Ollama is running
curl http://localhost:11434/api/tags

Install Python Dependencies

# Create a virtual environment
python3 -m venv summarizer-env
source summarizer-env/bin/activate

# Install all document loaders and the Ollama client
pip install pymupdf python-docx openpyxl python-pptx requests tqdm

Package versions tested: PyMuPDF 1.25.1, python-docx 1.1.2, openpyxl 3.1.5, python-pptx 1.0.2.

PyMuPDF is the fastest Python PDF library — it extracts text from a 200-page PDF in under 1 second, compared to 10-30 seconds with alternatives like pdfminer.

---

Text Extraction: Every Format {#text-extraction-every-format}

PDF Extraction (PyMuPDF)

import fitz  # PyMuPDF

def extract_pdf(file_path: str) -> str:
    """Extract all text from a PDF file, page by page."""
    doc = fitz.open(file_path)
    text_parts = []

    for page_num, page in enumerate(doc):
        text = page.get_text("text")
        if text.strip():
            text_parts.append(f"--- Page {page_num + 1} ---\n{text}")

    doc.close()
    return "\n\n".join(text_parts)

Word DOCX Extraction

from docx import Document

def extract_docx(file_path: str) -> str:
    """Extract text from a Word document, preserving paragraph structure."""
    doc = Document(file_path)
    paragraphs = []

    for para in doc.paragraphs:
        if para.text.strip():
            # Preserve heading structure
            if para.style.name.startswith("Heading"):
                level = para.style.name.replace("Heading ", "")
                paragraphs.append(f"{'#' * int(level)} {para.text}")
            else:
                paragraphs.append(para.text)

    # Also extract from tables
    for table in doc.tables:
        for row in table.rows:
            row_text = " | ".join(cell.text.strip() for cell in row.cells)
            if row_text.strip(" |"):
                paragraphs.append(row_text)

    return "\n\n".join(paragraphs)

Excel XLSX Extraction

from openpyxl import load_workbook

def extract_xlsx(file_path: str) -> str:
    """Extract all data from an Excel workbook, sheet by sheet."""
    wb = load_workbook(file_path, data_only=True)
    sections = []

    for sheet_name in wb.sheetnames:
        ws = wb[sheet_name]
        rows = list(ws.iter_rows(values_only=True))

        if not rows:
            continue

        section = f"## Sheet: {sheet_name}\n"

        # First row as headers
        headers = [str(h) if h else "" for h in rows[0]]
        section += " | ".join(headers) + "\n"
        section += " | ".join(["---"] * len(headers)) + "\n"

        # Data rows
        for row in rows[1:]:
            values = [str(v) if v is not None else "" for v in row]
            section += " | ".join(values) + "\n"

        sections.append(section)

    wb.close()
    return "\n\n".join(sections)

PowerPoint PPTX Extraction

from pptx import Presentation

def extract_pptx(file_path: str) -> str:
    """Extract text from all slides including speaker notes."""
    prs = Presentation(file_path)
    slides_text = []

    for slide_num, slide in enumerate(prs.slides, 1):
        parts = [f"--- Slide {slide_num} ---"]

        for shape in slide.shapes:
            if shape.has_text_frame:
                for paragraph in shape.text_frame.paragraphs:
                    text = paragraph.text.strip()
                    if text:
                        parts.append(text)

        # Speaker notes often contain important context
        if slide.has_notes_slide:
            notes = slide.notes_slide.notes_text_frame.text.strip()
            if notes:
                parts.append(f"[Speaker Notes: {notes}]")

        slides_text.append("\n".join(parts))

    return "\n\n".join(slides_text)

Universal Extractor

from pathlib import Path

def extract_text(file_path: str) -> str:
    """Extract text from any supported file type."""
    suffix = Path(file_path).suffix.lower()

    extractors = {
        ".pdf": extract_pdf,
        ".docx": extract_docx,
        ".xlsx": extract_xlsx,
        ".pptx": extract_pptx,
        ".txt": lambda f: Path(f).read_text(encoding="utf-8"),
        ".md": lambda f: Path(f).read_text(encoding="utf-8"),
        ".csv": lambda f: Path(f).read_text(encoding="utf-8"),
    }

    extractor = extractors.get(suffix)
    if not extractor:
        raise ValueError(f"Unsupported file type: {suffix}")

    return extractor(file_path)

---

Chunking Strategy {#chunking-strategy}

Local models have limited context windows. Even models that support 32K tokens perform best with focused input. Chunking splits long documents into digestible pieces.

Recursive Text Splitter

def chunk_text(text: str, chunk_size: int = 500, overlap: int = 50) -> list[str]:
    """
    Split text into chunks of approximately chunk_size tokens.
    Uses word count as a proxy (1 token ≈ 0.75 words).
    Overlap ensures context is not lost at chunk boundaries.
    """
    words = text.split()
    # Convert token target to word count (tokens are ~0.75 words)
    word_chunk_size = int(chunk_size * 0.75)
    word_overlap = int(overlap * 0.75)

    chunks = []
    start = 0

    while start < len(words):
        end = start + word_chunk_size
        chunk = " ".join(words[start:end])

        # Try to break at a sentence boundary
        if end < len(words):
            last_period = chunk.rfind(". ")
            last_newline = chunk.rfind("\n")
            break_point = max(last_period, last_newline)

            if break_point > len(chunk) * 0.5:  # Only if past halfway
                chunk = chunk[:break_point + 1]
                # Adjust next start based on actual chunk length
                actual_words = len(chunk.split())
                start = start + actual_words - word_overlap
            else:
                start = end - word_overlap
        else:
            start = end

        if chunk.strip():
            chunks.append(chunk.strip())

    return chunks

Why 500 tokens? Through testing across dozens of document types, 500-token chunks produce the best balance of context retention and summary quality. Smaller chunks (250 tokens) lose too much context. Larger chunks (1,000 tokens) reduce summary quality because the model has to compress more information.

Why 50-token overlap? The overlap ensures that sentences split across chunk boundaries are captured in at least one chunk. Without overlap, you lose information at every boundary.

---

Summarization Approaches {#summarization-approaches}

Approach 1: Stuff (Small Documents)

Concatenate everything into one prompt. Only works when total text fits within the model's context window.

import requests
import json

def summarize_stuff(text: str, model: str = "qwen2.5:14b") -> str:
    """Single-pass summarization for short documents."""
    prompt = f"""Summarize the following document. Provide:
1. A one-paragraph executive summary
2. 5-10 key points as bullet points
3. Any action items or recommendations

Document:
{text}

Summary:"""

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False},
        timeout=300
    )
    return response.json()["response"]

Approach 2: Map-Reduce (Large Documents)

Summarize each chunk independently, then combine the summaries.

def summarize_map_reduce(chunks: list[str], model: str = "qwen2.5:14b") -> str:
    """Map-reduce summarization for large documents."""

    # MAP PHASE: Summarize each chunk
    chunk_summaries = []
    for i, chunk in enumerate(chunks):
        prompt = f"""Summarize this section of a larger document in 2-3 sentences.
Capture the key facts, numbers, and conclusions.
This is section {i + 1} of {len(chunks)}.

Text:
{chunk}

Summary:"""

        response = requests.post(
            "http://localhost:11434/api/generate",
            json={"model": model, "prompt": prompt, "stream": False},
            timeout=120
        )
        summary = response.json()["response"].strip()
        chunk_summaries.append(summary)
        print(f"  Mapped chunk {i + 1}/{len(chunks)}")

    # REDUCE PHASE: Combine chunk summaries into final summary
    combined = "\n\n".join(
        f"Section {i+1}: {s}" for i, s in enumerate(chunk_summaries)
    )

    reduce_prompt = f"""Below are summaries of consecutive sections from one document.
Synthesize them into a single, coherent summary with:
1. An executive summary (one paragraph)
2. Key findings (bullet points)
3. Notable data points or numbers mentioned
4. Recommendations or action items (if any)

Section summaries:
{combined}

Final Summary:"""

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": reduce_prompt, "stream": False},
        timeout=300
    )
    return response.json()["response"]

Approach 3: Refine (Highest Quality)

Build the summary iteratively by refining it with each new chunk.

def summarize_refine(chunks: list[str], model: str = "qwen2.5:14b") -> str:
    """Iterative refinement for highest quality summaries. Slower but more coherent."""

    # Start with the first chunk
    prompt = f"""Summarize this document section:

{chunks[0]}

Summary:"""

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False},
        timeout=120
    )
    running_summary = response.json()["response"].strip()
    print(f"  Initial summary from chunk 1/{len(chunks)}")

    # Refine with each subsequent chunk
    for i, chunk in enumerate(chunks[1:], 2):
        refine_prompt = f"""Here is an existing summary of a document:

{running_summary}

New information from the next section:

{chunk}

Produce an updated summary that incorporates the new information.
Keep the summary concise but comprehensive. Do not drop important
details from the existing summary.

Updated Summary:"""

        response = requests.post(
            "http://localhost:11434/api/generate",
            json={"model": model, "prompt": refine_prompt, "stream": False},
            timeout=120
        )
        running_summary = response.json()["response"].strip()
        print(f"  Refined with chunk {i}/{len(chunks)}")

    return running_summary

---

The Complete Summarizer Script {#the-complete-summarizer-script}

Here is the full pipeline, combining extraction, chunking, and summarization into one callable script.

#!/usr/bin/env python3
"""
local_summarizer.py — Summarize any document locally with Ollama.
Supports: PDF, DOCX, XLSX, PPTX, TXT, CSV, MD

Usage:
    python local_summarizer.py document.pdf
    python local_summarizer.py document.pdf --model llama3.3:70b-instruct-q4_K_M
    python local_summarizer.py document.pdf --strategy refine
    python local_summarizer.py ./reports/ --batch
"""

import argparse
import sys
import json
import time
from pathlib import Path
from datetime import datetime

import fitz  # PyMuPDF
from docx import Document
from openpyxl import load_workbook
from pptx import Presentation
import requests

# --- Text Extraction (all format functions from above) ---

def extract_pdf(file_path: str) -> str:
    doc = fitz.open(file_path)
    parts = []
    for i, page in enumerate(doc):
        text = page.get_text("text")
        if text.strip():
            parts.append(f"--- Page {i + 1} ---\n{text}")
    doc.close()
    return "\n\n".join(parts)

def extract_docx(file_path: str) -> str:
    doc = Document(file_path)
    paragraphs = []
    for para in doc.paragraphs:
        if para.text.strip():
            paragraphs.append(para.text)
    for table in doc.tables:
        for row in table.rows:
            row_text = " | ".join(cell.text.strip() for cell in row.cells)
            if row_text.strip(" |"):
                paragraphs.append(row_text)
    return "\n\n".join(paragraphs)

def extract_xlsx(file_path: str) -> str:
    wb = load_workbook(file_path, data_only=True)
    sections = []
    for name in wb.sheetnames:
        ws = wb[name]
        rows = list(ws.iter_rows(values_only=True))
        if not rows:
            continue
        lines = [f"## Sheet: {name}"]
        for row in rows:
            lines.append(" | ".join(str(v) if v else "" for v in row))
        sections.append("\n".join(lines))
    wb.close()
    return "\n\n".join(sections)

def extract_pptx(file_path: str) -> str:
    prs = Presentation(file_path)
    slides = []
    for i, slide in enumerate(prs.slides, 1):
        parts = [f"--- Slide {i} ---"]
        for shape in slide.shapes:
            if shape.has_text_frame:
                for p in shape.text_frame.paragraphs:
                    if p.text.strip():
                        parts.append(p.text.strip())
        if slide.has_notes_slide:
            notes = slide.notes_slide.notes_text_frame.text.strip()
            if notes:
                parts.append(f"[Notes: {notes}]")
        slides.append("\n".join(parts))
    return "\n\n".join(slides)

def extract_text(file_path: str) -> str:
    suffix = Path(file_path).suffix.lower()
    extractors = {
        ".pdf": extract_pdf,
        ".docx": extract_docx,
        ".xlsx": extract_xlsx,
        ".pptx": extract_pptx,
        ".txt": lambda f: Path(f).read_text(encoding="utf-8"),
        ".md": lambda f: Path(f).read_text(encoding="utf-8"),
        ".csv": lambda f: Path(f).read_text(encoding="utf-8"),
    }
    extractor = extractors.get(suffix)
    if not extractor:
        raise ValueError(f"Unsupported: {suffix}")
    return extractor(file_path)

# --- Chunking ---

def chunk_text(text: str, chunk_size: int = 500, overlap: int = 50) -> list:
    words = text.split()
    wcs = int(chunk_size * 0.75)
    wov = int(overlap * 0.75)
    chunks, start = [], 0
    while start < len(words):
        end = start + wcs
        chunk = " ".join(words[start:end])
        if end < len(words):
            bp = max(chunk.rfind(". "), chunk.rfind("\n"))
            if bp > len(chunk) * 0.5:
                chunk = chunk[:bp + 1]
                start = start + len(chunk.split()) - wov
            else:
                start = end - wov
        else:
            start = end
        if chunk.strip():
            chunks.append(chunk.strip())
    return chunks

# --- Ollama Inference ---

def ollama_generate(prompt: str, model: str) -> str:
    resp = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False},
        timeout=300
    )
    resp.raise_for_status()
    return resp.json()["response"].strip()

# --- Summarization ---

def summarize(text: str, model: str, strategy: str) -> str:
    chunks = chunk_text(text)
    total_words = len(text.split())
    print(f"  Document: {total_words:,} words, {len(chunks)} chunks")

    if len(chunks) <= 5 or strategy == "stuff":
        print("  Strategy: stuff (single pass)")
        prompt = f"""Summarize this document with:
1. Executive summary (one paragraph)
2. Key points (bullet list)
3. Action items (if any)

Document:
{text[:12000]}

Summary:"""
        return ollama_generate(prompt, model)

    elif strategy == "refine":
        print("  Strategy: refine (iterative)")
        summary = ollama_generate(
            f"Summarize this section:\n\n{chunks[0]}\n\nSummary:", model
        )
        for i, chunk in enumerate(chunks[1:], 2):
            prompt = f"""Existing summary:\n{summary}\n\nNew section:\n{chunk}\n
Update the summary to incorporate new information. Keep it concise.\n\nUpdated Summary:"""
            summary = ollama_generate(prompt, model)
            print(f"  Refined {i}/{len(chunks)}")
        return summary

    else:  # map-reduce (default)
        print("  Strategy: map-reduce")
        chunk_sums = []
        for i, chunk in enumerate(chunks):
            prompt = f"Summarize in 2-3 sentences (section {i+1}/{len(chunks)}):\n\n{chunk}\n\nSummary:"
            s = ollama_generate(prompt, model)
            chunk_sums.append(s)
            print(f"  Mapped {i+1}/{len(chunks)}")

        combined = "\n\n".join(f"Section {i+1}: {s}" for i, s in enumerate(chunk_sums))
        reduce_prompt = f"""Synthesize these section summaries into one coherent summary:
1. Executive summary (one paragraph)
2. Key findings (bullet points)
3. Notable numbers or data
4. Recommendations (if any)

{combined}

Final Summary:"""
        return ollama_generate(reduce_prompt, model)

# --- Main ---

def main():
    parser = argparse.ArgumentParser(description="Summarize documents locally with Ollama")
    parser.add_argument("path", help="File or directory to summarize")
    parser.add_argument("--model", default="qwen2.5:14b", help="Ollama model name")
    parser.add_argument("--strategy", default="map-reduce",
                        choices=["stuff", "map-reduce", "refine"])
    parser.add_argument("--batch", action="store_true", help="Process entire directory")
    parser.add_argument("--output-dir", default=None, help="Output directory for summaries")
    args = parser.parse_args()

    target = Path(args.path)

    if args.batch and target.is_dir():
        extensions = {".pdf", ".docx", ".xlsx", ".pptx", ".txt", ".md", ".csv"}
        files = [f for f in target.rglob("*") if f.suffix.lower() in extensions]
        print(f"Found {len(files)} documents to process")

        out_dir = Path(args.output_dir) if args.output_dir else target / "summaries"
        out_dir.mkdir(exist_ok=True)

        for f in files:
            print(f"\nProcessing: {f.name}")
            try:
                text = extract_text(str(f))
                result = summarize(text, args.model, args.strategy)
                out_file = out_dir / f"{f.stem}_summary.md"
                out_file.write_text(
                    f"# Summary: {f.name}\n\n"
                    f"*Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}*\n"
                    f"*Model: {args.model}*\n\n"
                    f"{result}\n",
                    encoding="utf-8"
                )
                print(f"  Saved: {out_file}")
            except Exception as e:
                print(f"  ERROR: {e}")
    else:
        print(f"Processing: {target.name}")
        text = extract_text(str(target))
        start = time.time()
        result = summarize(text, args.model, args.strategy)
        elapsed = time.time() - start

        print(f"\n{'='*60}")
        print(result)
        print(f"{'='*60}")
        print(f"\nCompleted in {elapsed:.1f}s")

if __name__ == "__main__":
    main()

Save this as local_summarizer.py and run it:

# Single file
python local_summarizer.py quarterly-report.pdf

# With a specific model
python local_summarizer.py contract.docx --model llama3.3:70b-instruct-q4_K_M

# Highest quality (slower)
python local_summarizer.py research-paper.pdf --strategy refine

# Batch process an entire folder
python local_summarizer.py ./client-files/ --batch --output-dir ./summaries/

---

Model Selection for Summarization {#model-selection-for-summarization}

Not all models summarize equally well. Here are measured results from summarizing the same 30-page financial report:

"Key Detail Retention" measures what percentage of important facts, numbers, and conclusions from the original document appear in the summary. Measured by manually checking 20 key facts from the source document.

Recommendations:

• Best quality, no budget constraint: Llama 3.3 70B or Qwen 2.5 72B
• Best quality on consumer GPU (24GB): Qwen 2.5 32B
• Best quality on 12GB GPU: Qwen 2.5 14B — this is the sweet spot
• Fastest acceptable quality: Llama 3.2 8B
• Avoid for summarization: Models under 3B parameters. They miss too many details.

For a complete list of model sizes and VRAM requirements, see our Ollama model RAM/VRAM reference table.

---

Batch Processing Entire Folders {#batch-processing-entire-folders}

The batch mode walks a directory tree and summarizes every supported file:

# Summarize all documents in a folder
python local_summarizer.py ./legal-cases/ --batch

# Outputs to ./legal-cases/summaries/ by default:
# ./legal-cases/summaries/case-001_summary.md
# ./legal-cases/summaries/case-002_summary.md
# ./legal-cases/summaries/financials-q4_summary.md

# Custom output directory
python local_summarizer.py ./reports/ --batch --output-dir ./report-summaries/

# Use the fastest model for large batches
python local_summarizer.py ./archive/ --batch --model llama3.2

Performance for batch processing:

For very large batches, run overnight. The script processes files sequentially to avoid GPU memory fragmentation.

---

Output Formats {#output-formats}

The summarizer produces three output types. You can extend the reduce prompt to request any format.

1. Full Markdown Summary

# Summary: Q4-2025-Financial-Report.pdf

*Generated: 2026-04-11 14:30*
*Model: qwen2.5:14b*

## Executive Summary
Revenue grew 12% year-over-year to $4.2M, driven primarily by
enterprise contract expansion. Operating margins contracted
by 2 points to 18% due to increased R&D headcount...

## Key Findings
- Revenue: $4.2M (+12% YoY)
- Operating margin: 18% (down from 20%)
- New enterprise contracts: 14 (up from 9)
- Customer churn: 3.2% (improved from 4.1%)
- R&D spend: $890K (up 34%)

## Notable Data Points
- Largest single contract: $340K annual value
- Average deal size increased 23% to $89K
- 67% of revenue from top 20 accounts

## Recommendations
- Monitor margin compression as R&D scales
- Diversify revenue concentration (top 20 = 67%)

2. Key Points Extraction

Modify the prompt to extract only bullet points:

KEY_POINTS_PROMPT = """Extract the 10 most important facts, numbers,
and conclusions from this text. Return only bullet points, no prose.

Text:
{text}

Key Points:"""

3. Executive Brief (One Paragraph)

For email-ready summaries:

EXEC_BRIEF_PROMPT = """Write a single paragraph (4-6 sentences) executive
brief summarizing this document. Include the most critical numbers and
the primary conclusion. Write for a busy executive who has 30 seconds.

Text:
{text}

Executive Brief:"""

---

Extending the Pipeline {#extending-the-pipeline}

Once you have the base summarizer working, here are practical extensions:

Add OCR for scanned PDFs:

pip install pytesseract Pillow
# Requires: brew install tesseract (Mac) or apt install tesseract-ocr (Linux)

Add email (.eml) support:

pip install email-parser

Compare against the original with RAG: Feed the summary and original into a local RAG pipeline to verify no critical information was dropped.

Build a web UI: Wrap the script with a Flask or FastAPI server and add a drag-and-drop file upload. This turns the command-line tool into something non-technical colleagues can use.

For a more advanced setup that lets you ask questions about your documents (not just summarize), see our private AI knowledge base guide.

---

Frequently Asked Questions {#faq}

See the FAQ section below for detailed answers to common questions about local document summarization.

---

What You Have Built

A document summarization pipeline that:

• Processes PDF, Word, Excel, PowerPoint, and plain text
• Runs entirely on your local hardware — no data leaves your machine
• Handles documents of any length via map-reduce chunking
• Produces structured summaries with key points and executive briefs
• Batch processes entire folders of documents
• Costs nothing per document after the initial hardware investment

The script is 200 lines of Python. It has no cloud dependencies, no API keys, no subscription fees. Copy it, modify it, deploy it wherever you need private document intelligence.

---

Want to go further? Build a full question-answering system over your documents with our RAG setup guide, or set up the underlying Ollama server with the complete Ollama guide.