tinkerfin-langgraph-store 0.1.1__tar.gz

tinkerfin_langgraph_store-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Theodore Ni
+
+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.

tinkerfin_langgraph_store-0.1.1/NOTICE

@@ -0,0 +1,5 @@
+Portions of the LangGraph Store namespace validation and batch semantics are
+adapted from langgraph-checkpoint-mysql 3.0.0 by Theodore Ni:
+https://github.com/tjni/langgraph-checkpoint-mysql
+
+The applicable MIT License and copyright notice are included in LICENSE.

tinkerfin_langgraph_store-0.1.1/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: tinkerfin-langgraph-store
+Version: 0.1.1
+Summary: Async persistent LangGraph memory with exact namespaces and structured search.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tinkerfin-ai/tinkerfin-harness
+Project-URL: Repository, https://github.com/tinkerfin-ai/tinkerfin-harness
+Project-URL: Issues, https://github.com/tinkerfin-ai/tinkerfin-harness/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: langgraph-checkpoint==4.2.0
+Provides-Extra: sqlalchemy
+Requires-Dist: sqlalchemy[asyncio]==2.0.52; extra == "sqlalchemy"
+Requires-Dist: tinkerfin-sqlalchemy==0.1.1; extra == "sqlalchemy"
+Requires-Dist: tinkerfin-contracts==0.1.1; extra == "sqlalchemy"
+Dynamic: license-file
+
+# TinkerFin LangGraph Store
+
+Persistent LangGraph memory with asynchronous reads, atomic batches, structured
+search, and namespace listing. SQLite, PostgreSQL, and MySQL use the same
+query and batch API.
+
+## Installation
+
+```bash
+pip install "tinkerfin-langgraph-store[sqlalchemy]" aiosqlite
+```
+
+Choose `asyncpg` for PostgreSQL or `asyncmy` for MySQL. Supply a SQLAlchemy
+`AsyncEngine` configured with that driver.
+
+## Quick start
+
+```python
+import asyncio
+
+from sqlalchemy.ext.asyncio import create_async_engine
+from tinkerfin_langgraph_store import SqlAlchemyStore
+
+
+async def main() -> None:
+    engine = create_async_engine("sqlite+aiosqlite:///memory.db")
+    try:
+        async with SqlAlchemyStore(engine) as store:
+            await store.aput(("users", "alice"), "preferences", {"language": "en"})
+            item = await store.aget(("users", "alice"), "preferences")
+            print(item.value if item else None)
+            matches = await store.asearch(("users",), filter={"language": "en"})
+            print([item.namespace for item in matches])
+    finally:
+        await engine.dispose()
+
+
+asyncio.run(main())
+```
+
+Pass the Store to `TinkerFin(store=store).with_namespace(...).build(model=...)` to
+isolate memory by Runtime namespace. The caller owns the Engine. Closing the Store
+waits for accepted operations and does not close the Engine. Setup is automatic;
+`await store.setup()` can validate storage at application startup.
+
+## Stored data and queries
+
+- `aget`, `aput`, `adelete`, and `abatch` use complete namespace/key identities.
+  A batch reads one snapshot before writing; the final write to each key wins.
+  Updates preserve `created_at`.
+- `acompare_and_set(namespace, key, expected=observed, value=replacement)` commits
+  only when the complete JSON value still matches. `expected=None` requires
+  absence; `value=None` deletes. A conflict returns `False` without changing
+  data. Conditions are checked in the write transaction across Store instances.
+- `asearch_exact(namespace, limit=100, offset=0)` pages one collection and
+  excludes descendant namespaces before pagination. It returns independent
+  `DocumentSnapshot` values from `tinkerfin_contracts.storage`, ordered by update
+  time descending and then key ascending.
+- `asearch` matches a literal namespace prefix. Results sort by `updated_at`
+  descending, then namespace and key ascending. `limit` and `offset` apply after
+  filtering.
+- Filters use literal top-level field names. `$eq` and `$ne` compare typed JSON
+  values; use `$eq` for an object value. Missing fields match neither operator.
+  Null differs from missing, booleans differ from numbers, and object key order
+  does not affect equality. Integral floats equal their corresponding integers.
+- `$gt`, `$gte`, `$lt`, and `$lte` compare numbers at binary64 precision. Operands
+  must be finite numbers within that range. Multiple fields and operators combine
+  with AND.
+- `alist_namespaces` matches complete paths before `max_depth`, deduplication,
+  sorting, and pagination. Its `*` matches one label; search treats `*` literally.
+  Only namespaces containing documents appear.
+
+Namespaces follow LangGraph's label rules. Namespace, key, and document sizes are
+subject to the database's payload and resource limits. Document values must be
+finite JSON objects. TTL, semantic search, vector indexing, and synchronous
+database calls are unsupported.
+
+Use a pool with exclusive checkouts. File SQLite Engines use one by default;
+in-memory SQLite needs `AsyncAdaptedQueuePool(pool_size=1, max_overflow=0)`.
+Existing tables and indexes must match the complete current structure.
+
+## Documentation and license
+
+[TinkerFin documentation](https://github.com/tinkerfin-ai/tinkerfin-harness/tree/main/docs/en)
+· [MIT License](https://github.com/tinkerfin-ai/tinkerfin-harness/blob/main/packages/tinkerfin-langgraph-store/LICENSE)
+· [NOTICE](https://github.com/tinkerfin-ai/tinkerfin-harness/blob/main/packages/tinkerfin-langgraph-store/NOTICE)

tinkerfin_langgraph_store-0.1.1/README.md

@@ -0,0 +1,86 @@
+# TinkerFin LangGraph Store
+
+Persistent LangGraph memory with asynchronous reads, atomic batches, structured
+search, and namespace listing. SQLite, PostgreSQL, and MySQL use the same
+query and batch API.
+
+## Installation
+
+```bash
+pip install "tinkerfin-langgraph-store[sqlalchemy]" aiosqlite
+```
+
+Choose `asyncpg` for PostgreSQL or `asyncmy` for MySQL. Supply a SQLAlchemy
+`AsyncEngine` configured with that driver.
+
+## Quick start
+
+```python
+import asyncio
+
+from sqlalchemy.ext.asyncio import create_async_engine
+from tinkerfin_langgraph_store import SqlAlchemyStore
+
+
+async def main() -> None:
+    engine = create_async_engine("sqlite+aiosqlite:///memory.db")
+    try:
+        async with SqlAlchemyStore(engine) as store:
+            await store.aput(("users", "alice"), "preferences", {"language": "en"})
+            item = await store.aget(("users", "alice"), "preferences")
+            print(item.value if item else None)
+            matches = await store.asearch(("users",), filter={"language": "en"})
+            print([item.namespace for item in matches])
+    finally:
+        await engine.dispose()
+
+
+asyncio.run(main())
+```
+
+Pass the Store to `TinkerFin(store=store).with_namespace(...).build(model=...)` to
+isolate memory by Runtime namespace. The caller owns the Engine. Closing the Store
+waits for accepted operations and does not close the Engine. Setup is automatic;
+`await store.setup()` can validate storage at application startup.
+
+## Stored data and queries
+
+- `aget`, `aput`, `adelete`, and `abatch` use complete namespace/key identities.
+  A batch reads one snapshot before writing; the final write to each key wins.
+  Updates preserve `created_at`.
+- `acompare_and_set(namespace, key, expected=observed, value=replacement)` commits
+  only when the complete JSON value still matches. `expected=None` requires
+  absence; `value=None` deletes. A conflict returns `False` without changing
+  data. Conditions are checked in the write transaction across Store instances.
+- `asearch_exact(namespace, limit=100, offset=0)` pages one collection and
+  excludes descendant namespaces before pagination. It returns independent
+  `DocumentSnapshot` values from `tinkerfin_contracts.storage`, ordered by update
+  time descending and then key ascending.
+- `asearch` matches a literal namespace prefix. Results sort by `updated_at`
+  descending, then namespace and key ascending. `limit` and `offset` apply after
+  filtering.
+- Filters use literal top-level field names. `$eq` and `$ne` compare typed JSON
+  values; use `$eq` for an object value. Missing fields match neither operator.
+  Null differs from missing, booleans differ from numbers, and object key order
+  does not affect equality. Integral floats equal their corresponding integers.
+- `$gt`, `$gte`, `$lt`, and `$lte` compare numbers at binary64 precision. Operands
+  must be finite numbers within that range. Multiple fields and operators combine
+  with AND.
+- `alist_namespaces` matches complete paths before `max_depth`, deduplication,
+  sorting, and pagination. Its `*` matches one label; search treats `*` literally.
+  Only namespaces containing documents appear.
+
+Namespaces follow LangGraph's label rules. Namespace, key, and document sizes are
+subject to the database's payload and resource limits. Document values must be
+finite JSON objects. TTL, semantic search, vector indexing, and synchronous
+database calls are unsupported.
+
+Use a pool with exclusive checkouts. File SQLite Engines use one by default;
+in-memory SQLite needs `AsyncAdaptedQueuePool(pool_size=1, max_overflow=0)`.
+Existing tables and indexes must match the complete current structure.
+
+## Documentation and license
+
+[TinkerFin documentation](https://github.com/tinkerfin-ai/tinkerfin-harness/tree/main/docs/en)
+· [MIT License](https://github.com/tinkerfin-ai/tinkerfin-harness/blob/main/packages/tinkerfin-langgraph-store/LICENSE)
+· [NOTICE](https://github.com/tinkerfin-ai/tinkerfin-harness/blob/main/packages/tinkerfin-langgraph-store/NOTICE)

tinkerfin_langgraph_store-0.1.1/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "tinkerfin-langgraph-store"
+version = "0.1.1"
+description = "Async persistent LangGraph memory with exact namespaces and structured search."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE", "NOTICE"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+]
+dependencies = ["langgraph-checkpoint==4.2.0"]
+
+[project.optional-dependencies]
+sqlalchemy = ["sqlalchemy[asyncio]==2.0.52", "tinkerfin-sqlalchemy==0.1.1", "tinkerfin-contracts==0.1.1"]
+
+[project.urls]
+Homepage = "https://github.com/tinkerfin-ai/tinkerfin-harness"
+Repository = "https://github.com/tinkerfin-ai/tinkerfin-harness"
+Issues = "https://github.com/tinkerfin-ai/tinkerfin-harness/issues"
+
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+tinkerfin_langgraph_store = ["py.typed"]

tinkerfin_langgraph_store-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tinkerfin_langgraph_store-0.1.1/src/tinkerfin_langgraph_store/__init__.py

@@ -0,0 +1,42 @@
+"""Persistent, asynchronous LangGraph memory stores."""
+
+from typing import TYPE_CHECKING
+
+from .errors import LangGraphStoreError as LangGraphStoreError
+from .errors import StoreClosedError as StoreClosedError
+from .errors import StoreCorruptionError as StoreCorruptionError
+from .errors import StoreDriverError as StoreDriverError
+from .errors import StoreSchemaError as StoreSchemaError
+
+if TYPE_CHECKING:
+    from .sqlalchemy import SqlAlchemyStore as SqlAlchemyStore
+
+__all__ = [
+    "LangGraphStoreError",
+    "SqlAlchemyStore",
+    "StoreClosedError",
+    "StoreCorruptionError",
+    "StoreDriverError",
+    "StoreSchemaError",
+]
+
+
+def __getattr__(name: str) -> object:
+    """Load a requested database integration without making it a core dependency."""
+
+    if name == "SqlAlchemyStore":
+        try:
+            from .sqlalchemy import SqlAlchemyStore
+        except ModuleNotFoundError as error:
+            if error.name not in {
+                "sqlalchemy",
+                "tinkerfin_sqlalchemy",
+                "tinkerfin_contracts",
+            }:
+                raise
+            raise ImportError(
+                'Install "tinkerfin-langgraph-store[sqlalchemy]" to use SqlAlchemyStore'
+            ) from error
+        globals()[name] = SqlAlchemyStore
+        return SqlAlchemyStore
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

tinkerfin_langgraph_store-0.1.1/src/tinkerfin_langgraph_store/_lifetime.py

@@ -0,0 +1,61 @@
+"""Track accepted operations without owning the caller's database or task."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Generator
+from contextlib import contextmanager
+
+from .errors import LangGraphStoreError, StoreClosedError
+
+
+class StoreLifetime:
+    """Close admission immediately, then join every accepted operation."""
+
+    def __init__(self) -> None:
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._closed = False
+        self._active = 0
+        self._idle = asyncio.Event()
+        self._idle.set()
+
+    def _check_loop(self) -> None:
+        current = asyncio.get_running_loop()
+        if self._loop is None:
+            self._loop = current
+        elif self._loop is not current:
+            raise LangGraphStoreError(
+                "A Store must be used and closed on one event loop"
+            )
+
+    @contextmanager
+    def operation(self) -> Generator[None]:
+        """Account for an operation, including time waiting for setup or a connection."""
+
+        self._check_loop()
+        if self._closed:
+            raise StoreClosedError("The Store is closed")
+        self._active += 1
+        self._idle.clear()
+        try:
+            yield
+        finally:
+            self._active -= 1
+            if not self._active:
+                self._idle.set()
+
+    async def close(self) -> None:
+        """Wait for accepted work before delivering repeated close-waiter cancellation."""
+
+        self._check_loop()
+        self._closed = True
+        cancellation: asyncio.CancelledError | None = None
+        # Event.wait cancellation only removes this waiter. Accepted operations are
+        # caller-owned and keep their outcome; there is no background shutdown task.
+        while self._active:
+            try:
+                await self._idle.wait()
+            except asyncio.CancelledError as error:
+                cancellation = cancellation or error
+        if cancellation is not None:
+            raise cancellation

tinkerfin_langgraph_store-0.1.1/src/tinkerfin_langgraph_store/_operations.py

@@ -0,0 +1,286 @@
+"""Validate and snapshot LangGraph operations before any database work."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Literal, TypeAlias, TypeGuard
+
+from langgraph.store.base import (
+    GetOp,
+    InvalidNamespaceError,
+    ListNamespacesOp,
+    Op,
+    PutOp,
+    SearchOp,
+)
+
+JsonValue: TypeAlias = (
+    None | bool | int | float | str | list["JsonValue"] | dict[str, "JsonValue"]
+)
+Comparison: TypeAlias = Literal["$eq", "$ne", "$gt", "$gte", "$lt", "$lte"]
+
+
+def _is_dict(value: object) -> TypeGuard[dict[object, object]]:
+    return isinstance(value, dict)
+
+
+def _is_list(value: object) -> TypeGuard[list[object]]:
+    return isinstance(value, list)
+
+
+def json_value(value: object, ancestors: frozenset[int] = frozenset()) -> JsonValue:
+    """Copy finite JSON without coercing keys, tuples, bytes, or custom objects."""
+
+    if value is None or isinstance(value, bool | int):
+        return value
+    if isinstance(value, str):
+        value.encode("utf-8")
+        return value
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            raise ValueError("Store JSON numbers must be finite")
+        return value
+    if id(value) in ancestors:
+        raise ValueError("Store JSON must not contain cycles")
+    parents = ancestors | {id(value)}
+    if _is_list(value):
+        return [json_value(item, parents) for item in value]
+    if _is_dict(value):
+        result: dict[str, JsonValue] = {}
+        for key, item in value.items():
+            if not isinstance(key, str):
+                raise TypeError("Store JSON object keys must be strings")
+            key.encode("utf-8")
+            result[key] = json_value(item, parents)
+        return result
+    raise TypeError("Store values must contain only JSON types")
+
+
+def json_object(value: object) -> dict[str, JsonValue]:
+    """Require a JSON object while keeping null available as a delete operation."""
+
+    copied = json_value(value)
+    if not isinstance(copied, dict):
+        raise TypeError("Store document values must be JSON objects")
+    return copied
+
+
+def encode_json(value: JsonValue) -> str:
+    """Serialize validated JSON, preserving Unicode and integer precision."""
+
+    return json.dumps(value, ensure_ascii=True, allow_nan=False, separators=(",", ":"))
+
+
+def _equality_value(value: JsonValue) -> JsonValue:
+    if value is None:
+        return ["null"]
+    if isinstance(value, bool):
+        return ["bool", value]
+    if isinstance(value, int | float):
+        numerator, denominator = (
+            (value, 1) if isinstance(value, int) else value.as_integer_ratio()
+        )
+        return ["number", str(numerator), str(denominator)]
+    if isinstance(value, str):
+        return ["string", value]
+    if isinstance(value, list):
+        return ["array", [_equality_value(item) for item in value]]
+    return ["object", [[key, _equality_value(value[key])] for key in sorted(value)]]
+
+
+def equality_key(value: JsonValue) -> str:
+    """Encode exact typed equality, including equal integral floats and integers."""
+
+    return encode_json(_equality_value(value)).encode("ascii").hex()
+
+
+def digest(value: str) -> bytes:
+    """Build a compact index key whose full identity is stored and checked separately."""
+
+    return hashlib.sha256(value.encode("utf-8")).digest()
+
+
+def namespace_text(namespace: tuple[str, ...]) -> str:
+    """Encode tuple ordering and complete labels without database collation rules."""
+
+    return ".".join(label.encode("utf-8").hex() for label in namespace)
+
+
+def decode_namespace(value: str) -> tuple[str, ...]:
+    """Recover complete labels, including the empty tuple used by max_depth=0."""
+
+    return (
+        tuple(bytes.fromhex(label).decode("utf-8") for label in value.split("."))
+        if value
+        else ()
+    )
+
+
+def _namespace(value: tuple[str, ...], *, document: bool) -> tuple[str, ...]:
+    if not isinstance(value, tuple):
+        raise InvalidNamespaceError("Namespace must be a tuple of labels")
+    if document and not value:
+        raise InvalidNamespaceError("Document namespace cannot be empty")
+    for label in value:
+        if not isinstance(label, str) or not label or "." in label:
+            raise InvalidNamespaceError(
+                "Namespace labels must be non-empty strings without periods"
+            )
+        label.encode("utf-8")
+    if document and value[0] == "langgraph":
+        raise InvalidNamespaceError("The langgraph root namespace is reserved")
+    return value
+
+
+def _nonnegative(value: int, name: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"{name} must be an integer")
+    if value < 0:
+        raise ValueError(f"{name} must be non-negative")
+    return value
+
+
+@dataclass(frozen=True, slots=True)
+class Get:
+    """A validated exact document lookup."""
+
+    namespace: tuple[str, ...]
+    key: str
+
+
+@dataclass(frozen=True, slots=True)
+class Put:
+    """A copied JSON document or an explicit deletion."""
+
+    namespace: tuple[str, ...]
+    key: str
+    value: dict[str, JsonValue] | None
+
+
+@dataclass(frozen=True, slots=True)
+class Filter:
+    """One typed comparison against a literal top-level field."""
+
+    field: str
+    comparison: Comparison
+    value: JsonValue
+
+
+@dataclass(frozen=True, slots=True)
+class Search:
+    """A prefix-scoped query whose filters precede pagination."""
+
+    prefix: tuple[str, ...]
+    filters: tuple[Filter, ...]
+    limit: int
+    offset: int
+
+
+@dataclass(frozen=True, slots=True)
+class ListNamespaces:
+    """Full-path conditions with truncation applied only after matching."""
+
+    conditions: tuple[tuple[Literal["prefix", "suffix"], tuple[str, ...]], ...]
+    max_depth: int | None
+    limit: int
+    offset: int
+
+
+Operation: TypeAlias = Get | Put | Search | ListNamespaces
+
+
+def number_operand(value: JsonValue) -> float:
+    """Require a finite binary64 ordering operand without bool or string coercion."""
+
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        raise TypeError("Store ordering operands must be numbers")
+    try:
+        operand = float(value)
+    except OverflowError as error:
+        raise ValueError(
+            "Store ordering operands must fit finite binary64 precision"
+        ) from error
+    if not math.isfinite(operand):
+        raise ValueError("Store ordering operands must be finite")
+    return operand
+
+
+def _filters(value: object) -> tuple[Filter, ...]:
+    if value is None:
+        return ()
+    copied = json_object(value)
+    result: list[Filter] = []
+    for field, condition in copied.items():
+        comparisons = condition if isinstance(condition, dict) else {"$eq": condition}
+        if not comparisons:
+            raise ValueError("Use $eq for an object-valued filter")
+        for operator, operand in comparisons.items():
+            if operator not in {"$eq", "$ne", "$gt", "$gte", "$lt", "$lte"}:
+                raise ValueError("Unsupported Store filter; use $eq for object values")
+            if operator in {"$gt", "$gte", "$lt", "$lte"}:
+                number_operand(operand)
+            match operator:
+                case "$eq" | "$ne" | "$gt" | "$gte" | "$lt" | "$lte":
+                    result.append(Filter(field, operator, operand))
+                case _:
+                    raise ValueError("Unsupported Store filter operator")
+    return tuple(result)
+
+
+def prepare_operations(operations: Iterable[Op]) -> tuple[Operation, ...]:
+    """Consume inputs once and reject the entire invalid batch before I/O."""
+
+    result: list[Operation] = []
+    for op in operations:
+        if isinstance(op, GetOp | PutOp):
+            namespace = _namespace(op.namespace, document=True)
+            if not isinstance(op.key, str):
+                raise TypeError("Store document keys must be strings")
+            op.key.encode("utf-8")
+            if isinstance(op, PutOp):
+                if op.ttl is not None:
+                    raise NotImplementedError("This Store does not support TTL")
+                if op.index is not None and op.index is not False:
+                    raise NotImplementedError(
+                        "This Store does not support vector indexing"
+                    )
+                value = None if op.value is None else json_object(op.value)
+                result.append(Put(namespace, op.key, value))
+            else:
+                result.append(Get(namespace, op.key))
+        elif isinstance(op, SearchOp):
+            if op.query is not None:
+                raise NotImplementedError("This Store does not support semantic search")
+            result.append(
+                Search(
+                    _namespace(op.namespace_prefix, document=False),
+                    _filters(op.filter),
+                    _nonnegative(op.limit, "limit"),
+                    _nonnegative(op.offset, "offset"),
+                )
+            )
+        elif isinstance(op, ListNamespacesOp):
+            conditions: list[tuple[Literal["prefix", "suffix"], tuple[str, ...]]] = []
+            for condition in op.match_conditions or ():
+                if condition.match_type not in {"prefix", "suffix"}:
+                    raise ValueError("Namespace match type must be prefix or suffix")
+                conditions.append(
+                    (condition.match_type, _namespace(condition.path, document=False))
+                )
+            result.append(
+                ListNamespaces(
+                    tuple(conditions),
+                    None
+                    if op.max_depth is None
+                    else _nonnegative(op.max_depth, "max_depth"),
+                    _nonnegative(op.limit, "limit"),
+                    _nonnegative(op.offset, "offset"),
+                )
+            )
+        else:
+            raise TypeError("Unsupported LangGraph Store operation")
+    return tuple(result)