ai-memory-layer-client 4.0.0__tar.gz

ai_memory_layer_client-4.0.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: ai-memory-layer-client
+Version: 4.0.0
+Summary: Python REST client for the memory-layer server
+License-Expression: MIT
+Project-URL: Repository, https://github.com/gstarling/memory-layer
+Project-URL: Documentation, https://github.com/gstarling/memory-layer/tree/main/clients/python
+Project-URL: Issues, https://github.com/gstarling/memory-layer/issues
+Keywords: ai,memory,agent,retrieval
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1.0.0,>=0.27.0
+Provides-Extra: dev
+Requires-Dist: build<2.0.0,>=1.2.0; extra == "dev"
+Requires-Dist: pytest<9.0.0,>=8.3.0; extra == "dev"
+Requires-Dist: pytest-asyncio<1.0.0,>=0.24.0; extra == "dev"
+Requires-Dist: pytest-httpx<1.0.0,>=0.35.0; extra == "dev"
+Requires-Dist: ruff<1.0.0,>=0.7.0; extra == "dev"
+
+# memory-layer-client
+
+Python client for the `memory-layer` HTTP service.
+
+## Install
+
+```bash
+pip install memory-layer-client
+```
+
+For local development and tests:
+
+```bash
+pip install -e '.[dev]'
+pytest
+```
+
+## Quick Start
+
+```python
+from memory_layer_client import MemoryClient, MemoryRuntimeClient, MemoryScope
+
+client = MemoryClient(
+    "http://localhost:3100",
+    api_key="dev-key",
+    default_scope=MemoryScope(
+        tenant_id="acme",
+        system_id="python-worker",
+        collaboration_id="release-42",
+        scope_id="run-42",
+    ),
+)
+runtime = MemoryRuntimeClient(client)
+
+result = runtime.run_turn(
+    "Remember that deployments must stay blue-green.",
+    lambda prepared: "Stored. I will keep rollout constraints in memory.",
+)
+print(result.prepared.prompt)
+```
+
+## Async Client
+
+```python
+import asyncio
+from memory_layer_client import AsyncMemoryClient, AsyncMemoryRuntimeClient
+
+async def main() -> None:
+    client = AsyncMemoryClient("http://localhost:3100", api_key="dev-key")
+    runtime = AsyncMemoryRuntimeClient(client)
+    result = await runtime.run_turn(
+        "Track migration status.",
+        lambda prepared: "I will keep the migration status in memory.",
+    )
+    health = await client.health()
+    print(result.prepared.context.token_estimate, health.active_turn_count)
+    await client.aclose()
+
+asyncio.run(main())
+```
+
+## Scope Resolution
+
+Each request can inherit a default scope and override it per call. This matches the multi-tenant routing model used by the HTTP server.
+
+`MemoryScope` also supports `collaboration_id`, so Python clients can participate in shared multi-agent workspaces the same way the TypeScript server and SDK do.
+
+## Hosted Runtime And Changes
+
+```python
+from memory_layer_client import MemoryClient, MemoryRuntimeClient
+
+client = MemoryClient("http://localhost:3100")
+runtime = MemoryRuntimeClient(client)
+
+knowledge = client.list_knowledge(limit=20)
+detail = client.inspect_knowledge(knowledge.items[0]["id"])
+changes = client.poll_changes("2026-03-01T00:00:00Z", scope_level="workspace")
+cross_scope = client.search_cross_scope("rollback", scope_level="workspace")
+prepared = runtime.before_model_call("What changed in the shared workspace?")
+print(prepared.prompt)
+for event in client.stream_events(event_types=["knowledge_change"], scope_level="workspace"):
+    print(event.type, event.meta)
+    break
+```
+
+## CLI
+
+```bash
+memory-layer-client --base-url http://localhost:3100 health
+memory-layer-client --base-url http://localhost:3100 search "rollback checklist"
+memory-layer-client --base-url http://localhost:3100 inspect-knowledge --limit 10
+memory-layer-client --base-url http://localhost:3100 run-reverification --admin-key secret
+```

ai_memory_layer_client-4.0.0/README.md

@@ -0,0 +1,94 @@
+# memory-layer-client
+
+Python client for the `memory-layer` HTTP service.
+
+## Install
+
+```bash
+pip install memory-layer-client
+```
+
+For local development and tests:
+
+```bash
+pip install -e '.[dev]'
+pytest
+```
+
+## Quick Start
+
+```python
+from memory_layer_client import MemoryClient, MemoryRuntimeClient, MemoryScope
+
+client = MemoryClient(
+    "http://localhost:3100",
+    api_key="dev-key",
+    default_scope=MemoryScope(
+        tenant_id="acme",
+        system_id="python-worker",
+        collaboration_id="release-42",
+        scope_id="run-42",
+    ),
+)
+runtime = MemoryRuntimeClient(client)
+
+result = runtime.run_turn(
+    "Remember that deployments must stay blue-green.",
+    lambda prepared: "Stored. I will keep rollout constraints in memory.",
+)
+print(result.prepared.prompt)
+```
+
+## Async Client
+
+```python
+import asyncio
+from memory_layer_client import AsyncMemoryClient, AsyncMemoryRuntimeClient
+
+async def main() -> None:
+    client = AsyncMemoryClient("http://localhost:3100", api_key="dev-key")
+    runtime = AsyncMemoryRuntimeClient(client)
+    result = await runtime.run_turn(
+        "Track migration status.",
+        lambda prepared: "I will keep the migration status in memory.",
+    )
+    health = await client.health()
+    print(result.prepared.context.token_estimate, health.active_turn_count)
+    await client.aclose()
+
+asyncio.run(main())
+```
+
+## Scope Resolution
+
+Each request can inherit a default scope and override it per call. This matches the multi-tenant routing model used by the HTTP server.
+
+`MemoryScope` also supports `collaboration_id`, so Python clients can participate in shared multi-agent workspaces the same way the TypeScript server and SDK do.
+
+## Hosted Runtime And Changes
+
+```python
+from memory_layer_client import MemoryClient, MemoryRuntimeClient
+
+client = MemoryClient("http://localhost:3100")
+runtime = MemoryRuntimeClient(client)
+
+knowledge = client.list_knowledge(limit=20)
+detail = client.inspect_knowledge(knowledge.items[0]["id"])
+changes = client.poll_changes("2026-03-01T00:00:00Z", scope_level="workspace")
+cross_scope = client.search_cross_scope("rollback", scope_level="workspace")
+prepared = runtime.before_model_call("What changed in the shared workspace?")
+print(prepared.prompt)
+for event in client.stream_events(event_types=["knowledge_change"], scope_level="workspace"):
+    print(event.type, event.meta)
+    break
+```
+
+## CLI
+
+```bash
+memory-layer-client --base-url http://localhost:3100 health
+memory-layer-client --base-url http://localhost:3100 search "rollback checklist"
+memory-layer-client --base-url http://localhost:3100 inspect-knowledge --limit 10
+memory-layer-client --base-url http://localhost:3100 run-reverification --admin-key secret
+```

ai_memory_layer_client-4.0.0/ai_memory_layer_client.egg-info/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: ai-memory-layer-client
+Version: 4.0.0
+Summary: Python REST client for the memory-layer server
+License-Expression: MIT
+Project-URL: Repository, https://github.com/gstarling/memory-layer
+Project-URL: Documentation, https://github.com/gstarling/memory-layer/tree/main/clients/python
+Project-URL: Issues, https://github.com/gstarling/memory-layer/issues
+Keywords: ai,memory,agent,retrieval
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1.0.0,>=0.27.0
+Provides-Extra: dev
+Requires-Dist: build<2.0.0,>=1.2.0; extra == "dev"
+Requires-Dist: pytest<9.0.0,>=8.3.0; extra == "dev"
+Requires-Dist: pytest-asyncio<1.0.0,>=0.24.0; extra == "dev"
+Requires-Dist: pytest-httpx<1.0.0,>=0.35.0; extra == "dev"
+Requires-Dist: ruff<1.0.0,>=0.7.0; extra == "dev"
+
+# memory-layer-client
+
+Python client for the `memory-layer` HTTP service.
+
+## Install
+
+```bash
+pip install memory-layer-client
+```
+
+For local development and tests:
+
+```bash
+pip install -e '.[dev]'
+pytest
+```
+
+## Quick Start
+
+```python
+from memory_layer_client import MemoryClient, MemoryRuntimeClient, MemoryScope
+
+client = MemoryClient(
+    "http://localhost:3100",
+    api_key="dev-key",
+    default_scope=MemoryScope(
+        tenant_id="acme",
+        system_id="python-worker",
+        collaboration_id="release-42",
+        scope_id="run-42",
+    ),
+)
+runtime = MemoryRuntimeClient(client)
+
+result = runtime.run_turn(
+    "Remember that deployments must stay blue-green.",
+    lambda prepared: "Stored. I will keep rollout constraints in memory.",
+)
+print(result.prepared.prompt)
+```
+
+## Async Client
+
+```python
+import asyncio
+from memory_layer_client import AsyncMemoryClient, AsyncMemoryRuntimeClient
+
+async def main() -> None:
+    client = AsyncMemoryClient("http://localhost:3100", api_key="dev-key")
+    runtime = AsyncMemoryRuntimeClient(client)
+    result = await runtime.run_turn(
+        "Track migration status.",
+        lambda prepared: "I will keep the migration status in memory.",
+    )
+    health = await client.health()
+    print(result.prepared.context.token_estimate, health.active_turn_count)
+    await client.aclose()
+
+asyncio.run(main())
+```
+
+## Scope Resolution
+
+Each request can inherit a default scope and override it per call. This matches the multi-tenant routing model used by the HTTP server.
+
+`MemoryScope` also supports `collaboration_id`, so Python clients can participate in shared multi-agent workspaces the same way the TypeScript server and SDK do.
+
+## Hosted Runtime And Changes
+
+```python
+from memory_layer_client import MemoryClient, MemoryRuntimeClient
+
+client = MemoryClient("http://localhost:3100")
+runtime = MemoryRuntimeClient(client)
+
+knowledge = client.list_knowledge(limit=20)
+detail = client.inspect_knowledge(knowledge.items[0]["id"])
+changes = client.poll_changes("2026-03-01T00:00:00Z", scope_level="workspace")
+cross_scope = client.search_cross_scope("rollback", scope_level="workspace")
+prepared = runtime.before_model_call("What changed in the shared workspace?")
+print(prepared.prompt)
+for event in client.stream_events(event_types=["knowledge_change"], scope_level="workspace"):
+    print(event.type, event.meta)
+    break
+```
+
+## CLI
+
+```bash
+memory-layer-client --base-url http://localhost:3100 health
+memory-layer-client --base-url http://localhost:3100 search "rollback checklist"
+memory-layer-client --base-url http://localhost:3100 inspect-knowledge --limit 10
+memory-layer-client --base-url http://localhost:3100 run-reverification --admin-key secret
+```

ai_memory_layer_client-4.0.0/ai_memory_layer_client.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+ai_memory_layer_client.egg-info/PKG-INFO
+ai_memory_layer_client.egg-info/SOURCES.txt
+ai_memory_layer_client.egg-info/dependency_links.txt
+ai_memory_layer_client.egg-info/entry_points.txt
+ai_memory_layer_client.egg-info/requires.txt
+ai_memory_layer_client.egg-info/top_level.txt
+memory_layer_client/__init__.py
+memory_layer_client/cli.py
+memory_layer_client/client.py
+memory_layer_client/models.py
+memory_layer_client/py.typed
+memory_layer_client/runtime.py
+tests/test_async_client.py
+tests/test_cli.py
+tests/test_client.py
+tests/test_models.py
+tests/test_runtime.py

ai_memory_layer_client-4.0.0/ai_memory_layer_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ai_memory_layer_client-4.0.0/ai_memory_layer_client.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+memory-layer-client = memory_layer_client.cli:main

ai_memory_layer_client-4.0.0/ai_memory_layer_client.egg-info/requires.txt

@@ -0,0 +1,8 @@
+httpx<1.0.0,>=0.27.0
+
+[dev]
+build<2.0.0,>=1.2.0
+pytest<9.0.0,>=8.3.0
+pytest-asyncio<1.0.0,>=0.24.0
+pytest-httpx<1.0.0,>=0.35.0
+ruff<1.0.0,>=0.7.0

ai_memory_layer_client-4.0.0/ai_memory_layer_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+memory_layer_client

ai_memory_layer_client-4.0.0/memory_layer_client/__init__.py

@@ -0,0 +1,114 @@
+"""memory-layer-client: Python REST client for the memory-layer server."""
+
+from .client import AsyncMemoryClient, MemoryClient, MemoryLayerError
+from .models import (
+    ActorRef,
+    Association,
+    AssociationGraph,
+    AssociationNode,
+    AuditListResponse,
+    ChangeListResponse,
+    CoordinationState,
+    CognitiveMemoryItem,
+    CognitiveSearchHit,
+    CognitiveSearchResult,
+    CompactionLogListResponse,
+    CompactResponse,
+    ContextResponse,
+    CreatedResource,
+    DueReverificationResponse,
+    EpisodeRecap,
+    EpisodeSearchResponse,
+    EpisodeSourceReference,
+    EpisodeSummary,
+    HandoffListResponse,
+    HandoffRecord,
+    HealthResponse,
+    KnowledgeInspectionResponse,
+    KnowledgeListResponse,
+    MaintenanceResponse,
+    MemoryEvent,
+    MemoryEventRecord,
+    MemoryScope,
+    MonitorResponse,
+    Playbook,
+    PlaybookRevision,
+    PlaybookSearchHit,
+    PreparedMemoryTurn,
+    Profile,
+    ProfileEntry,
+    ReadyResponse,
+    ReflectResult,
+    ReverificationResponse,
+    RevisePlaybookResult,
+    RuntimeTurnResult,
+    SearchResponse,
+    StoredExchange,
+    StoredTurn,
+    TemporalDiffResponse,
+    TemporalEventLogResponse,
+    TemporalStateResponse,
+    TrustAssessmentResponse,
+    WorkClaim,
+    WorkClaimListResponse,
+)
+from .runtime import AsyncMemoryRuntimeClient, MemoryRuntimeClient, format_prompt
+
+__all__ = [
+    "ActorRef",
+    "Association",
+    "AssociationGraph",
+    "AssociationNode",
+    "AsyncMemoryClient",
+    "AsyncMemoryRuntimeClient",
+    "AuditListResponse",
+    "ChangeListResponse",
+    "CoordinationState",
+    "CognitiveMemoryItem",
+    "CognitiveSearchHit",
+    "CognitiveSearchResult",
+    "CompactResponse",
+    "CompactionLogListResponse",
+    "ContextResponse",
+    "CreatedResource",
+    "DueReverificationResponse",
+    "EpisodeRecap",
+    "EpisodeSearchResponse",
+    "EpisodeSourceReference",
+    "EpisodeSummary",
+    "HandoffListResponse",
+    "HandoffRecord",
+    "HealthResponse",
+    "KnowledgeInspectionResponse",
+    "KnowledgeListResponse",
+    "MaintenanceResponse",
+    "MemoryEvent",
+    "MemoryEventRecord",
+    "MemoryClient",
+    "MemoryLayerError",
+    "MemoryScope",
+    "MemoryRuntimeClient",
+    "MonitorResponse",
+    "Playbook",
+    "PlaybookRevision",
+    "PlaybookSearchHit",
+    "PreparedMemoryTurn",
+    "Profile",
+    "ProfileEntry",
+    "ReadyResponse",
+    "ReflectResult",
+    "ReverificationResponse",
+    "RevisePlaybookResult",
+    "RuntimeTurnResult",
+    "SearchResponse",
+    "StoredExchange",
+    "StoredTurn",
+    "TemporalDiffResponse",
+    "TemporalEventLogResponse",
+    "TemporalStateResponse",
+    "TrustAssessmentResponse",
+    "WorkClaim",
+    "WorkClaimListResponse",
+    "format_prompt",
+]
+__version__ = "4.0.0"

ai_memory_layer_client-4.0.0/memory_layer_client/cli.py

@@ -0,0 +1,199 @@
+"""Command-line entry point for the memory-layer Python client."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from dataclasses import asdict, is_dataclass
+from typing import Any
+
+from .client import MemoryClient
+from .models import MemoryScope
+
+
+def _add_scope_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--tenant-id")
+    parser.add_argument("--system-id")
+    parser.add_argument("--scope-id")
+    parser.add_argument("--workspace-id")
+    parser.add_argument("--collaboration-id")
+
+
+def _resolve_scope(args: argparse.Namespace) -> MemoryScope | None:
+    if args.tenant_id and args.system_id and args.scope_id:
+        return MemoryScope(
+            tenant_id=args.tenant_id,
+            system_id=args.system_id,
+            scope_id=args.scope_id,
+            workspace_id=args.workspace_id,
+            collaboration_id=args.collaboration_id,
+        )
+    return None
+
+
+def _to_payload(value: Any) -> Any:
+    if is_dataclass(value):
+        return asdict(value)
+    return value
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="memory-layer-client")
+    parser.add_argument("--base-url", default="http://localhost:3100")
+    parser.add_argument("--api-key")
+    parser.add_argument("--admin-key")
+    parser.add_argument("--timeout", type=float, default=10.0)
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    store_turn = subparsers.add_parser("store-turn")
+    store_turn.add_argument("role")
+    store_turn.add_argument("content")
+    store_turn.add_argument("--actor")
+    _add_scope_arguments(store_turn)
+
+    store_exchange = subparsers.add_parser("store-exchange")
+    store_exchange.add_argument("user_content")
+    store_exchange.add_argument("assistant_content")
+    _add_scope_arguments(store_exchange)
+
+    context = subparsers.add_parser("context")
+    context.add_argument("--query")
+    _add_scope_arguments(context)
+
+    search = subparsers.add_parser("search")
+    search.add_argument("query")
+    search.add_argument("--limit", type=int)
+    _add_scope_arguments(search)
+
+    cross_scope = subparsers.add_parser("search-cross-scope")
+    cross_scope.add_argument("query")
+    cross_scope.add_argument("--scope-level", default="workspace")
+    cross_scope.add_argument("--limit", type=int)
+    _add_scope_arguments(cross_scope)
+
+    learn_fact = subparsers.add_parser("learn-fact")
+    learn_fact.add_argument("fact")
+    learn_fact.add_argument("fact_type")
+    learn_fact.add_argument("--confidence", default="high")
+    _add_scope_arguments(learn_fact)
+
+    for name in ("health", "live", "ready", "inspect-monitor"):
+        subparser = subparsers.add_parser(name)
+        _add_scope_arguments(subparser)
+
+    changes = subparsers.add_parser("changes")
+    changes.add_argument("--since", required=True)
+    changes.add_argument("--scope-level", default="scope")
+    _add_scope_arguments(changes)
+
+    inspect_knowledge = subparsers.add_parser("inspect-knowledge")
+    inspect_knowledge.add_argument("--knowledge-id", type=int)
+    inspect_knowledge.add_argument("--limit", type=int)
+    inspect_knowledge.add_argument("--cursor", type=int)
+    _add_scope_arguments(inspect_knowledge)
+
+    audits = subparsers.add_parser("inspect-audits")
+    audits.add_argument("--knowledge-id", type=int)
+    audits.add_argument("--limit", type=int)
+    _add_scope_arguments(audits)
+
+    compactions = subparsers.add_parser("inspect-compactions")
+    compactions.add_argument("--limit", type=int)
+    _add_scope_arguments(compactions)
+
+    inspect_reverification = subparsers.add_parser("inspect-reverification")
+    inspect_reverification.add_argument("--limit", type=int)
+    _add_scope_arguments(inspect_reverification)
+
+    run_reverification = subparsers.add_parser("run-reverification")
+    run_reverification.add_argument("--limit", type=int)
+    _add_scope_arguments(run_reverification)
+
+    reverify_one = subparsers.add_parser("reverify-knowledge")
+    reverify_one.add_argument("knowledge_id", type=int)
+    _add_scope_arguments(reverify_one)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    scope = _resolve_scope(args)
+    client = MemoryClient(
+        args.base_url,
+        api_key=args.api_key,
+        default_scope=scope,
+        timeout=args.timeout,
+    )
+    try:
+        if args.command == "store-turn":
+            result = client.store_turn(args.role, args.content, actor=args.actor, scope=scope)
+        elif args.command == "store-exchange":
+            result = client.store_exchange(args.user_content, args.assistant_content, scope=scope)
+        elif args.command == "context":
+            result = client.get_context(query=args.query, scope=scope)
+        elif args.command == "search":
+            result = client.search(args.query, limit=args.limit, scope=scope)
+        elif args.command == "search-cross-scope":
+            result = client.search_cross_scope(
+                args.query,
+                scope_level=args.scope_level,
+                limit=args.limit,
+                scope=scope,
+            )
+        elif args.command == "learn-fact":
+            result = client.learn_fact(
+                args.fact,
+                args.fact_type,
+                confidence=args.confidence,
+                scope=scope,
+            )
+        elif args.command == "health":
+            result = client.health(scope=scope)
+        elif args.command == "live":
+            result = client.live()
+        elif args.command == "ready":
+            result = client.ready()
+        elif args.command == "changes":
+            result = client.poll_changes(args.since, scope_level=args.scope_level, scope=scope)
+        elif args.command == "inspect-knowledge":
+            if args.knowledge_id is not None:
+                result = client.inspect_knowledge(args.knowledge_id, scope=scope)
+            else:
+                result = client.list_knowledge(limit=args.limit, cursor=args.cursor, scope=scope)
+        elif args.command == "inspect-audits":
+            result = client.list_audits(
+                knowledge_id=args.knowledge_id,
+                limit=args.limit,
+                scope=scope,
+            )
+        elif args.command == "inspect-monitor":
+            result = client.inspect_monitor(scope=scope)
+        elif args.command == "inspect-compactions":
+            result = client.inspect_compactions(limit=args.limit, scope=scope)
+        elif args.command == "inspect-reverification":
+            result = client.inspect_reverification(limit=args.limit, scope=scope)
+        elif args.command == "run-reverification":
+            result = client.run_reverification(
+                limit=args.limit,
+                scope=scope,
+                admin_key=args.admin_key,
+            )
+        elif args.command == "reverify-knowledge":
+            result = client.reverify_knowledge(
+                args.knowledge_id,
+                scope=scope,
+                admin_key=args.admin_key,
+            )
+        else:
+            parser.error(f"Unknown command: {args.command}")
+        print(json.dumps(_to_payload(result), indent=2))
+        return 0
+    finally:
+        client.close()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())