chore: Update examples

Author: paul-paliychuk

examples/chat_history/memory.py

@@ -3,12 +3,12 @@
 
 This script demonstrates the following functionality:
 - Creating a user.
-- Creating a session associated with the created user.
-- Adding messages to the session.
-- Searching the session memory for a specific query.
-- Searching the session memory with MMR reranking.
-- Searching the session memory with a metadata filter.
-- optionally deleting the session.
+- Creating a thread associated with the created user.
+- Adding messages to the thread.
+- Searching the thread memory for a specific query.
+- Searching the thread memory with MMR reranking.
+- Searching the thread memory with a metadata filter.
+- optionally deleting the thread.
 """
 
 import asyncio
@@ -53,71 +53,39 @@ async def main() -> None:
         metadata={"vip": "true"},
     )
 
-    # await asyncio.sleep(1)
     print(f"User added: {user_id}")
-    session_id = uuid.uuid4().hex  # unique session id. can be any alphanum string
+    thread_id = uuid.uuid4().hex  # unique thread id. can be any alphanum string
 
-    # Create session associated with the above user
-    print(f"\n---Creating session: {session_id}")
+    # Create thread associated with the above user
+    print(f"\n---Creating thread: {thread_id}")
 
-    await client.memory.add_session(
-        session_id=session_id,
+    await client.thread.create(
+        thread_id=thread_id,
         user_id=user_id,
         metadata={"foo": "bar"},
     )
-    # await asyncio.sleep(1)
-    # Update session metadata
-    print(f"\n---Updating session: {session_id}")
-    await client.memory.update_session(session_id=session_id, metadata={"bar": "foo"})
-    # await asyncio.sleep(3)
-    # Get session
-    print(f"\n---Getting session: {session_id}")
-    session = await client.memory.get_session(session_id)
-    print(f"Session details: {session}")
-    # await asyncio.sleep(3)
-
-    # Add Memory for session
-    print(f"\n---Add Memory for Session: {session_id}")
+
+    print(f"\n---Getting thread: {thread_id}")
+    thread = await client.thread.get(thread_id)
+    print(f"thread details: {thread}")
+
+    print(f"\n---Add messages to the thread: {thread_id}")
     for m in history:
         print(f"{m['role']}: {m['content']}")
-        await client.memory.add(session_id=session_id, messages=[Message(**m)])
+        await client.thread.add_messages(thread_id=thread_id, messages=[Message(**m)])
         # await asyncio.sleep(0.5)
 
     #  Wait for the messages to be processed
     await asyncio.sleep(50)
 
-    # Synthesize a question from most recent messages.
-    # Useful for RAG apps. This is faster than using an LLM chain.
-    print("\n---Synthesize a question from most recent messages")
-    question = await client.memory.synthesize_question(session_id, last_n_messages=3)
-    print(f"Question: {question}")
-
-    # Classify the session.
-    # Useful for semantic routing, filtering, and many other use cases.
-    print("\n---Classify the session")
-    classes = [
-        "low spender <$50",
-        "medium spender >=$50, <$100",
-        "high spender >=$100",
-        "unknown",
-    ]
-    classification = await client.memory.classify_session(
-        session_id, name="spender_category", classes=classes, persist=True
-    )
-    print(f"Classification: {classification}")
-
-    # Get Memory for session
-    print(f"\n---Get Perpetual Memory for Session: {session_id}")
-    memory = await client.memory.get(session_id)
-    print(f"Memory: {memory}")
-    print("\n---End of Memory")
 
-    print(f"Memory context: {memory.context}")
+    print(f"\n---Get user context for thread: {thread_id}")
+    memory = await client.thread.get_user_context(thread_id)
+    print(f"Context: {memory.context}")
 
-    # Delete Memory for session
+    # Delete thread and wipe thread memory
     # Uncomment to run
-    # print(f"\n6---deleteMemory for Session: {session_id}")
-    # await client.memory.delete(session_id)
+    # await client.thread.delete(thread_id)
 
 
 if __name__ == "__main__":

examples/graph_example/group_graph_example.py

@@ -2,15 +2,15 @@
 Example of using the Zep Python SDK asynchronously with Graph functionality.
 
 This script demonstrates the following functionality:
-- Creating a group.
-- Updating a group.
-- Adding episodes to the group (text and JSON).
-- Retrieving nodes from the group.
-- Retrieving edges from the group.
-- Searching the group for specific content.
+- Creating a graph.
+- Updating a graph.
+- Adding episodes to the graph (text and JSON).
+- Retrieving nodes from the graph.
+- Retrieving edges from the graph.
+- Searching the graph for specific content.
 
 The script showcases various operations using the Zep Graph API, including
-group management, adding different types of episodes, and querying the graph structure.
+graph management, adding different types of episodes, and querying the graph structure.
 """
 
 import asyncio
@@ -33,68 +33,68 @@ async def main() -> None:
         api_key=API_KEY,
     )
 
-    group_id = f"slack:{uuid.uuid4().hex}"
-    print(f"Creating group {group_id}...")
-    group = await client.group.add(
-        group_id=group_id,
-        name="My Group",
-        description="This is my group",
+    graph_id = f"slack:{uuid.uuid4().hex}"
+    print(f"Creating graph {graph_id}...")
+    graph = await client.graph.create(
+        graph_id=graph_id,
+        name="My Graph",
+        description="This is my graph",
     )
     await asyncio.sleep(2)
-    print(f"Group {group_id} created {group}")
+    print(f"graph {graph_id} created {graph}")
 
-    print(f"Adding episode to group {group_id}...")
+    print(f"Adding episode to graph {graph_id}...")
     await client.graph.add(
-        group_id=group_id,
+        graph_id=graph_id,
         data="This is a test episode",
         type="text",
     )
     await asyncio.sleep(2)
-    print(f"Adding more meaningful episode to group {group_id}...")
+    print(f"Adding more meaningful episode to graph {graph_id}...")
     await client.graph.add(
-        group_id=group_id,
+        graph_id=graph_id,
         data="Eric Clapton is a rock star",
         type="text",
     )
     await asyncio.sleep(2)
-    print(f"Adding a JSON episode to group {group_id}...")
+    print(f"Adding a JSON episode to graph {graph_id}...")
     json_string = '{"name": "Eric Clapton", "age": 78, "genre": "Rock"}'
     await client.graph.add(
-        group_id=group_id,
+        graph_id=graph_id,
         data=json_string,
         type="json",
     )
     await asyncio.sleep(20)
 
     # TODO: Need to enable non-message episodic content retrieval
-    print(f"Getting episodes from group {group_id}...")
-    results = await client.graph.episode.get_by_group_id(group_id, lastn=2)
+    print(f"Getting episodes from graph {graph_id}...")
+    results = await client.graph.episode.get_by_graph_id(graph_id, lastn=2)
     await asyncio.sleep(2)
-    print(f"Episodes from group {group_id} {results.episodes}")
+    print(f"Episodes from graph {graph_id} {results.episodes}")
     episode = await client.graph.episode.get(results.episodes[0].uuid_)
     await asyncio.sleep(2)
-    print(f"Episode {episode.uuid_} from group {group_id} {episode}")
+    print(f"Episode {episode.uuid_} from graph {graph_id} {episode}")
 
-    print(f"Getting nodes from group {group_id}...")
-    nodes = await client.graph.node.get_by_group_id(group_id)
+    print(f"Getting nodes from graph {graph_id}...")
+    nodes = await client.graph.node.get_by_graph_id(graph_id)
     await asyncio.sleep(2)
-    print(f"Nodes from group {group_id} {nodes}")
+    print(f"Nodes from graph {graph_id} {nodes}")
 
-    print(f"Getting edges from group {group_id}...")
-    edges = await client.graph.edge.get_by_group_id(group_id)
+    print(f"Getting edges from graph {graph_id}...")
+    edges = await client.graph.edge.get_by_graph_id(graph_id)
     await asyncio.sleep(2)
-    print(f"Edges from group {group_id} {edges}")
+    print(f"Edges from graph {graph_id} {edges}")
 
-    print(f"Searching group {group_id}...")
+    print(f"Searching graph {graph_id}...")
     search_results = await client.graph.search(
-        group_id=group_id,
+        graph_id=graph_id,
         query="Eric Clapton",
     )
     await asyncio.sleep(2)
-    print(f"Search results from group {group_id} {search_results}")
+    print(f"Search results from graph {graph_id} {search_results}")
 
-    # await client.group.delete(group_id)
-    print(f"Group {group_id} deleted")
+    # await client.graph.delete(graph_id)
+    # print(f"graph {graph_id} deleted")
 
 
 if __name__ == "__main__":

examples/graph_example/user_graph_example.py

@@ -3,15 +3,15 @@
 
 This script demonstrates the following functionality:
 - Creating a user.
-- Creating a session associated with the created user.
-- Adding messages to the session.
+- Creating a thread associated with the created user.
+- Adding messages to the thread.
 - Retrieving episodes, edges, and nodes for a user.
 - Searching the user's graph memory.
 - Adding text and JSON episodes to the graph.
 - Performing a centered search on a specific node.
 
 The script showcases various operations using the Zep Graph API, including
-user and session management, adding different types of episodes, and querying
+user and thread management, adding different types of episodes, and querying
 the graph structure.
 """
 
@@ -37,14 +37,14 @@ async def main() -> None:
         api_key=API_KEY,
     )
     user_id = uuid.uuid4().hex
-    session_id = uuid.uuid4().hex
+    thread_id = uuid.uuid4().hex
     await client.user.add(user_id=user_id, first_name="Paul")
     print(f"User {user_id} created")
-    await client.memory.add_session(session_id=session_id, user_id=user_id)
-    print(f"Session {session_id} created")
+    await client.thread.create(thread_id=thread_id, user_id=user_id)
+    print(f"thread {thread_id} created")
     for message in history[2]:
-        await client.memory.add(
-            session_id,
+        await client.thread.add_messages(
+            thread_id,
             messages=[
                 Message(
                     role_type=message["role_type"],
@@ -55,18 +55,10 @@ async def main() -> None:
 
     print("Waiting for the graph to be updated...")
     await asyncio.sleep(30)
-    print("Getting memory for session")
-    session_memory = await client.memory.get(session_id)
-    print(session_memory)
-    print("Searching user memory...")
-    search_results = await client.memory.search_sessions(
-        text="What is the weather in San Francisco?",
-        user_id=user_id,
-        search_scope="facts",
-    )
-    print(search_results)
-    sessions = await client.user.get_sessions(user_id)
-    print(sessions)
+    print("Getting memory for thread")
+    thread_memory = await client.thread.get_user_context(thread_id)
+    print(thread_memory)
+
     print("Getting episodes for user")
     episode_result = await client.graph.episode.get_by_user_id(user_id, lastn=3)
     episodes = episode_result.episodes