Docling is a production-grade Python library for converting diverse document formats (PDF, DOCX, PPTX, XLSX, HTML, LaTeX, EPUB, images, audio, video, email, EBCDIC, and more) into a unified, structured `DoclingDocument` representation. It is designed to serve as the document understanding layer for AI workflows, particularly Retrieval-Augmented Generation (RAG), agentic AI, and document extraction pipelines. The system provides a rich Python SDK, a Typer-based CLI (`docling convert`), a service client for remote conversion via `docling-serve`, and an MCP server. It supports multiple output formats including Markdown, JSON, HTML, DocTags, and plain text. Architecturally, Docling employs a modular pipeline system with pluggable backends for each input format and a stage-based processing model. The core pipeline (`StandardPdfPipeline`, `VlmPipeline`, `AsrPipeline`) orchestrates page-level operations (preprocessing, OCR, layout detection, table structure recognition, picture classification, reading order) and document-level enrichments (code/formula extraction, heading hierarchy, picture description). Inference engines are abstracted behind factory patterns supporting ONNX Runtime, HuggingFace Transformers, vLLM, MLX, KServe v2, and remote APIs. The library integrates with over 20 OCR engines and vision-language models, and includes a plugin system for extensibility. Key entry points include the `DocumentConverter` class, the CLI (`docling.cli.main`), and the service client (`docling.service_client`). External dependencies span PDF libraries (pypdfium2, docling-parse), ML frameworks (torch, transformers, onnxruntime), OCR engines (Tesseract, EasyOCR, RapidOCR), and cloud services (KServe, Azure, S3). The codebase is actively maintained with frequent releases, extensive test coverage, and a clear migration path from legacy components.
OfficeCLI is a cross-platform CLI application written in C#/.NET that creates, reads, and mutates OOXML Office documents (Word .docx, Excel .xlsx, PowerPoint .pptx) without requiring Microsoft Office. It is explicitly engineered as an agent-facing tool: every document element is addressable through a uniform path syntax (e.g. /slide[1]/shape[2]), all commands emit structured JSON with error codes and suggestions, and it ships AI-skill files for Claude/Copilot/Cursor/Codex, an MCP server, plus Python and Node SDKs. The core operation model is a batch command language: documents are mutated by replayable JSON items (add/set/remove/get) executed atomically through the CLI or over a named pipe to a resident process. Architecturally the repo is a single .NET binary (embedded runtime) with a CommandBuilder layer, a DocumentHandlerFactory dispatching to three large partial-class handlers (WordHandler, ExcelHandler, PowerPointHandler), and a shared Core layer containing chart-to-SVG rendering, a formula evaluator implementing 350+ Excel functions with statistical distributions, pivot table construction, Mermaid diagram parsing, OOXML theme/table-style resolution, HTML/PNG/SVG preview rendering, and a plugin protocol for foreign-format dump-readers and exporters. Security is taken seriously: SsrfGuard validates remote fetch targets, HyperlinkUriValidator allowlists URI schemes, XmlTextValidator and DocumentLimits guard against decompression bombs and DOM sprawl, and AtomicPackageWriter prevents torn file writes. Quality is strong but carries real maintenance debt. The code demonstrates deep OOXML craftsmanship - schema-order-correct XML insertion, exact EMU unit round-trips, Lanczos-based gamma functions, and curated chart-style galleries. However, handlers are split across dozens of partial-class files that evolved from former god methods, the property API is stringly-typed (props dictionaries parsed per key), examples must be maintained in parallel shell and Python twins, and the tool deliberately tolerates 'UNSUPPORTED props' warnings (exit code 2), which can mask incomplete feature coverage. The best reuse targets are the self-contained Core utilities rather than the format handlers. The project is actively maintained with multi-platform CI publishing to npm and PyPI.
This is the Microsoft Open XML SDK, a production-grade .NET library for reading, writing, creating, and validating Office Open XML documents (Word, Excel, PowerPoint). It provides a strongly-typed DOM (OpenXmlElement hierarchy), LINQ-to-XML integration via generated XName constants, Flat OPC serialization, and a comprehensive validation framework based on the OOXML standard. The architecture combines hand-crafted foundations (OpenXmlElement, OpenXmlPart, OpenXmlPackage, FeatureCollection pattern) with schema-driven source generators that produce hundreds of typed classes, part definitions, and namespace constants from bundled JSON metadata. Key entry points are WordprocessingDocument, SpreadsheetDocument, and PresentationDocument, each with static factory methods (Open, Create, FromFlatOpc). The library is actively maintained by Microsoft, supports Office versions from 2007 through Microsoft365, and includes numerous samples, extensive xUnit tests, and performance benchmarks.
MinerU is a production-grade document parsing engine that converts PDFs, images, and Office documents (DOCX, PPTX, XLSX) into structured Markdown and JSON. It supports multiple backends: a fast pipeline (layout analysis + OCR + formula/table recognition), a high-accuracy hybrid mode combining VLM and OCR, and a pure VLM mode using vLLM/LMDeploy. The system is deployed as a CLI tool, FastAPI service, Gradio web UI, or Docker container, with integrations for RAG frameworks like LangChain, LlamaIndex, and Dify. The codebase is well-architected with clean abstractions for data I/O (file/S3), model initialization (singleton pattern), and output generation (client-side rendering). It handles 109 languages and includes specialized modules for mathematical formula recognition (UniMERNet), table structure recovery (SLANet+/UNet), and office document normalization. While the code is actively maintained and functionally rich, it carries some technical debt from its PaddleOCR heritage (vendored code, eval-based builders) and has a complex optional dependency matrix for hardware accelerators.
This repository contains 'officeParser', a robust Node.js and browser library for parsing 12 office document formats (DOCX, PPTX, XLSX, ODT, ODP, ODS, PDF, RTF, CSV, MD, HTML, EPUB) into a unified abstract syntax tree (AST) and generating high-fidelity output in 9 formats (JSON, text, Markdown, HTML, CSV, RTF, PDF, EPUB, and RAG-focused chunks). It provides a first-class CLI (`npx officeparser`) and a programmatic API (`parseOffice()` → AST → `.to(format, config?)`), with extensive configuration for OCR, chunking strategies, security limits, and format-specific dialects. The architecture follows a strict pipeline: format-specific parsers normalize documents into `OfficeParserAST`, then format-agnostic generators produce the desired output, enabling cross-format conversion and round-trip fidelity. The codebase demonstrates high craftsmanship with reusable utility modules (sanitization, typed error/warning systems, lazy ZIP handling, MathML-to-LaTeX conversion) and a comprehensive test suite covering parser baselines, generator baselines, security injection tests, and exhaustively tested edge cases. It supports browser and Node runtimes via dual CJS/ESM packages and bundled builds, including slim variants that minimize dependencies for browser environments. Key data flows include document metadata extraction, attachment handling (images, charts), OCR via Tesseract.js, PDF generation via Puppeteer, and semantic chunking for LLM ingestion. External dependencies include `pdfjs-dist`, `tesseract.js`, `fflate`, `chart.js`, and `puppeteer` (optional). While the repository is actively maintained with recent commits and CI across multiple Node versions, it shows some technical drift: deprecated API fields remain documented alongside replacements, and large files (e.g., OpenOfficeParser.ts at ~1600 lines) increase maintenance complexity. The builder has addressed past packaging issues (webpack context-module) and maintains sophisticated browser shims. Overall, it is a production-grade document conversion toolkit with exceptional reusability in its core utilities and a clean separation between parsing and generation.
PPT Master is a Python-based application designed to generate natively editable PowerPoint (PPTX) presentations from diverse source formats including PDF, DOCX, Markdown, and URLs. The system operates as a CLI tool and AI agent skill, orchestrating a workflow that converts source content into SVG intermediates before rendering them into native DrawingML shapes within the PPTX file. This approach prioritizes editability over flattened image exports, allowing users to modify text and shapes directly in PowerPoint. The architecture relies heavily on external AI APIs for content generation and image creation, with a local Flask server providing live preview and confirmation capabilities. The codebase functions as a presentation engineering toolkit, featuring bidirectional conversion between PPTX and SVG, template management, and asset handling. It enforces strict design constraints via machine-readable 'spec_lock' files to maintain visual consistency across generated decks. The application is structured as a modular skill within AI IDEs (Claude Code, Cursor), allowing developers to invoke presentation generation via chat commands. While the core conversion logic is robust, the system's stability is intrinsically linked to the availability and schema of external AI providers and the specific behavior of the python-pptx library. This repository represents a hybrid of application engineering and data pipeline logic. While the primary output is a software artifact (the PPTX file), the internal processing involves significant data transformation (document parsing, image generation, XML manipulation). The extensive example suite serves as both documentation and regression testing for the conversion engine, demonstrating the tool's capability across technical, business, and artistic domains.
PPTist is a full-featured web-based slide editor and presentation application, built with Vue 3, TypeScript, and Pinia. It replicates core PowerPoint functionality entirely in the browser, supporting text, image, shape, line, chart, table, video, audio, and LaTeX elements. Users can create, edit, animate, and present slides, with import/export support for PPTX, PDF, images, and a custom .pptist format. An AI-assisted slide generation feature allows users to input a topic and receive a complete slide deck via an external API, with template-based layout and image selection. The architecture is a single-page application with a custom canvas rendering system, rich text editing via ProseMirror, and state management through Pinia stores. The editor is divided into three main modes: Editor (full editing with thumbnails, toolbar, and canvas), Screen (presentation with speaker notes, audience view, writing board, and laser pointer), and Mobile (basic editing and preview for touch devices). Data persistence uses IndexedDB via Dexie for undo/redo snapshots, and slide data is stored as JSON in Pinia stores. External dependencies include ECharts for charts, pptxgenjs for PPTX export, and a backend server for AI generation and image search. Key entry points include src/App.vue (top-level routing), src/views/Editor/index.vue (main editor), src/views/Screen/index.vue (presentation mode), and src/views/Mobile/index.vue (mobile mode). Data flows center on the slide store: user actions trigger mutations captured as snapshots for undo/redo, export processes convert internal JSON to target formats, and import parses external files into the internal schema. The AI PPT flow sends a user prompt to the backend, receives an outline and slide data, then fills template slides with content and images. The application is actively maintained with a large community (9386 stars, 1770 forks) and is licensed under AGPL-3.0. It relies on an external backend for AI features and image search, meaning those features are not self-contained. The codebase is well-structured but lacks automated tests, and some components (e.g., HTML parser, shape library) are self-contained and potentially reusable in other projects.
This repository implements an AI-agent skill that converts images, PDFs, and image-based PPT/PPTX files into fully editable PowerPoint (.pptx) documents. The system uses a deterministic CLI state machine (`editppt`) with a four-phase workflow: normalize input into per-page jobs, dispatch to subagents for page reconstruction, record page manifests, and finalize by rebuilding the PPTX from manifests. It integrates OCR (PaddleOCR or offline detector) for text bounding boxes, image generation/editing backends (built-in, OpenAI-compatible, or Codex OAuth), and LaTeX rendering for formulas. The output preserves native text boxes, shapes (including custom paths and polygons), tables, images, and speaker notes, with strict provenance tracking for all assets. The codebase is well-structured with clear separation of concerns, a manifest-driven assembly pattern, and comprehensive tests. However, the last commit date is anomalously in the future (2026-09-16), suggesting the repository may be abandoned or the timestamp is erroneous; combined with only 1 open issue and no recent activity, it is classified as stale. The technical drift is low as the code uses modern Python and standard libraries, but external dependencies (OCR, image APIs, LaTeX) may become incompatible over time.
This repository is a Python library and Claude Code plugin for generating McKinsey-style PowerPoint (PPTX) presentations. It provides ~40 slide templates (executive summaries, charts, matrices, org charts, roadmaps, etc.) with a consistent deep-navy/bright-blue design system. The core architecture is a builder pattern: `PresentationBuilder` accepts slide specs (as dicts or keyword arguments) and delegates to slide-specific drawing functions in the `slides/` subpackage. A CLI (`mckinsey_pptx.cli`) reads JSON specs and produces `.pptx` files. The Claude Code integration includes an agent definition (`mckinsey-slide-agent.md`) that reads a template catalog, plans a deck story arc, generates a Python build script, executes it, and optionally renders PNG previews via LibreOffice/Poppler. The code is well-structured with a clean separation of concerns: theme dataclasses, base primitives, slide templates, and a builder. The adaptive slide type inference (`infer_slide_type`) is a clever design pattern that allows the same API to accept loosely-typed payloads. The library is production-ready, with provenance from a real consulting tool (AX Labs).
UniOffice is a commercial Go library for reading, writing, and converting Office Open XML (OOXML) documents, including Word (.docx), Excel (.xlsx), and PowerPoint (.pptx) formats. It provides a high-level API for document manipulation, supporting features such as text formatting, tables, images, charts, animations, ActiveX controls, digital ink, and 3D models. The library also includes conversion to PDF via the UniPDF dependency. Architecturally, the library is layered: low-level schema types auto-generated from OOXML schemas handle XML marshalling/unmarshalling and validation; a middle layer of wrapper structs (e.g., Document, Spreadsheet, Presentation) provides a user-friendly interface; and conversion utilities transform documents to PDF. Key entry points include the main module (unioffice.go) for namespace handling and document type detection, common/common.go for core types like DocBase and ContentTypes, and the document/spreadsheet/presentation modules for specific operations. Data flows involve reading a ZIP package, parsing XML into schema types, manipulating via the high-level API, and writing back. The library relies on external dependencies such as unipdf (PDF generation), unichart (chart rendering), unitype (font parsing), and others for encryption and image processing. It requires a license key and uses obfuscated generated code to protect intellectual property. Despite the obfuscation, the library contains several well-designed, reusable components such as a storage abstraction, logger interface, wildcard matching, natural sort, measurement conversions, color parsing, MS-CFB binary format reader/writer, and an Excel number format engine. These components are self-contained and could be extracted for use in other projects.