zep-cloud 3.2.0__tar.gz → 3.4.0__tar.gz

{zep_cloud-3.2.0 → zep_cloud-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zep-cloud
-Version: 3.2.0
+Version: 3.4.0
 Summary: 
 Requires-Python: >=3.9.0,<4.0
 Classifier: Intended Audience :: Developers

{zep_cloud-3.2.0 → zep_cloud-3.4.0}/pyproject.toml

@@ -3,7 +3,7 @@ name = "zep-cloud"
 
 [tool.poetry]
 name = "zep-cloud"
-version = "3.2.0"
+version = "3.4.0"
 description = ""
 readme = "README.md"
 authors = []

{zep_cloud-3.2.0 → zep_cloud-3.4.0}/src/zep_cloud/__init__.py

@@ -3,6 +3,7 @@
 # isort: skip_file
 
 from .types import (
+    AddThreadMessagesRequest,
     AddThreadMessagesResponse,
     AddTripleResponse,
     ApiError,
@@ -53,6 +54,7 @@ from .thread import ThreadGetUserContextRequestMode
 from .version import __version__
 
 __all__ = [
+    "AddThreadMessagesRequest",
     "AddThreadMessagesResponse",
     "AddTripleResponse",
     "ApiError",

{zep_cloud-3.2.0 → zep_cloud-3.4.0}/src/zep_cloud/core/client_wrapper.py

@@ -22,10 +22,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "zep-cloud/3.2.0",
+            "User-Agent": "zep-cloud/3.4.0",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "zep-cloud",
-            "X-Fern-SDK-Version": "3.2.0",
+            "X-Fern-SDK-Version": "3.4.0",
             **(self.get_custom_headers() or {}),
         }
         headers["Authorization"] = f"Api-Key {self.api_key}"

{zep_cloud-3.2.0 → zep_cloud-3.4.0}/src/zep_cloud/graph/client.py

@@ -389,7 +389,7 @@ class GraphClient:
         Returns
         -------
         CloneGraphResponse
-            Response object containing group_id or user_id pointing to the new graph
+            Response object containing graph_id or user_id pointing to the new graph
 
         Examples
         --------
@@ -467,7 +467,7 @@ class GraphClient:
         request_options: typing.Optional[RequestOptions] = None,
     ) -> GraphListResponse:
         """
-        List all graphs. In order to list users, use user.list_ordered instead
+        Returns all graphs. In order to list users, use user.list_ordered instead
 
         Parameters
         ----------
@@ -1107,7 +1107,7 @@ class AsyncGraphClient:
         Returns
         -------
         CloneGraphResponse
-            Response object containing group_id or user_id pointing to the new graph
+            Response object containing graph_id or user_id pointing to the new graph
 
         Examples
         --------
@@ -1201,7 +1201,7 @@ class AsyncGraphClient:
         request_options: typing.Optional[RequestOptions] = None,
     ) -> GraphListResponse:
         """
-        List all graphs. In order to list users, use user.list_ordered instead
+        Returns all graphs. In order to list users, use user.list_ordered instead
 
         Parameters
         ----------

{zep_cloud-3.2.0 → zep_cloud-3.4.0}/src/zep_cloud/graph/raw_client.py

@@ -573,7 +573,7 @@ class RawGraphClient:
         Returns
         -------
         HttpResponse[CloneGraphResponse]
-            Response object containing group_id or user_id pointing to the new graph
+            Response object containing graph_id or user_id pointing to the new graph
         """
         _response = self._client_wrapper.httpx_client.request(
             "graph/clone",
@@ -727,7 +727,7 @@ class RawGraphClient:
         request_options: typing.Optional[RequestOptions] = None,
     ) -> HttpResponse[GraphListResponse]:
         """
-        List all graphs. In order to list users, use user.list_ordered instead
+        Returns all graphs. In order to list users, use user.list_ordered instead
 
         Parameters
         ----------
@@ -1704,7 +1704,7 @@ class AsyncRawGraphClient:
         Returns
         -------
         AsyncHttpResponse[CloneGraphResponse]
-            Response object containing group_id or user_id pointing to the new graph
+            Response object containing graph_id or user_id pointing to the new graph
         """
         _response = await self._client_wrapper.httpx_client.request(
             "graph/clone",
@@ -1858,7 +1858,7 @@ class AsyncRawGraphClient:
         request_options: typing.Optional[RequestOptions] = None,
     ) -> AsyncHttpResponse[GraphListResponse]:
         """
-        List all graphs. In order to list users, use user.list_ordered instead
+        Returns all graphs. In order to list users, use user.list_ordered instead
 
         Parameters
         ----------

zep_cloud-3.4.0/src/zep_cloud/graph/utils.py

@@ -0,0 +1,135 @@
+from datetime import datetime
+from typing import List
+
+from zep_cloud import EntityEdge, EntityNode, Episode
+
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+
+def parse_iso_datetime(iso_string: str) -> datetime:
+    """Parse ISO datetime string, handling Z suffix for UTC."""
+    try:
+        return datetime.fromisoformat(iso_string)
+    except ValueError:
+        # Handle Z suffix for Python 3.9 compatibility
+        if iso_string.endswith('Z'):
+            return datetime.fromisoformat(iso_string[:-1] + '+00:00')
+        raise
+
+TEMPLATE_STRING = """
+FACTS and ENTITIES{episodes_header} represent relevant context to the current conversation.
+
+# These are the most relevant facts and their valid date ranges
+# format: FACT (Date range: from - to)
+<FACTS>
+{facts}
+</FACTS>
+
+# These are the most relevant entities
+# Name: ENTITY_NAME
+# Label: entity_label (if present)
+# Attributes: (if present)
+#   attr_name: attr_value
+# Summary: entity summary
+<ENTITIES>
+{entities}
+</ENTITIES>
+{episodes_section}
+"""
+
+
+def format_edge_date_range(edge: EntityEdge) -> str:
+    """
+    Format the date range of an entity edge.
+    
+    Args:
+        edge: The entity edge to format.
+        
+    Returns:
+        A string representation of the date range.
+    """
+    valid_at = "date unknown"
+    invalid_at = "present"
+
+    if edge.valid_at is not None:
+        valid_at = parse_iso_datetime(edge.valid_at).strftime(DATE_FORMAT)
+    if edge.invalid_at is not None:
+        invalid_at = parse_iso_datetime(edge.invalid_at).strftime(DATE_FORMAT)
+
+    return f"{valid_at} - {invalid_at}"
+
+
+def compose_context_string(edges: List[EntityEdge], nodes: List[EntityNode], episodes: List[Episode]) -> str:
+    """
+    Compose a search context from entity edges, nodes, and episodes.
+    
+    Args:
+        edges: List of entity edges.
+        nodes: List of entity nodes.
+        episodes: List of episodes.
+        
+    Returns:
+        A formatted string containing facts, entities, and episodes.
+    """
+    facts = []
+    for edge in edges:
+        fact = f"  - {edge.fact} (Date range: {format_edge_date_range(edge)})"
+        facts.append(fact)
+
+    entities = []
+    for node in nodes:
+        entity_parts = [f"Name: {node.name}"]
+        
+        if hasattr(node, 'labels') and node.labels:
+            labels = list(node.labels)  # Create a copy to avoid modifying original
+            if 'Entity' in labels:
+                labels.remove('Entity')
+            if labels:  # Only add label if there are remaining labels after removing 'Entity'
+                entity_parts.append(f"Label: {labels[0]}")
+        
+        if hasattr(node, 'attributes') and node.attributes:
+            # Filter out 'labels' from attributes as it's redundant with the Label field
+            filtered_attributes = {k: v for k, v in node.attributes.items() if k != 'labels'}
+            if filtered_attributes:  # Only add attributes section if there are non-label attributes
+                entity_parts.append("Attributes:")
+                for attr_name, attr_value in filtered_attributes.items():
+                    entity_parts.append(f"  {attr_name}: {attr_value}")
+        
+        if node.summary:
+            entity_parts.append(f"Summary: {node.summary}")
+        
+        entity = "\n".join(entity_parts)
+        entities.append(entity)
+
+    # Format episodes
+    episodes_list = []
+    if episodes:
+        for episode in episodes:
+            role_prefix = ""
+            if hasattr(episode, 'role') and episode.role:
+                if hasattr(episode, 'role_type') and episode.role_type:
+                    role_prefix = f"{episode.role} ({episode.role_type}): "
+                else:
+                    role_prefix = f"{episode.role}: "
+            elif hasattr(episode, 'role_type') and episode.role_type:
+                role_prefix = f"({episode.role_type}): "
+
+            timestamp = parse_iso_datetime(episode.created_at).strftime(DATE_FORMAT)
+            
+            episode_str = f"  - {role_prefix}{episode.content} ({timestamp})"
+            episodes_list.append(episode_str)
+
+    facts_str = "\n".join(facts) if facts else ""
+    entities_str = "\n".join(entities) if entities else ""
+    episodes_str = "\n".join(episodes_list) if episodes_list else ""
+    
+    # Determine if episodes section should be included
+    episodes_header = ", and EPISODES" if episodes else ""
+    episodes_section = f"\n# These are the most relevant episodes\n<EPISODES>\n{episodes_str}\n</EPISODES>" if episodes else ""
+    
+    return TEMPLATE_STRING.format(
+        episodes_header=episodes_header,
+        facts=facts_str,
+        entities=entities_str,
+        episodes_section=episodes_section
+    )

{zep_cloud-3.2.0 → zep_cloud-3.4.0}/src/zep_cloud/thread/client.py

@@ -308,6 +308,68 @@ class ThreadClient:
         )
         return _response.data
 
+    def add_messages_batch(
+        self,
+        thread_id: str,
+        *,
+        messages: typing.Sequence[Message],
+        ignore_roles: typing.Optional[typing.Sequence[RoleType]] = OMIT,
+        return_context: typing.Optional[bool] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AddThreadMessagesResponse:
+        """
+        Add messages to a thread in batch mode. This will process messages concurrently, which is useful for data migrations.
+
+        Parameters
+        ----------
+        thread_id : str
+            The ID of the thread to which messages should be added.
+
+        messages : typing.Sequence[Message]
+            A list of message objects, where each message contains a role and content.
+
+        ignore_roles : typing.Optional[typing.Sequence[RoleType]]
+            Optional list of role types to ignore when adding messages to graph memory.
+            The message itself will still be added, retained and used as context for messages
+            that are added to a user's graph.
+
+        return_context : typing.Optional[bool]
+            Optionally return memory context relevant to the most recent messages.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AddThreadMessagesResponse
+            An object, optionally containing user context retrieved for the last thread message
+
+        Examples
+        --------
+        from zep_cloud import Message, Zep
+
+        client = Zep(
+            api_key="YOUR_API_KEY",
+        )
+        client.thread.add_messages_batch(
+            thread_id="threadId",
+            messages=[
+                Message(
+                    content="content",
+                    role="norole",
+                )
+            ],
+        )
+        """
+        _response = self._raw_client.add_messages_batch(
+            thread_id,
+            messages=messages,
+            ignore_roles=ignore_roles,
+            return_context=return_context,
+            request_options=request_options,
+        )
+        return _response.data
+
 
 class AsyncThreadClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -647,3 +709,73 @@ class AsyncThreadClient:
             request_options=request_options,
         )
         return _response.data
+
+    async def add_messages_batch(
+        self,
+        thread_id: str,
+        *,
+        messages: typing.Sequence[Message],
+        ignore_roles: typing.Optional[typing.Sequence[RoleType]] = OMIT,
+        return_context: typing.Optional[bool] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AddThreadMessagesResponse:
+        """
+        Add messages to a thread in batch mode. This will process messages concurrently, which is useful for data migrations.
+
+        Parameters
+        ----------
+        thread_id : str
+            The ID of the thread to which messages should be added.
+
+        messages : typing.Sequence[Message]
+            A list of message objects, where each message contains a role and content.
+
+        ignore_roles : typing.Optional[typing.Sequence[RoleType]]
+            Optional list of role types to ignore when adding messages to graph memory.
+            The message itself will still be added, retained and used as context for messages
+            that are added to a user's graph.
+
+        return_context : typing.Optional[bool]
+            Optionally return memory context relevant to the most recent messages.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AddThreadMessagesResponse
+            An object, optionally containing user context retrieved for the last thread message
+
+        Examples
+        --------
+        import asyncio
+
+        from zep_cloud import AsyncZep, Message
+
+        client = AsyncZep(
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.thread.add_messages_batch(
+                thread_id="threadId",
+                messages=[
+                    Message(
+                        content="content",
+                        role="norole",
+                    )
+                ],
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.add_messages_batch(
+            thread_id,
+            messages=messages,
+            ignore_roles=ignore_roles,
+            return_context=return_context,
+            request_options=request_options,
+        )
+        return _response.data

{zep_cloud-3.2.0 → zep_cloud-3.4.0}/src/zep_cloud/thread/raw_client.py

@@ -506,6 +506,88 @@ class RawThreadClient:
             status_code=_response.status_code, headers=dict(_response.headers), body=_response_json
         )
 
+    def add_messages_batch(
+        self,
+        thread_id: str,
+        *,
+        messages: typing.Sequence[Message],
+        ignore_roles: typing.Optional[typing.Sequence[RoleType]] = OMIT,
+        return_context: typing.Optional[bool] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[AddThreadMessagesResponse]:
+        """
+        Add messages to a thread in batch mode. This will process messages concurrently, which is useful for data migrations.
+
+        Parameters
+        ----------
+        thread_id : str
+            The ID of the thread to which messages should be added.
+
+        messages : typing.Sequence[Message]
+            A list of message objects, where each message contains a role and content.
+
+        ignore_roles : typing.Optional[typing.Sequence[RoleType]]
+            Optional list of role types to ignore when adding messages to graph memory.
+            The message itself will still be added, retained and used as context for messages
+            that are added to a user's graph.
+
+        return_context : typing.Optional[bool]
+            Optionally return memory context relevant to the most recent messages.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[AddThreadMessagesResponse]
+            An object, optionally containing user context retrieved for the last thread message
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"threads/{jsonable_encoder(thread_id)}/messages-batch",
+            method="POST",
+            json={
+                "ignore_roles": ignore_roles,
+                "messages": convert_and_respect_annotation_metadata(
+                    object_=messages, annotation=typing.Sequence[Message], direction="write"
+                ),
+                "return_context": return_context,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    AddThreadMessagesResponse,
+                    parse_obj_as(
+                        type_=AddThreadMessagesResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        types_api_error_ApiError,
+                        parse_obj_as(
+                            type_=types_api_error_ApiError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise core_api_error_ApiError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.text
+            )
+        raise core_api_error_ApiError(
+            status_code=_response.status_code, headers=dict(_response.headers), body=_response_json
+        )
+
 
 class AsyncRawThreadClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -984,3 +1066,85 @@ class AsyncRawThreadClient:
         raise core_api_error_ApiError(
             status_code=_response.status_code, headers=dict(_response.headers), body=_response_json
         )
+
+    async def add_messages_batch(
+        self,
+        thread_id: str,
+        *,
+        messages: typing.Sequence[Message],
+        ignore_roles: typing.Optional[typing.Sequence[RoleType]] = OMIT,
+        return_context: typing.Optional[bool] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[AddThreadMessagesResponse]:
+        """
+        Add messages to a thread in batch mode. This will process messages concurrently, which is useful for data migrations.
+
+        Parameters
+        ----------
+        thread_id : str
+            The ID of the thread to which messages should be added.
+
+        messages : typing.Sequence[Message]
+            A list of message objects, where each message contains a role and content.
+
+        ignore_roles : typing.Optional[typing.Sequence[RoleType]]
+            Optional list of role types to ignore when adding messages to graph memory.
+            The message itself will still be added, retained and used as context for messages
+            that are added to a user's graph.
+
+        return_context : typing.Optional[bool]
+            Optionally return memory context relevant to the most recent messages.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[AddThreadMessagesResponse]
+            An object, optionally containing user context retrieved for the last thread message
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"threads/{jsonable_encoder(thread_id)}/messages-batch",
+            method="POST",
+            json={
+                "ignore_roles": ignore_roles,
+                "messages": convert_and_respect_annotation_metadata(
+                    object_=messages, annotation=typing.Sequence[Message], direction="write"
+                ),
+                "return_context": return_context,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    AddThreadMessagesResponse,
+                    parse_obj_as(
+                        type_=AddThreadMessagesResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        types_api_error_ApiError,
+                        parse_obj_as(
+                            type_=types_api_error_ApiError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise core_api_error_ApiError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.text
+            )
+        raise core_api_error_ApiError(
+            status_code=_response.status_code, headers=dict(_response.headers), body=_response_json
+        )

{zep_cloud-3.2.0 → zep_cloud-3.4.0}/src/zep_cloud/types/__init__.py

@@ -2,6 +2,7 @@
 
 # isort: skip_file
 
+from .add_thread_messages_request import AddThreadMessagesRequest
 from .add_thread_messages_response import AddThreadMessagesResponse
 from .add_triple_response import AddTripleResponse
 from .api_error import ApiError
@@ -45,6 +46,7 @@ from .user_list_response import UserListResponse
 from .user_node_response import UserNodeResponse
 
 __all__ = [
+    "AddThreadMessagesRequest",
     "AddThreadMessagesResponse",
     "AddTripleResponse",
     "ApiError",

zep_cloud-3.4.0/src/zep_cloud/types/add_thread_messages_request.py

@@ -0,0 +1,36 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .message import Message
+from .role_type import RoleType
+
+
+class AddThreadMessagesRequest(UniversalBaseModel):
+    ignore_roles: typing.Optional[typing.List[RoleType]] = pydantic.Field(default=None)
+    """
+    Optional list of role types to ignore when adding messages to graph memory.
+    The message itself will still be added, retained and used as context for messages
+    that are added to a user's graph.
+    """
+
+    messages: typing.List[Message] = pydantic.Field()
+    """
+    A list of message objects, where each message contains a role and content.
+    """
+
+    return_context: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Optionally return memory context relevant to the most recent messages.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

{zep_cloud-3.2.0 → zep_cloud-3.4.0}/src/zep_cloud/types/add_thread_messages_response.py

@@ -8,6 +8,7 @@ from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
 
 class AddThreadMessagesResponse(UniversalBaseModel):
     context: typing.Optional[str] = None
+    message_uuids: typing.Optional[typing.List[str]] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

zep_cloud-3.2.0/src/zep_cloud/graph/utils.py

@@ -1,70 +0,0 @@
-from datetime import datetime
-from typing import List
-
-from zep_cloud import EntityEdge, EntityNode
-
-DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
-
-TEMPLATE_STRING = """
-FACTS and ENTITIES represent relevant context to the current conversation.
-
-# These are the most relevant facts and their valid date ranges
-# format: FACT (Date range: from - to)
-<FACTS>
-%s
-</FACTS>
-
-# These are the most relevant entities
-# ENTITY_NAME: entity summary
-<ENTITIES>
-%s
-</ENTITIES>
-"""
-
-
-def format_edge_date_range(edge: EntityEdge) -> str:
-    """
-    Format the date range of an entity edge.
-    
-    Args:
-        edge: The entity edge to format.
-        
-    Returns:
-        A string representation of the date range.
-    """
-    valid_at = "date unknown"
-    invalid_at = "present"
-
-    if edge.valid_at is not None:
-        valid_at = datetime.fromisoformat(edge.valid_at).strftime(DATE_FORMAT)
-    if edge.invalid_at is not None:
-        invalid_at = datetime.fromisoformat(edge.invalid_at).strftime(DATE_FORMAT)
-
-    return f"{valid_at} - {invalid_at}"
-
-
-def compose_context_string(edges: List[EntityEdge], nodes: List[EntityNode]) -> str:
-    """
-    Compose a search context from entity edges and nodes.
-    
-    Args:
-        edges: List of entity edges.
-        nodes: List of entity nodes.
-        
-    Returns:
-        A formatted string containing facts and entities.
-    """
-    facts = []
-    for edge in edges:
-        fact = f"  - {edge.fact} ({format_edge_date_range(edge)})"
-        facts.append(fact)
-
-    entities = []
-    for node in nodes:
-        entity = f"  - {node.name}: {node.summary}"
-        entities.append(entity)
-
-    facts_str = "\n".join(facts)
-    entities_str = "\n".join(entities)
-
-    return TEMPLATE_STRING % (facts_str, entities_str)