OfficeIMO.Reader

Why OfficeIMO.Reader?

OfficeIMO.Reader provides a single API to extract structured content from common document formats. Feed it Word, Excel, PowerPoint, Markdown, PDF, or text-like inputs and get back normalized chunks with location data, source hashes, and token estimates. Optional adapters extend the same reader model to CSV/TSV, JSON, XML, HTML, EPUB, and ZIP-oriented ingestion. It is purpose-built for RAG pipelines, search indexing, and any workflow where you need reproducible document slices instead of ad-hoc parsers.

Features

• Extract from Word, Excel, PowerPoint, Markdown & PDF — one result model across the supported handlers you install
• Modern and legacy Office input — route .doc, .xls, .ppt, .pot, and .pps through the owning OfficeIMO engines with diagnostics and password support
• Deterministic extraction chunks — emit stable chunk boundaries with configurable character and row limits
• Heading-aware extraction with citations — preserve document structure and source locations on each chunk
• Token estimates per chunk — budget prompts and indexing payloads without an extra preprocessing pass
• Folder batch processing — process entire directories with progress callbacks, skip reporting, and cancellation support
• Pluggable handler registration — register custom extractors for proprietary or domain-specific formats
• Adapter packages — add CSV, JSON, XML, HTML, EPUB, ZIP, or structured text support without bloating every reader deployment

What teams build with Reader

Reader package family

Quick start

using OfficeIMO.Reader;
using OfficeIMO.Reader.Word;

OfficeDocumentReader reader = new OfficeDocumentReaderBuilder()
    .AddWordHandler()
    .Build();

var chunks = reader.Read("report.docx", new ReaderOptions {
    MaxChars = 4_000,
    ComputeHashes = true
}).ToList();

foreach (var chunk in chunks)
{
    Console.WriteLine($"{chunk.Id} :: {chunk.Kind} :: ~{chunk.TokenEstimate ?? 0} tokens");
    Console.WriteLine(chunk.Location.HeadingPath ?? chunk.Location.Path ?? "unknown");
    Console.WriteLine(chunk.Markdown ?? chunk.Text);
    Console.WriteLine();
}

var documents = reader.ReadFolderDocuments(
    folderPath: "./documents",
    folderOptions: new ReaderFolderOptions
    {
        Recurse = true,
        DeterministicOrder = true,
        MaxFiles = 500
    },
    options: new ReaderOptions
    {
        MaxChars = 4_000,
        ComputeHashes = true
    },
    onProgress: progress =>
        Console.WriteLine($"{progress.Kind}: scanned={progress.FilesScanned}, parsed={progress.FilesParsed}, skipped={progress.FilesSkipped}, chunks={progress.ChunksProduced}")
).ToList();

Console.WriteLine($"Processed {documents.Count} files");
Console.WriteLine($"Parsed {documents.Count(d => d.Parsed)} files");
Console.WriteLine($"Returned {documents.Sum(d => d.ChunksProduced)} chunks");

Typical ingestion flow

1. Detect the source format and extract chunks, headings, tables, visuals, and source information with one API call.
2. Normalize the result into a shape your pipeline understands, regardless of whether the input was Word, Excel, PowerPoint, Markdown, PDF, or text.
3. Tune ReaderOptions so citations and downstream embeddings stay stable across repeated runs.
4. Store the chunks, source hashes, and source references in your vector store, search index, or audit trail.
5. Reuse the same extractor in local tools, hosted services, or CI jobs without changing the document pipeline.

Compatibility

OfficeIMO.Reader targets the same cross-platform .NET runtimes as the packages it builds on, and the core extraction flow is a good fit for containers, hosted services, and server-side indexing jobs. As with any mixed-format pipeline, validate your exact deployment shape, input set, and runtime targets before treating it as broadly portable across every environment.

Related guides