deepset-ai/haystack · error · SerializationError

Cannot determine the value of the init parameter

Error message

Cannot determine the value of the init parameter '{param_name}' for the class {obj.__class__.__name__}.You can fix this error by assigning 'self.{param_name} = {param_name}' or adding a custom serialization method 'to_dict' to the class.

What it means

component_to_dict (serialization.py:76) raises SerializationError when it cannot determine the value of a required __init__ parameter for a component being serialized. It infers init parameter values from same-named instance attributes; if the attribute is missing and the parameter has no default, serialization cannot proceed. The error tells you exactly how to fix it.

Solutions

Assign the init parameter to an attribute of the same name in __init__: self.<param_name> = <param_name>.
Implement a custom to_dict() (and from_dict()) on the component that serializes the parameter explicitly.
Give the init parameter a default value so serialization can fall back to it.
If you don't own the component, subclass it and add to_dict.

Example fix

// before
class MyComponent:
    def __init__(self, threshold: float):
        self.cutoff = threshold  # name mismatch; required param 'threshold' not stored
// after
class MyComponent:
    def __init__(self, threshold: float):
        self.threshold = threshold

Defensive patterns

Strategy: validation

Validate before calling

import inspect
for name, p in inspect.signature(MyComponent.__init__).parameters.items():
    if name == 'self' or p.default is not inspect.Parameter.empty:
        continue
    if not hasattr(instance, name):
        raise TypeError(f'store self.{name} = {name} in __init__ or implement to_dict')

Type guard

def serializable_init_params(cls, instance) -> bool:
    import inspect
    sig = inspect.signature(cls.__init__)
    return all(
        p.default is not inspect.Parameter.empty or hasattr(instance, n)
        for n, p in sig.parameters.items() if n not in ('self', 'args', 'kwargs')
    )

Try / catch

try:
    d = component.to_dict()
except SerializationError as e:
    print(e)  # names the class and param; fix __init__ or add to_dict

Prevention

Always assign every required init parameter to self.<same_name> in component __init__.
Implement to_dict/from_dict for components with derived or renamed state.
Run haystack's pytest helpers (test_to_dict) on custom components in CI.
Give init parameters sensible defaults where possible.

When it happens

Trigger: A component whose __init__ takes a required parameter but never stores it as self.<param_name>; calling component.to_dict() or pipeline dumps (to_dict/to_yaml) on such a component; pytest haystack test helpers like test_to_dict.

Common situations: Custom components storing params under different attribute names or computed into other state; components refactored so init params are only used transiently; vendored/third-party components lacking to_dict.

Related errors

AI-assisted analysis of deepset-ai/haystack@e318778c9b (2026-08-30). Data as JSON: /api/errors/14ebcb45b3889d23. Report an issue: GitHub.

Appendix: source

Thrown at haystack/core/serialization.py:76

        If the values of the init parameters can't be determined.
        If a non-basic Python type is used in the serialized data.
    """
    if hasattr(obj, "to_dict"):
        data = obj.to_dict()
    else:
        init_parameters = {}
        for param_name, param in inspect.signature(obj.__init__).parameters.items():
            # Ignore `args` and `kwargs`, used by the default constructor
            if param_name in ("args", "kwargs"):
                continue
            try:
                # This only works if the Component constructor assigns the init
                # parameter to an instance variable or property with the same name
                param_value = getattr(obj, param_name)
            except AttributeError as e:
                # If the parameter doesn't have a default value, raise an error
                if param.default is param.empty:
                    raise SerializationError(
                        f"Cannot determine the value of the init parameter '{param_name}' "
                        f"for the class {obj.__class__.__name__}."
                        f"You can fix this error by assigning 'self.{param_name} = {param_name}' or adding a "
                        f"custom serialization method 'to_dict' to the class."
                    ) from e
                # In case the init parameter was not assigned, we use the default value
                param_value = param.default
            init_parameters[param_name] = param_value

        data = default_to_dict(obj, **init_parameters)

    _validate_component_to_dict_output(obj, name, data)
    return data


def _validate_component_to_dict_output(component: Any, name: str, data: dict[str, Any]) -> None:
    # Ensure that only basic Python types are used in the serde data.
    def is_allowed_type(obj: Any) -> bool:

View on GitHub (pinned to e318778c9b)