xyberos-documents 0.1.0__tar.gz

xyberos_documents-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: xyberos-documents
+Version: 0.1.0
+Summary: Filesystem + document loaders plugin (M1): PDF, DOCX, HTML, CSV, XLSX -> IngestingKnowledge
+License: Apache-2.0
+Keywords: xyberos,plugin,documents,loader,knowledge,ingestion
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: xyberos>=1.0
+Provides-Extra: documents
+Requires-Dist: pypdf; extra == "documents"
+Requires-Dist: python-docx; extra == "documents"
+Requires-Dist: openpyxl; extra == "documents"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+# xyberos-documents
+
+**Filesystem + document loaders plugin — RFC-0019, M1.** Turns plain-text-only
+ingestion into real document ingestion.
+
+Loaders return text chunks consumed by
+[`IngestingKnowledge.ingest`](https://docs.xyberos.com):
+
+| Loader | Formats | Dependency |
+| ------ | ------- | ---------- |
+| `FileLoader` | `.md .txt .json .py .rst …` + directory walks | stdlib only |
+| `HtmlLoader` | `.html .htm` (tag stripping) | stdlib only |
+| `CsvLoader` | `.csv` | stdlib only |
+| `PdfLoader` | `.pdf` | lazy `pypdf` / `PyPDF2` / `pymupdf` |
+| `DocxLoader` | `.docx` | lazy `python-docx` |
+| `XlsxLoader` | `.xlsx .xlsm` | lazy `openpyxl` |
+
+The stdlib loaders keep the zero-dependency core sacred; the binary loaders
+import their backend lazily and raise a clear `ProviderError` when missing.
+
+## Install
+
+```bash
+pip install -e ./documents
+# PDF/DOCX/XLSX backends (also available as the core extra):
+pip install xyberos[documents]     # pypdf, python-docx, openpyxl
+```
+
+## Usage
+
+Load a document as text chunks, then feed `IngestingKnowledge`:
+
+```python
+from xyberos import create_app
+from xyberos.knowledge import IngestingKnowledge
+from xyberos.llm import HashEmbedder
+from xyberos.vector import SqliteVectorStore
+from xyberos_documents import DocumentsPlugin, load_document
+
+app = create_app(
+    knowledge=IngestingKnowledge(SqliteVectorStore("learning.db"), embedder=HashEmbedder())
+)
+app.load_plugin(DocumentsPlugin())
+
+app.tools.execute("ingest_document", None, path="report.pdf", chunk_size=512)
+app.tools.execute("ingest_directory", None, path="docs/", extensions=[".pdf", ".docx"])
+```
+
+Each loader can also be used standalone (no app required):
+
+```python
+from xyberos_documents import PdfLoader, DocxLoader, HtmlLoader, load_document
+
+for doc in PdfLoader().load("report.pdf"):
+    print(doc.text)
+```
+
+## Tools registered
+
+- `ingest_document(path, chunk_size=512, loader=None)` — auto-detect by
+  extension (`loader` can force `text`/`html`/`pdf`/`docx`/`csv`/`xlsx`).
+- `ingest_directory(path, extensions=None, chunk_size=512, recursive=True)` —
+  walk a folder and route each file to the right loader.
+
+Both require the registered `knowledge` provider to support `ingest()` (an
+`IngestingKnowledge`); otherwise a clear `ProviderError` is raised.
+
+## Examples
+
+- `examples/ingest_documents.py` — generates a sample PDF + DOCX and ingests
+  both, then queries the knowledge base.
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+Optional-dep tests (`pdf`, `docx`, `xlsx`) skip cleanly when their library is
+not installed — the same pattern as the core's `test_sentence_embedder.py`.
+
+## Contract & ship location
+
+- **Contract:** `Knowledge` (via `IngestingKnowledge`), plus `Tool` for the
+  two ingest tools.
+- **Ship:** `FileLoader` / `HtmlLoader` / `CsvLoader` are stdlib (would be
+  Core); `PdfLoader` / `DocxLoader` / `XlsxLoader` map to the `[documents]`
+  extra.
+- **Dependencies:** `xyberos>=1.0`; optional `[documents]` for binary formats.

xyberos_documents-0.1.0/README.md

@@ -0,0 +1,90 @@
+# xyberos-documents
+
+**Filesystem + document loaders plugin — RFC-0019, M1.** Turns plain-text-only
+ingestion into real document ingestion.
+
+Loaders return text chunks consumed by
+[`IngestingKnowledge.ingest`](https://docs.xyberos.com):
+
+| Loader | Formats | Dependency |
+| ------ | ------- | ---------- |
+| `FileLoader` | `.md .txt .json .py .rst …` + directory walks | stdlib only |
+| `HtmlLoader` | `.html .htm` (tag stripping) | stdlib only |
+| `CsvLoader` | `.csv` | stdlib only |
+| `PdfLoader` | `.pdf` | lazy `pypdf` / `PyPDF2` / `pymupdf` |
+| `DocxLoader` | `.docx` | lazy `python-docx` |
+| `XlsxLoader` | `.xlsx .xlsm` | lazy `openpyxl` |
+
+The stdlib loaders keep the zero-dependency core sacred; the binary loaders
+import their backend lazily and raise a clear `ProviderError` when missing.
+
+## Install
+
+```bash
+pip install -e ./documents
+# PDF/DOCX/XLSX backends (also available as the core extra):
+pip install xyberos[documents]     # pypdf, python-docx, openpyxl
+```
+
+## Usage
+
+Load a document as text chunks, then feed `IngestingKnowledge`:
+
+```python
+from xyberos import create_app
+from xyberos.knowledge import IngestingKnowledge
+from xyberos.llm import HashEmbedder
+from xyberos.vector import SqliteVectorStore
+from xyberos_documents import DocumentsPlugin, load_document
+
+app = create_app(
+    knowledge=IngestingKnowledge(SqliteVectorStore("learning.db"), embedder=HashEmbedder())
+)
+app.load_plugin(DocumentsPlugin())
+
+app.tools.execute("ingest_document", None, path="report.pdf", chunk_size=512)
+app.tools.execute("ingest_directory", None, path="docs/", extensions=[".pdf", ".docx"])
+```
+
+Each loader can also be used standalone (no app required):
+
+```python
+from xyberos_documents import PdfLoader, DocxLoader, HtmlLoader, load_document
+
+for doc in PdfLoader().load("report.pdf"):
+    print(doc.text)
+```
+
+## Tools registered
+
+- `ingest_document(path, chunk_size=512, loader=None)` — auto-detect by
+  extension (`loader` can force `text`/`html`/`pdf`/`docx`/`csv`/`xlsx`).
+- `ingest_directory(path, extensions=None, chunk_size=512, recursive=True)` —
+  walk a folder and route each file to the right loader.
+
+Both require the registered `knowledge` provider to support `ingest()` (an
+`IngestingKnowledge`); otherwise a clear `ProviderError` is raised.
+
+## Examples
+
+- `examples/ingest_documents.py` — generates a sample PDF + DOCX and ingests
+  both, then queries the knowledge base.
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+Optional-dep tests (`pdf`, `docx`, `xlsx`) skip cleanly when their library is
+not installed — the same pattern as the core's `test_sentence_embedder.py`.
+
+## Contract & ship location
+
+- **Contract:** `Knowledge` (via `IngestingKnowledge`), plus `Tool` for the
+  two ingest tools.
+- **Ship:** `FileLoader` / `HtmlLoader` / `CsvLoader` are stdlib (would be
+  Core); `PdfLoader` / `DocxLoader` / `XlsxLoader` map to the `[documents]`
+  extra.
+- **Dependencies:** `xyberos>=1.0`; optional `[documents]` for binary formats.

xyberos_documents-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xyberos-documents"
+version = "0.1.0"
+description = "Filesystem + document loaders plugin (M1): PDF, DOCX, HTML, CSV, XLSX -> IngestingKnowledge"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+dependencies = ["xyberos>=1.0"]
+keywords = ["xyberos", "plugin", "documents", "loader", "knowledge", "ingestion"]
+
+[project.optional-dependencies]
+documents = [
+    "pypdf",
+    "python-docx",
+    "openpyxl",
+]
+test = [
+    "pytest",
+]
+
+[project.entry-points."xyberos.plugins"]
+documents = "xyberos_documents.plugin:plugin"
+
+[tool.setuptools]
+packages = ["xyberos_documents"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]

xyberos_documents-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xyberos_documents-0.1.0/tests/test_csv_loader.py

@@ -0,0 +1,20 @@
+"""Tests for the stdlib CsvLoader."""
+
+from __future__ import annotations
+
+from xyberos_documents import CsvLoader
+
+_CSV = "name,value\nalpha,1\nbeta,2\n"
+
+
+def test_parses_rows(tmp_path):
+    path = tmp_path / "data.csv"
+    path.write_text(_CSV, encoding="utf-8")
+    docs = CsvLoader().load(str(path))
+    assert len(docs) == 1
+    text = docs[0].text
+    assert "name | value" in text
+    assert "alpha | 1" in text
+    assert "beta | 2" in text
+    assert docs[0].metadata["columns"] == ["name", "value"]
+    assert docs[0].metadata["row_count"] == 3

xyberos_documents-0.1.0/tests/test_docx_loader.py

@@ -0,0 +1,16 @@
+"""Tests for the lazy DocxLoader (skips when python-docx is missing)."""
+
+from __future__ import annotations
+
+from xyberos_documents import DocxLoader
+
+
+def test_extracts_paragraphs_and_tables(sample_docx):
+    docs = DocxLoader().load(str(sample_docx))
+    assert len(docs) == 1
+    text = docs[0].text
+    assert "First paragraph." in text
+    assert "Second paragraph." in text
+    assert "Alpha" in text
+    assert "Name | Value" in text
+    assert docs[0].metadata["tables"] == 1

xyberos_documents-0.1.0/tests/test_file_loader.py

@@ -0,0 +1,40 @@
+"""Tests for the stdlib FileLoader."""
+
+from __future__ import annotations
+
+import pytest
+
+from xyberos_documents import FileLoader
+
+
+def test_load_single_file(sample_txt):
+    docs = FileLoader().load(str(sample_txt))
+    assert len(docs) == 1
+    assert "quick brown fox" in docs[0].text
+    assert docs[0].metadata["extension"] == ".md"
+
+
+def test_load_directory_recursive_with_extension_filter(sample_dir):
+    docs = FileLoader(extensions=[".md", ".txt"]).load(str(sample_dir))
+    sources = {d.source for d in docs}
+    assert len(sources) == 3  # a.md, b.txt, nested/c.md
+    assert not any("skip.md" in s for s in sources)  # hidden dir skipped
+
+
+def test_load_directory_non_recursive(sample_dir):
+    docs = FileLoader(extensions=[".md"], recursive=False).load(str(sample_dir))
+    assert {d.source for d in docs} == {str(sample_dir / "a.md")}
+
+
+def test_chunking(sample_txt):
+    long_text = "\n\n".join(f"Paragraph number {i} with enough words to split." for i in range(20))
+    sample_txt.write_text(long_text, encoding="utf-8")
+    docs = FileLoader(chunk_size=50).load(str(sample_txt))
+    assert len(docs) > 1
+    assert all(len(d.text) <= 50 for d in docs)
+    assert docs[0].metadata["chunk"] == 0
+
+
+def test_missing_path_raises(tmp_path):
+    with pytest.raises(FileNotFoundError):
+        FileLoader().load(str(tmp_path / "nope.txt"))

xyberos_documents-0.1.0/tests/test_html_loader.py

@@ -0,0 +1,40 @@
+"""Tests for the stdlib HtmlLoader."""
+
+from __future__ import annotations
+
+from xyberos_documents import HtmlLoader
+
+_HTML = """
+<html>
+  <head><title>Test Page</title></head>
+  <body>
+    <h1>Heading</h1>
+    <p>Some <b>bold</b> text.</p>
+    <script>var secret = "no";</script>
+    <style>.hidden { color: red; }</style>
+    <p>After script.</p>
+  </body>
+</html>
+"""
+
+
+def test_strips_tags_and_script(tmp_path):
+    path = tmp_path / "page.html"
+    path.write_text(_HTML, encoding="utf-8")
+    docs = HtmlLoader().load(str(path))
+    assert len(docs) == 1
+    text = docs[0].text
+    assert "Some bold text." in text
+    assert "After script." in text
+    assert "Heading" in text
+    assert "var secret" not in text
+    assert ".hidden" not in text
+    assert docs[0].metadata["title"] == "Test Page"
+
+
+def test_chunking(tmp_path):
+    body = "".join(f"<p>Sentence {i} here.</p>" for i in range(30))
+    path = tmp_path / "big.html"
+    path.write_text(f"<html><body>{body}</body></html>", encoding="utf-8")
+    docs = HtmlLoader(chunk_size=60).load(str(path))
+    assert len(docs) > 1

xyberos_documents-0.1.0/tests/test_pdf_loader.py

@@ -0,0 +1,20 @@
+"""Tests for the lazy PdfLoader (skips when no PDF library is installed)."""
+
+from __future__ import annotations
+
+import importlib.util
+
+import pytest
+
+from xyberos_documents import PdfLoader
+
+PDF_LIBS = ("pypdf", "PyPDF2", "fitz")
+
+
+def test_extracts_text(sample_pdf):
+    if not any(importlib.util.find_spec(lib) for lib in PDF_LIBS):
+        pytest.skip("no pypdf / PyPDF2 / PyMuPDF available")
+    docs = PdfLoader().load(str(sample_pdf))
+    assert len(docs) == 1
+    assert "Hello Xyberos PDF" in docs[0].text
+    assert docs[0].metadata["pages"] == 1

xyberos_documents-0.1.0/tests/test_plugin.py

@@ -0,0 +1,79 @@
+"""Tests for loading the documents plugin into a Xyberos app."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+from xyberos import create_app
+from xyberos.exceptions.provider import ProviderError
+from xyberos.knowledge import IngestingKnowledge
+from xyberos.llm import HashEmbedder
+from xyberos.vector import SqliteVectorStore
+
+from xyberos_documents import DocumentsPlugin
+
+
+def _app_with_ingesting_knowledge():
+    knowledge = IngestingKnowledge(SqliteVectorStore(":memory:"), embedder=HashEmbedder())
+    return create_app(knowledge=knowledge)
+
+
+def test_plugin_conforms_to_contract():
+    plugin = DocumentsPlugin()
+    assert plugin.name == "documents"
+    assert callable(plugin.register) and callable(plugin.unregister)
+    assert {tool.name for tool in plugin.tools()} == {"ingest_document", "ingest_directory"}
+
+
+def test_ingest_document(sample_txt):
+    app = _app_with_ingesting_knowledge()
+    app.load_plugin(DocumentsPlugin())
+    result = app.tools.execute("ingest_document", None, path=str(sample_txt))
+    assert result["documents"] == 1
+    assert result["chunks"] == 1
+    # Exact-match query against the ingested chunk returns the fact.
+    knowledge = app.knowledge
+    rendered = knowledge.query(SimpleNamespace(prompt="The quick brown fox jumps over the lazy dog."))
+    assert "The quick brown fox jumps over the lazy dog." in rendered
+    app.unload_plugin("documents")
+
+
+def test_ingest_directory(sample_dir):
+    app = _app_with_ingesting_knowledge()
+    app.load_plugin(DocumentsPlugin())
+    result = app.tools.execute(
+        "ingest_directory", None, path=str(sample_dir), extensions=[".md"]
+    )
+    assert result["documents"] == 2  # a.md + nested/c.md
+    assert result["chunks"] == 2
+    app.unload_plugin("documents")
+
+
+def test_ingest_directory_mixed_formats(sample_dir, sample_pdf):
+    import importlib.util
+
+    if not any(importlib.util.find_spec(lib) for lib in ("pypdf", "PyPDF2", "fitz")):
+        pytest.skip("no PDF library available")
+    # The sample_dir fixture is tmp_path, and sample_pdf writes into the same
+    # tmp_path — so the walk covers every format automatically.
+    app = _app_with_ingesting_knowledge()
+    app.load_plugin(DocumentsPlugin())
+    # a.md, b.txt, page.html, nested/c.md, sample.pdf
+    result = app.tools.execute(
+        "ingest_directory",
+        None,
+        path=str(sample_dir),
+        extensions=[".md", ".txt", ".html", ".pdf"],
+    )
+    assert result["documents"] == 5
+    assert result["chunks"] >= 5
+    app.unload_plugin("documents")
+
+
+def test_ingest_requires_ingesting_knowledge():
+    app = create_app()  # default InMemoryKnowledge — no ingest()
+    app.load_plugin(DocumentsPlugin())
+    with pytest.raises(ProviderError, match="ingest"):
+        app.tools.execute("ingest_document", None, path="anything.md")
+    app.unload_plugin("documents")

xyberos_documents-0.1.0/tests/test_registry.py

@@ -0,0 +1,54 @@
+"""Tests for extension -> loader routing."""
+
+from __future__ import annotations
+
+import importlib.util
+
+import pytest
+
+from xyberos_documents import (
+    CsvLoader,
+    DocxLoader,
+    FileLoader,
+    HtmlLoader,
+    PdfLoader,
+    XlsxLoader,
+    get_loader,
+    load_document,
+    loader_for,
+)
+
+
+def test_loader_for_known_extensions():
+    assert isinstance(loader_for(".html"), HtmlLoader)
+    assert isinstance(loader_for(".htm"), HtmlLoader)
+    assert isinstance(loader_for(".pdf"), PdfLoader)
+    assert isinstance(loader_for(".docx"), DocxLoader)
+    assert isinstance(loader_for(".csv"), CsvLoader)
+    assert isinstance(loader_for(".xlsx"), XlsxLoader)
+
+
+def test_loader_for_defaults_to_text():
+    loader = loader_for(".md")
+    assert isinstance(loader, FileLoader)
+    assert "md" in loader.extensions
+
+
+def test_get_loader_by_name():
+    assert isinstance(get_loader("html"), HtmlLoader)
+    assert isinstance(get_loader("pdf"), PdfLoader)
+    assert isinstance(get_loader("text"), FileLoader)
+
+
+def test_get_loader_unknown_raises():
+    with pytest.raises(ValueError, match="unknown loader"):
+        get_loader("bogus")
+
+
+def test_load_document_auto_detect(tmp_path, sample_pdf, sample_docx):
+    md = tmp_path / "note.md"
+    md.write_text("Markdown text.", encoding="utf-8")
+    assert load_document(str(md))[0].text == "Markdown text."
+    if any(importlib.util.find_spec(lib) for lib in ("pypdf", "PyPDF2", "fitz")):
+        assert "Hello Xyberos PDF" in load_document(str(sample_pdf))[0].text
+    assert load_document(str(sample_docx))[0].metadata["extension"] == ".docx"

xyberos_documents-0.1.0/tests/test_xlsx_loader.py

@@ -0,0 +1,17 @@
+"""Tests for the lazy XlsxLoader (skips when openpyxl is missing)."""
+
+from __future__ import annotations
+
+from xyberos_documents import XlsxLoader
+
+
+def test_parses_cells(sample_xlsx):
+    docs = XlsxLoader().load(str(sample_xlsx))
+    assert len(docs) == 1
+    text = docs[0].text
+    assert "# Sheet1" in text
+    assert "name | value" in text
+    assert "alpha | 1" in text
+    assert "beta | 2" in text
+    assert docs[0].metadata["sheets"] == ["Sheet1"]
+    assert docs[0].metadata["row_count"] == 3

xyberos_documents-0.1.0/xyberos_documents/__init__.py

@@ -0,0 +1,44 @@
+"""Filesystem + document loaders plugin (RFC-0019, M1).
+
+Turns plain-text-only ingestion into real document ingestion. Each loader
+returns text chunks that ``IngestingKnowledge.ingest`` consumes directly:
+
+* :class:`FileLoader` and :class:`HtmlLoader` are **stdlib-only** (the
+  zero-dependency core stays sacred).
+* :class:`PdfLoader`, :class:`DocxLoader` and :class:`XlsxLoader` import their
+  backend lazily and raise a clear ``ProviderError`` when it is missing
+  (``pip install xyberos[documents]`` provides ``pypdf`` / ``python-docx`` /
+  ``openpyxl``).
+* :class:`CsvLoader` is stdlib-only (``csv``).
+
+The :class:`~xyberos_documents.plugin.DocumentsPlugin` registers two tools —
+``ingest_document`` and ``ingest_directory`` — that feed the app's
+``IngestingKnowledge``.
+"""
+
+from .base import Document, Loader, chunk_text, chunk_documents
+from .csv_loader import CsvLoader
+from .docx_loader import DocxLoader
+from .file_loader import FileLoader
+from .html_loader import HtmlLoader
+from .pdf_loader import PdfLoader
+from .plugin import DocumentsPlugin
+from .registry import get_loader, load_document, loader_for
+from .xlsx_loader import XlsxLoader
+
+__all__ = [
+    "CsvLoader",
+    "Document",
+    "DocumentsPlugin",
+    "DocxLoader",
+    "FileLoader",
+    "HtmlLoader",
+    "Loader",
+    "PdfLoader",
+    "XlsxLoader",
+    "chunk_documents",
+    "chunk_text",
+    "get_loader",
+    "load_document",
+    "loader_for",
+]

xyberos_documents-0.1.0/xyberos_documents/base.py

@@ -0,0 +1,59 @@
+"""Shared types and text chunking for the documents plugin."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping, Protocol, runtime_checkable
+
+
+@dataclass
+class Document:
+    """One loaded document: its source, extracted text, and metadata."""
+
+    source: str
+    text: str
+    metadata: Mapping[str, Any] | None = None
+
+
+@runtime_checkable
+class Loader(Protocol):
+    """Any object that turns a path into a list of :class:`Document`."""
+
+    def load(self, path: str, **kwargs: Any) -> list[Document]: ...
+
+
+def chunk_text(text: str, chunk_size: int = 512) -> list[str]:
+    """Split ``text`` into paragraph-aware chunks of at most ``chunk_size`` chars.
+
+    Mirrors ``xyberos.knowledge.ingesting._chunk_text`` so the loaders and the
+    core agree on chunk boundaries.
+    """
+    if chunk_size <= 0:
+        raise ValueError("chunk_size must be a positive integer")
+    text = (text or "").strip()
+    if not text:
+        return []
+    paragraphs = [p.strip() for p in text.split("\n\n") if p.strip()]
+    chunks: list[str] = []
+    for paragraph in paragraphs:
+        if len(paragraph) <= chunk_size:
+            chunks.append(paragraph)
+        else:
+            chunks.extend(
+                paragraph[index : index + chunk_size]
+                for index in range(0, len(paragraph), chunk_size)
+            )
+    return chunks
+
+
+def chunk_documents(documents: list[Document], chunk_size: int | None) -> list[Document]:
+    """Expand each document into one :class:`Document` per chunk (if sized)."""
+    if chunk_size is None:
+        return documents
+    expanded: list[Document] = []
+    for doc in documents:
+        for index, chunk in enumerate(chunk_text(doc.text, chunk_size)):
+            metadata = dict(doc.metadata or {})
+            metadata["chunk"] = index
+            expanded.append(Document(source=doc.source, text=chunk, metadata=metadata))
+    return expanded

xyberos_documents-0.1.0/xyberos_documents/csv_loader.py

@@ -0,0 +1,39 @@
+"""CSV loader — stdlib-only (``csv``).
+
+Each row becomes one line with columns joined by ``" | "``; the first row is
+kept as the header line and also recorded in metadata.
+"""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+from .base import Document, chunk_documents
+
+
+class CsvLoader:
+    """Loads a CSV file as text (one line per row, columns joined)."""
+
+    def __init__(self, chunk_size: int | None = None, *, delimiter: str = ",") -> None:
+        self._chunk_size = chunk_size
+        self._delimiter = delimiter
+
+    def load(self, path: str) -> list[Document]:
+        path_obj = Path(path)
+        if not path_obj.is_file():
+            raise FileNotFoundError(path)
+        with path_obj.open(newline="", encoding="utf-8-sig") as handle:
+            rows = list(csv.reader(handle, delimiter=self._delimiter))
+        columns = rows[0] if rows else []
+        lines = [" | ".join(cell.strip() for cell in row) for row in rows]
+        document = Document(
+            source=str(path_obj),
+            text="\n".join(lines),
+            metadata={
+                "columns": columns,
+                "row_count": len(rows),
+                "extension": ".csv",
+            },
+        )
+        return chunk_documents([document], self._chunk_size)