Skip to content
Back to search

DocMeld

Lightweight Doc-to-agent-ready knowledge pipeline. Three-stage Bronze→Silver→Gold architecture extracts structured elements, page content, and AI-enriched metadata from research papers and books. Generate PRDs, workflows, topic clusters, and Claude Code skills from PDFs. No OCR required.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/agentii-ai--docmeld/badge.svg)](/listings/agentii-ai--docmeld)

HTML

<a href="/listings/agentii-ai--docmeld"><img src="/api/listings/agentii-ai--docmeld/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Installation

pip install docmeld

Optional backends for richer formats:

pip install docmeld[docling]   # Docling backend (DOCX + advanced PDF)
pip install docmeld[pptx]      # PowerPoint (.pptx) via python-pptx
pip install docmeld[office]    # Everything: Docling + python-pptx

> Legacy `.doc` / `.ppt` additionally require [LibreOffice](https://www.libreoffice.org/download/) (`soffice`) on your PATH.

Process your first document

from docmeld import DocMeldParser

parser = DocMeldParser("research_paper.pdf")   # or .docx / .pptx
result = parser.process_all()
print(f"Processed {result.successful}/{result.total_files} files in {result.processing_time_seconds}s")

Or from the command line:

docmeld process research_paper.pdf
docmeld process quarterly_deck.pptx --backend auto

That's it. Your document is now structured JSON, page-by-page JSONL, and (optionally) AI-enriched metadata.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 543 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="docmeld/assets/banner.png" alt="DocMeld Banner" width="100%">
  3. </p>
  4. <h1 align="center">DocMeld</h1>
  5. <p align="center">Lightweight Doc to agent-ready knowledge pipeline</p>
  6. <p align="center">
  7. <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
  8. <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="Python 3.9+"></a>
  9. <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black"></a>
  10. <a href="https://docs.astral.sh/ruff/"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff"></a>
  11. <a href="https://mypy-lang.org/"><img src="https://img.shields.io/badge/type%20checked-mypy-blue.svg" alt="Checked with mypy"></a>
  12. <img src="https://img.shields.io/badge/tests-315%20passed-brightgreen.svg" alt="Tests: 315 passed">
  13. <img src="https://img.shields.io/badge/coverage-78%25-green.svg" alt="Coverage: 78%">
  14. <a href="https://pypi.org/project/docmeld/"><img src="https://img.shields.io/badge/pypi-0.3.1-blue.svg" alt="PyPI: 0.3.1"></a>
  15. </p>
  16. <p align="center">
  17. <a href="#quick-start">Quick Start</a> •
  18. <a href="#pipeline-architecture">Architecture</a> •
  19. <a href="#python-api">Python API</a> •
  20. <a href="#cli-reference">CLI</a> •
  21. <a href="#configuration">Configuration</a> •
  22. <a href="#contributing">Contributing</a>
  23. </p>
  24. ---
  25. DocMeld converts PDF, Word, and PowerPoint documents into structured, agent-consumable formats through a three-stage pipeline — without requiring expensive OCR, VLM, or multimodal models. Built for the age of AI agents, it bridges the gap between static documents and the structured knowledge that LLMs need.
  26. Most tools stop at format conversion. DocMeld goes further: **Document → Structured Elements → Page Knowledge → AI-Enriched Metadata**, producing outputs ready for RAG pipelines, agent systems, and downstream AI workflows.
  27. **Supported formats:** `.pdf`, `.docx`, `.doc` (via LibreOffice), `.pptx`, `.ppt` (via LibreOffice).
  28. ## Why DocMeld?
  29. | | DocMeld | MinerU | Docling | Marker | MarkItDown |
  30. |---|---|---|---|---|---|
  31. | No ML models required | ✅ | ❌ | ❌ | ❌ | ✅ |
  32. | Runs fully offline (core) | ✅ | ❌ | ✅ | ✅ | ✅ |
  33. | Agent-ready outputs | ✅ | ❌ | ❌ | ❌ | ❌ |
  34. | AI metadata enrichment | ✅ | ❌ | ❌ | ❌ | ❌ |
  35. | Lightweight install | ✅ | ❌ | ❌ | ❌ | ✅ |
  36. | MIT license | ✅ | ❌ (AGPL) | ✅ | ❌ (GPL) | ✅ |
  37. | Swappable backends | ✅ | ❌ | N/A | ❌ | ❌ |
  38. ## Quick Start
  39. ### Installation
  40. ```bash
  41. pip install docmeld
  42. ```
  43. Optional backends for richer formats:
  44. ```bash
  45. pip install docmeld[docling] # Docling backend (DOCX + advanced PDF)
  46. pip install docmeld[pptx] # PowerPoint (.pptx) via python-pptx
  47. pip install docmeld[office] # Everything: Docling + python-pptx
  48. ```
  49. > Legacy `.doc` / `.ppt` additionally require [LibreOffice](https://www.libreoffice.org/download/) (`soffice`) on your PATH.
  50. ### Process your first document
  51. ```python
  52. from docmeld import DocMeldParser
  53. parser = DocMeldParser("research_paper.pdf") # or .docx / .pptx
  54. result = parser.process_all()
  55. print(f"Processed {result.successful}/{result.total_files} files in {result.processing_time_seconds}s")
  56. ```
  57. Or from the command line:
  58. ```bash
  59. docmeld process research_paper.pdf
  60. docmeld process quarterly_deck.pptx --backend auto
  61. ```
  62. That's it. Your document is now structured JSON, page-by-page JSONL, and (optionally) AI-enriched metadata.
  63. ## Pipeline Architecture
  64. DocMeld uses a three-stage medallion architecture. Each stage is independently runnable and idempotent — re-running skips already-processed files.
  65. ```
  66. ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
  67. │ BRONZE │ │ SILVER │ │ GOLD │
  68. │ │ │ │ │ │
  69. │ Doc → JSON │─────▶│ JSON → JSONL│─────▶│ JSONL → AI │
  70. │ elements │ │ pages │ │ metadata │
  71. │ │ │ │ │ │
  72. │ PyMuPDF / │ │ Title │ │ DeepSeek │
  73. │ Docling / │ │ hierarchy │ │ enrichment │
  74. │ python-pptx│ │ │ │ │
  75. └─────────────┘ └─────────────┘ └─────────────┘
  76. offline offline requires API key
  77. ```
  78. ### Bronze: Document → Structured JSON
  79. Extracts document elements (titles, text, tables, images, charts, formulas, SmartArt, speaker notes, comments, and more) into a unified JSON format with element IDs and parent-child hierarchy. The page unit is the physical page for PDF/Word and the **slide** for PowerPoint.
  80. ```json
  81. [
  82. {
  83. "type": "title",
  84. "level": 0,
  85. "content": "Executive Summary",
  86. "page_no": 1,
  87. "element_id": "e_0001",
  88. "parent_id": ""
  89. },
  90. {
  91. "type": "text",
  92. "content": "The company reported strong Q2 results...",
  93. "page_no": 1,
  94. "element_id": "e_0002",
  95. "parent_id": "e_0001"
  96. },
  97. {
  98. "type": "table",
  99. "content": "| Metric | Q1 | Q2 |\n|---|---|---|\n| Revenue | 10M | 15M |",
  100. "summary": "Items: Revenue",
  101. "page_no": 2,
  102. "element_id": "e_0003",
  103. "parent_id": "e_0001",
  104. "table_data": {
  105. "headers": ["Metric", "Q1", "Q2"],
  106. "rows": [["Revenue", "10M", "15M"]],
  107. "num_rows": 1,
  108. "num_cols": 3
  109. }
  110. }
  111. ]
  112. ```
  113. Supported element types:
  114. | Type | Fields | Description |
  115. |---|---|---|
  116. | `title` | `level`, `content` | Headings with hierarchy (0–5) |
  117. | `text` | `content` | Paragraph content (hyperlinks preserved inline as `[text](url)`) |
  118. | `table` | `content`, `summary`, `table_data` | Markdown tables with structured data |
  119. | `image` | `image_name`, `image`, `bbox`, `image_id` | Base64-encoded images with metadata |
  120. | `chart` | `chart_type`, `content`, `image` | Chart data as a markdown table + image fallback |
  121. | `formula` | `content`, `formula_type` | Equations (LaTeX / OMML) |
  122. | `smartart` | `smartart_type`, `content`, `image` | SmartArt diagram text (PPTX) |
  123. | `notes` | `content` | Speaker notes (PPTX) |
  124. | `group` | `content`, `child_count` | Grouped shapes; children link via `parent_id` (PPTX) |
  125. | `comment` | `content`, `author` | Reviewer comments (PPTX) |
  126. | `footer` | `content`, `page_scope` | Slide/page footers |
  127. | `header` / `footnote` / `endnote` | `content`, … | Document margins & notes (DOCX) |
  128. All elements include `page_no`, `element_id`, and `parent_id` for cross-referencing. Elements on hidden slides carry `hidden: true`.
  129. ### Silver: JSON → Page-by-Page JSONL
  130. Transforms flat element lists into self-contained page documents with title hierarchy tracking, markdown rendering, and global table numbering.
  131. ```json
  132. {
  133. "metadata": {
  134. "uuid": "a1b2c3d4-...",
  135. "source": "research_paper.pdf",
  136. "page_no": "page1",
  137. "session_title": "# Executive Summary\n"
  138. },
  139. "page_content": "# Executive Summary\n\nThe company reported strong Q2 results...\n\n[[Table1]]\n| Metric | Q1 | Q2 |\n|---|---|---|\n| Revenue | 10M | 15M |\n[/Table1]"
  140. }
  141. ```
  142. Each page carries its full title context, so pages are independently meaningful — ideal for chunked retrieval in RAG systems.
  143. ### Gold: JSONL → AI-Enriched Metadata
  144. Adds semantic descriptions and keywords to each page using DeepSeek-chat, with exponential backoff retry and per-page error resilience.
  145. ```json
  146. {
  147. "metadata": {
  148. "uuid": "a1b2c3d4-...",
  149. "source": "research_paper.pdf",
  150. "page_no": "page1",
  151. "session_title": "# Executive Summary\n",
  152. "description": "Company reports strong Q2 results with 50% revenue growth",
  153. "keywords": ["revenue", "quarterly results", "growth", "financial performance"]
  154. },
  155. "page_content": "..."
  156. }
  157. ```
  158. The gold stage is optional — bronze and silver run fully offline with zero API calls.
  159. ### Knowledge Generation (v0.3.1+)
  160. Beyond per-page enrichment, DocMeld can generate structured, agent-ready artifacts from document content:
  161. | Feature | CLI | Python API | Output |
  162. |---------|-----|-----------|--------|
  163. | **Categorize** | `docmeld categorize papers/` | `parser.process_categorize()` | Topic clusters + `categories.json` |
  164. | **PRD Generator** | `docmeld prd paper.pdf` | `parser.process_prd()` | Product Requirements Document |
  165. | **Workflow** | `docmeld workflow paper.pdf` | `parser.process_workflow()` | Step-by-step implementation workflow |
  166. | **Skills** | `docmeld skills book.pdf` | `parser.process_skills()` | Claude Code skill files |
  167. All four support swappable LLM backends via the `LLMProvider` Protocol (see Python API).
  168. ## Output Structure
  169. After processing `research_paper.pdf`:
  170. ```
  171. research_paper.pdf # Original (untouched)
  172. research_paper_a3f5c2/ # Output folder (name + MD5 suffix)
  173. ├── research_paper_a3f5c2.json # Bronze: structured elements
  174. ├── research_paper_a3f5c2.jsonl # Silver: page-by-page documents
  175. └── research_paper_a3f5c2_gold.jsonl # Gold: AI-enriched (optional)
  176. ```
  177. Output folder names are sanitized and include an MD5 hash suffix for uniqueness, ensuring safe cross-platform filenames even for PDFs with unicode or special characters.
  178. ## Python API
  179. ### Full Pipeline
  180. ```python
  181. from docmeld import DocMeldParser
  182. # Single file — all three stages
  183. parser = DocMeldParser("paper.pdf")
  184. result = parser.process_all()
  185. # Batch — process every PDF in a folder
  186. parser = DocMeldParser("/path/to/papers/")
  187. result = parser.process_all()
  188. print(f"{result.successful}/{result.total_files} files, {result.processing_time_seconds}s")
  189. ```
  190. ### Individual Stages
  191. ```python
  192. from docmeld import DocMeldParser
  193. parser = DocMeldParser("paper.pdf")
  194. # Bronze only
  195. bronze = parser.process_bronze()
  196. print(f"{bronze.element_count} elements across {bronze.page_count} pages")
  197. print(f"Output: {bronze.output_path}")
  198. # Silver (requires bronze output)
  199. silver = parser.process_silver(bronze.output_path)
  200. print(f"{silver.page_count} pages → {silver.output_path}")
  201. # Gold (requires silver output + API key)
  202. gold = parser.process_gold(silver.output_path)
  203. print(f"{gold.pages_enriched} enriched, {gold.pages_failed} failed")
  204. ```
  205. ### Swappable Backends
  206. DocMeld supports multiple parsing backends through a pluggable architecture. With `--backend auto` (default), the format is detected from the file extension and routed automatically:
  207. ```python
  208. # PDF (default): PyMuPDF — lightweight, fast
  209. parser = DocMeldParser("paper.pdf", backend="pymupdf")
  210. # DOCX: Docling (IBM's ML-powered OOXML parser)
  211. parser = DocMeldParser("report.docx", backend="docling")
  212. # PPTX: python-pptx — native slide/shape extraction
  213. parser = DocMeldParser("deck.pptx", backend="pptx")
  214. # Legacy .doc / .ppt: LibreOffice bridge → PDF → PyMuPDF
  215. parser = DocMeldParser("old.ppt", backend="soffice")
  216. # Auto-detect by extension (recommended)
  217. parser = DocMeldParser("anything.pptx", backend="auto")
  218. ```
  219. | Backend | Formats | Requires |
  220. |---|---|---|
  221. | `pymupdf` | `.pdf` | core install |
  222. | `docling` | `.docx`, `.pdf` | `docmeld[docling]` |
  223. | `pptx` | `.pptx` | `docmeld[pptx]` |
  224. | `soffice` | `.doc`, `.ppt` | LibreOffice |
  225. | `auto` | all of the above | per-format |
  226. ### Working with Elements
  227. ```python
  228. import json
  229. # Load bronze output
  230. with open("paper_a3f5c2/paper_a3f5c2.json") as f:
  231. elements = json.load(f)
  232. # Filter by type
  233. titles = [e for e in elements if e["type"] == "title"]
  234. tables = [e for e in elements if e["type"] == "table"]
  235. # Navigate hierarchy via parent_id
  236. for elem in elements:
  237. if elem["parent_id"] == "e_001":
  238. print(f" Child of first title: {elem['content'][:50]}")
  239. # Access structured table data
  240. for table in tables:
  241. headers = table["table_data"]["headers"]
  242. rows = table["table_data"]["rows"]
  243. print(f"Table: {len(rows)} rows × {len(headers)} cols")
  244. ```
  245. ### Knowledge Generation
  246. ```python
  247. # Categorize papers into topic clusters
  248. parser = DocMeldParser("/path/to/papers/")
  249. result = parser.process_categorize(reorganize=False)
  250. # Generate a PRD from a research paper
  251. prd = parser.process_prd()
  252. # Extract a workflow
  253. wf = parser.process_workflow()
  254. # Extract Claude Code skills from a book
  255. skills = parser.process_skills()
  256. ```
  257. ### Swappable LLM Provider
  258. ```python
  259. from docmeld.gold.provider import LLMProvider
  260. class MyProvider:
  261. def extract_metadata(self, content): ...
  262. def generate(self, prompt): ...
  263. def categorize(self, prompt): ...
  264. parser = DocMeldParser("paper.pdf", provider=MyProvider())
  265. prd = parser.process_prd() # uses your provider, not DeepSeek
  266. ```
  267. When no provider is given, a `DeepSeekClient` is constructed from environment variables — behavior is unchanged.
  268. ### Result Models
  269. All pipeline stages return typed Pydantic models:
  270. ```python
  271. BronzeResult(output_path, output_dir, element_count, page_count, skipped)
  272. SilverResult(output_path, page_count, skipped)
  273. GoldResult(output_path, pages_enriched, pages_failed, skipped)
  274. ProcessingResult(total_files, successful, failed, failures, processing_time_seconds, ...)
  275. CategorizeResult(index_path, total_papers, total_categories, papers_failed, reorganized)
  276. PrdResult(output_path, sections, source_pdf, skipped)
  277. WorkflowResult(output_path, sections, source_pdf, skipped)
  278. SkillsResult(output_dir, skill_count, source_pdf, skipped)
  279. ```
  280. ## CLI Reference
  281. ```bash
  282. # Full pipeline (bronze → silver → gold)
  283. docmeld process paper.pdf
  284. docmeld process /path/to/papers/
  285. # Individual stages
  286. docmeld bronze paper.pdf # Doc → JSON
  287. docmeld silver paper_a3f5c2/paper_a3f5c2.json # JSON → JSONL
  288. docmeld gold paper_a3f5c2/paper_a3f5c2.jsonl # JSONL → enriched JSONL
  289. # Choose parsing backend
  290. docmeld bronze report.docx --backend docling
  291. docmeld bronze deck.pptx --backend pptx
  292. docmeld process paper.pdf --backend auto # default — detects format
  293. # Knowledge Generation (requires DEEPSEEK_API_KEY)
  294. docmeld categorize /path/to/papers/ # Topic clustering → categories.json
  295. docmeld categorize /path/to/papers/ --reorganize # Move files into category folders
  296. docmeld prd paper.pdf # Generate Product Requirements Document
  297. docmeld workflow paper.pdf # Extract step-by-step workflow
  298. docmeld skills book.pdf # Extract Claude Code skills
  299. ```
  300. ## Configuration
  301. ### Gold Stage (AI Enrichment)
  302. Create a `.env.local` file in your working directory:
  303. ```bash
  304. DEEPSEEK_API_KEY=your_key_here
  305. # Optional: custom API endpoint
  306. # DEEPSEEK_API_ENDPOINT=https://api.deepseek.com
  307. ```
  308. The gold stage is entirely optional. Bronze and silver stages run offline with no API keys, no network calls, and no model downloads.
  309. ### Logging
  310. DocMeld writes timestamped log files (`docmeld_YYYYMMDD_HHMMSS.log`) to the working directory. Console output shows INFO-level messages; log files capture full DEBUG output.
  311. ## Unified Element Schema
  312. DocMeld enforces a strict element schema via Pydantic models. This contract guarantees downstream consumers always get a predictable structure.
  313. ```python
  314. from docmeld.bronze.element_types import (
  315. TitleElement, # type, level, content, page_no, element_id, parent_id
  316. TextElement, # type, content, page_no, element_id, parent_id
  317. TableElement, # type, content, summary, page_no, element_id, parent_id, table_data
  318. ImageElement, # type, image_name, content, image, image_id, bbox, ...
  319. ChartElement, # type, chart_type, content, image, image_name, ...
  320. FormulaElement, # type, content, formula_type, ...
  321. SmartArtElement, # type, smartart_type, content, image, ...
  322. NotesElement, # type, content, ... (speaker notes)
  323. GroupElement, # type, content, child_count, ...
  324. CommentElement, # type, content, author, ...
  325. # + HeaderElement, FooterElement, FootnoteElement, EndnoteElement
  326. )
  327. ```
  328. Element types are validated at creation time. All 14 types share `type`, `page_no`, `element_id`, `parent_id`, and an optional `hidden` flag. New types may be added in minor versions, but existing types will never change shape in minor/patch releases.
  329. ## Roadmap
  330. - [x] Bronze → Silver → Gold pipeline
  331. - [x] CLI interface with subcommands
  332. - [x] Swappable backends (PyMuPDF + Docling)
  333. - [x] Element hierarchy (`element_id` / `parent_id`)
  334. - [x] Structured table data extraction
  335. - [x] Idempotent processing
  336. - [x] Batch folder processing
  337. - [x] DOCX support (Docling backend)
  338. - [x] PPTX / PPT support (python-pptx + LibreOffice bridge)
  339. - [x] Rich element types (chart, formula, SmartArt, notes, comments, groups)
  340. - [x] Research paper batch categorization + topic clustering
  341. - [x] Paper-to-PRD generation
  342. - [x] Paper-to-workflow extraction
  343. - [x] Book-to-Claude-Skills generation
  344. - [x] Swappable LLM provider
  345. - [ ] OCR for scanned PDFs (`pip install docmeld[ocr]`)
  346. - [ ] Agent prompt generation
  347. - [ ] LangChain / LlamaIndex integration
  348. ## Development
  349. ### Setup
  350. ```bash
  351. git clone https://github.com/agentii-ai/docmeld.git
  352. cd docmeld
  353. python3 -m venv venv
  354. source venv/bin/activate
  355. pip install -e ".[dev]"
  356. ```
  357. ### Quality Gates
  358. ```bash
  359. pytest tests/ -v --cov=docmeld # 315 tests, 78% coverage
  360. ruff check docmeld/ # Linting
  361. black --check docmeld/ # Formatting
  362. mypy docmeld/ # Strict type checking
  363. ```
  364. ### Project Structure
  365. ```
  366. docmeld/
  367. ├── docmeld/
  368. │ ├── __init__.py # Public API (DocMeldParser, __version__)
  369. │ ├── parser.py # Pipeline orchestrator
  370. │ ├── cli.py # CLI entry point (argparse)
  371. │ ├── bronze/
  372. │ │ ├── backends/
  373. │ │ │ ├── pymupdf_backend.py # PyMuPDF + pymupdf4llm
  374. │ │ │ ├── docling_backend.py # Docling (optional, DOCX/PDF)
  375. │ │ │ ├── pptx_backend.py # python-pptx (PPTX slide extraction)
  376. │ │ │ └── soffice_backend.py # LibreOffice bridge (.doc/.ppt)
  377. │ │ ├── element_extractor.py # Extraction + post-processing
  378. │ │ ├── element_types.py # Pydantic element models
  379. │ │ ├── filename_sanitizer.py # Safe filenames + MD5 hashing
  380. │ │ └── processor.py # Bronze orchestrator
  381. │ ├── silver/
  382. │ │ ├── page_aggregator.py # Group elements by page
  383. │ │ ├── page_models.py # Result models (Pydantic)
  384. │ │ ├── markdown_renderer.py # Elements → markdown
  385. │ │ ├── title_tracker.py # Title hierarchy state
  386. │ │ └── processor.py # Silver orchestrator
  387. │ ├── gold/
  388. │ │ ├── deepseek_client.py # API client + retry logic
  389. │ │ ├── provider.py # LLMProvider Protocol (swappable)
  390. │ │ ├── metadata_extractor.py # Content → description + keywords
  391. │ │ └── processor.py # Gold orchestrator
  392. │ ├── categorize/ # Topic clustering (categorize)
  393. │ ├── prd/ # PRD generation (prd)
  394. │ ├── workflow/ # Workflow extraction (workflow)
  395. │ ├── skills/ # Skills extraction (skills)
  396. │ └── utils/
  397. │ ├── env_loader.py # .env.local loading
  398. │ ├── logging.py # Timestamped log setup
  399. │ ├── progress.py # Progress indicators
  400. │ ├── silver_io.py # Shared JSONL loading
  401. │ ├── content.py # Content aggregation
  402. │ └── text.py # Text helpers
  403. ├── scripts/ # Example scripts (not shipped in package)
  404. ├── tests/ # Unit, integration, contract tests
  405. ├── pyproject.toml
  406. ├── CONTRIBUTING.md
  407. ├── CHANGELOG.md
  408. └── LICENSE # MIT
  409. ```
  410. ## Contributing
  411. We welcome contributions. See [CONTRIBUTING.md](CONTRIBUTING.md) for the full guide. The short version:
  412. 1. Fork and clone
  413. 2. Write tests first (TDD is non-negotiable)
  414. 3. Run all quality gates before pushing
  415. 4. Open a PR with a clear description
  416. ## License
  417. MIT License — see [LICENSE](LICENSE) for details.
  418. ## Citation
  419. ```bibtex
  420. @software{docmeld2026,
  421. title = {DocMeld: Lightweight PDF, Word & PowerPoint to Agent-Ready Knowledge Pipeline},
  422. year = {2026},
  423. license = {MIT},
  424. url = {https://github.com/agentii-ai/docmeld}
  425. }
  426. ```

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.