atomicmemory 1.0.0__py3-none-any.whl

atomicmemory/providers/atomicmemory/async_handle_impl.py

@@ -0,0 +1,198 @@
+"""Async AtomicMemoryHandle root implementation.
+
+Async counterpart of :mod:`atomicmemory.providers.atomicmemory.handle_impl`.
+Reuses the same scope mappers, body construction, and response shaping
+helpers; the only difference is awaiting the HTTP transport.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+from urllib.parse import quote, urlencode
+
+import httpx
+
+from atomicmemory.core.errors import ProviderError
+from atomicmemory.providers.atomicmemory.agents import AsyncAtomicMemoryAgents
+from atomicmemory.providers.atomicmemory.audit import AsyncAtomicMemoryAudit
+from atomicmemory.providers.atomicmemory.config_handle import AsyncAtomicMemoryConfig
+from atomicmemory.providers.atomicmemory.handle import (
+    AtomicMemoryIngestInput,
+    AtomicMemoryIngestResult,
+    AtomicMemoryListOptions,
+    AtomicMemoryListResultPage,
+    AtomicMemoryMemory,
+    AtomicMemorySearchRequest,
+    AtomicMemorySearchResultPage,
+    MemoryScope,
+    WorkspaceScope,
+)
+from atomicmemory.providers.atomicmemory.handle_impl import (
+    _assert_list_options_scope_compat,
+    _coerce_list_options,
+    _map_search_response,
+    _to_atomic_memory,
+)
+from atomicmemory.providers.atomicmemory.http import (
+    HttpOptions,
+    afetch_json,
+    afetch_json_or_none,
+    afetch_void,
+)
+from atomicmemory.providers.atomicmemory.lessons import AsyncAtomicMemoryLessons
+from atomicmemory.providers.atomicmemory.lifecycle import AsyncAtomicMemoryLifecycle
+from atomicmemory.providers.atomicmemory.scope_mapper import (
+    assert_scope_allows_visibility,
+    scope_to_fields,
+    scope_to_query_pairs,
+    strip_agent_scope,
+)
+
+Route = Callable[[str], str]
+
+
+class AsyncAtomicMemoryHandle:
+    """Async typed handle for AtomicMemory-specific routes."""
+
+    def __init__(self, client: httpx.AsyncClient, http: HttpOptions, route: Route) -> None:
+        self._client = client
+        self._http = http
+        self._route = route
+        self.lifecycle = AsyncAtomicMemoryLifecycle(client, http, route)
+        self.audit = AsyncAtomicMemoryAudit(client, http, route)
+        self.lessons = AsyncAtomicMemoryLessons(client, http, route)
+        self.config = AsyncAtomicMemoryConfig(client, http, route)
+        self.agents = AsyncAtomicMemoryAgents(client, http, route)
+
+    async def ingest_full(self, input: AtomicMemoryIngestInput, scope: MemoryScope) -> AtomicMemoryIngestResult:
+        return await self._post_ingest(self._route("/memories/ingest"), input, scope)
+
+    async def ingest_quick(
+        self,
+        input: AtomicMemoryIngestInput,
+        scope: MemoryScope,
+        skip_extraction: bool = False,
+    ) -> AtomicMemoryIngestResult:
+        return await self._post_ingest(
+            self._route("/memories/ingest/quick"), input, scope, skip_extraction=skip_extraction
+        )
+
+    async def search(self, request: AtomicMemorySearchRequest, scope: MemoryScope) -> AtomicMemorySearchResultPage:
+        return await self._post_search(self._route("/memories/search"), request, scope)
+
+    async def search_fast(self, request: AtomicMemorySearchRequest, scope: MemoryScope) -> AtomicMemorySearchResultPage:
+        return await self._post_search(self._route("/memories/search/fast"), request, scope)
+
+    async def expand(self, refs: list[str], scope: MemoryScope) -> list[AtomicMemoryMemory]:
+        body: dict[str, Any] = {**scope_to_fields(scope), "memory_ids": refs}
+        raw = await afetch_json(
+            self._client,
+            self._http,
+            self._route("/memories/expand"),
+            method="POST",
+            json=body,
+        )
+        echoed = strip_agent_scope(scope)
+        return [_to_atomic_memory(m, echoed) for m in raw.get("memories", [])]
+
+    async def list(
+        self,
+        scope: MemoryScope,
+        options: AtomicMemoryListOptions | dict[str, Any] | None = None,
+    ) -> AtomicMemoryListResultPage:
+        opts = _coerce_list_options(options)
+        _assert_list_options_scope_compat(scope, opts)
+        pairs: list[tuple[str, str]] = scope_to_query_pairs(scope)
+        if opts.limit is not None:
+            pairs.append(("limit", str(opts.limit)))
+        if opts.offset is not None:
+            pairs.append(("offset", str(opts.offset)))
+        if opts.source_site:
+            pairs.append(("source_site", opts.source_site))
+        if opts.episode_id:
+            pairs.append(("episode_id", opts.episode_id))
+        path = self._route(f"/memories/list?{urlencode(pairs)}")
+        raw = await afetch_json(self._client, self._http, path)
+        limit = opts.limit if opts.limit is not None else 20
+        offset = opts.offset if opts.offset is not None else 0
+        memories_raw = raw.get("memories", [])
+        next_offset = offset + len(memories_raw)
+        has_more = len(memories_raw) == limit
+        echoed = strip_agent_scope(scope)
+        return AtomicMemoryListResultPage(
+            memories=[_to_atomic_memory(m, echoed) for m in memories_raw],
+            count=raw.get("count", len(memories_raw)),
+            cursor=str(next_offset) if has_more else None,
+        )
+
+    async def get(self, id: str, scope: MemoryScope) -> AtomicMemoryMemory | None:
+        path = self._route(f"/memories/{quote(id, safe='')}?{urlencode(scope_to_query_pairs(scope))}")
+        raw = await afetch_json_or_none(self._client, self._http, path)
+        if raw is None:
+            return None
+        return _to_atomic_memory(raw, strip_agent_scope(scope))
+
+    async def delete(self, id: str, scope: MemoryScope) -> None:
+        path = self._route(f"/memories/{quote(id, safe='')}?{urlencode(scope_to_query_pairs(scope))}")
+        try:
+            await afetch_void(self._client, self._http, path, method="DELETE")
+        except ProviderError as exc:
+            if exc.status_code == 404:
+                return
+            raise
+
+    async def _post_ingest(
+        self,
+        path: str,
+        input: AtomicMemoryIngestInput,
+        scope: MemoryScope,
+        *,
+        skip_extraction: bool = False,
+    ) -> AtomicMemoryIngestResult:
+        assert_scope_allows_visibility(scope, input.visibility)
+        body: dict[str, Any] = {
+            **scope_to_fields(scope),
+            "conversation": input.conversation,
+            "source_site": input.source_site,
+            "source_url": input.source_url or "",
+        }
+        if isinstance(scope, WorkspaceScope) and input.visibility:
+            body["visibility"] = input.visibility
+        if input.config_override is not None:
+            body["config_override"] = input.config_override
+        if skip_extraction:
+            body["skip_extraction"] = True
+        raw = await afetch_json(self._client, self._http, path, method="POST", json=body)
+        return AtomicMemoryIngestResult.model_validate(raw)
+
+    async def _post_search(
+        self,
+        path: str,
+        request: AtomicMemorySearchRequest,
+        scope: MemoryScope,
+    ) -> AtomicMemorySearchResultPage:
+        body: dict[str, Any] = {
+            **scope_to_fields(scope, include_agent_scope=True),
+            "query": request.query,
+        }
+        if request.limit is not None:
+            body["limit"] = request.limit
+        if request.threshold is not None:
+            body["threshold"] = request.threshold
+        if request.as_of is not None:
+            body["as_of"] = request.as_of.isoformat()
+        if request.retrieval_mode is not None:
+            body["retrieval_mode"] = request.retrieval_mode
+        if request.token_budget is not None:
+            body["token_budget"] = request.token_budget
+        if request.namespace_scope is not None:
+            body["namespace_scope"] = request.namespace_scope
+        if request.source_site is not None:
+            body["source_site"] = request.source_site
+        if request.skip_repair:
+            body["skip_repair"] = True
+        if request.config_override is not None:
+            body["config_override"] = request.config_override
+        raw = await afetch_json(self._client, self._http, path, method="POST", json=body)
+        return _map_search_response(raw, scope)

atomicmemory/providers/atomicmemory/async_provider.py

@@ -0,0 +1,245 @@
+"""Async AtomicMemoryProvider — V3 core + Packager + TemporalSearch + Versioner + Health.
+
+Async counterpart of `provider.py`. Uses :class:`httpx.AsyncClient` and
+the ``a*`` HTTP helpers; body construction is delegated to the shared
+private builders defined alongside the sync provider.
+
+The ``atomicmemory.*`` handle namespace is wired in
+``async_handle_impl.py``; this module owns provider lifecycle + the
+``do_*`` overrides on :class:`BaseAsyncMemoryProvider`.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+import httpx
+
+from atomicmemory.core.errors import ProviderError
+from atomicmemory.memory.provider import BaseAsyncMemoryProvider
+from atomicmemory.memory.types import (
+    Capabilities,
+    CapabilitiesExtensions,
+    CapabilitiesRequiredScope,
+    ContextPackage,
+    CustomExtensionMeta,
+    HealthStatus,
+    IngestInput,
+    IngestResult,
+    ListRequest,
+    ListResultPage,
+    Memory,
+    MemoryRef,
+    MemoryVersion,
+    PackageRequest,
+    SearchRequest,
+    SearchResult,
+    SearchResultPage,
+)
+from atomicmemory.providers.atomicmemory.async_handle_impl import AsyncAtomicMemoryHandle
+from atomicmemory.providers.atomicmemory.config import AtomicMemoryProviderConfig
+from atomicmemory.providers.atomicmemory.handle import ATOMICMEMORY_EXTENSION_NAMES
+from atomicmemory.providers.atomicmemory.http import (
+    HttpOptions,
+    adelete_ignore_404,
+    afetch_json,
+    afetch_json_or_none,
+)
+from atomicmemory.providers.atomicmemory.mappers import (
+    to_ingest_result,
+    to_memory,
+    to_memory_version,
+    to_search_result,
+)
+from atomicmemory.providers.atomicmemory.path import normalize_api_version
+from atomicmemory.providers.atomicmemory.provider import (
+    _build_ingest_body,
+    _build_package_body,
+    _build_search_body,
+    _qs,
+)
+
+_ATOMICMEMORY_CUSTOM_EXTENSIONS: dict[str, CustomExtensionMeta] = {
+    name: CustomExtensionMeta(version="1.0.0") for name in ATOMICMEMORY_EXTENSION_NAMES
+}
+
+
+class AsyncAtomicMemoryProvider(BaseAsyncMemoryProvider):
+    """Async HTTP-backed V3 provider for atomicmemory-core."""
+
+    name = "atomicmemory"
+
+    def __init__(self, config: AtomicMemoryProviderConfig) -> None:
+        self._config = config
+        self._http_options = HttpOptions(
+            api_url=config.api_url.rstrip("/"),
+            api_key=config.api_key,
+            timeout_seconds=config.timeout_seconds,
+        )
+        self._api_prefix = normalize_api_version(config.api_version)
+        self._client: httpx.AsyncClient | None = None
+        self._handle: AsyncAtomicMemoryHandle | None = None
+        self._initialized = False
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def initialize(self) -> None:
+        if self._client is None:
+            self._client = httpx.AsyncClient()
+        if self._handle is None:
+            self._handle = AsyncAtomicMemoryHandle(self._client, self._http_options, self._route)
+        self._initialized = True
+
+    async def close(self) -> None:
+        self._handle = None
+        if self._client is not None:
+            await self._client.aclose()
+            self._client = None
+        self._initialized = False
+
+    # ------------------------------------------------------------------
+    # V3 core methods
+    # ------------------------------------------------------------------
+
+    async def do_ingest(self, input: IngestInput) -> IngestResult:
+        body = _build_ingest_body(input)
+        path = self._route("/memories/ingest/quick" if input.mode == "verbatim" else "/memories/ingest")
+        raw = await afetch_json(self._require_client(), self._http_options, path, method="POST", json=body)
+        return to_ingest_result(raw)
+
+    async def do_search(self, request: SearchRequest) -> SearchResultPage:
+        body = _build_search_body(request)
+        raw = await afetch_json(
+            self._require_client(),
+            self._http_options,
+            self._route("/memories/search/fast"),
+            method="POST",
+            json=body,
+        )
+        return SearchResultPage(
+            results=[to_search_result(m, request.scope) for m in raw.get("memories", [])],
+        )
+
+    async def do_get(self, ref: MemoryRef) -> Memory | None:
+        path = self._route(f"/memories/{ref.id}?user_id={_qs(ref.scope.user)}")
+        raw = await afetch_json_or_none(self._require_client(), self._http_options, path)
+        if raw is None:
+            return None
+        return to_memory(raw, ref.scope)
+
+    async def do_delete(self, ref: MemoryRef) -> None:
+        path = self._route(f"/memories/{ref.id}?user_id={_qs(ref.scope.user)}")
+        await adelete_ignore_404(self._require_client(), self._http_options, path)
+
+    async def do_list(self, request: ListRequest) -> ListResultPage:
+        offset = int(request.cursor) if request.cursor else 0
+        limit = request.limit if request.limit is not None else 20
+        path = self._route(f"/memories/list?user_id={_qs(request.scope.user)}&limit={limit}&offset={offset}")
+        raw = await afetch_json(self._require_client(), self._http_options, path)
+        memories = [to_memory(m, request.scope) for m in raw.get("memories", [])]
+        next_offset = offset + len(memories)
+        cursor = str(next_offset) if len(memories) == limit else None
+        return ListResultPage(memories=memories, cursor=cursor)
+
+    # ------------------------------------------------------------------
+    # Capabilities + extension dispatch
+    # ------------------------------------------------------------------
+
+    def capabilities(self) -> Capabilities:
+        return Capabilities(
+            ingest_modes=["text", "messages", "verbatim"],
+            required_scope=CapabilitiesRequiredScope(default=["user"]),
+            extensions=CapabilitiesExtensions(
+                package=True,
+                temporal=True,
+                versioning=True,
+                health=True,
+            ),
+            custom_extensions=_ATOMICMEMORY_CUSTOM_EXTENSIONS,
+        )
+
+    def get_extension(self, name: str) -> Any | None:
+        if name in {"package", "temporal", "versioning", "health"}:
+            return self
+        if name == "atomicmemory.base":
+            return self._handle
+        if name == "atomicmemory.lifecycle" and self._handle is not None:
+            return self._handle.lifecycle
+        if name == "atomicmemory.audit" and self._handle is not None:
+            return self._handle.audit
+        if name == "atomicmemory.lessons" and self._handle is not None:
+            return self._handle.lessons
+        if name == "atomicmemory.config" and self._handle is not None:
+            return self._handle.config
+        if name == "atomicmemory.agents" and self._handle is not None:
+            return self._handle.agents
+        return None
+
+    # ------------------------------------------------------------------
+    # V3 extensions implemented inline
+    # ------------------------------------------------------------------
+
+    async def package(self, request: PackageRequest) -> ContextPackage:
+        body = _build_package_body(request)
+        raw = await afetch_json(
+            self._require_client(),
+            self._http_options,
+            self._route("/memories/search"),
+            method="POST",
+            json=body,
+        )
+        results: list[SearchResult] = [to_search_result(m, request.scope) for m in raw.get("memories", [])]
+        budget_constrained = raw.get("budget_constrained")
+        if not isinstance(budget_constrained, bool):
+            raise ValueError(
+                "atomicmemory async provider.package: backend response missing required boolean "
+                "field `budget_constrained`"
+            )
+        return ContextPackage(
+            text=raw.get("injection_text") or "",
+            results=results,
+            tokens=raw.get("estimated_context_tokens") or 0,
+            budget_constrained=budget_constrained,
+        )
+
+    async def search_as_of(self, request: SearchRequest, as_of: datetime) -> SearchResultPage:
+        body = _build_search_body(request)
+        body["as_of"] = as_of.isoformat()
+        raw = await afetch_json(
+            self._require_client(),
+            self._http_options,
+            self._route("/memories/search"),
+            method="POST",
+            json=body,
+        )
+        return SearchResultPage(
+            results=[to_search_result(m, request.scope) for m in raw.get("memories", [])],
+        )
+
+    async def history(self, ref: MemoryRef) -> list[MemoryVersion]:
+        path = self._route(f"/memories/{ref.id}/audit?user_id={_qs(ref.scope.user)}")
+        raw = await afetch_json(self._require_client(), self._http_options, path)
+        return [to_memory_version(entry) for entry in raw.get("trail", [])]
+
+    async def health(self) -> HealthStatus:
+        path = self._route("/memories/health")
+        raw = await afetch_json(self._require_client(), self._http_options, path)
+        return HealthStatus(ok=raw.get("status") == "ok")
+
+    # ------------------------------------------------------------------
+    # Internals
+    # ------------------------------------------------------------------
+
+    def _route(self, path: str) -> str:
+        return f"{self._api_prefix}{path}"
+
+    def _require_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            raise ProviderError(
+                "AsyncAtomicMemoryProvider is not initialized. Call initialize() first.",
+                provider=self.name,
+            )
+        return self._client

atomicmemory/providers/atomicmemory/audit.py

@@ -0,0 +1,74 @@
+"""AtomicMemoryAudit — mutation audit category.
+
+Port of the audit section of
+`atomicmemory-sdk/src/memory/atomicmemory-provider/handle-impl.ts:720-880`.
+All routes are user-scoped.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from urllib.parse import quote
+
+import httpx
+
+from atomicmemory.providers.atomicmemory.handle import (
+    AuditTrailResult,
+    MutationSummary,
+    RecentMutationsResult,
+)
+from atomicmemory.providers.atomicmemory.http import HttpOptions, afetch_json, fetch_json
+
+Route = Callable[[str], str]
+
+
+class AtomicMemoryAudit:
+    """Audit-trail accessors for a user's claim-version history."""
+
+    def __init__(self, client: httpx.Client, http: HttpOptions, route: Route) -> None:
+        self._client = client
+        self._http = http
+        self._route = route
+
+    def summary(self, user_id: str) -> MutationSummary:
+        path = self._route(f"/memories/audit/summary?user_id={quote(user_id, safe='')}")
+        raw = fetch_json(self._client, self._http, path)
+        return MutationSummary.model_validate(raw)
+
+    def recent(self, user_id: str, limit: int | None = None) -> RecentMutationsResult:
+        url = f"/memories/audit/recent?user_id={quote(user_id, safe='')}"
+        if limit is not None:
+            url += f"&limit={limit}"
+        raw = fetch_json(self._client, self._http, self._route(url))
+        return RecentMutationsResult.model_validate(raw)
+
+    def trail(self, memory_id: str, user_id: str) -> AuditTrailResult:
+        path = self._route(f"/memories/{quote(memory_id, safe='')}/audit?user_id={quote(user_id, safe='')}")
+        raw = fetch_json(self._client, self._http, path)
+        return AuditTrailResult.model_validate(raw)
+
+
+class AsyncAtomicMemoryAudit:
+    """Async counterpart of :class:`AtomicMemoryAudit`."""
+
+    def __init__(self, client: httpx.AsyncClient, http: HttpOptions, route: Route) -> None:
+        self._client = client
+        self._http = http
+        self._route = route
+
+    async def summary(self, user_id: str) -> MutationSummary:
+        path = self._route(f"/memories/audit/summary?user_id={quote(user_id, safe='')}")
+        raw = await afetch_json(self._client, self._http, path)
+        return MutationSummary.model_validate(raw)
+
+    async def recent(self, user_id: str, limit: int | None = None) -> RecentMutationsResult:
+        url = f"/memories/audit/recent?user_id={quote(user_id, safe='')}"
+        if limit is not None:
+            url += f"&limit={limit}"
+        raw = await afetch_json(self._client, self._http, self._route(url))
+        return RecentMutationsResult.model_validate(raw)
+
+    async def trail(self, memory_id: str, user_id: str) -> AuditTrailResult:
+        path = self._route(f"/memories/{quote(memory_id, safe='')}/audit?user_id={quote(user_id, safe='')}")
+        raw = await afetch_json(self._client, self._http, path)
+        return AuditTrailResult.model_validate(raw)

atomicmemory/providers/atomicmemory/config.py

@@ -0,0 +1,38 @@
+"""AtomicMemory provider configuration.
+
+Port of `atomicmemory-sdk/src/memory/atomicmemory-provider/types.ts:1-36`.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+ATOMICMEMORY_DEFAULT_TIMEOUT_SECONDS: float = 30.0
+"""Default request timeout (seconds). Mirrors TS ``ATOMICMEMORY_DEFAULT_TIMEOUT`` (ms)."""
+
+ATOMICMEMORY_DEFAULT_API_VERSION: str = "v1"
+"""Matches core's mount at `atomicmemory-core/src/app/create-app.ts:31-32`."""
+
+
+class AtomicMemoryProviderConfig(BaseModel):
+    """Inputs to construct an AtomicMemoryProvider."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    api_url: str = Field(alias="apiUrl")
+    """Base URL of the atomicmemory-core instance, e.g. ``http://localhost:3050``."""
+
+    api_key: str | None = Field(default=None, alias="apiKey")
+    """Optional bearer token forwarded as ``Authorization: Bearer <api_key>``."""
+
+    timeout_seconds: float = Field(
+        default=ATOMICMEMORY_DEFAULT_TIMEOUT_SECONDS,
+        alias="timeoutSeconds",
+    )
+    """Per-request timeout (seconds). Default 30s. Pre-port note: TS uses ms."""
+
+    api_version: str = Field(
+        default=ATOMICMEMORY_DEFAULT_API_VERSION,
+        alias="apiVersion",
+    )
+    """API-version segment prepended to every route path (e.g. ``v1`` → ``/v1/...``)."""

atomicmemory/providers/atomicmemory/config_handle.py

@@ -0,0 +1,123 @@
+"""AtomicMemoryConfig — runtime config category.
+
+Port of the config section of
+`atomicmemory-sdk/src/memory/atomicmemory-provider/handle-impl.ts:1008-1098`.
+``health`` is global; ``update_config`` is gated on
+``CORE_RUNTIME_CONFIG_MUTATION_ENABLED`` server-side.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from typing import Any
+
+import httpx
+
+from atomicmemory.providers.atomicmemory.handle import (
+    AtomicMemoryHealthStatus,
+    ConfigUpdateResult,
+    ConfigUpdates,
+    HealthConfig,
+)
+from atomicmemory.providers.atomicmemory.http import HttpOptions, afetch_json, fetch_json
+
+Route = Callable[[str], str]
+
+_SNAKE_TO_CAMEL_RE = re.compile(r"_([a-z])")
+
+
+def _snake_to_camel(value: str) -> str:
+    """Convert a snake_case identifier to camelCase.
+
+    Mirrors TS handle-impl.ts: applied field names are echoed back to
+    Python in the same camelCase the TS SDK uses. Pure cosmetic; the
+    actual config payload is already mapped via Pydantic.
+    """
+    return _SNAKE_TO_CAMEL_RE.sub(lambda m: m.group(1).upper(), value)
+
+
+class AtomicMemoryConfig:
+    """Runtime configuration accessors."""
+
+    def __init__(self, client: httpx.Client, http: HttpOptions, route: Route) -> None:
+        self._client = client
+        self._http = http
+        self._route = route
+
+    def health(self) -> AtomicMemoryHealthStatus:
+        raw = fetch_json(self._client, self._http, self._route("/memories/health"))
+        return AtomicMemoryHealthStatus.model_validate(
+            {"status": raw.get("status", "ok"), "config": HealthConfig.model_validate(raw["config"])}
+        )
+
+    def update_config(self, updates: ConfigUpdates | dict[str, Any]) -> ConfigUpdateResult:
+        if isinstance(updates, dict):
+            updates = ConfigUpdates.model_validate(updates)
+        body: dict[str, Any] = {}
+        if updates.similarity_threshold is not None:
+            body["similarity_threshold"] = updates.similarity_threshold
+        if updates.audn_candidate_threshold is not None:
+            body["audn_candidate_threshold"] = updates.audn_candidate_threshold
+        if updates.clarification_conflict_threshold is not None:
+            body["clarification_conflict_threshold"] = updates.clarification_conflict_threshold
+        if updates.max_search_results is not None:
+            body["max_search_results"] = updates.max_search_results
+        raw = fetch_json(
+            self._client,
+            self._http,
+            self._route("/memories/config"),
+            method="PUT",
+            json=body,
+        )
+        applied = [_snake_to_camel(name) for name in raw.get("applied", [])]
+        return ConfigUpdateResult.model_validate(
+            {
+                "applied": applied,
+                "config": HealthConfig.model_validate(raw["config"]),
+                "note": raw.get("note", ""),
+            }
+        )
+
+
+class AsyncAtomicMemoryConfig:
+    """Async counterpart of :class:`AtomicMemoryConfig`."""
+
+    def __init__(self, client: httpx.AsyncClient, http: HttpOptions, route: Route) -> None:
+        self._client = client
+        self._http = http
+        self._route = route
+
+    async def health(self) -> AtomicMemoryHealthStatus:
+        raw = await afetch_json(self._client, self._http, self._route("/memories/health"))
+        return AtomicMemoryHealthStatus.model_validate(
+            {"status": raw.get("status", "ok"), "config": HealthConfig.model_validate(raw["config"])}
+        )
+
+    async def update_config(self, updates: ConfigUpdates | dict[str, Any]) -> ConfigUpdateResult:
+        if isinstance(updates, dict):
+            updates = ConfigUpdates.model_validate(updates)
+        body: dict[str, Any] = {}
+        if updates.similarity_threshold is not None:
+            body["similarity_threshold"] = updates.similarity_threshold
+        if updates.audn_candidate_threshold is not None:
+            body["audn_candidate_threshold"] = updates.audn_candidate_threshold
+        if updates.clarification_conflict_threshold is not None:
+            body["clarification_conflict_threshold"] = updates.clarification_conflict_threshold
+        if updates.max_search_results is not None:
+            body["max_search_results"] = updates.max_search_results
+        raw = await afetch_json(
+            self._client,
+            self._http,
+            self._route("/memories/config"),
+            method="PUT",
+            json=body,
+        )
+        applied = [_snake_to_camel(name) for name in raw.get("applied", [])]
+        return ConfigUpdateResult.model_validate(
+            {
+                "applied": applied,
+                "config": HealthConfig.model_validate(raw["config"]),
+                "note": raw.get("note", ""),
+            }
+        )