bytedance/deer-flow · error · ValueError

mem0 startup_policy must be one of {sorted(_STARTUP_POLICIES

Error message

mem0 startup_policy must be one of {sorted(_STARTUP_POLICIES)}

What it means

Raised by Mem0Config.from_backend_config when memory.backend_config.startup_policy is not one of the two supported values: fail_fast (default; performs an auth check in from_config so a bad key/URL fails at boot) and tolerate (defer checks to first use). The values are checked after str() coercion, so any other string (including typos and case variants) is rejected.

Source

Thrown at backend/packages/harness/deerflow/agents/memory/backends/mem0/config.py:97

            raise ValueError(f"mem0 failure_policy has unknown keys: {sorted(unknown_fp)}")
        allow_insecure_http = cfg.get("allow_insecure_http", False)
        if not isinstance(allow_insecure_http, bool):
            raise ValueError("mem0 allow_insecure_http must be a boolean")

        config = cls(
            api_key_env=str(cfg.get("api_key_env", "MEM0_API_KEY")),
            base_url=str(cfg.get("base_url", "https://api.mem0.ai")).rstrip("/"),
            allow_insecure_http=allow_insecure_http,
            top_k=int(cfg.get("top_k", 8)),
            score_threshold=float(cfg.get("score_threshold", 0.1)),
            max_injection_chars=int(cfg.get("max_injection_chars", 12000)),
            timeout_seconds=float(cfg.get("timeout_seconds", 10.0)),
            startup_policy=str(cfg.get("startup_policy", "fail_fast")),
            read_policy=str(failure_policy.get("read", "fail_open")),
            write_policy=str(failure_policy.get("write", "log_and_drop")),
        )
        if config.startup_policy not in _STARTUP_POLICIES:
            raise ValueError(f"mem0 startup_policy must be one of {sorted(_STARTUP_POLICIES)}")
        if config.read_policy not in _READ_POLICIES:
            raise ValueError(f"mem0 failure_policy.read must be one of {sorted(_READ_POLICIES)}")
        if config.write_policy not in _WRITE_POLICIES:
            raise ValueError(f"mem0 failure_policy.write must be one of {sorted(_WRITE_POLICIES)}")
        if not 1 <= config.top_k <= 1000:
            raise ValueError("mem0 top_k must be in [1, 1000]")
        if not 0.0 <= config.score_threshold <= 1.0:
            raise ValueError("mem0 score_threshold must be in [0, 1]")
        if config.max_injection_chars <= 0:
            raise ValueError("mem0 max_injection_chars must be positive")
        if config.timeout_seconds <= 0:
            raise ValueError("mem0 timeout_seconds must be positive")
        if not config.api_key_env.strip():
            raise ValueError("mem0 api_key_env must be a non-empty env var name")
        parsed_base_url = urlsplit(config.base_url)
        if parsed_base_url.scheme not in {"http", "https"} or not parsed_base_url.netloc:
            raise ValueError("mem0 base_url must be an absolute http:// or https:// URL")
        if parsed_base_url.scheme == "http" and not config.allow_insecure_http:

View on GitHub (pinned to 1dd6ba1acb)

Solutions

1. Use exactly fail_fast or tolerate (lowercase, underscore)
2. For production, keep the default fail_fast so auth problems surface at startup
3. Remove the key entirely if the default (fail_fast) is what you want

Example fix

# before (config.yaml)
memory:
  backend_config:
    startup_policy: fast-fail   # not recognized

# after
memory:
  backend_config:
    startup_policy: fail_fast

STARTUP_POLICIES = {"fail_fast", "tolerate"}

def startup_policy_ok(backend_config: dict) -> bool:
    return str((backend_config or {}).get("startup_policy", "fail_fast")) in STARTUP_POLICIES

def is_startup_policy(v: object) -> bool:
    return v in ("fail_fast", "tolerate")

When it happens

Trigger: startup_policy: fast_fail, fail-fast, Fail_Fast, lazy, or startup_policy: "" in backend_config.

Common situations: Typos and case mismatches; using vocabulary from other systems (lazy/deferred/eager); copy-pasting from outdated docs.

Related errors

• mem0 backend_config has unknown keys: {sorted(unknown)}
• mem0 failure_policy must be a mapping {read, write}
• mem0 failure_policy has unknown keys: {sorted(unknown_fp)}
• mem0 allow_insecure_http must be a boolean
• mem0 failure_policy.read must be one of {sorted(_READ_POLICI

AI-assisted analysis of bytedance/deer-flow@1dd6ba1acb (2026-08-14). Data as JSON: /api/errors/4c67c72e37c06974. Report an issue: GitHub.