docpilot-ai 0.2.0__py3-none-any.whl

docpilot_ai-0.2.0.dist-info/METADATA

@@ -0,0 +1,287 @@
+Metadata-Version: 2.5
+Name: docpilot-ai
+Version: 0.2.0
+Summary: AI-powered local-first CLI that converts documents into clean, structured, AI-ready Markdown
+Author-email: Anuj Paroha <dev.77anuj77@gmail.com>
+License: MIT
+Keywords: ai,cli,document-conversion,docx,llm,markdown,pdf,pptx
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: openai>=1.0
+Requires-Dist: pillow>=10.0
+Requires-Dist: pydantic>=2.5
+Requires-Dist: pymupdf>=1.23
+Requires-Dist: pytesseract>=0.3.10
+Requires-Dist: python-docx>=1.1
+Requires-Dist: python-pptx>=0.6
+Requires-Dist: rich>=13.0
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ParseDoc
+
+> Document → AI → Markdown. A local-first CLI that converts documents into clean, structured, AI-ready Markdown.
+
+ParseDoc turns PDFs, Word docs, PowerPoint decks, HTML pages, plain text, and images into well-structured Markdown. Libraries extract the raw facts, an optional AI model understands the structure, and a deterministic renderer produces the final output. It works **fully offline** (local rule-based structuring) and can optionally use an AI provider for smarter structuring.
+
+---
+
+## Features
+
+- **Local-first**: conversion works with no AI provider configured (deterministic fallback).
+- **Multi-format input**: PDF, DOCX, PPTX, HTML, TXT/MD, and images (PNG/JPG) via OCR.
+- **AI structuring** (optional): `local`, `ai`, or `hybrid` modes.
+- **Pluggable AI providers**: OpenAI-compatible (vLLM/LM Studio), OpenAI, Google Gemini, and Ollama (native, no SDK needed).
+- **Image extraction**: pull embedded images from DOCX into an assets folder.
+- **OCR**: Tesseract-backed text extraction for scanned PDFs and images.
+- **Multiple output formats**: `markdown` (default), `json`, `html`, `text`.
+
+---
+
+## Installation
+
+```bash
+git clone <repo-url>
+cd parsedoc
+pip install -e .
+```
+
+This installs the `parsedoc` command. (Requires Python 3.10+.)
+
+### Optional dependencies
+
+| Capability | What you need |
+|------------|---------------|
+| PDF parsing | `pymupdf` (fitz) |
+| DOCX / PPTX | `python-docx`, `python-pptx` |
+| HTML | `beautifulsoup4`, `lxml` |
+| OCR | [Tesseract](https://github.com/tesseract-ocr/tesseract) installed + `pytesseract` |
+
+---
+
+## CLI Usage
+
+The CLI is built with Typer. Run `parsedoc --help` for the full list.
+
+### Commands
+
+| Command | Purpose |
+|---------|---------|
+| `parsedoc convert` | Convert a single document to Markdown. |
+| `parsedoc batch` | Convert every matching file in a directory. |
+| `parsedoc inspect` | Inspect a document's extracted structure (JSON or summary). |
+| `parsedoc config` | View or edit the TOML configuration (`list`, `set`, `reset`). |
+| `parsedoc version` | Print version + banner. |
+
+### `convert`
+
+```bash
+parsedoc convert INPUT_FILE \
+  --output out.md \
+  --format markdown \
+  --mode hybrid \
+  --ai-provider ollama \
+  --model qwen3 \
+  --extract-images
+```
+
+**Options**
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--output`, `-o` | stdout | Write output to a file. |
+| `--format`, `-f` | `markdown` | `markdown`, `json`, `html`, `text`. |
+| `--mode`, `-m` | `hybrid` | `local`, `ai`, or `hybrid`. |
+| `--ai-provider` | config | Override the AI provider. |
+| `--model` | config | Override the model name. |
+| `--temperature` | `0.2` | AI sampling temperature. |
+| `--max-tokens` | `2048` | Max AI tokens. |
+| `--ocr` | off | Force OCR processing. |
+| `--extract-images` | off | Extract embedded images (DOCX) into `<stem>_assets/`. |
+| `--quiet` / `--verbose` | off | Logging verbosity. |
+
+### `batch`
+
+```bash
+parsedoc batch ./docs --pattern "*.docx" --format markdown --extract-images
+```
+
+### `inspect`
+
+```bash
+parsedoc inspect INPUT_FILE --format json     # full extracted structure
+parsedoc inspect INPUT_FILE --format summary  # blocks / title / format
+```
+
+---
+
+## Configuration
+
+ParseDoc stores config as TOML (default location: `~/.config/parsedoc/config.toml`, or via `default_config_path()`). You can edit it directly or use the CLI.
+
+```bash
+parsedoc config list
+parsedoc config set --key ai_provider --value ollama
+parsedoc config set --key model --value qwen3
+parsedoc config reset
+```
+
+### Environment variables
+
+These override the TOML/config values at runtime:
+
+| Variable | Maps to |
+|----------|---------|
+| `PARSEDOC_AI_PROVIDER` | `ai_provider` |
+| `PARSEDOC_BASE_URL` | `base_url` |
+| `PARSEDOC_MODEL` | `model` |
+| `PARSEDOC_API_KEY` | `api_key` |
+| `PARSEDOC_OCR_LANGUAGE` | `ocr_language` |
+
+---
+
+## Integrating AI Providers
+
+ParseDoc supports four provider types, selected via `--ai-provider` (CLI), the `ai.provider` config key, or `PARSEDOC_AI_PROVIDER`.
+
+| Provider value | Use case |
+|----------------|----------|
+| `openai-compatible` | Any OpenAI-compatible endpoint (vLLM, LM Studio, local servers, OpenRouter, etc.) |
+| `openai` | OpenAI's hosted API |
+| `gemini` | Google Gemini API |
+| `ollama` | Ollama running locally (native HTTP, no SDK required) |
+
+Provider is chosen by the factory in `parsedoc/ai/base.py:build_provider`.
+
+### 1. OpenAI-compatible (default)
+
+This is the default and works with most self-hosted / drop-in OpenAI servers.
+
+```bash
+export PARSEDOC_BASE_URL="http://localhost:11434/v1"   # e.g. Ollama's OpenAI shim
+export PARSEDOC_API_KEY="local"                         # or your real key
+export PARSEDOC_MODEL="qwen3"
+parsedoc config set --key ai_provider --value openai-compatible
+```
+
+TOML equivalent (`~/.config/parsedoc/config.toml`):
+
+```toml
+[ai]
+enabled = true
+provider = "openai-compatible"
+base_url = "http://localhost:11434/v1"
+model = "qwen3"
+api_key = "local"
+temperature = 0.2
+max_tokens = 4096
+```
+
+### 2. OpenAI (hosted)
+
+```bash
+export PARSEDOC_BASE_URL="https://api.openai.com/v1"
+export PARSEDOC_API_KEY="sk-..."
+export PARSEDOC_MODEL="gpt-4o-mini"
+parsedoc config set --key ai_provider --value openai
+```
+
+### 3. Google Gemini
+
+```bash
+export PARSEDOC_API_KEY="AIza..."
+export PARSEDOC_MODEL="gemini-1.5-flash"
+parsedoc config set --key ai_provider --value gemini
+```
+
+> Note: the Gemini provider uses its own endpoint; `base_url` is optional and falls back to the Google Generative Language API.
+
+### 4. Ollama (native)
+
+No Python SDK required — ParseDoc talks to Ollama over HTTP using the standard library.
+
+```bash
+export PARSEDOC_BASE_URL="http://localhost:11434"   # Ollama root, not the /v1 shim
+export PARSEDOC_MODEL="qwen3"
+parsedoc config set --key ai_provider --value ollama
+```
+
+Then make sure the model is pulled:
+
+```bash
+ollama pull qwen3
+```
+
+---
+
+## Processing Modes
+
+| Mode | Behavior |
+|------|----------|
+| `local` | Pure rule-based structuring. No network calls. Fast and private. |
+| `ai` | Structures content using the configured AI provider. |
+| `hybrid` | Uses AI when available, falls back to local structuring on failure. |
+
+Set via `--mode` on `convert`/`batch`, or `output`/`ai` config sections (the `provider`/`enabled` keys).
+
+---
+
+## Supported Input Formats
+
+| Format | Extensions |
+|--------|-----------|
+| PDF | `.pdf` |
+| Word | `.docx` |
+| PowerPoint | `.pptx` |
+| HTML | `.html`, `.htm` |
+| Text / Markdown | `.txt`, `.md`, `.markdown` |
+| Images | `.png`, `.jpg`, `.jpeg` (OCR) |
+
+Check support before converting:
+
+```bash
+python -c "from parsedoc.core.detection import is_supported; print(is_supported('file.docx'))"
+```
+
+---
+
+## Using ParseDoc as a Library
+
+```python
+from parsedoc.core.config import Config
+from parsedoc.core.pipeline import Pipeline
+
+config = Config().load_from_file()
+pipeline = Pipeline(config)
+
+markdown = pipeline.process(
+    "report.docx",
+    output_format="markdown",
+    mode="hybrid",
+    extract_images=True,
+    output_path="report.md",
+)
+```
+
+---
+
+## License
+
+See repository for license details.

docpilot_ai-0.2.0.dist-info/RECORD

@@ -0,0 +1,53 @@
+parsedoc/__init__.py,sha256=MfqF421g7syQuYnaELGJxPDAbvnRN-z5x8Th_5FzjRk,87
+parsedoc/__main__.py,sha256=vANrez1SjD08QTogjLaEkc2A_28Z0Pg9ngtsMZKrVes,123
+parsedoc/cli.py,sha256=0DILrkFbnAxX50_DjAb21Vfb4KQqTR5pRfWLXrdg49A,7648
+parsedoc/ai/__init__.py,sha256=7onRegAvnO5fXo57g7X1K2AvdOF-bKjVg-FeXxt5NrU,500
+parsedoc/ai/base.py,sha256=T4VORY1-DD03A3xcGNl8x0QZ-To_DoeDK25_k3_HYZ8,1784
+parsedoc/ai/cache.py,sha256=82VUFzpEN3ZdhvduEyW5khugZ8zuc21_2swhbjDYVD4,1390
+parsedoc/ai/compatible.py,sha256=S5TuXkTiOpG3OFKj98OHL_gdWsxUbcyAk3VVrL_8QbE,1706
+parsedoc/ai/gemini.py,sha256=I1X2fRqYxCHW49SlQ2Xco6Dwd-gBxrsIqqVOwfz5PqM,1141
+parsedoc/ai/ollama.py,sha256=7Fb-B8EtjWXsRZNAiGm1Z0XP6XQ6XHNDUpO1g-Oxm4k,1901
+parsedoc/ai/openai.py,sha256=14cMwn2Y4WFfg6TmpPlN2EiY7K4eGGHqrdj1yPdeePc,1234
+parsedoc/ai/prompts.py,sha256=Xeq1xtjK4Z6ZR-k59OmGOTNZCgv4pw388R1_GIOIZWo,1826
+parsedoc/core/__init__.py,sha256=cjPiNahyuXFC12_CSN8vwPZIe-zxH8mjaXuFczDnX4E,272
+parsedoc/core/chunking.py,sha256=GjoVrV6_TSQARGjZy8vrGoSZ7koS61gx8ZjCluivLkE,1548
+parsedoc/core/config.py,sha256=YkK2nJuCxZOjDy4PPXaulNJIuth7UektgecCwO6e9l0,6642
+parsedoc/core/detection.py,sha256=74QZc5pdS6E9jMcaqT87G296EIbSG3d6BAOhGE68A9U,1218
+parsedoc/core/document.py,sha256=NJR6mFoEWDF8CuaBT8OFBhufa2rgaLqWngQsgLkj-Y8,375
+parsedoc/core/pipeline.py,sha256=z8XBpniP0qdERhUlbVvNDUcfsskm5nfqSmNClRLPBjE,11438
+parsedoc/extraction/__init__.py,sha256=1Q2qStA4zt6FiK-GP6P7ciczJcrGqL9vEESR4DwDPs0,576
+parsedoc/extraction/images.py,sha256=j8uw9XOmeLFAJw1h1d6omp8HYcV9LHc55X3s3F349f4,3118
+parsedoc/extraction/layout.py,sha256=mcig8FcfAd-h1O8k7IgazQWSznRU4qF2ywYf8E1mXfE,497
+parsedoc/extraction/quality.py,sha256=8Bo3im90rR7dhumbQzxgD5LFcIoAQVMC0TVUnnHx-yo,944
+parsedoc/extraction/tables.py,sha256=V9V34Kkv_c_BAAA50e9q0woSHL6_fPKo6XIXHf4cZLg,835
+parsedoc/extraction/text.py,sha256=2fJHSRT_VxduUfv_PPP9kEFFqM5cNGOMOaT_AnVp7DI,2971
+parsedoc/ocr/__init__.py,sha256=ponvt0umORudlLDnFyeVWpuMH9spmDgmAU144IzUaS0,189
+parsedoc/ocr/base.py,sha256=s3srGEdhbTJEqFU6Ve4jHdw8XUshTXt4NefGcRdnhDA,696
+parsedoc/ocr/tesseract.py,sha256=5vHrk6_whhfqlgD9A0A1-yxwHxNqxASDaMM_Hkg0Ai8,1258
+parsedoc/parsers/__init__.py,sha256=9aUo8RyiwN5Wwn7f89F3DkyppE7VbatPq6_UZcI9Qz0,895
+parsedoc/parsers/base.py,sha256=lSmN3cIu6tIl_Pvx0_U9vF0kOQ-Zs62C8WyWyLrSntw,1870
+parsedoc/parsers/docx.py,sha256=yhqjY7Ln3l9pgNpyM9_NyALoNtTj96TNMtErHkukDjE,2645
+parsedoc/parsers/html.py,sha256=DtyBDTEhEfRfXhbcRjnMHH_1YkjmSYaeurRKJEl_T_E,4180
+parsedoc/parsers/image.py,sha256=q_qngZ0NjnIfddxS_upAbm8_sX3rcSEwUfIny54w0hU,1355
+parsedoc/parsers/pdf.py,sha256=_NvQF54s0V_9fpY4s09P9OXEJ3-LcX2HdMndS48zbtA,1605
+parsedoc/parsers/pptx.py,sha256=g_mPh70xEQMoPun_cUzsQOQYVtFzqHPkNz3tZPhdA7M,1202
+parsedoc/parsers/text.py,sha256=O0Lqri09U4wAVV1TsT9ucD9mmV-V-Szp4Y3wM0_kRFs,1892
+parsedoc/renderers/__init__.py,sha256=bptHtTqsVgTsBTAD6M86fYJUAfBFGNG1Ys4DAfVRNo4,726
+parsedoc/renderers/html.py,sha256=7qoK6X7v1tnT6YN5G5k_94VUKABWu2Ewpg5HSTKczu8,2058
+parsedoc/renderers/json.py,sha256=Yg80uRMjCj05fX5xSx1cWUTozC5_Pz2EsazrhS888Pc,245
+parsedoc/renderers/markdown.py,sha256=xzz7LlloXeFf68Fs3jpDXg35YcciEGqNhzeyrCssoQY,2217
+parsedoc/renderers/text.py,sha256=QSnCxTEb8Z3znHVq5IbEpAZKKWreJ0NFELgu-X4tS0Q,726
+parsedoc/schema/__init__.py,sha256=W-YCULJUbiT9jnySL3jVPd3HRKOeC0ABBhl94ETIvu0,270
+parsedoc/schema/document.py,sha256=ObpE6M6q4SDP4bbat9WJ0BhdMOPgKSZqb32prW0miMk,1142
+parsedoc/schema/validation.py,sha256=3XReGUt1gdwqPwcXgscT4LpwGWJ051mbOxKp34xlzaU,896
+parsedoc/tests/AYANTRA TECHNOLOGIES - Official Commercial Pricing & Service Engagement Framework.docx,sha256=g5ndZKLggpbk8NS7wterCgSqOkoyA4YPc5fFa8tNyig,1995630
+parsedoc/tests/Ayantra  - Quotation Quotation-AY-QT-2026-001.docx,sha256=O1l-D2AMvFowrVqNANUi0qPXZHfZJDbNO5HAg9YbJJE,422551
+parsedoc/tests/Presentation-1.pptx,sha256=KlMpG4dk9117FEJQzdY1CfO91NhYjzQJLPg9YNKP5Mo,1753060
+parsedoc/utils/__init__.py,sha256=ZCvDs_noYPDmsoVYFhmJrMF7sulbzOPmtJuUGd38J9U,450
+parsedoc/utils/filesystem.py,sha256=kNtvxcNL9Z2Qv2thorfNKRblllA418HTpEjDLrFAGic,930
+parsedoc/utils/logging.py,sha256=31WnTaL6CEAr00vf93CktoTDk105wiuOJ3w6nxoGNco,795
+parsedoc/utils/timing.py,sha256=goESFFeTKCWjsgkhvGVVLWWNXcqmNvWovUOjP89aPmA,954
+docpilot_ai-0.2.0.dist-info/METADATA,sha256=r915tskRhaYS-1dhbCbcpk0QZLUZPGtjG0K9M7u9o3I,8455
+docpilot_ai-0.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+docpilot_ai-0.2.0.dist-info/entry_points.txt,sha256=oz_b-Rlrxb8eBVa6EoYmxUWcFcujf7onbcJGMzn-wEU,46
+docpilot_ai-0.2.0.dist-info/RECORD,,

docpilot_ai-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

docpilot_ai-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+parsedoc = parsedoc.cli:app

parsedoc/__init__.py

@@ -0,0 +1,3 @@
+"""ParseDoc - AI-powered document to Markdown conversion CLI"""
+
+__version__ = "0.2.0"

parsedoc/__main__.py

@@ -0,0 +1,6 @@
+"""ParseDoc package entry point for ``python -m parsedoc``."""
+
+from .cli import app
+
+if __name__ == "__main__":
+    app()

parsedoc/ai/__init__.py

@@ -0,0 +1,21 @@
+"""ParseDoc AI package"""
+
+from .base import AIProvider, build_provider
+from .compatible import OpenAICompatibleProvider
+from .openai import OpenAIProvider
+from .gemini import GeminiProvider
+from .ollama import OllamaProvider
+from .prompts import PROMPT_VERSION, get_prompt
+from . import cache
+
+__all__ = [
+    "AIProvider",
+    "build_provider",
+    "OpenAICompatibleProvider",
+    "OpenAIProvider",
+    "GeminiProvider",
+    "OllamaProvider",
+    "PROMPT_VERSION",
+    "get_prompt",
+    "cache",
+]

parsedoc/ai/base.py

@@ -0,0 +1,59 @@
+"""ParseDoc AI Provider abstraction (PRD #12)"""
+
+import abc
+from typing import Optional
+
+
+class AIProvider(abc.ABC):
+    """Abstract interface for AI providers.
+
+    Every provider must implement :meth:`generate`, which takes a prompt and
+    content and returns the model's raw text response.
+    """
+
+    name: str = "base"
+    model: str = ""
+
+    @abc.abstractmethod
+    def generate(self, prompt: str, content: str) -> str:
+        """Generate a response from the model for the given prompt + content."""
+        raise NotImplementedError
+
+    def is_available(self) -> bool:
+        """Return True if the provider can be used (dependencies/config present)."""
+        return True
+
+
+def build_provider(
+    provider: Optional[str] = None,
+    base_url: Optional[str] = None,
+    model: Optional[str] = None,
+    api_key: Optional[str] = None,
+) -> AIProvider:
+    """Factory that returns an AIProvider instance by name.
+
+    Supported names: openai-compatible, openai, gemini, ollama.
+    """
+    provider = (provider or "openai-compatible").lower()
+
+    if provider in ("openai-compatible", "vllm", "lm-studio"):
+        from .compatible import OpenAICompatibleProvider
+
+        return OpenAICompatibleProvider(base_url=base_url, model=model, api_key=api_key)
+
+    if provider == "ollama":
+        from .ollama import OllamaProvider
+
+        return OllamaProvider(base_url=base_url, model=model, api_key=api_key)
+
+    if provider == "openai":
+        from .openai import OpenAIProvider
+
+        return OpenAIProvider(base_url=base_url, model=model, api_key=api_key)
+
+    if provider == "gemini":
+        from .gemini import GeminiProvider
+
+        return GeminiProvider(base_url=base_url, model=model, api_key=api_key)
+
+    raise ValueError(f"Unknown AI provider: {provider}")

parsedoc/ai/cache.py

@@ -0,0 +1,47 @@
+"""ParseDoc AI Cache (PRD #22, #46)"""
+
+import hashlib
+import json
+import os
+from pathlib import Path
+from typing import Dict, Optional
+
+from ..utils.filesystem import default_cache_dir
+
+
+def _hash_inputs(content: str, model: str, prompt_version: str, config_hash: str) -> str:
+    payload = f"{content}|{model}|{prompt_version}|{config_hash}"
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+def _config_hash(config: Dict) -> str:
+    return hashlib.sha256(json.dumps(config, sort_keys=True).encode("utf-8")).hexdigest()
+
+
+def cache_path() -> Path:
+    path = Path(default_cache_dir())
+    path.mkdir(parents=True, exist_ok=True)
+    return path / "ai_cache.json"
+
+
+def get_cache() -> Dict:
+    p = cache_path()
+    if p.exists():
+        try:
+            return json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            return {}
+    return {}
+
+
+def lookup(content: str, model: str, prompt_version: str, config: Dict) -> Optional[str]:
+    cache = get_cache()
+    key = _hash_inputs(content, model, prompt_version, _config_hash(config))
+    return cache.get(key)
+
+
+def store(content: str, model: str, prompt_version: str, config: Dict, result: str):
+    cache = get_cache()
+    key = _hash_inputs(content, model, prompt_version, _config_hash(config))
+    cache[key] = result
+    cache_path().write_text(json.dumps(cache, indent=2), encoding="utf-8")

parsedoc/ai/compatible.py

@@ -0,0 +1,58 @@
+"""ParseDoc OpenAI-compatible AI provider (PRD #13, P0)"""
+
+from typing import Optional
+
+from .base import AIProvider
+
+
+class OpenAICompatibleProvider(AIProvider):
+    """Provider that talks to any OpenAI-compatible chat completions API.
+
+    Works with OpenAI, Ollama, LM Studio, vLLM, etc. by pointing ``base_url``
+    at the server's ``/v1`` endpoint.
+    """
+
+    name = "openai-compatible"
+
+    def __init__(
+        self,
+        base_url: Optional[str] = "http://localhost:11434/v1",
+        model: Optional[str] = "qwen3",
+        api_key: Optional[str] = "local",
+    ):
+        self.base_url = base_url or "http://localhost:11434/v1"
+        self.model = model or "qwen3"
+        self.api_key = api_key or "local"
+
+    def generate(self, prompt: str, content: str) -> str:
+        try:
+            from openai import OpenAI
+        except ImportError as e:
+            raise RuntimeError(
+                "The 'openai' package is required for OpenAI-compatible providers. "
+                "Install with: pip install openai"
+            ) from e
+
+        client = OpenAI(
+            base_url=self.base_url,
+            api_key=self.api_key,
+            timeout=120,
+            max_retries=1,
+        )
+        response = client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": content},
+            ],
+            temperature=0.2,
+        )
+        return response.choices[0].message.content or ""
+
+    def is_available(self) -> bool:
+        try:
+            import openai  # noqa: F401
+
+            return True
+        except ImportError:
+            return False

parsedoc/ai/gemini.py

@@ -0,0 +1,38 @@
+"""ParseDoc Gemini provider (PRD #14, P1)"""
+
+from typing import Optional
+
+from .base import AIProvider
+
+
+class GeminiProvider(AIProvider):
+    name = "gemini"
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        model: Optional[str] = "gemini-1.5-flash",
+        api_key: Optional[str] = None,
+    ):
+        self.model = model or "gemini-1.5-flash"
+        self.api_key = api_key
+
+    def generate(self, prompt: str, content: str) -> str:
+        try:
+            import google.generativeai as genai
+        except ImportError as e:
+            raise RuntimeError(
+                "The 'google-generativeai' package is required. "
+                "Install with: pip install google-generativeai"
+            ) from e
+
+        if not self.api_key:
+            raise RuntimeError("Gemini requires an API key (GEMINI_API_KEY/GOOGLE_API_KEY).")
+
+        genai.configure(api_key=self.api_key)
+        model = genai.GenerativeModel(self.model)
+        response = model.generate_content(f"{prompt}\n\n{content}")
+        return response.text or ""
+
+    def is_available(self) -> bool:
+        return bool(self.api_key)

parsedoc/ai/ollama.py

@@ -0,0 +1,59 @@
+"""ParseDoc Ollama provider (PRD #14, P1) - native Ollama API.
+
+Uses the local Ollama REST API via the standard library so no extra SDK is
+required. Ollama also exposes an OpenAI-compatible ``/v1`` endpoint, but this
+implementation talks to ``/api/chat`` directly and requests JSON output.
+"""
+
+from typing import Optional
+
+from .base import AIProvider
+
+
+class OllamaProvider(AIProvider):
+    name = "ollama"
+
+    def __init__(
+        self,
+        base_url: Optional[str] = "http://localhost:11434",
+        model: Optional[str] = "qwen3",
+        api_key: Optional[str] = "ollama",
+    ):
+        self.base_url = (base_url or "http://localhost:11434").rstrip("/")
+        self.model = model or "qwen3"
+        self.api_key = api_key
+
+    def generate(self, prompt: str, content: str) -> str:
+        import json
+        import urllib.request
+
+        url = f"{self.base_url}/api/chat"
+        payload = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": content},
+            ],
+            "stream": False,
+            "format": "json",
+        }
+        request = urllib.request.Request(
+            url,
+            data=json.dumps(payload).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=300) as response:
+                data = json.loads(response.read().decode("utf-8"))
+            return data["message"]["content"] or ""
+        except Exception as exc:  # noqa: BLE001
+            raise RuntimeError(f"Ollama request failed: {exc}") from exc
+
+    def is_available(self) -> bool:
+        import urllib.request
+
+        try:
+            urllib.request.urlopen(f"{self.base_url}/api/tags", timeout=3)
+            return True
+        except Exception:
+            return False

parsedoc/ai/openai.py

@@ -0,0 +1,41 @@
+"""ParseDoc OpenAI provider (PRD #14, P2)"""
+
+from typing import Optional
+
+from .base import AIProvider
+
+
+class OpenAIProvider(AIProvider):
+    name = "openai"
+
+    def __init__(
+        self,
+        base_url: Optional[str] = "https://api.openai.com/v1",
+        model: Optional[str] = "gpt-4o-mini",
+        api_key: Optional[str] = None,
+    ):
+        self.base_url = base_url or "https://api.openai.com/v1"
+        self.model = model or "gpt-4o-mini"
+        self.api_key = api_key
+
+    def generate(self, prompt: str, content: str) -> str:
+        try:
+            from openai import OpenAI
+        except ImportError as e:
+            raise RuntimeError(
+                "The 'openai' package is required. Install with: pip install openai"
+            ) from e
+
+        client = OpenAI(base_url=self.base_url, api_key=self.api_key)
+        response = client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": content},
+            ],
+            temperature=0.2,
+        )
+        return response.choices[0].message.content or ""
+
+    def is_available(self) -> bool:
+        return bool(self.api_key)