langgraph-checkpointer-couchbase 1.0.1__tar.gz

langgraph_checkpointer_couchbase-1.0.1/.env.example

@@ -0,0 +1,6 @@
+OPENAI_API_KEY=
+CB_CLUSTER=
+CB_USERNAME=
+CB_PASSWORD=
+CB_BUCKET=
+CB_SCOPE=

langgraph_checkpointer_couchbase-1.0.1/.github/workflows/release.yaml

@@ -0,0 +1,45 @@
+name: Publish Package to PyPI
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+  
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: write
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.11"
+
+      - name: Install Dependencies
+        run: pip install -e .
+
+      - name: Install Hatch
+        run: pip install hatch
+
+      - 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
+
+      - name: Create GitHub Release
+        id: create_release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v${{ steps.hatch_version_step.outputs.VERSION }} 
+          draft: false
+          prerelease: false

langgraph_checkpointer_couchbase-1.0.1/.gitignore

@@ -0,0 +1,13 @@
+.venv/
+.env
+
+__pycache__/
+dist/
+build/
+
+*.pyc
+*.pyo
+*.pyd
+*.pyw
+*.pyz
+

langgraph_checkpointer_couchbase-1.0.1/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

langgraph_checkpointer_couchbase-1.0.1/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: langgraph-checkpointer-couchbase
+Version: 1.0.1
+Project-URL: Documentation, https://github.com/Lokesh Goel/langgraph-checkpointer-couchbase#readme
+Project-URL: Issues, https://github.com/Lokesh Goel/langgraph-checkpointer-couchbase/issues
+Project-URL: Source, https://github.com/Lokesh Goel/langgraph-checkpointer-couchbase
+Author-email: Lokesh Goel <lokesh.goel@couchbase.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: checkpointer,couchbase,langchain,langgraph,persistence
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+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
+Description-Content-Type: text/markdown
+
+# LangGraph Checkpoint Couchbase
+
+A Couchbase implementation of the LangGraph `CheckpointSaver` interface that enables persisting agent state and conversation history in a Couchbase database.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Overview
+
+This package provides a seamless way to persist LangGraph agent states in Couchbase, enabling:
+- State persistence across application restarts
+- Retrieval of historical conversation steps
+- Continued conversations from previous checkpoints
+- Both synchronous and asynchronous interfaces
+
+## Installation
+
+```bash
+pip install langgraph-checkpointer-couchbase
+```
+
+## Requirements
+
+- Python 3.8+
+- Couchbase Server (7.0+ recommended)
+- LangGraph 0.3.22+
+- LangChain OpenAI 0.3.11+
+
+## Prerequisites
+
+- A running Couchbase cluster
+- A bucket created for storing checkpoints
+- Appropriate credentials with read/write access
+
+## Quick Start
+
+First, set up your agent tools and model:
+
+```python
+from typing import Literal
+from langchain_openai import ChatOpenAI
+
+@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)
+```
+
+### Synchronous Usage
+
+```python
+import os
+from langgraph_checkpointer_couchbase import CouchbaseSaver
+from langgraph.graph import create_react_agent
+
+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:
+        # 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 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",
+    ) 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)
+```
+
+## Configuration Options
+
+| Parameter | Description | Default |
+|-----------|-------------|---------|
+| CB_CLUSTER | Couchbase connection string | couchbase://localhost |
+| CB_USERNAME | Username for Couchbase | Administrator |
+| CB_PASSWORD | Password for Couchbase | password |
+| CB_BUCKET | Bucket to store checkpoints | test |
+| CB_SCOPE | Scope within bucket | langgraph |
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+---
+
+# 📢 Support Policy
+
+We truly appreciate your interest in this project!  
+This project is **community-maintained**, which means it's **not officially supported** by our support team.
+
+If you need help, have found a bug, or want to contribute improvements, the best place to do that is right here — by [opening a GitHub issue](https://github.com/Couchbase-Ecosystem/langgraph-checkpointer-couchbase/issues).  
+Our support portal is unable to assist with requests related to this project, so we kindly ask that all inquiries stay within GitHub.
+
+Your collaboration helps us all move forward together — thank you!

langgraph_checkpointer_couchbase-1.0.1/README.md

@@ -0,0 +1,152 @@
+# LangGraph Checkpoint Couchbase
+
+A Couchbase implementation of the LangGraph `CheckpointSaver` interface that enables persisting agent state and conversation history in a Couchbase database.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Overview
+
+This package provides a seamless way to persist LangGraph agent states in Couchbase, enabling:
+- State persistence across application restarts
+- Retrieval of historical conversation steps
+- Continued conversations from previous checkpoints
+- Both synchronous and asynchronous interfaces
+
+## Installation
+
+```bash
+pip install langgraph-checkpointer-couchbase
+```
+
+## Requirements
+
+- Python 3.8+
+- Couchbase Server (7.0+ recommended)
+- LangGraph 0.3.22+
+- LangChain OpenAI 0.3.11+
+
+## Prerequisites
+
+- A running Couchbase cluster
+- A bucket created for storing checkpoints
+- Appropriate credentials with read/write access
+
+## Quick Start
+
+First, set up your agent tools and model:
+
+```python
+from typing import Literal
+from langchain_openai import ChatOpenAI
+
+@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)
+```
+
+### Synchronous Usage
+
+```python
+import os
+from langgraph_checkpointer_couchbase import CouchbaseSaver
+from langgraph.graph import create_react_agent
+
+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:
+        # 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 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",
+    ) 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)
+```
+
+## Configuration Options
+
+| Parameter | Description | Default |
+|-----------|-------------|---------|
+| CB_CLUSTER | Couchbase connection string | couchbase://localhost |
+| CB_USERNAME | Username for Couchbase | Administrator |
+| CB_PASSWORD | Password for Couchbase | password |
+| CB_BUCKET | Bucket to store checkpoints | test |
+| CB_SCOPE | Scope within bucket | langgraph |
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+---
+
+# 📢 Support Policy
+
+We truly appreciate your interest in this project!  
+This project is **community-maintained**, which means it's **not officially supported** by our support team.
+
+If you need help, have found a bug, or want to contribute improvements, the best place to do that is right here — by [opening a GitHub issue](https://github.com/Couchbase-Ecosystem/langgraph-checkpointer-couchbase/issues).  
+Our support portal is unable to assist with requests related to this project, so we kindly ask that all inquiries stay within GitHub.
+
+Your collaboration helps us all move forward together — thank you!

langgraph_checkpointer_couchbase-1.0.1/langgraph_checkpointer_couchbase/__init__.py

@@ -0,0 +1,4 @@
+from .async_cb_saver import AsyncCouchbaseSaver
+from .couchbase_saver import CouchbaseSaver
+
+__all__ = ["CouchbaseSaver", "AsyncCouchbaseSaver"]

langgraph_checkpointer_couchbase-1.0.1/langgraph_checkpointer_couchbase/async_cb_saver.py

@@ -0,0 +1,346 @@
+from contextlib import asynccontextmanager
+from datetime import timedelta
+from typing import Any, AsyncIterator, Dict, Optional, Sequence, Tuple
+
+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 langgraph.checkpoint.base import (
+    BaseCheckpointSaver,
+    ChannelVersions,
+    Checkpoint,
+    CheckpointMetadata,
+    CheckpointTuple,
+    get_checkpoint_id,
+)
+from .utils import _encode_binary, _decode_binary
+
+class AsyncCouchbaseSaver(BaseCheckpointSaver):
+    """A checkpoint saver that stores checkpoints in a Couchbase database."""
+
+    cluster: ACluster
+    bucket: ABucket
+    def __init__(
+        self,
+        cluster: ACluster,
+        bucket_name: str,
+        scope_name: str,
+        checkpoints_collection_name: str = "checkpoints",
+        checkpoint_writes_collection_name: str = "checkpoint_writes"
+    ) -> None:
+        super().__init__()
+        self.cluster = cluster
+        self.bucket_name = bucket_name
+        self.scope_name = scope_name
+        self.checkpoints_collection_name = checkpoints_collection_name
+        self.checkpoint_writes_collection_name = checkpoint_writes_collection_name
+
+    @classmethod
+    @asynccontextmanager
+    async def from_conn_info(
+        cls, *, cb_conn_str :str, cb_username: str, cb_password: str, bucket_name: str, scope_name: str, checkpoints_collection_name: str = "checkpoints", checkpoint_writes_collection_name: str = "checkpoint_writes"
+    ) -> AsyncIterator["AsyncCouchbaseSaver"]:
+        """Create a AsyncCouchbaseSaver from connection information.
+        
+        This allows reusing an existing cluster connection rather than creating a new one.
+        
+        Args:
+            cb_conn_str: Connection string for the Couchbase cluster
+            cb_username: Username for the Couchbase cluster
+            cb_password: Password for the Couchbase cluster
+            bucket_name: Name of the bucket to use
+            scope_name: Name of the scope within the bucket
+            checkpoints_collection_name: Name of the collection to store checkpoints
+            checkpoint_writes_collection_name: Name of the collection to store checkpoint writes
+            
+        Yields:
+            AsyncCouchbaseSaver: An instance of the AsyncCouchbaseSaver
+        """        
+        cluster = None
+        try:
+            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()
+            
+            yield saver
+        finally:
+            if cluster:
+                await cluster.close()
+
+    @classmethod
+    @asynccontextmanager
+    async def from_cluster(
+        cls, *, cluster: ACluster, bucket_name: str, scope_name: str, checkpoints_collection_name: str = "checkpoints", checkpoint_writes_collection_name: str = "checkpoint_writes"
+    ) -> AsyncIterator["AsyncCouchbaseSaver"]:
+        """Create a AsyncCouchbaseSaver from an existing cluster connection.
+        
+        This allows reusing an existing cluster connection rather than creating a new one.
+        
+        Args:
+            cluster: An existing Couchbase Cluster connection
+            bucket_name: Name of the bucket to use
+            scope_name: Name of the scope within the bucket
+            checkpoints_collection_name: Name of the collection to store checkpoints
+            checkpoint_writes_collection_name: Name of the collection to store checkpoint writes
+            
+        Yields:
+            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()
+        
+        yield saver
+
+    async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+        """Get a checkpoint tuple from the database asynchronously.
+
+        This method retrieves a checkpoint tuple from the Couchbase database based on the
+        provided config. If the config contains a "checkpoint_id" key, the checkpoint with
+        the matching thread ID and checkpoint ID is retrieved. Otherwise, the latest checkpoint
+        for the given thread ID is retrieved.
+
+        Args:
+            config (RunnableConfig): The config to use for retrieving the checkpoint.
+
+        Returns:
+            Optional[CheckpointTuple]: The retrieved checkpoint tuple, or None if no matching checkpoint was found.
+        """
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"].get("checkpoint_ns", "")
+        checkpoint_id = get_checkpoint_id(config)
+
+        if checkpoint_id:
+            query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3 ORDER BY checkpoint_id DESC LIMIT 1'
+            query_params = [thread_id, checkpoint_ns, checkpoint_id]
+        else:
+            query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 ORDER BY checkpoint_id DESC LIMIT 1'
+            query_params = [thread_id, checkpoint_ns]
+
+        print(query)
+        result = self.cluster.query(query, QueryOptions(positional_parameters=query_params))
+
+        async for row in result:
+            doc = row[self.checkpoints_collection_name]
+            config_values = {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": doc["checkpoint_id"],
+            }
+            checkpoint = self.serde.loads_typed((doc["type"], _decode_binary(doc["checkpoint"])))
+
+            serialized_writes_query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoint_writes_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3'
+            serialized_writes_params = [thread_id, checkpoint_ns, doc["checkpoint_id"] or ""]
+            
+            serialized_writes_result = self.cluster.query(serialized_writes_query, QueryOptions(positional_parameters=serialized_writes_params))
+
+            pending_writes = []
+            async for write_doc in serialized_writes_result:
+                print(f"write_doc: {write_doc}")  # Debugging statement to log the contents of write_doc
+                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")
+                else:
+                    pending_writes.append(
+                        (
+                            checkpoint_writes["task_id"],
+                            checkpoint_writes["channel"],
+                            self.serde.loads_typed((checkpoint_writes["type"], _decode_binary(checkpoint_writes["value"]))),
+                        )
+                    )
+
+            return CheckpointTuple(
+                {"configurable": config_values},
+                checkpoint,
+                self.serde.loads(_decode_binary(doc["metadata"])),
+                (
+                    {
+                        "configurable": {
+                            "thread_id": thread_id,
+                            "checkpoint_ns": checkpoint_ns,
+                            "checkpoint_id": doc["parent_checkpoint_id"],
+                        }
+                    }
+                    if doc.get("parent_checkpoint_id")
+                    else None
+                ),
+                pending_writes,
+            )
+
+    async def alist(
+            self,
+            config: Optional[RunnableConfig],
+            *,
+            filter: Optional[Dict[str, Any]] = None,
+            before: Optional[RunnableConfig] = None,
+            limit: Optional[int] = None,
+        ) -> AsyncIterator[CheckpointTuple]:
+        """List checkpoints from the database asynchronously.
+
+        This method retrieves a list of checkpoint tuples from the Couchbase database based
+        on the provided config. The checkpoints are ordered by checkpoint ID in descending order (newest first).
+
+        Args:
+            config (Optional[RunnableConfig]): The config to use for listing the checkpoints.
+            filter (Optional[Dict[str, Any]]): Additional filtering criteria for metadata. Defaults to None.
+            before (Optional[RunnableConfig]): If provided, only checkpoints before the specified checkpoint ID are returned. Defaults to None.
+            limit (Optional[int]): The maximum number of checkpoints to return. Defaults to None.
+
+        Yields:
+            AsyncIterator[CheckpointTuple]: An asynchronous iterator of checkpoint tuples.
+        """
+
+        query = f"SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE 1=1"
+        query_params = []
+
+        if config is not None:
+            query += " AND thread_id = $1 AND checkpoint_ns = $2"
+            query_params.extend([config["configurable"]["thread_id"], config["configurable"].get("checkpoint_ns", "")])
+
+        if filter:
+            for key, value in filter.items():
+                query += f" AND metadata.{key} = ${len(query_params) + 1}"
+                query_params.append(value)
+
+        if before is not None:
+            query += f" AND checkpoint_id < ${len(query_params) + 1}"
+            query_params.append(before["configurable"]["checkpoint_id"])
+
+        query += " ORDER BY checkpoint_id DESC"
+
+        if limit is not None:
+            query += f" LIMIT {limit}"
+
+        result = self.cluster.query(query, QueryOptions(positional_parameters=query_params))
+
+        async for row in result:
+            doc = row[self.checkpoints_collection_name]
+            checkpoint_data = _decode_binary(doc["checkpoint"])
+            checkpoint = self.serde.loads_typed((doc["type"], checkpoint_data))
+            yield CheckpointTuple(
+                {
+                    "configurable": {
+                        "thread_id": doc["thread_id"],
+                        "checkpoint_ns": doc["checkpoint_ns"],
+                        "checkpoint_id": doc["checkpoint_id"],
+                    }
+                },
+                checkpoint,
+                self.serde.loads(_decode_binary(doc["metadata"])),
+                (
+                    {
+                        "configurable": {
+                            "thread_id": doc["thread_id"],
+                            "checkpoint_ns": doc["checkpoint_ns"],
+                            "checkpoint_id": doc["parent_checkpoint_id"],
+                        }
+                    }
+                    if doc.get("parent_checkpoint_id")
+                    else None
+                ),
+            )
+
+    async def aput(
+            self,
+            config: RunnableConfig,
+            checkpoint: Checkpoint,
+            metadata: CheckpointMetadata,
+            new_versions: ChannelVersions,
+        ) -> RunnableConfig:
+        """Save a checkpoint to the database asynchronously.
+
+        This method saves a checkpoint to the Couchbase database. The checkpoint is associated
+        with the provided config and its parent config (if any).
+
+        Args:
+            config (RunnableConfig): The config to associate with the checkpoint.
+            checkpoint (Checkpoint): The checkpoint to save.
+            metadata (CheckpointMetadata): Additional metadata to save with the checkpoint.
+            new_versions (ChannelVersions): New channel versions as of this write.
+
+        Returns:
+            RunnableConfig: Updated configuration after storing the checkpoint.
+        """
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"]["checkpoint_ns"]
+        checkpoint_id = checkpoint["id"]
+        type_, serialized_checkpoint = self.serde.dumps_typed(checkpoint)
+        if serialized_checkpoint:
+            serialized_checkpoint = _encode_binary(serialized_checkpoint)
+            
+        metadata = self.serde.dumps(metadata)
+        if metadata:
+            metadata = _encode_binary(metadata)
+        
+        doc = {
+            "parent_checkpoint_id": config["configurable"].get("checkpoint_id"),
+            "type": type_,
+            "checkpoint": serialized_checkpoint,
+            "metadata": metadata,
+            "thread_id" : thread_id,
+            "checkpoint_ns": checkpoint_ns,
+            "checkpoint_id": checkpoint_id,
+        }
+        # print(json.dumps(doc))
+        upsert_key = f"{thread_id}::{checkpoint_ns}::{checkpoint_id}"
+
+        collection = self.bucket.scope(self.scope_name).collection(self.checkpoints_collection_name)
+        await collection.upsert(upsert_key, (doc), UpsertOptions(timeout=timedelta(seconds=5)))
+
+        return {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": checkpoint_id,
+            }
+        }
+
+    async def aput_writes(
+            self,
+            config: RunnableConfig,
+            writes: Sequence[Tuple[str, Any]],
+            task_id: str,
+        ) -> None:
+        """Store intermediate writes linked to a checkpoint asynchronously.
+
+        This method saves intermediate writes associated with a checkpoint to the Couchbase database.
+
+        Args:
+            config (RunnableConfig): Configuration of the related checkpoint.
+            writes (Sequence[Tuple[str, Any]]): List of writes to store, each as (channel, value) pair.
+            task_id (str): Identifier for the task creating the writes.
+        """
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"]["checkpoint_ns"]
+        checkpoint_id = config["configurable"]["checkpoint_id"]
+
+        collection = self.bucket.scope(self.scope_name).collection(self.checkpoint_writes_collection_name)
+
+        for idx, (channel, value) in enumerate(writes):
+            upsert_key = f"{thread_id}::{checkpoint_ns}::{checkpoint_id}::{task_id}::{idx}"
+            type_, serialized_value = self.serde.dumps_typed(value)
+            if serialized_value:
+                serialized_value = _encode_binary(serialized_value)
+            doc = {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": checkpoint_id,
+                "task_id": task_id,
+                "idx": idx,
+                "channel": channel,
+                "type": type_,
+                "value": serialized_value,
+            }
+            await collection.upsert(upsert_key, (doc), UpsertOptions(timeout=timedelta(seconds=5)))

langgraph_checkpointer_couchbase-1.0.1/langgraph_checkpointer_couchbase/couchbase_saver.py

@@ -0,0 +1,390 @@
+from contextlib import contextmanager
+from datetime import timedelta
+from typing import Any, Dict, Iterator, Optional, Sequence, Tuple
+
+from langchain_core.runnables import RunnableConfig
+from couchbase.cluster import Cluster
+from couchbase.bucket import Bucket
+from couchbase.auth import PasswordAuthenticator
+from couchbase.options import ClusterOptions, QueryOptions, UpsertOptions
+from couchbase.management.collections import CollectionSpec
+from couchbase.exceptions import CollectionAlreadyExistsException
+
+from langgraph.checkpoint.base import (
+    BaseCheckpointSaver,
+    ChannelVersions,
+    Checkpoint,
+    CheckpointMetadata,
+    CheckpointTuple,
+    get_checkpoint_id,
+)
+
+from .utils import _encode_binary, _decode_binary
+class CouchbaseSaver(BaseCheckpointSaver):
+    """A checkpoint saver that stores checkpoints in a Couchbase database.
+    
+    Initliaztion should be done using from_conn_info or from_cluster.
+    """
+
+    cluster: Cluster
+    bucket: Bucket
+    def __init__(
+        self,
+        cluster: Cluster,
+        bucket_name: str,
+        scope_name: str,
+        checkpoints_collection_name: str,
+        checkpoint_writes_collection_name: str,
+    ) -> None:
+        super().__init__()
+        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
+
+        self.create_collections()
+
+    @classmethod
+    @contextmanager
+    def from_conn_info(
+        cls, *, cb_conn_str :str, cb_username: str, cb_password: str, bucket_name: str, scope_name: str, checkpoints_collection_name: str = "checkpoints", checkpoint_writes_collection_name: str = "checkpoint_writes"    
+    ) -> Iterator["CouchbaseSaver"]:
+        """Create a CouchbaseSaver from connection information.
+
+        Cluster connection is created and closed automatically.
+
+        Args:
+            cb_conn_str: Connection string for the Couchbase cluster
+            cb_username: Username for the Couchbase cluster
+            cb_password: Password for the Couchbase cluster
+            bucket_name: Name of the bucket to use
+            scope_name: Name of the scope within the bucket
+            checkpoints_collection_name: Name of the collection to store checkpoints
+            checkpoint_writes_collection_name: Name of the collection to store checkpoint writes
+
+        Yields:
+            CouchbaseSaver: An instance of the CouchbaseSaver
+        """
+        
+        cluster = None
+        try:
+            # Connect to Couchbase Cluster
+            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
+
+            saver = CouchbaseSaver(cluster, bucket_name, scope_name, checkpoints_collection_name, checkpoint_writes_collection_name)
+
+            yield saver
+        finally:
+            if cluster:
+                cluster.close()
+
+    @classmethod
+    @contextmanager
+    def from_cluster(
+        cls, *, cluster: Cluster, bucket_name: str, scope_name: str, checkpoints_collection_name: str = "checkpoints", checkpoint_writes_collection_name: str = "checkpoint_writes"
+    ) -> Iterator["CouchbaseSaver"]:
+        """Create a CouchbaseSaver from an existing cluster connection.
+        
+        This allows reusing an existing cluster connection rather than creating a new one.
+        
+        Args:
+            cluster: An existing Couchbase Cluster connection
+            bucket_name: Name of the bucket to use
+            scope_name: Name of the scope within the bucket
+            
+        Yields:
+            CouchbaseSaver: An instance of the CouchbaseSaver
+        """        
+        
+        saver = CouchbaseSaver(cluster, bucket_name, scope_name, checkpoints_collection_name, checkpoint_writes_collection_name)
+        
+        yield saver
+    
+    def create_collections(self):
+        """Create collections in the Couchbase bucket if they do not exist."""
+
+        collection_manager = self.bucket.collections()
+        try:
+            collection_spec = CollectionSpec(collection_name=self.checkpoints_collection_name, scope_name=self.scope_name)
+            collection_manager.create_collection(collection_spec)
+        except CollectionAlreadyExistsException as caee:
+            pass
+        except Exception as e:
+            print(f"Error creating collections: {e}")
+            raise e
+        finally:
+            self.checkpoints_collection = self.bucket.scope(self.scope_name).collection(self.checkpoints_collection_name)
+        
+        try:
+            collection_spec = CollectionSpec(collection_name=self.checkpoint_writes_collection_name, scope_name=self.scope_name)
+            collection_manager.create_collection(collection_spec)
+        except CollectionAlreadyExistsException as caee:
+            pass
+        except Exception as e:
+            print(f"Error creating collections: {e}")
+            raise e
+        finally:
+            self.checkpoint_writes_collection = self.bucket.scope(self.scope_name).collection(self.checkpoint_writes_collection_name)
+
+    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+        """Get a checkpoint tuple from the database.
+
+        This method retrieves a checkpoint tuple from the Couchbase database based on the
+        provided config. If the config contains a "checkpoint_id" key, the checkpoint with
+        the matching thread ID and checkpoint ID is retrieved. Otherwise, the latest checkpoint
+        for the given thread ID is retrieved.
+
+        Args:
+            config (RunnableConfig): The config to use for retrieving the checkpoint.
+
+        Returns:
+            Optional[CheckpointTuple]: The retrieved checkpoint tuple, or None if no matching checkpoint was found.
+        """
+        
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"].get("checkpoint_ns", "")
+        checkpoint_id = get_checkpoint_id(config)
+
+        if checkpoint_id:
+            query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3 ORDER BY checkpoint_id DESC LIMIT 1'
+            query_params = [thread_id, checkpoint_ns, checkpoint_id]
+        else:
+            query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 ORDER BY checkpoint_id DESC LIMIT 1'
+            query_params = [thread_id, checkpoint_ns]
+
+        result = self.cluster.query(query, QueryOptions(positional_parameters=query_params))
+
+        for row in result:
+            doc = row[self.checkpoints_collection_name]
+            config_values = {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": doc["checkpoint_id"],
+            }
+            
+            # Decode and deserialize checkpoint data
+            checkpoint_data = _decode_binary(doc["checkpoint"])
+            checkpoint = self.serde.loads_typed((doc["type"], checkpoint_data))
+
+            serialized_writes_query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoint_writes_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3'
+            serialized_writes_params = [thread_id, checkpoint_ns, doc["checkpoint_id"] or ""]
+            serialized_writes_result = self.cluster.query(serialized_writes_query, QueryOptions(positional_parameters=serialized_writes_params))
+
+            pending_writes = []
+            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")
+                else:
+                    # Decode and deserialize value data
+                    value_data = _decode_binary(checkpoint_writes["value"])
+                    pending_writes.append(
+                        (
+                            checkpoint_writes["task_id"],
+                            checkpoint_writes["channel"],
+                            self.serde.loads_typed((checkpoint_writes["type"], value_data)),
+                        )
+                    )
+
+            # Decode and deserialize metadata
+            metadata = _decode_binary(doc["metadata"])
+            metadata = self.serde.loads(metadata)
+
+            return CheckpointTuple(
+                {"configurable": config_values},
+                checkpoint,
+                metadata,
+                (
+                    {
+                        "configurable": {
+                            "thread_id": thread_id,
+                            "checkpoint_ns": checkpoint_ns,
+                            "checkpoint_id": doc["parent_checkpoint_id"],
+                        }
+                    }
+                    if doc.get("parent_checkpoint_id")
+                    else None
+                ),
+                pending_writes,
+            )
+
+    def list(
+            self,
+            config: Optional[RunnableConfig],
+            *,
+            filter: Optional[Dict[str, Any]] = None,
+            before: Optional[RunnableConfig] = None,
+            limit: Optional[int] = None,
+        ) -> Iterator[CheckpointTuple]:
+        """List checkpoints from the database.
+
+        This method retrieves a list of checkpoint tuples from the Couchbase database based
+        on the provided config. The checkpoints are ordered by checkpoint ID in descending order (newest first).
+
+        Args:
+            config (RunnableConfig): The config to use for listing the checkpoints.
+            filter (Optional[Dict[str, Any]]): Additional filtering criteria for metadata. Defaults to None.
+            before (Optional[RunnableConfig]): If provided, only checkpoints before the specified checkpoint ID are returned. Defaults to None.
+            limit (Optional[int]): The maximum number of checkpoints to return. Defaults to None.
+
+        Yields:
+            Iterator[CheckpointTuple]: An iterator of checkpoint tuples.
+        """
+
+        query = f"SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE 1=1"
+        query_params = []
+
+        if config is not None:
+            query += " AND thread_id = $1 AND checkpoint_ns = $2"
+            query_params.extend([config["configurable"]["thread_id"], config["configurable"].get("checkpoint_ns", "")])
+
+        if filter:
+            for key, value in filter.items():
+                query += f" AND metadata.{key} = ${len(query_params) + 1}"
+                query_params.append(value)
+
+        if before is not None:
+            query += f" AND checkpoint_id < ${len(query_params) + 1}"
+            query_params.append(before["configurable"]["checkpoint_id"])
+
+        query += " ORDER BY checkpoint_id DESC"
+
+        if limit is not None:
+            query += f" LIMIT {limit}"
+
+        result = self.cluster.query(query, QueryOptions(positional_parameters=query_params))
+
+        for row in result:
+            doc = row[self.checkpoints_collection_name]
+            checkpoint_data = _decode_binary(doc["checkpoint"])
+            checkpoint = self.serde.loads_typed((doc["type"], checkpoint_data))
+            yield CheckpointTuple(
+                {
+                    "configurable": {
+                        "thread_id": doc["thread_id"],
+                        "checkpoint_ns": doc["checkpoint_ns"],
+                        "checkpoint_id": doc["checkpoint_id"],
+                    }
+                },
+                checkpoint,
+                self.serde.loads(_decode_binary(doc["metadata"])),
+                (
+                    {
+                        "configurable": {
+                            "thread_id": doc["thread_id"],
+                            "checkpoint_ns": doc["checkpoint_ns"],
+                            "checkpoint_id": doc["parent_checkpoint_id"],
+                        }
+                    }
+                    if doc.get("parent_checkpoint_id")
+                    else None
+                ),
+            )
+
+    def put(
+            self,
+            config: RunnableConfig,
+            checkpoint: Checkpoint,
+            metadata: CheckpointMetadata,
+            new_versions: ChannelVersions,
+        ) -> RunnableConfig:
+        """Save a checkpoint to the database.
+
+        This method saves a checkpoint to the Couchbase database. The checkpoint is associated
+        with the provided config and its parent config (if any).
+
+        Args:
+            config (RunnableConfig): The config to associate with the checkpoint.
+            checkpoint (Checkpoint): The checkpoint to save.
+            metadata (CheckpointMetadata): Additional metadata to save with the checkpoint.
+            new_versions (ChannelVersions): New channel versions as of this write.
+
+        Returns:
+            RunnableConfig: Updated configuration after storing the checkpoint.
+        """
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"]["checkpoint_ns"]
+        checkpoint_id = checkpoint["id"]
+        
+        # Serialize and encode checkpoint data
+        type_, serialized_checkpoint = self.serde.dumps_typed(checkpoint)
+        if serialized_checkpoint:
+            serialized_checkpoint = _encode_binary(serialized_checkpoint)
+            
+        # Serialize and encode metadata
+        metadata_bytes = self.serde.dumps(metadata)
+        if metadata_bytes:
+            metadata = _encode_binary(metadata_bytes)
+        
+        doc = {
+            "parent_checkpoint_id": config["configurable"].get("checkpoint_id"),
+            "type": type_,
+            "checkpoint": serialized_checkpoint,
+            "metadata": metadata,
+            "thread_id" : thread_id,
+            "checkpoint_ns": checkpoint_ns,
+            "checkpoint_id": checkpoint_id,
+        }
+        upsert_key = f"{thread_id}::{checkpoint_ns}::{checkpoint_id}"
+        
+        collection = self.checkpoints_collection
+        collection.upsert(upsert_key, (doc), UpsertOptions(timeout=timedelta(seconds=5)))
+
+        return {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": checkpoint_id,
+            }
+        }
+
+    def put_writes(
+            self,
+            config: RunnableConfig,
+            writes: Sequence[Tuple[str, Any]],
+            task_id: str,
+        ) -> None:
+        """Store intermediate writes linked to a checkpoint.
+
+        This method saves intermediate writes associated with a checkpoint to the Couchbase database.
+
+        Args:
+            config (RunnableConfig): Configuration of the related checkpoint.
+            writes (Sequence[Tuple[str, Any]]): List of writes to store, each as (channel, value) pair.
+            task_id (str): Identifier for the task creating the writes.
+        """
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"]["checkpoint_ns"]
+        checkpoint_id = config["configurable"]["checkpoint_id"]
+
+        collection = self.checkpoint_writes_collection
+
+        for idx, (channel, value) in enumerate(writes):
+            upsert_key = f"{thread_id}::{checkpoint_ns}::{checkpoint_id}::{task_id}::{idx}"
+            type_, serialized_value = self.serde.dumps_typed(value)
+            
+            # Encode the serialized value to base64 string
+            if serialized_value:
+                serialized_value = _encode_binary(serialized_value)
+
+            doc = {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": checkpoint_id,
+                "task_id": task_id,
+                "idx": idx,
+                "channel": channel,
+                "type": type_,
+                "value": serialized_value,
+            }
+            collection.upsert(upsert_key, (doc), UpsertOptions(timeout=timedelta(seconds=5)))

langgraph_checkpointer_couchbase-1.0.1/langgraph_checkpointer_couchbase/utils.py

@@ -0,0 +1,11 @@
+import base64
+
+__all__ = ["_encode_binary", "_decode_binary"]
+
+def _encode_binary(data: bytes) -> str:
+    """Encode binary data to base64 string."""
+    return base64.b64encode(data).decode('utf-8')
+
+def _decode_binary(data: str) -> bytes:
+    """Decode base64 string to binary data."""
+    return base64.b64decode(data)

langgraph_checkpointer_couchbase-1.0.1/pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langgraph-checkpointer-couchbase"
+version = "1.0.1"
+description = ''
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+keywords = ["langchain","langgraph", "couchbase", "checkpointer", "persistence"]
+authors = [
+  { name = "Lokesh Goel", email = "lokesh.goel@couchbase.com" },
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "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"
+]
+
+[project.urls]
+Documentation = "https://github.com/Lokesh Goel/langgraph-checkpointer-couchbase#readme"
+Issues = "https://github.com/Lokesh Goel/langgraph-checkpointer-couchbase/issues"
+Source = "https://github.com/Lokesh Goel/langgraph-checkpointer-couchbase"
+
+[tool.hatch.version]
+path = "src/langgraph_checkpointer_couchbase/__about__.py"
+
+[tool.hatch.envs.types]
+extra-dependencies = [
+  "mypy>=1.0.0",
+]
+[tool.hatch.envs.types.scripts]
+check = "mypy --install-types --non-interactive {args:src/langgraph_checkpointer_couchbase tests}"
+
+[tool.coverage.run]
+source_pkgs = ["langgraph_checkpointer_couchbase", "tests"]
+branch = true
+parallel = true
+omit = [
+  "src/langgraph_checkpointer_couchbase/__about__.py",
+]
+
+[tool.coverage.paths]
+langgraph_checkpointer_couchbase = ["src/langgraph_checkpointer_couchbase", "*/langgraph-checkpointer-couchbase/src/langgraph_checkpointer_couchbase"]
+tests = ["tests", "*/langgraph-checkpointer-couchbase/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]

langgraph_checkpointer_couchbase-1.0.1/tests/agent_e2e_test.py

@@ -0,0 +1,70 @@
+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())