flock-core 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

flock/evaluators/zep/zep_evaluator.py

@@ -0,0 +1,55 @@
+from typing import Any
+
+from pydantic import Field
+
+from flock.core.flock_agent import FlockAgent
+from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
+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
+
+
+class ZepEvaluatorConfig(FlockEvaluatorConfig):
+    zep_url: str = "http://localhost:8000"
+    zep_api_key: str = "apikey"
+    min_fact_rating: float = Field(
+        default=0.7, description="Minimum rating for facts to be considered"
+    )
+
+
+class ZepEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
+    """Evaluator that uses DSPy for generation."""
+
+    config: ZepEvaluatorConfig = Field(
+        default_factory=ZepEvaluatorConfig,
+        description="Evaluator configuration",
+    )
+
+    async def evaluate(
+        self, agent: FlockAgent, inputs: dict[str, Any], tools: list[Any]
+    ) -> dict[str, Any]:
+        """Simple evaluator that uses Zep.
+
+        if inputs contain "query", it searches memory for the query and returns the facts.
+        if inputs contain "data", it adds the data to memory
+        """
+        result = {}
+        zep = ZepModule(
+            name=self.name,
+            config=ZepModuleConfig(
+                zep_api_key=self.config.zep_api_key,
+                zep_url=self.config.zep_url,
+                min_fact_rating=self.config.min_fact_rating,
+            ),
+        )
+        client = zep.get_client()
+        if "query" in inputs:
+            query = inputs["query"]
+            facts = zep.search_memory(query, client)
+            result = {"facts": facts}
+
+        if "data" in inputs:
+            data = inputs["data"]
+            zep.add_to_memory(data, client)
+            result = {"message": "Data added to memory"}
+        return result

flock/modules/zep/zep_module.py

@@ -0,0 +1,177 @@
+import uuid
+from typing import Any
+
+from pydantic import Field
+from zep_python.client import Zep
+from zep_python.types import Message as ZepMessage, SessionSearchResult
+
+from flock.core.flock_agent import FlockAgent
+from flock.core.flock_module import FlockModule, FlockModuleConfig
+from flock.core.logging.logging import get_logger
+
+logger = get_logger("module.zep")
+
+
+class ZepModuleConfig(FlockModuleConfig):
+    """Configuration for the Zep module."""
+
+    zep_url: str = "http://localhost:8000"
+    zep_api_key: str = "apikey"
+    min_fact_rating: float = Field(
+        default=0.7, description="Minimum rating for facts to be considered"
+    )
+    enable_read: bool = True
+    enable_write: bool = False
+
+
+class ZepModule(FlockModule):
+    """Module that adds Zep capabilities to a Flock agent."""
+
+    name: str = "zep"
+    config: ZepModuleConfig = ZepModuleConfig()
+    session_id: str | None = None
+    user_id: str | None = None
+
+    def __init__(self, name, config: ZepModuleConfig) -> None:
+        """Initialize Zep module."""
+        super().__init__(name=name, config=config)
+        logger.debug("Initializing Zep module")
+        zep_client = Zep(
+            base_url=self.config.zep_url, api_key=self.config.zep_api_key
+        )
+        self.user_id = self.name
+        self._setup_user(zep_client)
+        self.session_id = str(uuid.uuid4())
+        self._setup_session(zep_client)
+
+    def _setup_user(self, zep_client: Zep) -> None:
+        """Set up user in Zep."""
+        if not zep_client or not self.user_id:
+            raise ValueError("Zep service or user_id not initialized")
+
+        try:
+            user = zep_client.user.get(user_id=self.user_id)
+            if not user:
+                zep_client.user.add(user_id=self.user_id)
+        except Exception:
+            zep_client.user.add(user_id=self.user_id)
+
+    def _setup_session(self, zep_client: Zep) -> None:
+        """Set up new session."""
+        if not zep_client or not self.user_id or not self.session_id:
+            raise ValueError(
+                "Zep service, user_id, or session_id not initialized"
+            )
+
+        zep_client.memory.add_session(
+            user_id=self.user_id,
+            session_id=self.session_id,
+        )
+
+    def get_client(self) -> Zep:
+        """Get Zep client."""
+        return Zep(
+            base_url=self.config.zep_url, api_key=self.config.zep_api_key
+        )
+
+    def get_memory(self, zep_client: Zep) -> str | None:
+        """Get memory for the current session."""
+        if not zep_client or not self.session_id:
+            logger.error("Zep service or session_id not initialized")
+            return None
+
+        try:
+            memory = zep_client.memory.get(
+                self.session_id, min_rating=self.config.min_fact_rating
+            )
+            if memory:
+                return f"{memory.relevant_facts}"
+        except Exception as e:
+            logger.error(f"Error fetching memory: {e}")
+            return None
+
+        return None
+
+    def split_text(
+        self, text: str | None, max_length: int = 1000
+    ) -> list[ZepMessage]:
+        """Split text into smaller chunks."""
+        result: list[ZepMessage] = []
+        if not text:
+            return result
+        if len(text) <= max_length:
+            return [ZepMessage(role="user", content=text, role_type="user")]
+        for i in range(0, len(text), max_length):
+            result.append(
+                ZepMessage(
+                    role="user",
+                    content=text[i : i + max_length],
+                    role_type="user",
+                )
+            )
+        return result
+
+    def add_to_memory(self, text: str, zep_client: Zep) -> None:
+        """Add text to memory."""
+        if not zep_client or not self.session_id:
+            logger.error("Zep service or session_id not initialized")
+            return
+
+        messages = self.split_text(text)
+        zep_client.memory.add(session_id=self.session_id, messages=messages)
+
+    def search_memory(
+        self, query: str, zep_client: Zep
+    ) -> list[SessionSearchResult]:
+        """Search memory for a query."""
+        if not zep_client or not self.user_id:
+            logger.error("Zep service or user_id not initialized")
+            return []
+
+        response = zep_client.memory.search_sessions(
+            text=query,
+            user_id=self.user_id,
+            search_scope="facts",
+            min_fact_rating=self.config.min_fact_rating,
+        )
+        if not response.results:
+            return []
+        return response.results
+
+    async def post_evaluate(
+        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Format and display the output."""
+        if not self.config.enable_write:
+            return result
+        logger.debug("Saving data to memory")
+        zep_client = Zep(
+            base_url=self.config.zep_url, api_key=self.config.zep_api_key
+        )
+        self.add_to_memory(str(result), zep_client)
+        return result
+
+    async def pre_evaluate(
+        self, agent: FlockAgent, inputs: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Format and display the output."""
+        if not self.config.enable_read:
+            return inputs
+
+        zep_client = Zep(
+            base_url=self.config.zep_url, api_key=self.config.zep_api_key
+        )
+
+        logger.debug("Searching memory")
+        facts = self.search_memory(str(inputs), zep_client)
+
+        # Add memory to inputs
+        facts_str = ""
+        if facts:
+            for fact in facts:
+                facts_str += fact.fact.fact + "\n"
+            logger.debug("Found facts in memory: {}", facts_str)
+            agent.input = agent.input + ", memory"
+            inputs["memory"] = facts_str
+
+        return inputs

{flock_core-0.3.1.dist-info → flock_core-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.1
+Version: 0.3.3
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -34,6 +34,7 @@ Requires-Dist: temporalio>=1.9.0
 Requires-Dist: tiktoken>=0.8.0
 Requires-Dist: toml>=0.10.2
 Requires-Dist: tqdm>=4.67.1
+Requires-Dist: zep-python>=2.0.2
 Provides-Extra: all-tools
 Requires-Dist: docling>=2.18.0; extra == 'all-tools'
 Requires-Dist: markdownify>=0.14.1; extra == 'all-tools'

{flock_core-0.3.1.dist-info → flock_core-0.3.3.dist-info}/RECORD

@@ -44,12 +44,14 @@ flock/core/util/input_resolver.py,sha256=g9vDPdY4OH-G7qjas5ksGEHueokHGFPMoLOvC-n
 flock/core/util/serializable.py,sha256=SymJ0YrjBx48mOBItYSqoRpKuzIc4vKWRS6ScTzre7s,2573
 flock/evaluators/declarative/declarative_evaluator.py,sha256=f8ldgZZp94zC4CoGzBufKvbvtckCGBe9EHTOoAZfZK0,1695
 flock/evaluators/natural_language/natural_language_evaluator.py,sha256=6nVEeh8_uwv_h-d3FWlA0GbzDzRtdhvxCGKirHtyvOU,2012
+flock/evaluators/zep/zep_evaluator.py,sha256=hEHQdgIwGsbC4ci9RvtdA2k7f4M0yznIok4v4XltNwg,1885
 flock/modules/callback/callback_module.py,sha256=hCCw-HNYjK4aHnUQfvw26ZP1Q_jdlKb9kDh3BHzbCQA,2916
 flock/modules/memory/memory_module.py,sha256=2grdmvw7FJWZvz0IjgASbDPCfyS1w4gWkRzOWtK7BFM,8214
 flock/modules/memory/memory_parser.py,sha256=2S7CmVEsm22gD7-MiFj4318FTg8wd_jB-RKMwXI14WM,4369
 flock/modules/memory/memory_storage.py,sha256=CNcLDMmvv0x7Z3YMKr6VveS_VCa7rKPw8l2d-XgqokA,27246
 flock/modules/output/output_module.py,sha256=_Hid4ycGEl14m7GEsVGE9wp88SYkQ3eq_x4avUQcTWI,6985
 flock/modules/performance/metrics_module.py,sha256=K5z5bizIjA4ZEUjBk5ShwTR9ZElR-Vmqa7H38dJ3z_0,16735
+flock/modules/zep/zep_module.py,sha256=BIJ5K-hg2bLeJmGKoDcVY1rVN7_0yYETiSaVrO-gtMI,5830
 flock/platform/docker_tools.py,sha256=fpA7-6rJBjPOUBLdQP4ny2QPgJ_042nmqRn5GtKnoYw,1445
 flock/platform/jaeger_install.py,sha256=MyOMJQx4TQSMYvdUJxfiGSo3YCtsfkbNXcAcQ9bjETA,2898
 flock/themes/3024-day.toml,sha256=uOVHqEzSyHx0WlUk3D0lne4RBsNBAPCTy3C58yU7kEY,667
@@ -393,8 +395,8 @@ flock/workflow/activities.py,sha256=2zcYyDoCuYs9oQbnhLjCzBUdEi7d5IEIemKJ7TV_B8w,
 flock/workflow/agent_activities.py,sha256=NhBZscflEf2IMfSRa_pBM_TRP7uVEF_O0ROvWZ33eDc,963
 flock/workflow/temporal_setup.py,sha256=VWBgmBgfTBjwM5ruS_dVpA5AVxx6EZ7oFPGw4j3m0l0,1091
 flock/workflow/workflow.py,sha256=I9MryXW_bqYVTHx-nl2epbTqeRy27CAWHHA7ZZA0nAk,1696
-flock_core-0.3.1.dist-info/METADATA,sha256=lctsSseYD8ZeFnzowlqwFLw9uJf6wTe_asp-ynomji4,20398
-flock_core-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.3.1.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.3.1.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.3.1.dist-info/RECORD,,
+flock_core-0.3.3.dist-info/METADATA,sha256=DmDTXx-eJoRlsZbhPGsyX-OEBZ16ahgDPFKb5N0YFBk,20431
+flock_core-0.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.3.3.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.3.3.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.3.3.dist-info/RECORD,,