feat(api): forward loader/chunker/extractor/resolver from apply_changes to ingest/update

graphrag_sdk/src/graphrag_sdk/api/main.py

@@ -1219,6 +1219,10 @@ async def apply_changes(
         added: list[str] | None = None,
         modified: list[str] | None = None,
         deleted: list[str] | None = None,
+        loader: LoaderStrategy | None = None,
+        chunker: ChunkingStrategy | None = None,
+        extractor: ExtractionStrategy | None = None,
+        resolver: ResolutionStrategy | None = None,
         max_concurrency: int = 3,
         update_concurrency: int = 1,
         ctx: Context | None = None,
@@ -1263,6 +1267,15 @@ async def apply_changes(
             added: New file paths to ingest.
             modified: File paths whose content changed.
             deleted: Document ids (typically file paths) to remove.
+            loader: Override the loader for ``added``/``modified`` (forwarded
+                to ``ingest()`` and ``update()``). Defaults to per-extension
+                auto-selection. ``deleted`` ignores this.
+            chunker: Override the chunking strategy for ``added``/``modified``.
+                Defaults to ``FixedSizeChunking``. ``deleted`` ignores this.
+            extractor: Override the entity-extraction strategy for
+                ``added``/``modified``. ``deleted`` ignores this.
+            resolver: Override the resolution strategy for ``added``/
+                ``modified``. ``deleted`` ignores this.
             max_concurrency: Parallelism cap for ``ingest()`` of the
                 ``added`` list. Matches ``ingest()``'s own knob and the
                 ``add`` step is pure ingestion with no orphan-cleanup
@@ -1351,6 +1364,10 @@ async def _update_one(path: str) -> BatchEntry[UpdateResult]:
                     return BatchEntry.ok(
                         await self.update(
                             path,
+                            loader=loader,
+                            chunker=chunker,
+                            extractor=extractor,
+                            resolver=resolver,
                             if_missing="ingest",
                             ctx=ctx.child(),
                         )
@@ -1376,6 +1393,10 @@ async def _update_one(path: str) -> BatchEntry[UpdateResult]:
         if added:
             batch_out = await self.ingest(
                 added,
+                loader=loader,
+                chunker=chunker,
+                extractor=extractor,
+                resolver=resolver,
                 max_concurrency=max_concurrency,
                 ctx=ctx,
             )
@@ -2027,6 +2048,10 @@ def apply_changes_sync(
         added: list[str] | None = None,
         modified: list[str] | None = None,
         deleted: list[str] | None = None,
+        loader: LoaderStrategy | None = None,
+        chunker: ChunkingStrategy | None = None,
+        extractor: ExtractionStrategy | None = None,
+        resolver: ResolutionStrategy | None = None,
         max_concurrency: int = 3,
         update_concurrency: int = 1,
         ctx: Context | None = None,
@@ -2045,6 +2070,10 @@ def apply_changes_sync(
                 added=added,
                 modified=modified,
                 deleted=deleted,
+                loader=loader,
+                chunker=chunker,
+                extractor=extractor,
+                resolver=resolver,
                 max_concurrency=max_concurrency,
                 update_concurrency=update_concurrency,
                 ctx=ctx,

graphrag_sdk/tests/test_facade.py

@@ -1737,6 +1737,78 @@ async def test_overlapping_ids_across_buckets_raises(
         with pytest.raises(ValueError, match=label_fragment):
             await graphrag.apply_changes(**kwargs)
 
+    async def test_strategy_overrides_forward_to_ingest_and_update(
+        self, graphrag, monkeypatch
+    ):
+        """``loader``/``chunker``/``extractor``/``resolver`` must reach the
+        inner ``ingest()`` and ``update()`` calls. Without forwarding,
+        CI callers using ``apply_changes`` as their single entrypoint
+        silently lose per-graph strategy customisation — the SDK falls
+        back to defaults instead."""
+        from graphrag_sdk.core.models import IngestionResult, UpdateResult
+        from graphrag_sdk.ingestion.chunking_strategies.fixed_size import FixedSizeChunking
+        from graphrag_sdk.ingestion.loaders.markdown_loader import MarkdownLoader
+        from graphrag_sdk.ingestion.resolution_strategies.exact_match import ExactMatchResolution
+
+        loader = MarkdownLoader()
+        chunker = FixedSizeChunking(chunk_size=500, chunk_overlap=50)
+        extractor = MagicMock()
+        resolver = ExactMatchResolution()
+
+        captured: dict[str, dict] = {"ingest": {}, "update": {}}
+
+        async def fake_ingest(source, **kwargs):
+            captured["ingest"] = dict(kwargs, source=source)
+            return [IngestionResult(document_id="a.md", chunks=0, entities=0, relations=0)]
+
+        async def fake_update(source, **kwargs):
+            captured["update"] = dict(kwargs, source=source)
+            return UpdateResult(
+                document_id="m.md", action="updated", chunks=0, entities=0, relations=0,
+            )
+
+        monkeypatch.setattr(graphrag, "ingest", fake_ingest)
+        monkeypatch.setattr(graphrag, "update", fake_update)
+
+        await graphrag.apply_changes(
+            added=["a.md"], modified=["m.md"],
+            loader=loader, chunker=chunker, extractor=extractor, resolver=resolver,
+        )
+
+        for inner in ("ingest", "update"):
+            assert captured[inner]["loader"] is loader
+            assert captured[inner]["chunker"] is chunker
+            assert captured[inner]["extractor"] is extractor
+            assert captured[inner]["resolver"] is resolver
+
+    async def test_strategy_overrides_default_to_none(
+        self, graphrag, monkeypatch
+    ):
+        """Default behaviour is unchanged: callers who don't pass strategies
+        get ``None`` forwarded, which the SDK reads as "use defaults"."""
+        from graphrag_sdk.core.models import IngestionResult, UpdateResult
+
+        captured: dict[str, dict] = {"ingest": {}, "update": {}}
+
+        async def fake_ingest(source, **kwargs):
+            captured["ingest"] = dict(kwargs)
+            return [IngestionResult(document_id="a.md", chunks=0, entities=0, relations=0)]
+
+        async def fake_update(source, **kwargs):
+            captured["update"] = dict(kwargs)
+            return UpdateResult(
+                document_id="m.md", action="updated", chunks=0, entities=0, relations=0,
+            )
+
+        monkeypatch.setattr(graphrag, "ingest", fake_ingest)
+        monkeypatch.setattr(graphrag, "update", fake_update)
+
+        await graphrag.apply_changes(added=["a.md"], modified=["m.md"])
+
+        for inner in ("ingest", "update"):
+            for k in ("loader", "chunker", "extractor", "resolver"):
+                assert captured[inner][k] is None
+
 
 class TestGraphRAGUpdateSyncWrapper:
     """v1.1.0: sync wrappers mirror the async signatures."""