test(strands): add live agent E2E and polish for public release

Bring zep-strands to peer parity: full Agent+MemoryManager integration
test (gated on ZEP+OPENAI), root README listing, and example/docs cleanup.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: mehulp93

README.md

@@ -49,7 +49,7 @@ Framework integration packages live under [`integrations/`](integrations/), orga
 framework-first then language: `integrations/<framework>/<language>/`. Each package is built,
 tested, and released independently.
 
-- **Python**: Google ADK, Microsoft Agent Framework, Microsoft AutoGen, AG2, CrewAI, LangGraph, LiveKit, Pydantic AI
+- **Python**: Google ADK, Microsoft Agent Framework, Microsoft AutoGen, AG2, CrewAI, LangGraph, LiveKit, Pydantic AI, Strands Agents
 - **TypeScript**: Google ADK, Mastra, Vercel AI SDK
 - **Go**: Google ADK
 

integrations/strands/python/CHANGELOG.md

@@ -2,15 +2,27 @@
 
 ## Unreleased
 
+### Added
+
+- Live agent integration test (`test_integration_full_lifecycle`) exercising
+  `Agent` + `MemoryManager` + `ZepMemoryStore` against Zep Cloud and OpenAI,
+  including cross-thread recall and `on_user_created` (gated on
+  `ZEP_API_KEY` + `OPENAI_API_KEY`). Store-only round-trip remains available
+  with just `ZEP_API_KEY`.
+
 ### Fixed
 
 - `ZepMemoryStore` now rejects `extraction=True` (or an `ExtractionConfig`) at construction unless the store is writable user-graph mode with both `user_id` and `thread_id`, so `MemoryManager` never schedules extraction that would raise on every cycle.
 - `add()` no longer truncates oversized `json` payloads. Slicing JSON strips its closing syntax, so the size guard produced a document Zep would reject; oversized `json` now raises a `ValueError` pointing at chunking. `text`/`message` payloads are still truncated with a warning.
+- Corrected the `provisioning` module docstring (it incorrectly referred to
+  `ZepContextProvider`).
 
 ### Changed
 
 - Documented that Strands' default extraction cadence is every **5 turns**, so conversation batches only reach Zep when the trigger fires (or on `flush()`), delaying graph building relative to turn-by-turn persistence — in addition to Zep's asynchronous ingestion after messages arrive.
 - Documented the failure-handling contract: Zep SDK errors propagate out of `search`/`add`/`add_messages` by design, because `MemoryManager` and `ExtractionCoordinator` own failure isolation (skip-and-log, `AggregateMemoryError`, and high-water-mark rollback for retry). Added tests pinning that behavior.
+- Example and live tests use every-turn extraction (`InvocationTrigger`) plus
+  `flush()` after `invoke_async` so demos are not flaky on the default cadence.
 
 ## 0.1.0 (2026-08-01)
 

integrations/strands/python/SETUP.md

@@ -72,10 +72,15 @@ Mock-based tests (no API keys needed):
 make test
 ```
 
-Live integration test (requires `ZEP_API_KEY`):
+Live integration tests:
 
 ```bash
+# Store round-trip (ZEP_API_KEY only)
+# Full agent lifecycle (also needs OPENAI_API_KEY)
 uv run pytest tests/test_integration.py -v -s -m integration
+
+# Or run the agent lifecycle as a standalone script:
+uv run python tests/test_integration.py
 ```
 
 ## Troubleshooting

integrations/strands/python/examples/basic_agent.py

@@ -1,15 +1,15 @@
 """
 Basic Strands Agents agent with Zep long-term memory via MemoryManager.
 
-This example wires a ``ZepMemoryStore`` into Strands' ``MemoryManager`` so the
-agent automatically:
+Wires a ``ZepMemoryStore`` into Strands' ``MemoryManager`` so the agent:
 
 * injects relevant Zep context before each model call
-* extracts conversation turns into the user graph (server-side, via
-  ``add_messages``) on the manager's default cadence
+* extracts conversation turns into the user graph (server-side via
+  ``add_messages``) on an every-turn trigger, then ``flush()`` after each
+  ``invoke_async`` so nothing is left buffered
 
-Earlier turns seed facts about the user; a later turn -- in a *new* conversation
-thread -- shows the agent recalling those facts from Zep's user graph.
+Earlier turns seed facts about the user; a later turn on a *new* thread shows
+cross-session recall from Zep's user graph.
 
 Prerequisites:
     pip install zep-strands 'strands-agents[openai]'
@@ -26,27 +26,13 @@
 
 from strands import Agent
 from strands.memory import MemoryManager
+from strands.memory.extraction.triggers import InvocationTrigger
+from strands.memory.extraction.types import ExtractionConfig
 from strands.types.content import Message
 from zep_cloud.client import AsyncZep
 
 from zep_strands import ZepMemoryStore, ensure_thread, ensure_user
 
-
-def _message_text(message: Message | object) -> str:
-    """Extract joined text blocks from an agent result message."""
-    if not isinstance(message, dict):
-        return str(message)
-    parts = [
-        block["text"]
-        for block in message.get("content") or []
-        if isinstance(block, dict) and "text" in block
-    ]
-    return "\n".join(parts) if parts else str(message)
-
-
-# ---------------------------------------------------------------------------
-# Configuration
-# ---------------------------------------------------------------------------
 ZEP_API_KEY = os.environ.get("ZEP_API_KEY", "")
 OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
 
@@ -61,6 +47,18 @@ def _message_text(message: Message | object) -> str:
 THREAD_2 = f"strands-example-thread2-{_suffix}"
 
 
+def _message_text(message: Message | object) -> str:
+    """Extract joined text blocks from an agent result message."""
+    if not isinstance(message, dict):
+        return str(message)
+    parts = [
+        block["text"]
+        for block in message.get("content") or []
+        if isinstance(block, dict) and "text" in block
+    ]
+    return "\n".join(parts) if parts else str(message)
+
+
 async def build_agent(zep: AsyncZep, thread_id: str) -> Agent:
     """Build an agent whose memory is scoped to USER_ID on the given thread."""
     await ensure_user(
@@ -80,7 +78,9 @@ async def build_agent(zep: AsyncZep, thread_id: str) -> Agent:
         last_name="Nguyen",
         email="alice@example.com",
         writable=True,
-        extraction=True,
+        # Every-turn extraction so the demo does not wait on the default
+        # 5-turn cadence; still flush after invoke_async (see main).
+        extraction=ExtractionConfig(trigger=InvocationTrigger()),
         expose_search_tool=True,
         search_pinned_params={"scope": "auto"},
     )
@@ -94,6 +94,14 @@ async def build_agent(zep: AsyncZep, thread_id: str) -> Agent:
     )
 
 
+async def chat(agent: Agent, message: str) -> str:
+    """Send one message and flush pending extraction writes."""
+    result = await agent.invoke_async(message)
+    if agent.memory_manager is not None:
+        await agent.memory_manager.flush()
+    return _message_text(result.message)
+
+
 async def main() -> None:
     zep = AsyncZep(api_key=ZEP_API_KEY)
 
@@ -107,17 +115,12 @@ async def main() -> None:
 
     print("--- Conversation 1: seeding facts ---\n")
     agent1 = await build_agent(zep, THREAD_1)
-    seed_messages = [
+    for message in (
         "Hi! I'm Alice, a data scientist living in Portland, Oregon.",
         "On weekends I love hiking and landscape photography.",
-    ]
-    for message in seed_messages:
+    ):
         print(f"User:  {message}")
-        result = await agent1.invoke_async(message)
-        # Flush pending extraction writes before moving on.
-        if agent1.memory_manager is not None:
-            await agent1.memory_manager.flush()
-        print(f"Agent: {_message_text(result.message)}\n")
+        print(f"Agent: {await chat(agent1, message)}\n")
 
     wait_seconds = 20
     print(f"--- Waiting {wait_seconds}s for Zep to process the graph ---\n")
@@ -127,8 +130,7 @@ async def main() -> None:
     agent2 = await build_agent(zep, THREAD_2)
     recall = "Where do I live, and what do I like to do on weekends?"
     print(f"User:  {recall}")
-    result = await agent2.invoke_async(recall)
-    print(f"Agent: {_message_text(result.message)}\n")
+    print(f"Agent: {await chat(agent2, recall)}\n")
 
 
 if __name__ == "__main__":

integrations/strands/python/src/zep_strands/provisioning.py

@@ -1,9 +1,9 @@
 """
 Explicit, out-of-band Zep resource provisioning.
 
-``ZepContextProvider``'s lazy call into these helpers (see
-``ZepContextProvider._ensure_resources``) is hot-path-wrapped and will never
-raise into an agent run. Callers who want provisioning failures (and
+``ZepMemoryStore.initialize`` (and its lazy ``_ensure_resources_lazy`` path)
+calls these helpers on the hot path and is wrapped so a Zep outage never
+raises into an agent turn. Callers who want provisioning failures (and
 ``on_created`` hook failures) to surface loudly -- e.g. during account/session
 onboarding, before the first turn -- should call :func:`ensure_user` and
 :func:`ensure_thread` directly, out-of-band.