flock-core 0.4.0b22__py3-none-any.whl → 0.4.0b24__py3-none-any.whl

flock/core/flock_registry.py

@@ -5,6 +5,7 @@ within the Flock framework to support dynamic lookup and serialization.
 
 from __future__ import annotations  # Add this at the very top
 
+import builtins
 import importlib
 import inspect
 import sys
@@ -31,6 +32,7 @@ if TYPE_CHECKING:
     from flock.core.flock_router import FlockRouter
 
     COMPONENT_BASE_TYPES = (FlockModule, FlockEvaluator, FlockRouter)
+
     IS_COMPONENT_CHECK_ENABLED = True
 else:
     # Define dummy types or skip check if not type checking
@@ -40,12 +42,15 @@ else:
 
 # Fallback if core types aren't available during setup
 
+from flock.core.flock_module import FlockModuleConfig
 from flock.core.logging.logging import get_logger
 
 logger = get_logger("registry")
 T = TypeVar("T")
 ClassType = TypeVar("ClassType", bound=type)
 FuncType = TypeVar("FuncType", bound=Callable)
+ConfigType = TypeVar("ConfigType", bound=BaseModel)
+_COMPONENT_CONFIG_MAP: dict[type[BaseModel], type[any]] = {}
 
 
 class FlockRegistry:
@@ -104,6 +109,45 @@ class FlockRegistry:
             except Exception as e:
                 logger.error(f"Failed to auto-register core type {t}: {e}")
 
+    @staticmethod
+    def register_config_component_pair(
+        config_cls: type[ConfigType], component_cls: type[ClassType]
+    ):
+        """Explicitly registers the mapping between a config and component class."""
+        from flock.core.flock_evaluator import (
+            FlockEvaluatorConfig,
+        )
+        from flock.core.flock_router import FlockRouterConfig
+
+        if not issubclass(
+            config_cls,
+            FlockModuleConfig | FlockRouterConfig | FlockEvaluatorConfig,
+        ):
+            logger.warning(
+                f"Config class {config_cls.__name__} does not inherit from a standard Flock config base."
+            )
+        # Add more checks if needed (e.g., component_cls inherits from Module/Router/Evaluator)
+
+        if (
+            config_cls in _COMPONENT_CONFIG_MAP
+            and _COMPONENT_CONFIG_MAP[config_cls] != component_cls
+        ):
+            logger.warning(
+                f"Config class {config_cls.__name__} already mapped to {_COMPONENT_CONFIG_MAP[config_cls].__name__}. Overwriting with {component_cls.__name__}."
+            )
+
+        _COMPONENT_CONFIG_MAP[config_cls] = component_cls
+        logger.debug(
+            f"Registered config mapping: {config_cls.__name__} -> {component_cls.__name__}"
+        )
+
+    @staticmethod
+    def get_component_class_for_config(
+        config_cls: type[ConfigType],
+    ) -> type[ClassType] | None:
+        """Looks up the Component Class associated with a Config Class."""
+        return _COMPONENT_CONFIG_MAP.get(config_cls)
+
     # --- Path String Generation ---
     @staticmethod
     def _get_path_string(obj: Callable | type) -> str | None:
@@ -172,57 +216,88 @@ class FlockRegistry:
         )
         return None
 
-    def get_callable(self, path_str: str) -> Callable:
-        """Retrieves a callable by its path string, attempting dynamic import if not found."""
-        if path_str in self._callables:
-            logger.debug(f"Found callable '{path_str}' in registry")
-            return self._callables[path_str]
+    def get_callable(self, name_or_path: str) -> Callable:
+        """Retrieves a callable by its registered name or full path string.
+        Attempts dynamic import if not found directly. Prioritizes exact match,
+        then searches for matches ending with '.{name}'.
+        """
+        # 1. Try exact match first (covers full paths and simple names if registered that way)
+        if name_or_path in self._callables:
+            logger.debug(
+                f"Found callable '{name_or_path}' directly in registry."
+            )
+            return self._callables[name_or_path]
+
+        # 2. If not found, and it looks like a simple name, search registered paths
+        if "." not in name_or_path:
+            matches = []
+            for path_str, func in self._callables.items():
+                # Check if path ends with ".{simple_name}" or exactly matches simple_name
+                if path_str == name_or_path or path_str.endswith(
+                    f".{name_or_path}"
+                ):
+                    matches.append(func)
 
-        logger.debug(
-            f"Callable '{path_str}' not in registry, attempting dynamic import."
-        )
-        try:
-            if "." not in path_str:  # Built-ins
-                logger.debug(f"Trying to import built-in callable '{path_str}'")
-                builtins_module = importlib.import_module("builtins")
-                if hasattr(builtins_module, path_str):
-                    func = getattr(builtins_module, path_str)
-                    if callable(func):
-                        self.register_callable(func, path_str)  # Cache it
-                        logger.info(
-                            f"Successfully imported built-in callable '{path_str}'"
-                        )
-                        return func
-                logger.error(f"Built-in callable '{path_str}' not found.")
-                raise KeyError(f"Built-in callable '{path_str}' not found.")
-
-            logger.debug(f"Trying to import module callable '{path_str}'")
-            module_name, func_name = path_str.rsplit(".", 1)
-            module = importlib.import_module(module_name)
-            func = getattr(module, func_name)
-            if callable(func):
-                self.register_callable(
-                    func, path_str
-                )  # Cache dynamically imported
-                logger.info(
-                    f"Successfully imported module callable '{path_str}'"
+            if len(matches) == 1:
+                logger.debug(
+                    f"Found unique callable for simple name '{name_or_path}' via path '{self.get_callable_path_string(matches[0])}'."
                 )
-                return func
-            else:
+                return matches[0]
+            elif len(matches) > 1:
+                # Ambiguous simple name - require full path
+                found_paths = [
+                    self.get_callable_path_string(f) for f in matches
+                ]
                 logger.error(
-                    f"Dynamically imported object '{path_str}' is not callable."
+                    f"Ambiguous callable name '{name_or_path}'. Found matches: {found_paths}. Use full path string for lookup."
                 )
-                raise TypeError(
-                    f"Dynamically imported object '{path_str}' is not callable."
+                raise KeyError(
+                    f"Ambiguous callable name '{name_or_path}'. Use full path string."
                 )
-        except (ImportError, AttributeError, KeyError, TypeError) as e:
-            logger.error(
-                f"Failed to dynamically load/find callable '{path_str}': {e}",
-                exc_info=True,
+            # else: Not found by simple name search in registry, proceed to dynamic import
+
+        # 3. Attempt dynamic import if it looks like a full path
+        if "." in name_or_path:
+            logger.debug(
+                f"Callable '{name_or_path}' not in registry cache, attempting dynamic import."
             )
-            raise KeyError(
-                f"Callable '{path_str}' not found or failed to load: {e}"
-            ) from e
+            try:
+                module_name, func_name = name_or_path.rsplit(".", 1)
+                module = importlib.import_module(module_name)
+                func = getattr(module, func_name)
+                if callable(func):
+                    self.register_callable(
+                        func, name_or_path
+                    )  # Cache dynamically imported
+                    logger.info(
+                        f"Successfully imported and registered module callable '{name_or_path}'"
+                    )
+                    return func
+                else:
+                    raise TypeError(
+                        f"Dynamically imported object '{name_or_path}' is not callable."
+                    )
+            except (ImportError, AttributeError, TypeError) as e:
+                logger.error(
+                    f"Failed to dynamically load/find callable '{name_or_path}': {e}",
+                    exc_info=False,
+                )
+                # Fall through to raise KeyError
+        # 4. Handle built-ins if not found yet (might be redundant if simple name check worked)
+        elif name_or_path in builtins.__dict__:
+            func = builtins.__dict__[name_or_path]
+            if callable(func):
+                self.register_callable(func, name_or_path)  # Cache it
+                logger.info(
+                    f"Found and registered built-in callable '{name_or_path}'"
+                )
+                return func
+
+        # 5. Final failure
+        logger.error(
+            f"Callable '{name_or_path}' not found in registry or via import."
+        )
+        raise KeyError(f"Callable '{name_or_path}' not found.")
 
     def get_callable_path_string(self, func: Callable) -> str | None:
         """Gets the path string for a callable, registering it if necessary."""
@@ -407,36 +482,41 @@ def get_registry() -> FlockRegistry:
 
 # Type hinting for decorators to preserve signature
 @overload
-def flock_component(cls: ClassType) -> ClassType: ...
+def flock_component(cls: ClassType) -> ClassType: ...  # Basic registration
 @overload
 def flock_component(
-    *, name: str | None = None
-) -> Callable[[ClassType], ClassType]: ...
+    *, name: str | None = None, config_class: type[ConfigType] | None = None
+) -> Callable[[ClassType], ClassType]: ...  # With options
 
 
 def flock_component(
-    cls: ClassType | None = None, *, name: str | None = None
+    cls: ClassType | None = None,
+    *,
+    name: str | None = None,
+    config_class: type[ConfigType] | None = None,
 ) -> Any:
-    """Decorator to register a Flock Component class (Module, Evaluator, Router).
-
-    Usage:
-        @flock_component
-        class MyModule(FlockModule): ...
-
-        @flock_component(name="CustomRouterAlias")
-        class MyRouter(FlockRouter): ...
-    """
+    """Decorator to register a Flock Component class and optionally link its config class."""
     registry = get_registry()
 
     def decorator(inner_cls: ClassType) -> ClassType:
         if not inspect.isclass(inner_cls):
             raise TypeError("@flock_component can only decorate classes.")
+
         component_name = name or inner_cls.__name__
-        registry.register_component(inner_cls, name=component_name)
+        registry.register_component(
+            inner_cls, name=component_name
+        )  # Register component by name
+
+        # If config_class is provided, register the mapping
+        if config_class:
+            FlockRegistry.register_config_component_pair(
+                config_class, inner_cls
+            )
+
         return inner_cls
 
     if cls is None:
-        # Called as @flock_component(name="...")
+        # Called as @flock_component(name="...", config_class=...)
         return decorator
     else:
         # Called as @flock_component

flock/core/flock_router.py

@@ -14,13 +14,26 @@ class HandOffRequest(BaseModel):
     next_agent: str = Field(default="", description="Next agent to invoke")
     # match = use the output fields of the current agent that also exists as input field of the next agent
     # add = add the output of the current agent to the input of the next agent
-    hand_off_mode: Literal["match", "add"] = Field(default="match")
+    output_to_input_merge_strategy: Literal["match", "add"] = Field(
+        default="match"
+    )
+    add_input_fields: list[str] | None = Field(
+        default=None,
+        description="List of input fields to add to the next agent",
+    )
+    add_output_fields: list[str] | None = Field(
+        default=None,
+        description="List of output fields to add to the next agent",
+    )
+    add_description: str | None = Field(
+        default=None, description="Add this description to the next agent"
+    )
     override_next_agent: Any | None = Field(
         default=None,
         description="Override the next agent to hand off to",
     )
     override_context: FlockContext | None = Field(
-        default=None, descrio="Override context parameters"
+        default=None, description="Override context parameters"
     )
 
 
@@ -34,10 +47,10 @@ class FlockRouterConfig(BaseModel):
     enabled: bool = Field(
         default=True, description="Whether the router is enabled"
     )
-    agents: list[str] | None = Field(
-        default=None,
-        description="List of agents to choose from",
-    )
+    # agents: list[str] | None = Field(
+    #     default=None,
+    #     description="List of agents to choose from",
+    # )
 
 
 class FlockRouter(BaseModel, ABC):

flock/core/serialization/serialization_utils.py

@@ -8,6 +8,7 @@ import sys
 import types
 import typing
 from collections.abc import Mapping, Sequence
+from enum import Enum
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -57,7 +58,9 @@ def _format_type_to_string(type_hint: type) -> str:
             inner_type = next(t for t in args if t is not type(None))
             return _format_type_to_string(inner_type)
         # return f"Optional[{_format_type_to_string(inner_type)}]"
-        return f"Union[{', '.join(_format_type_to_string(arg) for arg in args)}]"
+        return (
+            f"Union[{', '.join(_format_type_to_string(arg) for arg in args)}]"
+        )
     elif origin is Literal:
         formatted_args = []
         for arg in args:
@@ -66,7 +69,9 @@ def _format_type_to_string(type_hint: type) -> str:
             else:
                 formatted_args.append(str(arg))
         return f"Literal[{', '.join(formatted_args)}]"
-    elif hasattr(type_hint, "__forward_arg__"):  # Handle ForwardRefs if necessary
+    elif hasattr(
+        type_hint, "__forward_arg__"
+    ):  # Handle ForwardRefs if necessary
         return type_hint.__forward_arg__
     elif hasattr(type_hint, "__name__"):
         # Handle custom types registered in registry (get preferred name)
@@ -83,7 +88,9 @@ def _format_type_to_string(type_hint: type) -> str:
         type_repr = str(type_hint).replace("typing.", "")  # Basic cleanup
         type_repr = str(type_hint).replace("| None", "")
         type_repr = type_repr.strip()
-        logger.debug(f"Using fallback string representation for type: {type_repr}")
+        logger.debug(
+            f"Using fallback string representation for type: {type_repr}"
+        )
         return type_repr
 
 
@@ -189,18 +196,51 @@ def serialize_item(item: Any) -> Any:
 
     FlockRegistry = get_registry()
 
-    if isinstance(item, BaseModel):
-        dumped = item.model_dump(mode="json", exclude_none=True)
-        return serialize_item(dumped)
-    elif callable(item) and not isinstance(item, type):
-        path_str = FlockRegistry.get_callable_path_string(item)  # Use registry helper
+    if callable(item) and not isinstance(item, type):
+        path_str = FlockRegistry.get_callable_path_string(
+            item
+        )  # Use registry helper
         if path_str:
-            return {"__callable_ref__": path_str}
+            # Store the simple name (last part of the path) for cleaner YAML/JSON
+            simple_name = path_str.split(".")[-1]
+            logger.debug(
+                f"Serializing callable '{getattr(item, '__name__', 'unknown')}' as reference: '{simple_name}' (from path '{path_str}')"
+            )
+            return {
+                "__callable_ref__": simple_name
+            }  # Use simple name convention
         else:
+            # Handle unregistered callables (e.g., lambdas defined inline)
+            # Option 1: Raise error (stricter)
+            # raise ValueError(f"Cannot serialize unregistered callable: {getattr(item, '__name__', item)}")
+            # Option 2: Store string representation with warning (more lenient)
             logger.warning(
-                f"Could not get path string for callable {item}, storing as string."
+                f"Cannot serialize unregistered callable {getattr(item, '__name__', item)}, storing as string."
             )
             return str(item)
+    elif isinstance(item, BaseModel):
+        logger.debug(
+            f"Serializing Pydantic model instance: {item.__class__.__name__}"
+        )
+        serialized_dict = {}
+        # Iterate through defined fields in the model
+        fields_to_iterate = {}
+        if hasattr(item, "model_fields"):  # Pydantic v2
+            fields_to_iterate = item.model_fields
+
+        for field_name in fields_to_iterate:
+            # Get the value *from the instance*
+            try:
+                value = getattr(item, field_name)
+                if value is not None:  # Exclude None values
+                    # Recursively serialize the field's value
+                    serialized_dict[field_name] = serialize_item(value)
+            except AttributeError:
+                # Should not happen if iterating model_fields/__fields__ but handle defensively
+                logger.warning(
+                    f"Attribute '{field_name}' not found on instance of {item.__class__.__name__} during serialization."
+                )
+        return serialized_dict
     elif isinstance(item, Mapping):
         return {key: serialize_item(value) for key, value in item.items()}
     elif isinstance(item, Sequence) and not isinstance(item, str):
@@ -218,8 +258,12 @@ def serialize_item(item: Any) -> Any:
         )  # Check regular types/classes by path
         if type_name:
             return {"__type_ref__": type_name}
-        logger.warning(f"Could not serialize type object {item}, storing as string.")
+        logger.warning(
+            f"Could not serialize type object {item}, storing as string."
+        )
         return str(item)
+    elif isinstance(item, Enum):
+        return item.value
     else:
         # Return basic types as is
         return item
@@ -240,12 +284,24 @@ def deserialize_item(item: Any) -> Any:
 
     if isinstance(item, Mapping):
         if "__callable_ref__" in item and len(item) == 1:
-            path_str = item["__callable_ref__"]
+            ref_name = item["__callable_ref__"]
             try:
-                return FlockRegistry.get_callable(path_str)
+                # The registry's get_callable needs to handle lookup by simple name OR full path
+                # Or we assume get_callable handles finding the right function from the simple name
+                resolved_callable = FlockRegistry.get_callable(ref_name)
+                logger.debug(
+                    f"Deserialized callable reference '{ref_name}' to {resolved_callable}"
+                )
+                return resolved_callable
             except KeyError:
                 logger.error(
-                    f"Callable reference '{path_str}' not found during deserialization."
+                    f"Callable reference '{ref_name}' not found during deserialization."
+                )
+                return None  # Or raise?
+            except Exception as e:
+                logger.error(
+                    f"Error resolving callable reference '{ref_name}': {e}",
+                    exc_info=True,
                 )
                 return None
         elif "__component_ref__" in item and len(item) == 1:
@@ -273,7 +329,9 @@ def deserialize_item(item: Any) -> Any:
                         mod = importlib.import_module(module_name)
                     type_obj = getattr(mod, class_name)
                     if isinstance(type_obj, type):
-                        FlockRegistry.register_type(type_obj, type_name)  # Cache it
+                        FlockRegistry.register_type(
+                            type_obj, type_name
+                        )  # Cache it
                         return type_obj
                     else:
                         raise TypeError()
@@ -294,7 +352,9 @@ def deserialize_item(item: Any) -> Any:
 
 
 # --- Component Deserialization Helper ---
-def deserialize_component(data: dict | None, expected_base_type: type) -> Any | None:
+def deserialize_component(
+    data: dict | None, expected_base_type: type
+) -> Any | None:
     """Deserializes a component (Module, Evaluator, Router) from its dict representation.
     Uses the 'type' field to find the correct class via FlockRegistry.
     """
@@ -306,10 +366,14 @@ def deserialize_component(data: dict | None, expected_base_type: type) -> Any |
     if data is None:
         return None
     if not isinstance(data, dict):
-        logger.error(f"Expected dict for component deserialization, got {type(data)}")
+        logger.error(
+            f"Expected dict for component deserialization, got {type(data)}"
+        )
         return None
 
-    type_name = data.get("type")  # Assuming 'type' key holds the class name string
+    type_name = data.get(
+        "type"
+    )  # Assuming 'type' key holds the class name string
     if not type_name:
         logger.error(f"Component data missing 'type' field: {data}")
         return None
@@ -317,7 +381,9 @@ def deserialize_component(data: dict | None, expected_base_type: type) -> Any |
     try:
         ComponentClass = FlockRegistry.get_component(type_name)  # Use registry
         # Optional: Keep the base type check
-        if COMPONENT_BASE_TYPES and not issubclass(ComponentClass, expected_base_type):
+        if COMPONENT_BASE_TYPES and not issubclass(
+            ComponentClass, expected_base_type
+        ):
             raise TypeError(
                 f"Deserialized class {type_name} is not a subclass of {expected_base_type.__name__}"
             )

flock/core/util/input_resolver.py

@@ -152,6 +152,11 @@ def resolve_inputs(
                 continue
 
             # Fallback to the initial input
+            var_value = context.get_variable(key)
+            if var_value is not None:
+                inputs[key] = var_value
+                continue
+
             inputs[key] = context.get_variable("flock." + key)
 
         # Case 2: A compound key (e.g., "agent_name.property" or "context.property")

flock/evaluators/declarative/declarative_evaluator.py

@@ -2,11 +2,12 @@ from collections.abc import Generator
 from typing import Any
 
 import dspy
-from pydantic import Field
+from pydantic import Field, PrivateAttr
 from rich.console import Console
 
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
+from flock.core.flock_registry import flock_component
 from flock.core.logging.logging import get_logger
 from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
 from flock.core.mixin.prompt_parser import PromptParserMixin
@@ -35,7 +36,10 @@ class DeclarativeEvaluatorConfig(FlockEvaluatorConfig):
     kwargs: dict[str, Any] = Field(default_factory=dict)
 
 
-class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
+@flock_component(config_class=DeclarativeEvaluatorConfig)
+class DeclarativeEvaluator(
+    FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin
+):
     """Evaluator that uses DSPy for generation."""
 
     config: DeclarativeEvaluatorConfig = Field(
@@ -43,8 +47,8 @@ class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMix
         description="Evaluator configuration",
     )
 
-    cost: float = 0.0
-    lm_history: list = Field(default_factory=list)
+    _cost: float = PrivateAttr(default=0.0)
+    _lm_history: list = PrivateAttr(default_factory=list)
 
     async def evaluate(
         self, agent: FlockAgent, inputs: dict[str, Any], tools: list[Any]
@@ -89,10 +93,14 @@ class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMix
 
         # --- Conditional Evaluation (Stream vs No Stream) ---
         if self.config.stream:
-            logger.info(f"Evaluating agent '{agent.name}' with async streaming.")
+            logger.info(
+                f"Evaluating agent '{agent.name}' with async streaming."
+            )
             if not callable(agent_task):
                 logger.error("agent_task is not callable, cannot stream.")
-                raise TypeError("DSPy task could not be created or is not callable.")
+                raise TypeError(
+                    "DSPy task could not be created or is not callable."
+                )
 
             streaming_task = dspy.streamify(agent_task)
             stream_generator: Generator = streaming_task(**inputs)
@@ -115,8 +123,8 @@ class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMix
                 result_dict, cost, lm_history = self._process_result(
                     chunk, inputs
                 )
-                self.cost = cost
-                self.lm_history = lm_history
+                self._cost = cost
+                self._lm_history = lm_history
 
             console.print("\n")
             return self.filter_thought_process(
@@ -131,8 +139,8 @@ class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMix
                 result_dict, cost, lm_history = self._process_result(
                     result_obj, inputs
                 )
-                self.cost = cost
-                self.lm_history = lm_history
+                self._cost = cost
+                self._lm_history = lm_history
                 return self.filter_thought_process(
                     result_dict, self.config.include_thought_process
                 )

flock/evaluators/memory/memory_evaluator.py

@@ -4,6 +4,7 @@ from pydantic import Field
 
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
+from flock.core.flock_registry import flock_component
 from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
 from flock.core.mixin.prompt_parser import PromptParserMixin
 from flock.modules.memory.memory_module import MemoryModule, MemoryModuleConfig
@@ -45,6 +46,7 @@ class MemoryEvaluatorConfig(FlockEvaluatorConfig):
     )
 
 
+@flock_component(config_class=MemoryEvaluatorConfig)
 class MemoryEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
     """Evaluator that uses DSPy for generation."""
 

flock/evaluators/test/test_case_evaluator.py

@@ -4,6 +4,7 @@ from pydantic import Field
 
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
+from flock.core.flock_registry import flock_component
 from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
 
 
@@ -13,6 +14,7 @@ class TestCaseEvaluatorConfig(FlockEvaluatorConfig):
     pass
 
 
+@flock_component(config_class=TestCaseEvaluatorConfig)
 class TestCaseEvaluator(FlockEvaluator, DSPyIntegrationMixin):
     """Evaluator for test cases."""
 

flock/evaluators/zep/zep_evaluator.py

@@ -4,6 +4,7 @@ from pydantic import Field
 
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
+from flock.core.flock_registry import flock_component
 from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
 from flock.core.mixin.prompt_parser import PromptParserMixin
 from flock.modules.zep.zep_module import ZepModule, ZepModuleConfig
@@ -17,6 +18,7 @@ class ZepEvaluatorConfig(FlockEvaluatorConfig):
     )
 
 
+@flock_component(config_class=ZepEvaluatorConfig)
 class ZepEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
     """Evaluator that uses DSPy for generation."""