langgraph-store-dynamodb 0.1.0__tar.gz

langgraph_store_dynamodb-0.1.0/.gitignore

@@ -0,0 +1,42 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# Virtual environments
+venv/
+env/
+.env/
+.venv/
+ENV/
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Unit test / coverage reports
+htmcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Environment variables
+.env
+
+# Local development settings
+*.log
+.DS_Store

langgraph_store_dynamodb-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: langgraph_store_dynamodb
+Version: 0.1.0
+Summary: DynamoDB dtore for LangGraph
+Author-email: Kamal <skamalj@github.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: boto3
+Requires-Dist: botocore
+Requires-Dist: langchain-core
+Requires-Dist: langgraph
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# LangGraph DynamoDB Store
+
+A DynamoDB-based store implementation for LangGraph that allows long term memory implementation
+
+bash
+pip install langgraph-store-dynamodb
+
+
+## Usage
+
+### Basic Initialization
+
+python
+from langgraph_store_dynamodb import DynamoDBStore
+
+# Initialize the store with a table name
+store = DynamoDBStore(
+    table_name="your-dynamodb-table-name",
+    max_read_request_units=10,  # Optional, default is 10
+    max_write_request_units=10  # Optional, default is 10
+)
+
+
+### Alternative Initialization Using Context Manager
+
+python
+from langgraph_dynamodb_checkpoint import DynamoDBStore
+
+with DynamoDBStore.from_conn_info(table_name="your-dynamodb-table-name") as store:
+    # Use the store here
+    pass
+
+
+## Parameters
+
+### DynamoDBStore Constructor
+
+- `table_name` (str): Name of the DynamoDB table to use for storing checkpoints
+- `max_read_request_units` (int, optional): Maximum read request units for the DynamoDB table. Defaults to 10
+- `max_write_request_units` (int, optional): Maximum write request units for the DynamoDB table. Defaults to 10
+
+## Table Structure
+
+The store automatically creates a DynamoDB table if it doesn't exist, with the following structure:
+
+- Partition Key (PK): String type, used for namespace
+- Sort Key (SK): String type, used for memory key
+
+## AWS Configuration
+
+Ensure you have proper AWS credentials configured either through:
+- Environment variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)
+- AWS credentials file (~/.aws/credentials)
+- IAM role when running on AWS services
+
+The AWS credentials should have permissions to:
+- Create DynamoDB tables (if table doesn't exist)
+- Read and write to DynamoDB tables
+
+## Notes
+
+- The store automatically creates the DynamoDB table if it doesn't exist
+- Uses on-demand billing mode for DynamoDB
+- Implements methods required by the LangGraph BaseStore interface

langgraph_store_dynamodb-0.1.0/README.md

@@ -0,0 +1,64 @@
+# LangGraph DynamoDB Store
+
+A DynamoDB-based store implementation for LangGraph that allows long term memory implementation
+
+bash
+pip install langgraph-store-dynamodb
+
+
+## Usage
+
+### Basic Initialization
+
+python
+from langgraph_store_dynamodb import DynamoDBStore
+
+# Initialize the store with a table name
+store = DynamoDBStore(
+    table_name="your-dynamodb-table-name",
+    max_read_request_units=10,  # Optional, default is 10
+    max_write_request_units=10  # Optional, default is 10
+)
+
+
+### Alternative Initialization Using Context Manager
+
+python
+from langgraph_dynamodb_checkpoint import DynamoDBStore
+
+with DynamoDBStore.from_conn_info(table_name="your-dynamodb-table-name") as store:
+    # Use the store here
+    pass
+
+
+## Parameters
+
+### DynamoDBStore Constructor
+
+- `table_name` (str): Name of the DynamoDB table to use for storing checkpoints
+- `max_read_request_units` (int, optional): Maximum read request units for the DynamoDB table. Defaults to 10
+- `max_write_request_units` (int, optional): Maximum write request units for the DynamoDB table. Defaults to 10
+
+## Table Structure
+
+The store automatically creates a DynamoDB table if it doesn't exist, with the following structure:
+
+- Partition Key (PK): String type, used for namespace
+- Sort Key (SK): String type, used for memory key
+
+## AWS Configuration
+
+Ensure you have proper AWS credentials configured either through:
+- Environment variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)
+- AWS credentials file (~/.aws/credentials)
+- IAM role when running on AWS services
+
+The AWS credentials should have permissions to:
+- Create DynamoDB tables (if table doesn't exist)
+- Read and write to DynamoDB tables
+
+## Notes
+
+- The store automatically creates the DynamoDB table if it doesn't exist
+- Uses on-demand billing mode for DynamoDB
+- Implements methods required by the LangGraph BaseStore interface

langgraph_store_dynamodb-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langgraph_store_dynamodb"
+version = "0.1.0"
+description = "DynamoDB dtore for LangGraph"
+authors = [{name = "Kamal", email = "skamalj@github.com"}]
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "langchain-core",
+    "langgraph",
+    "boto3",
+    "botocore"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+    "black",
+    "isort",
+    "mypy"
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/langgraph_store_dynamodb"]
+
+[tool.black]
+line-length = 88
+target-version = ['py39']
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3

langgraph_store_dynamodb-0.1.0/readme.md

@@ -0,0 +1,64 @@
+# LangGraph DynamoDB Store
+
+A DynamoDB-based store implementation for LangGraph that allows long term memory implementation
+
+bash
+pip install langgraph-store-dynamodb
+
+
+## Usage
+
+### Basic Initialization
+
+python
+from langgraph_store_dynamodb import DynamoDBStore
+
+# Initialize the store with a table name
+store = DynamoDBStore(
+    table_name="your-dynamodb-table-name",
+    max_read_request_units=10,  # Optional, default is 10
+    max_write_request_units=10  # Optional, default is 10
+)
+
+
+### Alternative Initialization Using Context Manager
+
+python
+from langgraph_dynamodb_checkpoint import DynamoDBStore
+
+with DynamoDBStore.from_conn_info(table_name="your-dynamodb-table-name") as store:
+    # Use the store here
+    pass
+
+
+## Parameters
+
+### DynamoDBStore Constructor
+
+- `table_name` (str): Name of the DynamoDB table to use for storing checkpoints
+- `max_read_request_units` (int, optional): Maximum read request units for the DynamoDB table. Defaults to 10
+- `max_write_request_units` (int, optional): Maximum write request units for the DynamoDB table. Defaults to 10
+
+## Table Structure
+
+The store automatically creates a DynamoDB table if it doesn't exist, with the following structure:
+
+- Partition Key (PK): String type, used for namespace
+- Sort Key (SK): String type, used for memory key
+
+## AWS Configuration
+
+Ensure you have proper AWS credentials configured either through:
+- Environment variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)
+- AWS credentials file (~/.aws/credentials)
+- IAM role when running on AWS services
+
+The AWS credentials should have permissions to:
+- Create DynamoDB tables (if table doesn't exist)
+- Read and write to DynamoDB tables
+
+## Notes
+
+- The store automatically creates the DynamoDB table if it doesn't exist
+- Uses on-demand billing mode for DynamoDB
+- Implements methods required by the LangGraph BaseStore interface

langgraph_store_dynamodb-0.1.0/src/langgraph_store_dynamodb/dynamodbStore.py

@@ -0,0 +1,165 @@
+import boto3
+from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
+from boto3.dynamodb.conditions import Key
+from botocore.exceptions import ClientError
+from langgraph.store.base import BaseStore, Item, PutOp, Result, SearchItem, NamespacePath
+from datetime import datetime
+
+
+class DynamoDBStore(BaseStore):
+    def __init__(self, table_name: str,  max_read_request_units: int = 10, max_write_request_units: int = 10):
+        super().__init__()
+        self.dynamodb = boto3.resource('dynamodb')
+        self.table = self._get_or_create_table(table_name, max_read_request_units,max_write_request_units)
+    
+    def _get_or_create_table(self, table_name: str, max_read_request_units: int, max_write_request_units: int):
+        try:
+            # Attempt to load the table
+            table = self.dynamodb.Table(table_name)
+            table.load()  # This will raise an exception if the table does not exist
+            print(f"Table '{table_name}' already exists.")
+            return table
+        except ClientError as e:
+            if e.response['Error']['Code'] == 'ResourceNotFoundException':
+                # Table does not exist, create it
+                print(f"Table '{table_name}' not found. Creating table...")
+                key_schema = [
+                    {'AttributeName': 'PK', 'KeyType': 'HASH'},  # Partition key
+                    {'AttributeName': 'SK', 'KeyType': 'RANGE'},  # Sort key
+                ]
+                attribute_definitions = [
+                    {'AttributeName': 'PK', 'AttributeType': 'S'},  # String type
+                    {"AttributeName": "SK", "AttributeType": 'S'},
+                ]
+                
+                table = self.dynamodb.create_table(
+                    TableName=table_name,
+                    KeySchema=key_schema,
+                    AttributeDefinitions=attribute_definitions,
+                    BillingMode='PAY_PER_REQUEST',
+                    OnDemandThroughput={
+                        'MaxReadRequestUnits': max_read_request_units,
+                        'MaxWriteRequestUnits': max_write_request_units
+                    }
+                )
+                table.wait_until_exists()  # Wait for the table to become active
+                print(f"Table '{table_name}' created successfully.")
+                return table
+            else:
+                raise  # Re-raise any other exceptions
+    from datetime import datetime
+
+    def _map_to_item(result_dict, namespace, return_type='Item'):
+        # Extract values from the result_dict
+        key = result_dict['PK']  # Using 'PK' as the unique key
+        value = result_dict['value']
+        created_at = result_dict['created_at']
+        updated_at = result_dict['updated_at']
+
+        target_class = Item if return_type == 'Item' else SearchItem
+
+        # Create an Item object
+        item = target_class(
+            value=value,
+            key=key,
+            namespace=namespace,
+            created_at=created_at,
+            updated_at=updated_at
+        )    
+        return item
+
+    def batch(self, ops: Iterable[PutOp]) -> list[Result]:
+        results = []
+        for op in ops:
+            composite_key = self._construct_composite_key(op.namespace, op.key)
+            if op.value is None:
+                # Delete operation
+                result = self.delete(namespace=composite_key[0], key=composite_key[1])
+            else:                
+                result = self.put(
+                    namespace=composite_key[0], key=composite_key[1], value=op.value
+                )
+            # Append the operation result
+            results.append(result)
+        return results
+
+    def get(self, namespace: Tuple[str, ...], key: str) -> Optional[Item]:
+        """
+        Retrieve an item based on its composite key (namespace, key).
+        """
+        composite_key = self._construct_composite_key(namespace, key)
+        response = self.table.get_item(Key={'PK': composite_key[0], 'SK': composite_key[1]})
+        item = response.get('Item')
+        if item:
+            return self._map_to_item(item, namespace)
+        return None
+
+    def search(
+        self,
+        namespace_prefix: Tuple[str, ...],
+        *,
+        query: Optional[str] = None,
+        filter: Optional[Dict[str, Any]] = None,
+        limit: int = 10,
+        offset: int = 0
+    ) -> List[SearchItem]:
+        """
+        Search for items in a given namespace, applying optional query and filter.
+        """
+        namespace = ':'.join(namespace_prefix)
+        key_condition = "PK = :partitionkeyval AND SK = :sortkeyval"
+        filter_expression = None
+        
+        response = self.table.query(
+            ExpressionAttributeValues={
+                ':PK': namespace
+            },
+            KeyConditionExpression='PK = :PK',
+            Limit=limit
+        )
+
+        items = response.get('Items', [])
+        return [self._map_to_item(item, namespace, 'SearchItem') for item in items]
+
+    def put(
+        self,
+        namespace: Tuple[str, ...],
+        key: str,
+        value: Dict[str, Any],
+        index: Optional[Union[Literal[False], List[str]]] = None
+    ) -> None:
+        """
+        Insert or update an item in the table.
+        """
+        composite_key = self._construct_composite_key(namespace, key)
+        existing_item = self.get(namespace=composite_key[0], key=composite_key[0])
+        current_time = datetime.utcnow()
+        item = {
+            'PK': composite_key[0],
+            'SK': composite_key[0],
+            'value': value,
+            'created_at': existing_item.created_at if existing_item else current_time,
+            'updated_at': current_time,
+        }
+        self.table.put_item(Item=item)
+
+    def delete(self, namespace: Tuple[str, ...], key: str) -> None:
+        """
+        Delete an item based on its composite key (namespace, key).
+        """
+        composite_key = self._construct_composite_key(namespace, key)
+        self.table.delete_item(Key={'PK': composite_key[0], 'SK': composite_key[1]})
+
+    def list_namespaces(self, *, prefix: Optional[NamespacePath] = None, 
+                    suffix: Optional[NamespacePath] = None, 
+                    max_depth: Optional[int] = None, 
+                    limit: int = 100, offset: int = 0) -> list[tuple[str, ...]]:
+        raise NotImplementedError("The 'list_namespaces' method is not implemented yet.")
+
+
+    def _construct_composite_key(self, namespace: Tuple[str, ...], key: str) -> Tuple[str, str]:
+        """
+        Combine namespace and key to form a composite key (PK, SK).
+        """
+        namespace_str = ':'.join(namespace)
+        return (namespace_str, key)