langgraph-checkpointer-couchbase 1.0.6__tar.gz → 1.0.8__tar.gz

{langgraph_checkpointer_couchbase-1.0.6 → langgraph_checkpointer_couchbase-1.0.8}/.github/workflows/release.yaml

@@ -1,8 +1,8 @@
 name: Publish Package to PyPI
 on:
   push:
-    branches:
-      - main
+    tags:
+      - "v*"
   workflow_dispatch:
   
 jobs:
@@ -29,10 +29,6 @@ jobs:
       - name: Hatch build
         run: hatch build
 
-      - name: Get hatch version
-        id: hatch_version_step
-        run: echo "VERSION=$(hatch version)" >> $GITHUB_OUTPUT
-
       - name: Publish release distributions to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
 
@@ -40,6 +36,6 @@ jobs:
         id: create_release
         uses: softprops/action-gh-release@v2
         with:
-          tag_name: v${{ steps.hatch_version_step.outputs.VERSION }} 
+          tag_name: ${{ github.ref_name }} 
           draft: false
           prerelease: false

{langgraph_checkpointer_couchbase-1.0.6 → langgraph_checkpointer_couchbase-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-checkpointer-couchbase
-Version: 1.0.6
+Version: 1.0.8
 Project-URL: Documentation, https://github.com/couchbase-ecosystem/langgraph-checkpointer-couchbase#readme
 Project-URL: Issues, https://github.com/couchbase-ecosystem/langgraph-checkpointer-couchbase/issues
 Project-URL: Source, https://github.com/couchbase-ecosystem/langgraph-checkpointer-couchbase
@@ -18,11 +18,13 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.8
-Requires-Dist: couchbase>=4.3.5
-Requires-Dist: langchain-openai>=0.3.11
-Requires-Dist: langgraph>=0.3.22
-Requires-Dist: pydantic>=2.11.1
-Requires-Dist: typing-extensions>=4.13.0
+Requires-Dist: couchbase>=4.5.0
+Requires-Dist: langchain-openai>=1.1.3
+Requires-Dist: langchain>=1.1.3
+Requires-Dist: langgraph>=1.0.5
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: typing-extensions>=4.15.0
 Description-Content-Type: text/markdown
 
 # LangGraph Checkpoint Couchbase
@@ -95,58 +97,72 @@ with CouchbaseSaver.from_conn_info(
         bucket_name=os.getenv("CB_BUCKET") or "test",
         scope_name=os.getenv("CB_SCOPE") or "langgraph",
     ) as checkpointer:
-        # Create the agent with checkpointing
-        graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
-        
-        # Configure with a unique thread ID
-        config = {"configurable": {"thread_id": "1"}}
-        
-        # Run the agent
-        res = graph.invoke({"messages": [("human", "what's the weather in sf")]}, config)
-        
-        # Retrieve checkpoints
-        latest_checkpoint = checkpointer.get(config)
-        latest_checkpoint_tuple = checkpointer.get_tuple(config)
-        checkpoint_tuples = list(checkpointer.list(config))
-
-        print(latest_checkpoint)
-        print(latest_checkpoint_tuple)
-        print(checkpoint_tuples)
+    # Create the agent with checkpointing
+    graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
+    
+    # Configure with a unique thread ID
+    config = {"configurable": {"thread_id": "1"}}
+    
+    # Run the agent
+    res = graph.invoke({"messages": [("human", "what's the weather in sf")]}, config)
+    
+    # Retrieve checkpoints
+    latest_checkpoint = checkpointer.get(config)
+    latest_checkpoint_tuple = checkpointer.get_tuple(config)
+    checkpoint_tuples = list(checkpointer.list(config))
+
+    print(latest_checkpoint)
+    print(latest_checkpoint_tuple)
+    print(checkpoint_tuples)
 ```
 
 ### Asynchronous Usage
 
 ```python
 import os
+from acouchbase.cluster import Cluster as ACluster
+from couchbase.auth import PasswordAuthenticator
+from couchbase.options import ClusterOptions
 from langgraph_checkpointer_couchbase import AsyncCouchbaseSaver
 from langgraph.graph import create_react_agent
 
-async with AsyncCouchbaseSaver.from_conn_info(
-        cb_conn_str=os.getenv("CB_CLUSTER") or "couchbase://localhost",
-        cb_username=os.getenv("CB_USERNAME") or "Administrator",
-        cb_password=os.getenv("CB_PASSWORD") or "password",
-        bucket_name=os.getenv("CB_BUCKET") or "test",
-        scope_name=os.getenv("CB_SCOPE") or "langgraph",
+auth = PasswordAuthenticator(
+    os.getenv("CB_USERNAME") or "Administrator",
+    os.getenv("CB_PASSWORD") or "password",
+)
+options = ClusterOptions(auth)
+cluster = await ACluster.connect(os.getenv("CB_CLUSTER") or "couchbase://localhost", options)
+
+bucket_name = os.getenv("CB_BUCKET") or "test"
+scope_name = os.getenv("CB_SCOPE") or "langgraph"
+
+async with AsyncCouchbaseSaver.from_cluster(
+        cluster=cluster,
+        bucket_name=bucket_name,
+        scope_name=scope_name,
     ) as checkpointer:
-        # Create the agent with checkpointing
-        graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
-        
-        # Configure with a unique thread ID
-        config = {"configurable": {"thread_id": "2"}}
-        
-        # Run the agent asynchronously
-        res = await graph.ainvoke(
-            {"messages": [("human", "what's the weather in nyc")]}, config
-        )
-
-        # Retrieve checkpoints asynchronously
-        latest_checkpoint = await checkpointer.aget(config)
-        latest_checkpoint_tuple = await checkpointer.aget_tuple(config)
-        checkpoint_tuples = [c async for c in checkpointer.alist(config)]
-
-        print(latest_checkpoint)
-        print(latest_checkpoint_tuple)
-        print(checkpoint_tuples)
+    # Create the agent with checkpointing
+    graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
+    
+    # Configure with a unique thread ID
+    config = {"configurable": {"thread_id": "2"}}
+    
+    # Run the agent asynchronously
+    res = await graph.ainvoke(
+        {"messages": [("human", "what's the weather in nyc")]}, config
+    )
+
+    # Retrieve checkpoints asynchronously
+    latest_checkpoint = await checkpointer.aget(config)
+    latest_checkpoint_tuple = await checkpointer.aget_tuple(config)
+    checkpoint_tuples = [c async for c in checkpointer.alist(config)]
+
+    print(latest_checkpoint)
+    print(latest_checkpoint_tuple)
+    print(checkpoint_tuples)
+
+# Close the cluster when done
+await cluster.close()
 ```
 
 ## Configuration Options

{langgraph_checkpointer_couchbase-1.0.6 → langgraph_checkpointer_couchbase-1.0.8}/README.md

@@ -68,58 +68,72 @@ with CouchbaseSaver.from_conn_info(
         bucket_name=os.getenv("CB_BUCKET") or "test",
         scope_name=os.getenv("CB_SCOPE") or "langgraph",
     ) as checkpointer:
-        # Create the agent with checkpointing
-        graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
-        
-        # Configure with a unique thread ID
-        config = {"configurable": {"thread_id": "1"}}
-        
-        # Run the agent
-        res = graph.invoke({"messages": [("human", "what's the weather in sf")]}, config)
-        
-        # Retrieve checkpoints
-        latest_checkpoint = checkpointer.get(config)
-        latest_checkpoint_tuple = checkpointer.get_tuple(config)
-        checkpoint_tuples = list(checkpointer.list(config))
-
-        print(latest_checkpoint)
-        print(latest_checkpoint_tuple)
-        print(checkpoint_tuples)
+    # Create the agent with checkpointing
+    graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
+    
+    # Configure with a unique thread ID
+    config = {"configurable": {"thread_id": "1"}}
+    
+    # Run the agent
+    res = graph.invoke({"messages": [("human", "what's the weather in sf")]}, config)
+    
+    # Retrieve checkpoints
+    latest_checkpoint = checkpointer.get(config)
+    latest_checkpoint_tuple = checkpointer.get_tuple(config)
+    checkpoint_tuples = list(checkpointer.list(config))
+
+    print(latest_checkpoint)
+    print(latest_checkpoint_tuple)
+    print(checkpoint_tuples)
 ```
 
 ### Asynchronous Usage
 
 ```python
 import os
+from acouchbase.cluster import Cluster as ACluster
+from couchbase.auth import PasswordAuthenticator
+from couchbase.options import ClusterOptions
 from langgraph_checkpointer_couchbase import AsyncCouchbaseSaver
 from langgraph.graph import create_react_agent
 
-async with AsyncCouchbaseSaver.from_conn_info(
-        cb_conn_str=os.getenv("CB_CLUSTER") or "couchbase://localhost",
-        cb_username=os.getenv("CB_USERNAME") or "Administrator",
-        cb_password=os.getenv("CB_PASSWORD") or "password",
-        bucket_name=os.getenv("CB_BUCKET") or "test",
-        scope_name=os.getenv("CB_SCOPE") or "langgraph",
+auth = PasswordAuthenticator(
+    os.getenv("CB_USERNAME") or "Administrator",
+    os.getenv("CB_PASSWORD") or "password",
+)
+options = ClusterOptions(auth)
+cluster = await ACluster.connect(os.getenv("CB_CLUSTER") or "couchbase://localhost", options)
+
+bucket_name = os.getenv("CB_BUCKET") or "test"
+scope_name = os.getenv("CB_SCOPE") or "langgraph"
+
+async with AsyncCouchbaseSaver.from_cluster(
+        cluster=cluster,
+        bucket_name=bucket_name,
+        scope_name=scope_name,
     ) as checkpointer:
-        # Create the agent with checkpointing
-        graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
-        
-        # Configure with a unique thread ID
-        config = {"configurable": {"thread_id": "2"}}
-        
-        # Run the agent asynchronously
-        res = await graph.ainvoke(
-            {"messages": [("human", "what's the weather in nyc")]}, config
-        )
-
-        # Retrieve checkpoints asynchronously
-        latest_checkpoint = await checkpointer.aget(config)
-        latest_checkpoint_tuple = await checkpointer.aget_tuple(config)
-        checkpoint_tuples = [c async for c in checkpointer.alist(config)]
-
-        print(latest_checkpoint)
-        print(latest_checkpoint_tuple)
-        print(checkpoint_tuples)
+    # Create the agent with checkpointing
+    graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
+    
+    # Configure with a unique thread ID
+    config = {"configurable": {"thread_id": "2"}}
+    
+    # Run the agent asynchronously
+    res = await graph.ainvoke(
+        {"messages": [("human", "what's the weather in nyc")]}, config
+    )
+
+    # Retrieve checkpoints asynchronously
+    latest_checkpoint = await checkpointer.aget(config)
+    latest_checkpoint_tuple = await checkpointer.aget_tuple(config)
+    checkpoint_tuples = [c async for c in checkpointer.alist(config)]
+
+    print(latest_checkpoint)
+    print(latest_checkpoint_tuple)
+    print(checkpoint_tuples)
+
+# Close the cluster when done
+await cluster.close()
 ```
 
 ## Configuration Options

{langgraph_checkpointer_couchbase-1.0.6 → langgraph_checkpointer_couchbase-1.0.8}/langgraph_checkpointer_couchbase/async_cb_saver.py

@@ -1,12 +1,14 @@
 from contextlib import asynccontextmanager
 from datetime import timedelta
 from typing import Any, AsyncIterator, Dict, Optional, Sequence, Tuple
+import logging
 
 from langchain_core.runnables import RunnableConfig
 from acouchbase.cluster import Cluster as ACluster
 from acouchbase.bucket import Bucket as ABucket
 from couchbase.auth import PasswordAuthenticator
 from couchbase.options import ClusterOptions, QueryOptions, UpsertOptions
+from couchbase.exceptions import CollectionAlreadyExistsException
 
 from langgraph.checkpoint.base import (
     BaseCheckpointSaver,
@@ -18,6 +20,13 @@ from langgraph.checkpoint.base import (
 )
 from .utils import _encode_binary, _decode_binary
 
+logger = logging.getLogger(__name__)
+
+# Default timeout for database operations
+DEFAULT_TIMEOUT = timedelta(seconds=5)
+# Default serialization type for metadata (for backward compatibility)
+DEFAULT_METADATA_TYPE = "json"
+
 class AsyncCouchbaseSaver(BaseCheckpointSaver):
     """A checkpoint saver that stores checkpoints in a Couchbase database."""
 
@@ -35,9 +44,35 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
         self.cluster = cluster
         self.bucket_name = bucket_name
         self.scope_name = scope_name
+        self.bucket = self.cluster.bucket(bucket_name)
+        self.scope = self.bucket.scope(scope_name)
         self.checkpoints_collection_name = checkpoints_collection_name
         self.checkpoint_writes_collection_name = checkpoint_writes_collection_name
 
+    async def create_collections(self):
+        """Create collections in the Couchbase bucket if they do not exist."""
+
+        collection_manager = self.bucket.collections()
+        try:
+            await collection_manager.create_collection(self.scope_name, self.checkpoints_collection_name)
+        except CollectionAlreadyExistsException as _:
+            pass
+        except Exception as e:
+            logger.exception("Error creating collections")
+            raise e
+        finally:
+            self.checkpoints_collection =  self.bucket.scope(self.scope_name).collection(self.checkpoints_collection_name)
+        
+        try:
+            await collection_manager.create_collection(self.scope_name, self.checkpoint_writes_collection_name)
+        except CollectionAlreadyExistsException as _:
+            pass
+        except Exception as e:
+            logger.exception("Error creating collections")
+            raise e
+        finally:
+            self.checkpoint_writes_collection = self.bucket.scope(self.scope_name).collection(self.checkpoint_writes_collection_name)
+
     @classmethod
     @asynccontextmanager
     async def from_conn_info(
@@ -64,20 +99,26 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
             auth = PasswordAuthenticator(cb_username, cb_password)
             options = ClusterOptions(auth)
             cluster = await ACluster.connect(cb_conn_str, options)
-            
-            cls.cluster = cluster
-            cls.bucket_name = bucket_name
-            cls.scope_name = scope_name
 
-            saver = AsyncCouchbaseSaver(cluster, bucket_name, scope_name, checkpoints_collection_name, checkpoint_writes_collection_name)
-            cls.bucket = cluster.bucket(bucket_name)
-            await cls.bucket.on_connect()
+            bucket = cluster.bucket(bucket_name)
+            await bucket.on_connect()
+
+            saver = AsyncCouchbaseSaver(
+                cluster,
+                bucket_name,
+                scope_name,
+                checkpoints_collection_name,
+                checkpoint_writes_collection_name,
+            )
+
+            await saver.create_collections()
             
             yield saver
         finally:
             if cluster:
                 await cluster.close()
 
+
     @classmethod
     @asynccontextmanager
     async def from_cluster(
@@ -98,9 +139,18 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
             AsyncCouchbaseSaver: An instance of the AsyncCouchbaseSaver
         """        
         
-        saver = AsyncCouchbaseSaver(cluster, bucket_name, scope_name, checkpoints_collection_name, checkpoint_writes_collection_name)
-        cls.bucket = cluster.bucket(bucket_name)
-        await cls.bucket.on_connect()
+        bucket = cluster.bucket(bucket_name)
+        await bucket.on_connect()
+
+        saver = AsyncCouchbaseSaver(
+            cluster,
+            bucket_name,
+            scope_name,
+            checkpoints_collection_name,
+            checkpoint_writes_collection_name,
+        )
+
+        await saver.create_collections()
         
         yield saver
 
@@ -149,7 +199,7 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
             async for write_doc in serialized_writes_result:
                 checkpoint_writes = write_doc.get(self.checkpoint_writes_collection_name, {})
                 if "task_id" not in checkpoint_writes:
-                    print("Error: 'task_id' is not present in checkpoint_writes")
+                    logger.warning("'task_id' is not present in checkpoint_writes")
                 else:
                     pending_writes.append(
                         (
@@ -162,7 +212,7 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
             return CheckpointTuple(
                 {"configurable": config_values},
                 checkpoint,
-                self.serde.loads(_decode_binary(doc["metadata"])),
+                self.serde.loads_typed((doc.get("metadata_type", DEFAULT_METADATA_TYPE), _decode_binary(doc["metadata"]))) if doc.get("metadata") else None,
                 (
                     {
                         "configurable": {
@@ -177,6 +227,8 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
                 pending_writes,
             )
 
+        return None
+
     async def alist(
             self,
             config: Optional[RunnableConfig],
@@ -236,7 +288,7 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
                     }
                 },
                 checkpoint,
-                self.serde.loads(_decode_binary(doc["metadata"])),
+                self.serde.loads_typed((doc.get("metadata_type", DEFAULT_METADATA_TYPE), _decode_binary(doc["metadata"]))) if doc.get("metadata") else None,
                 (
                     {
                         "configurable": {
@@ -278,15 +330,16 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
         if serialized_checkpoint:
             serialized_checkpoint = _encode_binary(serialized_checkpoint)
             
-        metadata = self.serde.dumps(metadata)
-        if metadata:
-            metadata = _encode_binary(metadata)
+        # Serialize and encode metadata
+        metadata_type, metadata_bytes = self.serde.dumps_typed(metadata)
+        serialized_metadata = _encode_binary(metadata_bytes) if metadata_bytes else None
         
         doc = {
             "parent_checkpoint_id": config["configurable"].get("checkpoint_id"),
             "type": type_,
             "checkpoint": serialized_checkpoint,
-            "metadata": metadata,
+            "metadata": serialized_metadata,
+            "metadata_type": metadata_type,
             "thread_id" : thread_id,
             "checkpoint_ns": checkpoint_ns,
             "checkpoint_id": checkpoint_id,
@@ -294,8 +347,10 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
 
         upsert_key = f"{thread_id}::{checkpoint_ns}::{checkpoint_id}"
 
+        # ensure bucket connected (idempotent)
+        await self.bucket.on_connect()
         collection = self.bucket.scope(self.scope_name).collection(self.checkpoints_collection_name)
-        await collection.upsert(upsert_key, (doc), UpsertOptions(timeout=timedelta(seconds=5)))
+        await collection.upsert(upsert_key, (doc), UpsertOptions(timeout=DEFAULT_TIMEOUT))
 
         return {
             "configurable": {
@@ -324,6 +379,7 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
         checkpoint_ns = config["configurable"]["checkpoint_ns"]
         checkpoint_id = config["configurable"]["checkpoint_id"]
 
+        await self.bucket.on_connect()
         collection = self.bucket.scope(self.scope_name).collection(self.checkpoint_writes_collection_name)
 
         for idx, (channel, value) in enumerate(writes):
@@ -342,4 +398,4 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
                 "type": type_,
                 "value": serialized_value,
             }
-            await collection.upsert(upsert_key, (doc), UpsertOptions(timeout=timedelta(seconds=5)))
+            await collection.upsert(upsert_key, (doc), UpsertOptions(timeout=DEFAULT_TIMEOUT))

{langgraph_checkpointer_couchbase-1.0.6 → langgraph_checkpointer_couchbase-1.0.8}/langgraph_checkpointer_couchbase/couchbase_saver.py

@@ -1,6 +1,7 @@
 from contextlib import contextmanager
 from datetime import timedelta
 from typing import Any, Dict, Iterator, Optional, Sequence, Tuple
+import logging
 
 from langchain_core.runnables import RunnableConfig
 from couchbase.cluster import Cluster
@@ -19,6 +20,13 @@ from langgraph.checkpoint.base import (
 )
 
 from .utils import _encode_binary, _decode_binary
+
+logger = logging.getLogger(__name__)
+
+# Default timeout for database operations
+DEFAULT_TIMEOUT = timedelta(seconds=5)
+# Default serialization type for metadata (for backward compatibility)
+DEFAULT_METADATA_TYPE = "json"
 class CouchbaseSaver(BaseCheckpointSaver):
     """A checkpoint saver that stores checkpoints in a Couchbase database.
     
@@ -74,11 +82,7 @@ class CouchbaseSaver(BaseCheckpointSaver):
             auth = PasswordAuthenticator(cb_username, cb_password)
             options = ClusterOptions(auth)
             cluster = Cluster(cb_conn_str, options)
-            cluster.wait_until_ready(timedelta(seconds=5))
-            
-            cls.cluster = cluster
-            cls.bucket_name = bucket_name
-            cls.scope_name = scope_name
+            cluster.wait_until_ready(DEFAULT_TIMEOUT)
 
             saver = CouchbaseSaver(cluster, bucket_name, scope_name, checkpoints_collection_name, checkpoint_writes_collection_name)
 
@@ -118,7 +122,7 @@ class CouchbaseSaver(BaseCheckpointSaver):
         except CollectionAlreadyExistsException as _:
             pass
         except Exception as e:
-            print(f"Error creating collections: {e}")
+            logger.exception("Error creating collections")
             raise e
         finally:
             self.checkpoints_collection = self.bucket.scope(self.scope_name).collection(self.checkpoints_collection_name)
@@ -128,7 +132,7 @@ class CouchbaseSaver(BaseCheckpointSaver):
         except CollectionAlreadyExistsException as _:
             pass
         except Exception as e:
-            print(f"Error creating collections: {e}")
+            logger.exception("Error creating collections")
             raise e
         finally:
             self.checkpoint_writes_collection = self.bucket.scope(self.scope_name).collection(self.checkpoint_writes_collection_name)
@@ -181,7 +185,7 @@ class CouchbaseSaver(BaseCheckpointSaver):
             for write_doc in serialized_writes_result:
                 checkpoint_writes = write_doc.get(self.checkpoint_writes_collection_name, {})
                 if "task_id" not in checkpoint_writes:
-                    print("Error: 'task_id' is not present in checkpoint_writes")
+                    logger.warning("'task_id' is not present in checkpoint_writes")
                 else:
                     # Decode and deserialize value data
                     value_data = _decode_binary(checkpoint_writes["value"])
@@ -194,8 +198,8 @@ class CouchbaseSaver(BaseCheckpointSaver):
                     )
 
             # Decode and deserialize metadata
-            metadata = _decode_binary(doc["metadata"])
-            metadata = self.serde.loads(metadata)
+            metadata_data = _decode_binary(doc["metadata"])
+            metadata = self.serde.loads_typed((doc.get("metadata_type", DEFAULT_METADATA_TYPE), metadata_data))
 
             return CheckpointTuple(
                 {"configurable": config_values},
@@ -215,6 +219,8 @@ class CouchbaseSaver(BaseCheckpointSaver):
                 pending_writes,
             )
 
+        return None
+
     def list(
             self,
             config: Optional[RunnableConfig],
@@ -274,7 +280,7 @@ class CouchbaseSaver(BaseCheckpointSaver):
                     }
                 },
                 checkpoint,
-                self.serde.loads(_decode_binary(doc["metadata"])),
+                self.serde.loads_typed((doc.get("metadata_type", DEFAULT_METADATA_TYPE), _decode_binary(doc["metadata"]))),
                 (
                     {
                         "configurable": {
@@ -319,15 +325,15 @@ class CouchbaseSaver(BaseCheckpointSaver):
             serialized_checkpoint = _encode_binary(serialized_checkpoint)
             
         # Serialize and encode metadata
-        metadata_bytes = self.serde.dumps(metadata)
-        if metadata_bytes:
-            metadata = _encode_binary(metadata_bytes)
+        metadata_type, metadata_bytes = self.serde.dumps_typed(metadata)
+        serialized_metadata = _encode_binary(metadata_bytes) if metadata_bytes else None
         
         doc = {
             "parent_checkpoint_id": config["configurable"].get("checkpoint_id"),
             "type": type_,
             "checkpoint": serialized_checkpoint,
-            "metadata": metadata,
+            "metadata": serialized_metadata,
+            "metadata_type": metadata_type,
             "thread_id" : thread_id,
             "checkpoint_ns": checkpoint_ns,
             "checkpoint_id": checkpoint_id,
@@ -335,7 +341,7 @@ class CouchbaseSaver(BaseCheckpointSaver):
         upsert_key = f"{thread_id}::{checkpoint_ns}::{checkpoint_id}"
         
         collection = self.checkpoints_collection
-        collection.upsert(upsert_key, (doc), UpsertOptions(timeout=timedelta(seconds=5)))
+        collection.upsert(upsert_key, (doc), UpsertOptions(timeout=DEFAULT_TIMEOUT))
 
         return {
             "configurable": {
@@ -384,4 +390,4 @@ class CouchbaseSaver(BaseCheckpointSaver):
                 "type": type_,
                 "value": serialized_value,
             }
-            collection.upsert(upsert_key, (doc), UpsertOptions(timeout=timedelta(seconds=5)))
+            collection.upsert(upsert_key, doc, UpsertOptions(timeout=DEFAULT_TIMEOUT))

{langgraph_checkpointer_couchbase-1.0.6 → langgraph_checkpointer_couchbase-1.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph-checkpointer-couchbase"
-version = "1.0.6"
+version = "1.0.8"
 description = ''
 readme = "README.md"
 requires-python = ">=3.8"
@@ -25,11 +25,13 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
-  "couchbase>=4.3.5",
-  "langgraph>=0.3.22",
-  "langchain-openai>=0.3.11",
-  "pydantic>=2.11.1",
-  "typing_extensions>=4.13.0"
+  "couchbase>=4.5.0",
+  "langgraph>=1.0.5",
+  "langchain-openai>=1.1.3",
+  "pydantic>=2.12.5",
+  "typing_extensions>=4.15.0",
+  "langchain>=1.1.3",
+  "python-dotenv>=1.0.0",
 ]
 
 [project.urls]

langgraph_checkpointer_couchbase-1.0.8/tests/agent_e2e_test.py

@@ -0,0 +1,88 @@
+import asyncio
+from typing import Literal
+from langchain_core.tools import tool
+from langchain_openai import ChatOpenAI
+from langchain.agents import create_agent
+from langgraph_checkpointer_couchbase import CouchbaseSaver, AsyncCouchbaseSaver
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+@tool
+def get_weather(city: Literal["nyc", "sf"]):
+    """Use this to get weather information."""
+    if city == "nyc":
+        return "It might be cloudy in nyc"
+    elif city == "sf":
+        return "It's always sunny in sf"
+    else:
+        raise AssertionError("Unknown city")
+
+
+tools = [get_weather]
+model = ChatOpenAI(model="gpt-5-mini", temperature=0)
+
+
+def syncTest():
+    with CouchbaseSaver.from_conn_info(
+        cb_conn_str=os.getenv("CB_CLUSTER"),
+        cb_username=os.getenv("CB_USERNAME"),
+        cb_password=os.getenv("CB_PASSWORD"),
+        bucket_name=os.getenv("CB_BUCKET"),
+        scope_name=os.getenv("CB_SCOPE"),
+    ) as checkpointer:
+        graph = create_agent(
+            model,
+            tools=tools,
+            checkpointer=checkpointer,
+        )
+        config = {"configurable": {"thread_id": "1"}}
+        res = graph.invoke({"messages": [("human", "what's the weather in sf")]}, config)
+        
+        latest_checkpoint = checkpointer.get(config)
+        latest_checkpoint_tuple = checkpointer.get_tuple(config)
+        checkpoint_tuples = list(checkpointer.list(config))
+
+        print("=== Sync Test Results ===")
+        print(f"Response: {res}")
+        print(f"Latest checkpoint: {latest_checkpoint}")
+        print(f"Latest checkpoint tuple: {latest_checkpoint_tuple}")
+        print(f"All checkpoint tuples: {checkpoint_tuples}")
+
+
+async def asyncTest():
+    async with AsyncCouchbaseSaver.from_conn_info(
+        cb_conn_str=os.getenv("CB_CLUSTER"),
+        cb_username=os.getenv("CB_USERNAME"),
+        cb_password=os.getenv("CB_PASSWORD"),
+        bucket_name=os.getenv("CB_BUCKET"),
+        scope_name=os.getenv("CB_SCOPE"),
+    ) as checkpointer:
+        graph = create_agent(
+            model,
+            tools=tools,
+            checkpointer=checkpointer,
+        )
+        config = {"configurable": {"thread_id": "2"}}
+        res = await graph.ainvoke(
+            {"messages": [("human", "what's the weather in nyc")]}, config
+        )
+
+        latest_checkpoint = await checkpointer.aget(config)
+        latest_checkpoint_tuple = await checkpointer.aget_tuple(config)
+        checkpoint_tuples = [c async for c in checkpointer.alist(config)]
+
+        print("=== Async Test Results ===")
+        print(f"Response: {res}")
+        print(f"Latest checkpoint: {latest_checkpoint}")
+        print(f"Latest checkpoint tuple: {latest_checkpoint_tuple}")
+        print(f"All checkpoint tuples: {checkpoint_tuples}")
+
+
+if __name__ == "__main__":
+    print("Running sync test...")
+    syncTest()
+    print("\nRunning async test...")
+    asyncio.run(asyncTest())
+    print("\nAll tests completed!")

langgraph_checkpointer_couchbase-1.0.6/tests/agent_e2e_test.py

@@ -1,70 +0,0 @@
-import asyncio
-from typing import Literal
-from langchain_core.runnables import ConfigurableField
-from langchain_core.tools import tool
-from langchain_openai import ChatOpenAI
-from langgraph.prebuilt import create_react_agent
-from langgraph_checkpoint_couchbase import CouchbaseSaver, AsyncCouchbaseSaver
-from dotenv import load_dotenv
-import os
-load_dotenv()
-
-@tool
-def get_weather(city: Literal["nyc", "sf"]):
-    """Use this to get weather information."""
-    if city == "nyc":
-        return "It might be cloudy in nyc"
-    elif city == "sf":
-        return "It's always sunny in sf"
-    else:
-        raise AssertionError("Unknown city")
-
-
-tools = [get_weather]
-model = ChatOpenAI(model_name="gpt-4o-mini", temperature=0)
-
-def syncTest():
-    with CouchbaseSaver.from_conn_info(
-        cb_conn_str=os.getenv("CB_CLUSTER") or "couchbase://localhost",
-        cb_username=os.getenv("CB_USERNAME") or "Administrator",
-        cb_password=os.getenv("CB_PASSWORD") or "password",
-        bucket_name=os.getenv("CB_BUCKET") or "test",
-        scope_name=os.getenv("CB_SCOPE") or "langgraph",
-    ) as checkpointer:
-        graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
-        config = {"configurable": {"thread_id": "1"}}
-        res = graph.invoke({"messages": [("human", "what's the weather in sf")]}, config)
-        
-        latest_checkpoint = checkpointer.get(config)
-        latest_checkpoint_tuple = checkpointer.get_tuple(config)
-        checkpoint_tuples = list(checkpointer.list(config))
-
-        print(latest_checkpoint)
-        print(latest_checkpoint_tuple)
-        print(checkpoint_tuples)
-
-async def asyncTest():
-    async with AsyncCouchbaseSaver.from_conn_info(
-        cb_conn_str=os.getenv("CB_CLUSTER") or "couchbase://localhost",
-        cb_username=os.getenv("CB_USERNAME") or "Administrator",
-        cb_password=os.getenv("CB_PASSWORD") or "password",
-        bucket_name=os.getenv("CB_BUCKET") or "test",
-        scope_name=os.getenv("CB_SCOPE") or "langgraph",
-    ) as checkpointer:
-        graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
-        config = {"configurable": {"thread_id": "2"}}
-        res = await graph.ainvoke(
-            {"messages": [("human", "what's the weather in nyc")]}, config
-        )
-
-        latest_checkpoint = await checkpointer.aget(config)
-        latest_checkpoint_tuple = await checkpointer.aget_tuple(config)
-        checkpoint_tuples = [c async for c in checkpointer.alist(config)]
-
-        print(latest_checkpoint)
-        print(latest_checkpoint_tuple)
-        print(checkpoint_tuples)
-
-if __name__ == "__main__":
-    syncTest()
-    asyncio.run(asyncTest())