Repository navigation
Tags
Tags
Migrate zep-ingest to the Zep v4 API (0.4.0) (#632) * Migrate zep-ingest to the Zep v4 SDK Pin zep-cloud to 4.0.0a5 and target v4 only. Every public parameter now takes a server-generated UUID: graph_uuid for episode destinations and thread_uuid for thread messages. The package creates no user or thread and does no identifier lookup at run time. - Episodes go to graph.episode.add, batches to batch.create + batch.add_items + batch.process, nodes to graph.node.add, and fact triples to graph.edge.add. - search_when_ready calls the v4 per-scope search methods and returns the first page of items. - v4 batch items and thread messages have no reference-time field; created_at is validated, not sent, and counted in warnings. - Sequential thread ingestion tracks the task that thread.add_messages returns. - Examples, the production smoke script, README, and SETUP use the v4 UUID model. Add an Unreleased entry to the changelog. * Document the v4 create-contract change and skip ZEPAI-3605 smoke cases The v4 create endpoints reject user_id, thread_id, graph_id, and target_graph_id with 400 invalid_request. The package already passes no client-chosen identifier; the README and the changelog record the contract and name ZEPAI-3605, which now applies to every v4 thread because every v4 user has no user_id. The production smoke script skips its two sequential thread.add_messages cases under that defect. * Remove the ZEPAI-3605 skips and caveats from zep-ingest The production smoke script runs its two sequential thread.add_messages cases normally again. They will report FAIL with HTTP 404 until the backend fix for ZEPAI-3605 is deployed; that failure is accepted. The README and the changelog describe the correct behavior only and keep the standalone-graph batch gap, which is a different defect. * Send reference_time on every v4 submission path The v4 API renamed the developer-supplied created_at field to reference_time. The package now sends Episode.created_at and ThreadMessage.created_at as reference_time on graph.episode.add, on batch.add_items items, and on thread.add_messages messages. On zep-cloud 4.0.0a5 the wire models do not declare the field, so it travels as a pydantic extra on BatchItemInput and AddMessage and through the SDK's additional_body_parameters request option on episode.add. The declared field arrives in the v4.0.0-rc.1 SDK. The stale 'value was not sent' warnings and documentation text are removed, and the examples pass the source timestamp as created_at again. * Update zep-ingest for the stable zep-cloud 4.0.0 SDK Pin zep-cloud>=4.0.0,<5 and apply the V4 delta changes: - Use the declared reference_time field on AddMessage, BatchItemInput, and graph.episode.add instead of the alpha extra-field workarounds. - Pass page_size= on the search methods; the stable SDK renamed the limit parameter. - Submit fact triples with graph.edge.add(edges=[EdgeInput], deduplicate=True); the stable SDK returns AddEdgesResult. - Read task results through the typed TaskResult model. - Mark multi-thread sequential results as multi-queue so a tail-only episode poll cannot under-report. - Remove the standalone-graph batch workaround from the examples; the 404 gap no longer reproduces in production. * Release zep-ingest 0.4.0 * Release zep-ingest 1.0.0 * Point the v3 migration notes at the v4 migration guide * Read rejected_items from batch.add_items responses * Document the production smoke suite as a pre-release step * Add agent instructions for developing and releasing zep-ingest * Add a node and edge seeding scenario with search verification to the smoke suite * Record the batch rejected_items handling in the changelog * Keep the release at 0.4.0 while the API settles
Migrate the framework integrations to the Zep v4 SDK (#631) * Migrate zep-ms-agent-framework to the Zep v4 SDK The package now requires zep-cloud==4.0.0a5 and it addresses every resource by a server-generated UUID. - ZepContextProvider takes user_uuid, thread_uuid, and an optional graph_uuid. It makes no lookup call at run time, and it no longer creates a user or a thread on the turn path. - create_user and create_thread replace ensure_user and ensure_thread. The create response carries the UUIDs. - The search tool takes a graph_uuid and dispatches to the v4 per-scope graph search methods. The auto scope uses graph.get_context. - The tests, the example, the README, and SETUP.md follow the new API. * Migrate the Vercel AI TypeScript integration to the Zep v4 SDK The package now depends on @getzep/zep-cloud 4.0.0-alpha.5. The public API takes UUIDs. The middleware, the helpers, and the tools take a threadUuid, an optional userUuid, a graphUuid, and an optional templateUuid. The package does not call a lookup method at run time. createZepUserAndThread replaces ensureZepUserAndThread. It creates the user and the thread, and it returns the server-generated userUuid, graphUuid, and threadUuid. Context retrieval uses thread.getContext. Persistence uses thread.addMessages. Graph ingestion uses graph.episode.add. Search uses the scope-specific methods graph.searchEdges, graph.searchNodes, graph.searchEpisodes, graph.searchObservations, and graph.searchThreadSummaries, with graph.getContext for the auto scope. A search request puts the query fields in body and the limit at the top level, and the filter field is now filters. Zep v4 removes the norole role. An unrecognized role maps to undefined and the package omits the role from the message. The examples, the tests, the README, the SETUP, and the CHANGELOG follow the same convention. * feat(adk-go)!: migrate the Google ADK Go integration to the Zep v4 SDK The package now uses github.com/getzep/zep-go/v4 v4.0.0-alpha.5. Zep v4 addresses each user, thread, and graph by a UUID that the server generates, so the public API takes UUIDs and the integration makes no lookup call at run time. - CreateUser and CreateThread replace EnsureUser and EnsureThread, and they return the UUIDs that Zep generates. - WithUserUUID, WithThreadUUID, WithAfterThreadUUID, WithGraphUUID, and WithMemoryGraphUUID, together with the matching resolver options, supply the UUIDs to the callbacks, the search tool, and the memory service. - Graph search uses the v4 scope-specific methods and follows the cursor pages, and the package defines its own SearchScope values. - The README, the setup guide, and the changelog describe the v4 behavior. * Migrate the TypeScript Google ADK integration to the Zep v4 SDK The package now targets @getzep/zep-cloud 4.0.0-alpha.5. Zep v4 addresses a user, a thread, and a graph by a server-generated UUID, so the public API takes userUuid and threadUuid. - createUser and createThread replace ensureUser and ensureThread, and they return the UUIDs that Zep generates. - The callbacks and the tools take userUuid and threadUuid. The session-state keys are zep_user_uuid and zep_thread_uuid. - ZepGraphSearchTool and ZepMemoryService take a graphUuid, and they resolve the graph of the user with user.get when no graph UUID is given. - Graph search calls the v4 method for each scope, and the auto scope calls graph.getContext. - The tests, the examples, the README, SETUP.md, and the CHANGELOG follow the v4 API. The package adds a lint script and an ESLint configuration. * feat(ag2): migrate zep-ag2 to the Zep v4 SDK The package now uses zep-cloud 4.0.0a5 and addresses each resource by its UUID. ZepMemoryManager takes user_uuid and thread_uuid, ZepGraphMemoryManager takes graph_uuid, and each tool factory takes graph_uuid. The new create_user and create_thread helpers replace ensure_user and ensure_thread, and they replace the lazy provisioning path of the manager. Graph search uses the v4 scope methods, and graph ingestion uses graph.episode.add. * feat(adk-python): migrate zep-adk to the Zep v4 SDK The package now targets zep-cloud==4.0.0a5 and addresses every user, thread, and graph by a server-generated UUID. - Replace ensure_user and ensure_thread with create_user and create_thread, which return the created User and Thread. - Remove the on_created hook and the UserSetupHook type. - Rename the session-state keys to zep_user_uuid, zep_thread_uuid, and zep_graph_uuid, and give ContextInput user_uuid and thread_uuid. - Call the split v4 graph search methods and graph.get_context, and read the items of the returned pager. - Pass the thread UUID a 8000 s the first argument of thread.add_messages. - Update the tests, the example, the README, SETUP.md, and the CHANGELOG. * feat(autogen-python): migrate zep-autogen to the Zep v4 SDK The package now targets the Zep v4 API and requires zep-cloud==4.0.0a5. Zep v4 assigns the UUID of every user, thread, and graph. The public API takes user_uuid, thread_uuid, and graph_uuid. The helpers ensure_user and ensure_thread are replaced by create_user and create_thread, which return the SDK model. The integration does not resolve a name at run time. The package calls user.create, thread.add_messages, thread.get_context, thread.list_messages, graph.episode.add, graph.episode.list, graph.get_context, and the scope-specific graph search methods. Each list method and each search method returns a pager, and a new search module collects the results up to the requested limit. The tests, the examples, the README, the setup guide, and the changelog are updated for the v4 API. * feat(pydantic-ai): migrate the Python integration to the Zep v4 SDK The package now requires zep-cloud==4.0.0a5 and targets Zep v4 only. - ZepDeps and ContextInput take user_uuid, thread_uuid, and graph_uuid. - create_user and create_thread replace ensure_user and ensure_thread. Each helper returns the v4 model, so the application stores the UUIDs. - The history processor no longer creates a user or a thread on the turn path, and the integration does not look a name up at run time. - The search tool uses the v4 graph methods search_edges, search_nodes, search_episodes, search_observations, search_thread_summaries, and get_context, with the graph UUID as the first argument. - The tests, the example, the README, and SETUP.md show the v4 flow. * Migrate @getzep/zep-mastra to the Zep v4 SDK The package now depends on @getzep/zep-cloud 4.0.0-alpha.5. Zep v4 addresses every user, thread, and graph by a server-generated UUID, so the public API of the integration takes UUIDs. The integration does not call lookup at run time. The bindings take graphUuid and threadUuid. The processors take the same two fields, and a ZepIdentityResolver returns them. createZepUserAndThread replaces ensureZepUserAndThread, because Zep v4 has no name-addressed create. The new function returns the userUuid, the graphUuid, and the threadUuid, which the application stores and reuses. The Zep calls are migrated to their v4 replacements: thread.getContext, thread.addMessages, graph.episode.add, user.create, and the graph search scope methods. The zepSearch tool keeps the model-visible scope parameter. * Migrate zep-strands to the Zep v4 SDK The package now uses zep-cloud 4.0.0a5 and the v4 API only. The public store API takes a user UUID, a thread UUID, and a graph UUID. The provisioning helpers create a user and a thread and return the SDK objects, so that the application can keep the server-generated UUIDs. Graph search dispatches to the v4 scope methods and reads the pager items. The tests, the example, the README, the SETUP guide, and the changelog show the v4 code. * fix(autogen-python): label the user in the examples with a generated user_id Production v4 returns 404 on thread.add_messages and thread.get_context for a user that was created without a user_id. The examples pass a generated user_id label as a temporary workaround for that defect. The label is a name, not an address. The UUID still addresses the user, and the public API of the package stays UUID-only. * Give the example a user_id label as a workaround for a v4 defect For a user with no user_id label, thread.add_messages and thread.get_context give a 404 on production. The example passes a generated label so that the full loop runs. The label is not used for addressing: the example addresses every resource by UUID. * Mark the example userId label as a temporary workaround The comment now says that the label is a temporary workaround for a production v4 defect, and that Zep addresses the user by the UUID that it returns. * fix(pydantic-ai): give the example user a label as a temporary workaround A v4 production defect makes thread.add_messages return HTTP 404 for a user that has no user_id label. The example now passes a generated label on the user.create call, so the full loop runs end to end. The label is a name, not an address, and the package API, the tests, and the documentation stay UUID-only. * fix(adk-go): give the example a generated user_id label The production v4 API returns HTTP 404 from Thread.AddMessages when the thread belongs to a user that has no user_id label. The example creates the user with a generated label as a temporary workaround. The label is a name only, and the package continues to address each resource by its UUID. The example now creates the thread without a name. * Set a generated userId label in the Vercel AI examples A production v4 defect returns 404 from the thread message route and the thread context route for a user that has no userId. The examples set a generated userId label on the user.create call so that they complete end to end. The label is a name, not an address. The package public API and the documentation still use UUIDs only. * Keep the ADK Python documentation free of a user_id name The package documentation shows the create-without-a-name pattern again. The runnable example and the live integration test keep a generated user_id label, with a comment that names the label a temporary workaround for a production v4 defect. The label is not an address. * fix(ag2): add the user_id workaround and a working event loop to the examples The production v4 API rejects thread.add_messages and thread.get_context for a user that has no user_id label. The examples now pass a generated label on user.create. The label is not an address, because the examples use the UUIDs from the responses. The examples also do the provisioning in a separate event loop, because an AsyncZep client binds to the loop that first drives a request, and the synchronous AG2 hooks and tools use a background loop. * Keep the userId workaround in the example only The live test and the documentation now show the create-without-a-name pattern that the Zep v4 identity convention defines. The example keeps a generated userId label, with a comment that names the temporary production defect. The label is a name only; Zep addresses the user by its UUID. * Migrate zep-langgraph to the Zep v4 SDK The package now targets zep-cloud 4.0.0a5 only. Every public helper takes a server-generated UUID: thread_uuid for the context and persistence helpers, and graph_uuid for the search tool and ZepStore. The integration does not resolve an application identifier at run time. Context retrieval uses thread.get_context, persistence uses the v4 AddMessage type, graph ingestion uses graph.episode.add, and search uses the dedicated v4 graph search methods or graph.get_context. The provisioning helpers ensure_user and ensure_thread become create_user and create_thread, which return the created objects so the caller can store the UUIDs. The tests, the examples, the README, the SETUP guide, and the CHANGELOG are updated for the v4 API. * Migrate zep-livekit to the Zep v4 SDK The package now targets zep-cloud 4.0.0a5. Zep v4 addresses a user, a thread, and a graph by a server-generated UUID, so the public API of the integration takes UUIDs. - ZepUserAgent takes user_uuid and thread_uuid. - ZepGraphAgent takes graph_uuid and calls graph.get_context. The per-scope retrieval limits are replaced by max_characters. - ContextInput exposes user_uuid and thread_uuid; GraphContextInput exposes graph_uuid. - create_graph_search_tool requires graph_uuid and dispatches to the dedicated v4 search methods, which return pagers. - ensure_user and ensure_thread are replaced by create_user and create_thread, which return the response objects so the application can read and store the UUIDs. - The agent no longer creates resources on the hot path and does not resolve a name at run time. - The tests, examples, README, SETUP, CHANGELOG, and the package development guide are updated for the v4 flow. * Migrate zep-crewai to the Zep v4 SDK Target zep-cloud==4.0.0a5 and v4 UUID addressing throughout the package: - Storage adapters and tools take user_uuid, thread_uuid, and graph_uuid. ZepUserStorage, ZepStorage, ZepGraphStorage, create_search_tool, and create_add_data_tool address resources by UUID only. - Writes use thread.add_messages(thread_uuid, ...) and graph.episode.add(graph_uuid, ...). Thread context uses thread.get_context(thread_uuid). Graph context uses graph.get_context(graph_uuid, ...), which Zep assembles on the server. - The search tool calls the dedicated v4 method for each scope and reads the returned pager; scope 'auto' calls graph.get_context. - ensure_user and ensure_thread remain create-then-catch-conflict onboarding helpers. A v4 conflict carries details.uuid, so they fetch the existing resource with user.get/thread.get and never call lookup. - Storage adapters no longer provision lazily on the turn path and no longer take first_name, last_name, email, or on_created. - facts_limit and entity_limit are replaced by max_characters, the v4 server-side control for Context Block size. - Update tests, examples, README, SETUP, and the Unreleased changelog for the v4 API and the UUID identifier convention. * Give live-test users a user_id label to avoid the v4 thread 404 The v4 server cannot add a message to a thread whose user has no user_id, so the live tests create the user with a unique label. The package APIs stay UUID-only, and no integration calls lookup. Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * fix(autogen-python): remove the user_id workaround from the examples The examples create the user with no client-supplied identifier and read the UUID from the response, which is the long-term v4 pattern. The v4 defect that required the label is tracked as ZEPAI-3605, and the live test that needs a thread message add is skipped until the fix is deployed. * Remove the user_id workaround and skip the blocked live tests The example creates the user with no client-supplied identifier again, and it reads the UUIDs from the create response. The two live tests that need a thread message add are skipped with a reason that names ZEPAI-3605. * Remove the userId workaround from the Vercel AI examples The v4 thread defect is tracked as ZEPAI-3605. The integrations do not hold a workaround for it. The examples create the user without a client-supplied identifier and use only the returned UUIDs. The live test needs a thread message add, so it stays skipped until the fix is deployed. The skip comment names ZEPAI-3605. The SETUP note names the ticket and states the defect. * Remove the thread defect workaround from zep-strands The example creates a user with no client-supplied identifier again, and it reads the UUID from the create response. The live tests that add a thread message are skipped with a reason that names ZEPAI-3605. The README gives one short note about the defect. * fix(pydantic-ai): remove the user_id workaround and skip the live test The example creates the user with no client-supplied identifier again, and it uses the server-generated UUIDs for all later calls. The live lifecycle test is skipped with a reason that names ZEPAI-3605, because a user that is created without a user_id cannot receive a thread message until the fix is deployed. The mock tests continue to run. * Remove the userId workaround for ZEPAI-3605 The example creates the user with no client-supplied identifier and uses the server-generated UUIDs for all later calls. The live test is skipped, because a user without a userId cannot receive a thread message until the fix for ZEPAI-3605 is deployed. The README and the example carry one short note that names the ticket. * Skip the live zep-langgraph thread test until ZEPAI-3605 is fixed A user that is created without a user_id cannot receive a thread message, so the live lifecycle test cannot pass. The test is skipped with a reason that names ZEPAI-3605, and it keeps the UUID-only pattern. The ReAct example and the setup guide carry the same short note. * fix(adk-go): remove the user_id workaround for the v4 thread defect The example, the live tests, and the README now create the Zep user with no client-supplied identifier, and they use the UUIDs that Zep returns. A short note names ZEPAI-3605 and states that a thread of a user that has no user_id cannot receive a message until the fix is deployed. TestLiveCreateAndPersist adds a thread message, so it skips with that reason. The live tests that do not add a message continue to run. * fix(ag2): remove the user_id workaround for the v4 thread defect The examples and the tests now create a user with no client-supplied identifier, and they use the UUIDs from the responses. A short note names ZEPAI-3605 and states that a user without a user_id cannot receive a thread message until the fix is deployed. The live integration test is skipped with the same reason. * Remove the example userId workaround for the v4 thread defect The examples now create the user with no client-supplied identifier and use the UUID that Zep returns. A short note names ZEPAI-3605, which records that a user without a user_id cannot receive a thread message until the fix is deployed. The live test that needs a thread message add is skipped for the same reason. * Remove the user_id workaround from the ADK Python package The example and the live integration test create the Zep user with no client-supplied identifier and address every resource by the UUID from the create response. The live test adds thread messages, thus it is skipped with a reason that names ZEPAI-3605. SETUP.md keeps one short note about the defect. * Skip the live CrewAI test until the ZEPAI-3605 fix is deployed The integration test needs a thread message add, which the v4 API rejects for a user created without a user_id (ZEPAI-3605). The test keeps the correct long-term pattern: it creates the user with no client-supplied identifier and reads uuid_ from the response. It is skipped with a reason that names the ticket until the backend fix is deployed. Add a short note about the limitation to the README storage routing section. * Remove the client-chosen names from the zep-strands create calls A Zep v4 create operation accepts no client-chosen name, so create_user no longer accepts a user_id and create_thread no longer accepts a thread_id. The tests, the README, and the changelog show the new contract. * langgraph python: remove client-chosen identifiers from v4 create calls The v4 create endpoints reject user_id, thread_id, and graph_id. The live integration test now creates the user with create_user and no name. The README, the SETUP guide, and the example state the new rule, and the ZEPAI-3605 note explains that every v4 user has no user_id. * Remove the client-chosen create names from the ADK TypeScript package Zep v4 rejects a user_id on POST /users and a thread_id on POST /threads, so createUser and createThread no longer accept a name. * Remove the client-chosen identifiers from the ADK Python create calls Zep v4 rejects a user_id on user.create and a thread_id on thread.create. The create_user and create_thread helpers accept no such parameter now, and they create a resource that has no name. * fix(autogen-python): create the live-test user without a user_id The v4 create endpoints now reject a client-chosen identifier with 400 invalid_request. The live test calls create_user with no identifier and reads the UUID from the response. The test stays skipped with a ZEPAI-3605 reason because every v4 user has no user_id and the thread defect still applies. * adk/go: remove the client-chosen names from the v4 create calls The Zep v4 create endpoints do not accept a user_id or a thread_id any more, and the server rejects a request that carries one. CreateUser and CreateThread therefore take no name parameter, and they send no user ID and no thread ID. The tests assert that the requests carry no name. * Remove the client-chosen identifiers from the Mastra v4 create calls The v4 create endpoints reject a user_id and a thread_id, so createZepUserAndThread no longer accepts a userId or a threadId option and sends neither field. The tests, the example, the README, and the setup guide follow the same pattern. The live test stays skipped for ZEPAI-3605. * pydantic-ai(python): remove the client-chosen user_id from the live test The v4 create endpoints do not accept a client-chosen identifier. The live integration test now creates the user with create_user and no name, and it stays skipped for ZEPAI-3605. * Remove the client-chosen identifiers from the v4 create calls A v4 create call takes no client-chosen name. The create helpers no longer accept a user_id or a thread_id, and the tests, the example, and the documentation of the package no longer set one. The live tests that need a thread message add stay skipped for ZEPAI-3605. * fix(ag2): remove client-chosen identifiers from the v4 create calls The v4 create operations reject user_id and thread_id. The provisioning helpers, the tests, the live test, and the README no longer pass or document a client-chosen name. * Remove client-chosen identifiers from the Vercel AI creates The v4 create endpoints no longer accept user_id or thread_id, and a request that carries a non-empty value gets a 400 response. The package removes the userId and threadId options of createZepUserAndThread, and the create calls now pass only the identity fields. The public API stays UUID-only. * Remove client-chosen identifiers from zep-crewai create calls Zep v4 create endpoints no longer accept a client-chosen identifier: a non-empty user_id, thread_id, or graph_id is a 400 invalid_request. - ensure_user and ensure_thread drop the user_id and thread_id arguments. A successful call always creates a new resource, and the returned object carries the server-generated uuid_. The conflict path is unchanged: a 409 with details.uuid still resolves the existing resource with user.get or thread.get. No helper calls lookup. - The live integration test no longer gives the user a user_id label. It creates the user with no identifier and stays skipped for ZEPAI-3605, which now applies to every v4 thread. - Update the README, the package docstring, and the Unreleased changelog entry for the new signatures. * livekit(python): drop client-chosen names from v4 create calls The v4 create endpoints reject user_id, thread_id, and graph_id, so create_user and create_thread no longer expose them. The live integration test stays skipped under ZEPAI-3605. * adk/go: remove the ZEPAI-3605 test skip and notes The live callback test runs again and asserts the correct behavior. The example and the README no longer carry a temporary note about the ZEPAI-3605 defect. * Remove the ZEPAI-3605 skip and notes from zep-mastra The live test runs again and asserts the correct behavior. The README and the example no longer describe the defect. The live test will fail with HTTP 404 until the backend fix for ZEPAI-3605 is deployed. * fix(autogen-python): run the live test instead of skipping it for the backend defect The ZEPAI-3605 skip and the defect note are removed. The backend team will fix the thread message defect, and the test now asserts the correct behavior. The module still skips only when ZEP_API_KEY or OPENAI_API_KEY is not set. * Remove the ZEPAI-3605 test skips and notes The two live tests that add a thread message now run without a skip. The example and SETUP.md no longer describe the defect. The tests will fail with a 404 until the backend fix is deployed. * test(ag2): run the live test without the ZEPAI-3605 skip The live integration test now runs when the credentials are set. The ZEPAI-3605 notes are removed from the test and the examples, so the code describes the correct v4 behavior only. * Remove the ZEPAI-3605 skip and notes from the ADK TypeScript package The live test that adds a thread message now runs again. The examples no longer hold a ZEPAI-3605 note. * livekit(python): run the live test without a defect skip Remove the ZEPAI-3605 skip and its caveats. The test runs normally and asserts the correct behavior; it will fail with a 404 until the backend fix ships. The ZEP_API_KEY credential skip is kept. * Remove the ZEPAI-3605 skip from the Vercel AI live test The defect skip is removed on request: a skipped test must not depend on somebody remembering to unskip it after the backend fix. The live test now runs normally when ZEP_API_KEY is set. The SETUP note about the defect is removed as well. * Let the live CrewAI test fail for ZEPAI-3605 instead of skipping it Remove the defect skip and the temporary notes about it. The backend fix is in progress, and nobody must come back to un-skip the test. The test runs normally and asserts the correct behavior; the module-level skip for missing ZEP_API_KEY or OPENAI_API_KEY stays because it is a configuration skip, not a defect skip. * adk/go: make the live callback test check that both turns persist The callbacks log and swallow a Zep error, so the test captures the error log and reads the thread back. The test now fails when a persist fails. * Run the zep-strands live tests without the ZEPAI-3605 skips The live tests now run and assert the correct behavior. The README no longer holds the temporary ZEPAI-3605 note. * pydantic-ai(python): remove the ZEPAI-3605 test skip and note The live lifecycle test now runs when the API keys are set. The example no longer carries the ZEPAI-3605 note. The credential skip stays. * Remove the ZEPAI-3605 skip and note from the ADK Python package The live lifecycle test now runs when the credentials are set. It will fail until the backend fix for ZEPAI-3605 is deployed. The setup guide no longer describes the defect. * Run the zep-langgraph live test without the ZEPAI-3605 skip The live test will fail with a 404 on thread.add_messages until the backend fix is deployed. The SETUP and example notes about ZEPAI-3605 are removed. * Move zep-pydantic-ai to the stable zep-cloud 4.0.0 SDK Pin zep-cloud>=4.0.0,<5. Send page_size in place of limit to the graph search methods, graph.episode.list, and thread.list_messages. Remove the pre-release install note. * ms-agent-framework: use the stable zep-cloud 4.0.0 SDK Change the dependency to zep-cloud>=4.0.0,<5. Send page_size instead of limit on the v4 list and search calls. The search tool keeps its limit parameter and sends it as page_size. * fix(autogen-python): target the stable zep-cloud 4.0.0 SDK Pin zep-cloud to >=4.0.0,<5 and rename the page-size argument of every list and search call from limit to page_size. * zep-strands: use the stable zep-cloud 4.0.0 SDK Change the dependency to zep-cloud>=4.0.0,<5. Send the search page size as page_size, because the stable SDK removed limit. Use page_size in the live test list calls. Remove the pre-release install note. * Update zep-vercel-ai to the stable Zep v4 SDK Bump @getzep/zep-cloud to 4.0.0. The stable SDK removes the nested search body: each scope-specific search request now carries the query, the reranker, the filters, and the other parameters as flat fields, and the page size is the pageSize field. The package maps its public limit parameter to pageSize and casts the generic filters option to the filter type of the active scope. * Update zep-crewai to the stable v4 SDK Bump the pin to zep-cloud >=4.0.0,<5 and apply the v4 deltas: search calls pass page_size (the package keeps its limit parameter and translates it), test fixtures supply the new required Node fields, and the examples and docs show the stable filter types. ZEPAI-3605 is fixed, so the live lifecycle test now runs and passes against production. * feat(ag2): use the stable zep-cloud 4.0.0 SDK Change the pin to zep-cloud>=4.0.0,<5. Send the search limit to the SDK as page_size, because the 4.0.0 SDK renamed limit to page_size on every list and search call. Tell the reader that each search scope accepts only its own filter keys. * Move the ADK Python package to the stable zep-cloud 4.0.0 SDK Change the dependency to zep-cloud>=4.0.0,<5. Send the search limit as page_size, because the stable SDK replaces limit with page_size on each list and search call. Update the tests, the example, and the documents. * livekit(python): target the stable Zep v4 SDK The package pins zep-cloud>=4.0.0,<5, renames the search page-size parameter to page_size, and fixes the ontology example filter field. * zep-adk (TypeScript): use the stable Zep v4 SDK 4.0.0 Change the @getzep/zep-cloud dependency from 4.0.0-alpha.5 to ^4.0.0. Send the scoped graph search requests in the stable shape: query, pageSize, and the search fields are top-level request fields. Use the stable reranker type. Update the tests and the install text. * langgraph python: move to the stable zep-cloud 4.0.0 SDK The package now requires zep-cloud>=4.0.0,<5. The search tool, ZepStore, the example, and the live test send the result count as page_size, which replaces limit in the stable SDK. The documentation states that search_filters must use the filter type of the selected scope. * adk(go): move to zep-go/v4 v4.0.0 The stable SDK replaces the alpha graph search request types with one request type for each scope. The package now sends page_size, converts the search filters and the reranker for each scope, and defines zepadk.SearchReranker because the SDK has one reranker type for each scope. * Move zep-mastra to the stable Zep v4 SDK 4.0.0 The package depends on @getzep/zep-cloud ^4.0.0. The search tool sends pageSize in place of limit, and it sends the search fields at the top level of the request in place of a body object. The tool uses the scope-specific reranker and filter types of the stable SDK. * langgraph python: omit a reranker that the search scope does not support Zep v4 rejects some rerankers on some search scopes with HTTP 400, for example cross_encoder on episodes. The search tool now omits such a model-chosen reranker, so the search runs with the default reranker. The search_filters argument now accepts the typed v4 filter classes. * fix(ag2): use a second client for the tools in the manual test The manual test used one AsyncZep client for the provisioning and for the synchronous tools. The client binds to the event loop that first drives a request, so the first add_memory call failed with "Event loop is closed". The tools now use a second client. * livekit(python): describe the v4 context block without episodes graph.get_context does not return episodes in the Context Block in zep-cloud 4.0.0, so the docstring no longer lists them. * autogen/python: scope the search filters to the v4 filter types Each v4 search scope has its own filter type, and the server rejects a filter key that the scope does not support with 400 unsupported_filter. Define SearchFiltersLike as the union of the scoped filter types, widen search_filters on ZepGraphMemory and the search tool, and add a per-query filters override to ZepGraphMemory.query. The graph example now uses NodeSearchFilters with a node query. * adk(go): remove episode_mentions from the model reranker values The graph search tool does not offer the episode_mentions reranker to the model, because Zep requires the EpisodeUUIDs search filter for it. A model-supplied episode_mentions value falls back to the default reranker and is not sent to Zep. A developer can still set episode_mentions with WithToolReranker and EpisodeUUIDs in WithToolSearchFilters. * ms-agent-framework: set the package version to 0.3.0 The v4 migration is a breaking change. Change the version to 0.3.0, and change the CHANGELOG Unreleased heading to 0.3.0. Put the v4 SDK requirement, the UUID parameters, and the replaced helpers under a Breaking heading. * Set zep-vercel-ai version to 0.3.0 * langgraph python: set the version to 0.3.0 The v4 migration is a breaking change, so the minor version increases. The CHANGELOG lists the breaking changes under a Breaking heading. * Set the zep-pydantic-ai version to 0.3.0 for the breaking v4 migration * adk(go): release v0.2.0 in the changelog Change the Unreleased heading to v0.2.0 and put the breaking changes under a Breaking heading. Merge the untagged 0.2.0 entry into the same section, because v0.1.0 is the last tag of the module. * fix(ag2): use a sync Zep client for sync tools and release 0.3.0 The sync AG2 tools and the sync manager methods now call a synchronous Zep client. Before this change, they drove an AsyncZep client on a background event loop, and the first tool call failed with "Event loop is closed" after an async helper used the same client. An AsyncZep client given to a tool factory now raises TypeError. The managers take the new sync_client keyword for their sync methods. Set the package version to 0.3.0, because the V4 migration is a breaking change. The CHANGELOG lists the breaking changes. * Set the zep-mastra version to 0.3.0 and list the breaking changes in the changelog * zep-strands: Set the version to 0.2.0 and record the breaking v4 changes * Set the zep-adk TypeScript package version to 0.3.0 and list the breaking changes in the changelog * Set the zep-adk Python version to 0.4.0 The V4 migration is a breaking change. Change the version in pyproject.toml and __version__ to 0.4.0, and change the CHANGELOG Unreleased heading to 0.4.0 with a Breaking section. * autogen/python: release version 2.0.0 The v4 migration is a breaking change for the package. Set the version to 2.0.0, name the CHANGELOG entry, and move the breaking changes under a Breaking heading. * livekit(python): release 0.3.0 * Release zep-crewai 2.0.0 Bump the version to 2.0.0 for the breaking v4 migration and move the changelog entry from Unreleased to 2.0.0 with a Breaking section. * autogen/python: honor ZEP_API_URL in the examples and the live test The 4.0.0 SDK does not read ZEP_API_URL and uses the value of base_url as given. The examples and the live test now pass base_url with the /api/v4 path when ZEP_API_URL is set, so a run can target the development API. Without the change every run went to production. * vercel-ai(ts): honor ZEP_API_URL in the live test and examples * adk(go): release v1.0.0 in the changelog Change the release heading from v0.2.0 to v1.0.0. The V4 change breaks the package API, so the release uses a new major version. The module path does not change for v1. * Set the zep-adk Python version to 1.0.0 The V4 migration breaks the package API. Change the version in pyproject.toml and __version__ to 1.0.0, and change the CHANGELOG 0.4.0 heading to 1.0.0. The Breaking section does not change. * vercel-ai(ts): release 1.0.0 * Set the zep-adk TypeScript package version to 1.0.0 * langgraph python: set the version to 1.0.0 * Set the zep-mastra version to 1.0.0 * Set the zep-pydantic-ai version to 1.0.0 for the breaking v4 migration * livekit(python): release 1.0.0 * chore(ag2): release version 1.0.0 The V4 migration breaks the package API, so the package version is now 1.0.0. The CHANGELOG entry for this release is now 1.0.0. * ms-agent-framework: set the package version to 1.0.0 * Release zep-strands 1.0.0 Change the zep-strands version from 0.2.0 to 1.0.0. The V4 change breaks the package API, so the release uses a new major version. * ms-agent-framework: link the V4 migration guide in the 1.0.0 changelog * Point the zep-pydantic-ai migration notes to the V4 migration guide * adk(go): link the V4 migration guide in the changelog The Breaking section of v1.0.0 now links to the Zep V4 migration guide for the general procedure. It lists only the API changes of this package and where the developer gives each stored UUID. It also warns the reader not to create a new resource for an existing V3 user, thread, or graph. * Link the V4 migration guide in the zep-strands changelog The 1.0.0 Breaking section now links the V3 to V4 migration guide for the general procedure. It lists only the API changes of this package and warns the reader not to create a new resource for an existing V3 resource. * Point the zep-adk V3 migration text to the V4 migration guide The README migration section and the CHANGELOG Breaking section now link to the V4 migration guide for the general procedure. They list only the API changes that are specific to this package, and they warn the reader not to create new reso 8000 urces for an existing V3 user or thread. * langgraph python: link the V4 migration guide and list the package API changes * Point the zep-adk TypeScript migration text to the V4 migration guide and list only the package API changes * vercel-ai(ts): point the 1.0.0 migration notes at the v4 migration guide * Link the zep-mastra migration text to the V4 migration guide and list only the package changes * livekit(python): point the changelog migration text at the v4 guide * Point the zep-crewai migration notes at the v4 migration guide The changelog now links to the migration guide for the general procedure and lists only the package-specific API changes, with a warning against recreating resources that already exist. * docs(ag2): link the V4 migration guide for the V3 upgrade The CHANGELOG and the README now link to the V3 to V4 migration guide for the general procedure. They list only the API changes of this package, and they tell the reader not to create new resources for V3 data. * autogen/python: link the V4 migration guide in the 2.0.0 changelog * Validate the search settings of zep-strands before a request The search tool now shows the model only the rerankers that the Zep v4 API accepts for each scope. It returns a clear error for an invalid scope and reranker pair, and it sends mmr_lambda=0.5 for mmr when no value is given. An invalid pinned pair, or an invalid store scope and reranker pair, raises a ValueError at construction. * Validate the zep-mastra search scope and reranker pair before the Zep request * fix(ag2): send only valid search reranker pairs The search tools now offer only the rerankers that each scope supports. They drop an unsupported reranker that the model sends, and they send a default mmr_lambda for mmr. An invalid pinned pair raises ValueError when the tool is created. The pairs come from tests on the development API. * langgraph python: show the model only valid search rerankers and validate the settings before the request * adk(go): validate the graph search scope and reranker pair The graph search tool now shows only the scope and reranker pairs that Zep v4 accepts. It returns a clear error to the model for a pair that Zep rejects, and it makes no Zep call. NewGraphSearchTool returns an error for a pinned pair that Zep rejects. The mmr reranker uses mmr_lambda=0.5 when no value is set. * Validate the scope and reranker pair in the zep-adk TypeScript graph search tool The tool now shows the model only the rerankers that each scope accepts and that the other options let it use. It checks each pair before the request and returns an error message that names the valid values. The constructor throws an error for pinned options that cannot work together. The tool sends mmrLambda 0.5 when the reranker is mmr and no value is set. * Send each zep-pydantic-ai search scope only the filters that it supports * ms-agent-framework: validate the search filter keys for each scope * Validate search filters against the selected scope Zep v4 gives each search scope its own filter type and returns HTTP 400 unsupported_filter for a key that the scope cannot apply. The README example passed node_labels with the default edges scope, so every call with it failed. The tool now validates search_filters against the resolved scope. A pinned scope is checked at construction time; a model-chosen scope is checked before the SDK call and returns a clear error to the model. The README example uses edge_types for the default edges scope and shows node_labels pinned to the nodes scope. * ms-agent-framework: use the full name of the Zep user as the default user message name * Put the zep-pydantic-ai Quick Start code in an async main function * adk(go): require the graph and thread UUIDs in the README and constructors The two README snippets now set the stored graph UUID and thread UUID. NewGraphSearchTool returns an error when it has a client and no graph UUID. NewBeforeModelCallback, NewAfterModelCallback, and NewMemoryService log an error at construction when they have a client and no UUID, because ADK defines their return types. An empty UUID string counts as no UUID. * langgraph python: add the user message to the thread before the context call, so that the first turn of a new thread gets context * Require the Zep user UUID from the developer in ZepMemoryService ZepMemoryService used the ADK user_id as the Zep user UUID. With the README quickstart, the ADK user_id is an application identifier, so the service returned no memories and gave no clear error. The service now gets the Zep user UUID from a new resolve_user_uuid callable, or it uses a fixed graph_uuid. The constructor raises ValueError when neither is set. When the resolver returns no value or a value that is not a UUID, the service logs an error and does not call Zep. The README quickstart stores the UUID from create_user and gives it to the service. * Correct the contextBuilder example in the zep-adk TypeScript README The example sent the search query in a body object. The 4.0.0 SDK takes the query as a top-level field of graph.searchEdges, so the example did not compile. * autogen/python: reject removed V3 kwargs and fix ZEP_API_URL docs - ZepUserMemory and ZepGraphMemory now raise a TypeError that names the V4 replacement for each removed V3 keyword argument, and reject any other unexpected keyword argument. - README and SETUP.md now state that the SDK does not read ZEP_API_URL and that the caller must pass base_url explicitly. * vercel-ai(ts): persist the user message when the model writes text before a tool call * Point the docs at the stable zep-cloud requirement SETUP.md and the README told developers to pin the alpha zep-cloud==4.0.0a5 and described 4.x as a pre-release. The package requires zep-cloud>=4.0.0,<5, which resolves to the stable 4.0.0 release. * Pass base_url explicitly for a non-default Zep API The v4 SDK reads only ZEP_API_KEY and ignores ZEP_API_URL, so SETUP.md told developers that setting the variable would change the API target. The docs now show the correct form (base_url ending in /api/v4), and each example and the live test read ZEP_API_URL and pass it to the client. * fix(ag2): return an error for an invalid search reranker pair When the model selects a scope and reranker pair that Zep rejects, the search tools do not call Zep. They return an error that names the pair and lists the valid rerankers for the scope. * fix(langgraph): return an error for an invalid reranker and do not call Zep The search tool does not remove a model-selected reranker that the scope does not accept. It returns an error that names the invalid pair and lists the valid rerankers for the scope. A reranker with scope 'auto' also gives an error. When the model gives no reranker, the tool sends 'rrf' for every scope except 'auto'. When a reranker is pinned, the scope field does not show 'auto'. * fix(ag2): return an error for a reranker with the auto scope The auto scope takes no reranker. When the model sends a reranker with scope auto, the search tools return an error and do not call Zep. A pinned reranker with scope auto raises ValueError when the tool is created. The reranker parameter has no default value. * fix(strands): return an error for a reranker with the auto scope The auto scope takes no reranker. When the model sends a reranker with scope auto, the search tool returns an error and does not call Zep. A pinned reranker with scope auto, or a search_reranker with search_scope auto on ZepMemoryStore, raises ValueError at construction. The reranker parameter has no schema default. When the model gives no reranker for a scoped search, the tool sends rrf, as before. * fix(pydantic-ai): return an error for a reranker with the auto scope The auto scope takes no reranker. When the model sends a reranker with scope auto, the search tool returns an error and does not call Zep. A reranker pinned together with scope auto raises ValueError when the tool is created. The reranker parameter has no schema default. When the model sends no reranker for another scope, the tool still sends rrf. * fix(autogen): return an error for a reranker with the auto scope The 'auto' scope takes no reranker. When the model sends a reranker with scope 'auto', the search tool returns an error and does not call Zep. When the model does not send a reranker for another scope, the tool sends 'rrf' as before. A pinned reranker with scope 'auto' raises ValueError when the tool is created, and a pinned reranker removes 'auto' from the scope enum of the tool schema. The model-facing reranker parameter has no default value. * livekit(python): reject a reranker with the auto search scope The auto scope takes no reranker. A reranker that the model sends with scope auto now returns an error to the model and does not call Zep. Pinning a reranker removes auto from the scope choices, and pinning a reranker together with scope auto raises AgentConfigurationError when the tool is created. The reranker parameter has no default in the schema; when the model omits it for another scope, the tool still sends rrf. * crewai: error on reranker with scope auto instead of dropping it The 'auto' scope takes no reranker, and silently dropping a model- or developer-supplied reranker is no longer acceptable (matches AG2 and LangGraph): - A model-supplied reranker with scope 'auto' returns an error string that asks the model to search again with no reranker or another scope, without calling Zep. - Pinning a reranker together with scope 'auto' raises ValueError at construction. - The model-facing reranker field has no schema default, so an omitted reranker with 'auto' is not an error; for every other scope an omitted reranker sends 'rrf', the same request as before. - With a reranker pinned, the model-facing scope field does not offer 'auto'. Update the tests, the README, and the CHANGELOG for the new behavior. * test(ag2): read the reranker description after tool registration AG2 tool registration can replace the shared Annotated string metadata with a Field. The live test registers the tools before this test runs in CI, so the test now reads the description from either form. * crewai: correct the conflict-recovery claims in provisioning docs Zep v4 returns ResourceAlreadyExists with no details, so a create conflict never carries a UUID, and a create accepts no client-chosen identifier. The docstrings and the README now say only true behavior: a successful call always creates a new resource, the helpers never call lookup, and a failed create raises the error. The details.uuid code path is unchanged. * adk-go: return an error for a reranker with scope auto The graph search tool now rejects a reranker that the model sends with scope auto. The tool makes no Zep call and tells the model to call the tool again with no reranker or with a scope that accepts the reranker. The reranker parameter has no schema default, so auto with no reranker works. A call with no reranker still uses rrf for every scope except auto. * fix(mastra): return an error for a reranker with the auto search scope The zepSearch tool does not ignore a reranker with scope 'auto' now. A model-selected reranker with 'auto' returns an error and the tool does not call Zep. A pinned 'auto' scope with a pinned reranker throws at construction. The tool sends the default 'rrf' reranker only for the other scopes. * fix(adk-ts): return an error for a reranker with the auto search scope ZepGraphSearchTool no longer ignores a reranker with scope 'auto'. The tool returns an error message to the model and does not call Zep. The constructor throws when scope 'auto' and a reranker are both pinned. The reranker parameter has no default, so the tool sends no reranker when the model omits it, and Zep uses rrf. * crewai: remove the existing-resource claim from the CHANGELOG * ci: run the integration tests again after a live CrewAI recall failure on Python 3.13 --------- Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
feat(ingestion): submit all sources then poll the last episode (v0.3.… …0) (#607) * feat(ingestion): submit all sources then poll the last episode Stop treating sequential ingest as wait-for-each-file. Queue every file into a graph first; wait() is opt-in, polls the tail of the per-graph queue, and scales its timeout with how many episodes were submitted. Bump zep-ingest to 0.3.0 for the release. Co-authored-by: Cursor <cursoragent@cursor.com> * chore(ingestion): increase auto wait timeout to 60s per item Give episodes and manual graph updates more headroom before wait() raises IngestTimeoutError. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(ingestion): align wait() polling with ingestion status docs Poll thread backfills via the last message UUID per request, document batch vs episode vs task handles, and warn against mixing batch and sequential graph.add on one graph. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(ingestion): correct thread polling and multi-thread wait semantics Regular thread.add_messages returns message_uuids only (verified against production). Remove dead task_id fallback, poll one tail per thread, and stop falsely marking all threads done when one saga finishes. Co-authored-by: Cursor <cursoragent@cursor.com> * chore(ingestion): add production release smoke script for v0.3.0 Document pre-release prod checks and finalize 0.3.0 changelog notes for thread polling and combine(). Co-authored-by: Cursor <cursoragent@cursor.com> --------- Co-authored-by: Cursor <cursoragent@cursor.com>
fix: Update CrewAI integration for compatibility with v0.186.0+ (#428) * fix: Update CrewAI integration for compatibility with v0.186.0+ Changes external memory search results to use "context" key instead of "memory" to align with CrewAI's updated external memory interface. This fixes KeyError issues when using Zep with CrewAI v0.186.0 and later versions. Changes: - Updated ZepUserStorage, ZepGraphStorage, and ZepStorage search methods - Fixed test assertions to expect "context" key in results - Updated example scripts to display results using "context" key - All 60 tests pass, examples run successfully with CrewAI v0.186.1 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * chore: Bump version to 1.1.1 Update version for CrewAI v0.186.0+ compatibility bug fix. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> --------- Co-authored-by: Claude <noreply@anthropic.com>
feat(postgres): Add URL escaping to database connection string (#380) * feat(postgres): Add URL escaping to database connection string Add url.QueryEscape() to properly handle special characters in PostgreSQL connection parameters. This prevents potential connection issues and improves security when credentials contain special characters. Changes: - Escape username with url.QueryEscape() - Escape password with url.QueryEscape() - Escape hostname with url.QueryEscape() - Escape database name with url.QueryEscape() Example special characters handled: - @ in usernames (e.g., user@domain.com) - Special chars in passwords (e.g., *, (, ), @) - Special chars in database names This change ensures the DSN string is properly formatted regardless of the characters present in the connection parameters. Related to PostgreSQL connection string format: postgres://username:password@hostname:port/database * Update src/lib/config/config.go Remove url.QueryEscape for Host Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com> * Update config.go to match spacing format --------- Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com>
Mention telemetry in README (#378) * Update README.md * Update README.md Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com> --------- Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com>
PreviousNext