feat: llm_auto flag + memory auto-enablement (#35)

- llm_auto: bool on GoldenMatchConfig, applied uniformly
- When llm_auto=True + API key: LLM scorer with $0.05 budget
- Memory enabled only when llm_auto=True
- Pipeline forwards llm_scorer and memory from auto-config

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: benzsevern

goldenmatch/_api.py

@@ -269,6 +269,7 @@ def dedupe_df(
     blocking: list[str] | None = None,
     threshold: float | None = None,
     llm_scorer: bool = False,
+    llm_auto: bool = False,
     backend: str | None = None,
     source_name: str = "dataframe",
 ) -> DedupeResult:
@@ -314,6 +315,8 @@ def dedupe_df(
     if llm_scorer and hasattr(config, "llm_scorer"):
         from goldenmatch.config.schemas import LLMScorerConfig
         config.llm_scorer = LLMScorerConfig(enabled=True)
+    if llm_auto and hasattr(config, "llm_auto"):
+        config.llm_auto = llm_auto
 
     result = run_dedupe_df(
         df, config, source_name=source_name,

goldenmatch/config/schemas.py

@@ -429,6 +429,7 @@ class GoldenMatchConfig(BaseModel):
     transform: TransformConfig | None = None
     llm_boost: bool = False
     llm_scorer: LLMScorerConfig | None = None
+    llm_auto: bool = False
     domain: DomainConfig | None = None
     backend: str | None = None  # None (default Polars), "ray", "duckdb"
     memory: MemoryConfig | None = None

goldenmatch/core/autoconfig.py

@@ -12,10 +12,13 @@
 from goldenmatch.config.schemas import (
     BlockingConfig,
     BlockingKeyConfig,
+    BudgetConfig,
     GoldenMatchConfig,
     GoldenRulesConfig,
+    LLMScorerConfig,
     MatchkeyConfig,
     MatchkeyField,
+    MemoryConfig,
     OutputConfig,
 )
 from goldenmatch.core.profiler import _guess_type
@@ -970,7 +973,10 @@ def select_model(row_count: int, has_embedding_columns: bool, threshold: int = 5
 
 # ── Main entry point ──────────────────────────────────────────────────────
 
-def auto_configure_df(df: pl.DataFrame, llm_provider: str | None = None, domain_config=None) -> GoldenMatchConfig:
+def auto_configure_df(
+    df: pl.DataFrame, llm_provider: str | None = None,
+    domain_config=None, llm_auto: bool = False,
+) -> GoldenMatchConfig:
     """Auto-generate a GoldenMatchConfig from a DataFrame.
 
     Profiles columns by name heuristics and data sampling, then builds
@@ -1139,12 +1145,37 @@ def auto_configure_df(df: pl.DataFrame, llm_provider: str | None = None, domain_
                         mk.name, original, mk.threshold, avg_null, avg_len,
                     )
 
+    # ── LLM auto-config ──
+    llm_scorer_config = None
+    if llm_auto:
+        import os
+        _provider = None
+        if os.environ.get("ANTHROPIC_API_KEY"):
+            _provider = "anthropic"
+        elif os.environ.get("OPENAI_API_KEY"):
+            _provider = "openai"
+        if _provider:
+            llm_scorer_config = LLMScorerConfig(
+                enabled=True,
+                candidate_lo=0.60,
+                candidate_hi=0.90,
+                auto_threshold=0.90,
+                budget=BudgetConfig(max_cost_usd=0.05),
+            )
+            logger.info("LLM scorer auto-enabled (provider=%s, budget=$0.05)", _provider)
+        else:
+            logger.info("llm_auto=True but no API key found")
+
+    memory_config = MemoryConfig(enabled=True) if llm_auto else None
+
     # Build config
     config = GoldenMatchConfig(
         matchkeys=matchkeys,
         blocking=blocking,
         golden_rules=GoldenRulesConfig(default_strategy="most_complete"),
         output=OutputConfig(),
+        llm_scorer=llm_scorer_config,
+        memory=memory_config,
     )
 
     return config

goldenmatch/core/pipeline.py

@@ -227,11 +227,17 @@ def _run_dedupe_pipeline(
     if auto_config:
         from goldenmatch.core.autoconfig import auto_configure_df
         combined_df_tmp = combined_lf.collect()
-        auto_cfg = auto_configure_df(combined_df_tmp, llm_provider=auto_config_llm_provider)
+        auto_cfg = auto_configure_df(
+            combined_df_tmp,
+            llm_provider=auto_config_llm_provider,
+            llm_auto=config.llm_auto,
+        )
         config.matchkeys = auto_cfg.matchkeys
         config.match_settings = auto_cfg.match_settings
         config.blocking = auto_cfg.blocking
         config.golden_rules = auto_cfg.golden_rules
+        config.llm_scorer = auto_cfg.llm_scorer
+        config.memory = auto_cfg.memory
         matchkeys = config.get_matchkeys()
         logger.info("Auto-configured from cleaned data: %d matchkeys", len(matchkeys))
         combined_lf = combined_df_tmp.lazy()

tests/test_autoconfig.py

@@ -1050,3 +1050,51 @@ def test_threshold_raised_short_strings(self):
         weighted_mks = [mk for mk in config.get_matchkeys() if mk.type == "weighted"]
         assert len(weighted_mks) > 0, "Expected at least one weighted matchkey"
         assert weighted_mks[0].threshold >= 0.80
+
+
+class TestLLMMemoryAutoEnablement:
+    """Tests for LLM + memory auto-enablement."""
+
+    def test_llm_auto_with_api_key(self):
+        from goldenmatch.core.autoconfig import auto_configure_df
+        from unittest.mock import patch
+        df = pl.DataFrame({"name": ["John", "Jane", "Bob"], "email": ["a@t.com", "b@t.com", "c@t.com"]})
+        with patch.dict("os.environ", {"OPENAI_API_KEY": "sk-fake"}):
+            config = auto_configure_df(df, llm_auto=True)
+        assert config.llm_scorer is not None
+        assert config.llm_scorer.enabled is True
+        assert config.llm_scorer.budget.max_cost_usd == 0.05
+
+    def test_llm_auto_no_key(self):
+        from goldenmatch.core.autoconfig import auto_configure_df
+        from unittest.mock import patch
+        import os
+        df = pl.DataFrame({"name": ["John", "Jane", "Bob"], "email": ["a@t.com", "b@t.com", "c@t.com"]})
+        with patch.dict("os.environ", {"OPENAI_API_KEY": "", "ANTHROPIC_API_KEY": ""}):
+            os.environ.pop("OPENAI_API_KEY", None)
+            os.environ.pop("ANTHROPIC_API_KEY", None)
+            config = auto_configure_df(df, llm_auto=True)
+        assert config.llm_scorer is None
+
+    def test_llm_auto_off(self):
+        from goldenmatch.core.autoconfig import auto_configure_df
+        from unittest.mock import patch
+        df = pl.DataFrame({"name": ["John", "Jane", "Bob"], "email": ["a@t.com", "b@t.com", "c@t.com"]})
+        with patch.dict("os.environ", {"OPENAI_API_KEY": "sk-fake"}):
+            config = auto_configure_df(df, llm_auto=False)
+        assert config.llm_scorer is None
+
+    def test_memory_with_llm_auto(self):
+        from goldenmatch.core.autoconfig import auto_configure_df
+        from unittest.mock import patch
+        df = pl.DataFrame({"name": ["John", "Jane", "Bob"], "email": ["a@t.com", "b@t.com", "c@t.com"]})
+        with patch.dict("os.environ", {"OPENAI_API_KEY": "sk-fake"}):
+            config = auto_configure_df(df, llm_auto=True)
+        assert config.memory is not None
+        assert config.memory.enabled is True
+
+    def test_memory_off_by_default(self):
+        from goldenmatch.core.autoconfig import auto_configure_df
+        df = pl.DataFrame({"name": ["John", "Jane", "Bob"], "email": ["a@t.com", "b@t.com", "c@t.com"]})
+        config = auto_configure_df(df)
+        assert config.memory is None