feat: agentmemory v0.1.2 — 5 new features

- AutoGen adapter: AutoGenMemoryHook + get_autogen_memory_context
- Qdrant backend: MemoryStore now accepts qdrant_url param + example
- Export/import JSON: MemoryStore.export_json() / import_json()
- CLI: agentmemory inspect / export / import subcommands
- AsyncMemoryStore: full async/await API via ThreadPoolExecutor
- 67 new tests (123 total, all passing)
- README: 5 new integration sections + roadmap updated

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: pinexai

README.md

@@ -294,6 +294,155 @@ Works with Claude Code, Cursor, and any MCP-compatible AI coding assistant.
 
 ---
 
+## AutoGen Integration
+
+Give AutoGen agents persistent memory that survives across sessions.
+
+```python
+from agentmemory import MemoryStore
+from agentmemory.adapters.autogen import AutoGenMemoryHook, get_autogen_memory_context
+import autogen
+
+memory = MemoryStore(agent_id="my-autogen-agent")
+
+# Inject past context into the agent's system_message
+context = get_autogen_memory_context(memory, role="Research Assistant",
+                                     goal="literature review on LLMs")
+
+assistant = autogen.AssistantAgent(
+    name="researcher",
+    system_message=context + "\nYou are a helpful research assistant.",
+    llm_config={"model": "gpt-4o-mini"},
+)
+
+# Hook captures every reply and stores it in memory
+hook = AutoGenMemoryHook(memory, importance=6)
+assistant.register_reply(
+    trigger=autogen.ConversableAgent,
+    reply_func=hook.on_agent_reply,
+    position=0,
+)
+```
+
+Install: `pip install "agentcortex[autogen]"`
+
+---
+
+## Qdrant Production Backend
+
+Scale to millions of vectors with a dedicated vector database.
+
+```python
+from agentmemory import MemoryStore
+
+# docker run -p 6333:6333 qdrant/qdrant
+memory = MemoryStore(
+    agent_id="my-agent",
+    semantic_backend="qdrant",
+    qdrant_url="http://localhost:6333",      # or Qdrant Cloud URL
+    embedding_provider="sentence-transformers",
+)
+
+memory.remember("Production architecture uses microservices", importance=8)
+results = memory.recall("architecture")
+```
+
+Install: `pip install "agentcortex[qdrant]"`
+
+---
+
+## Memory Export / Import (JSON)
+
+Back up and restore episodic memories across machines or agent instances.
+
+```python
+from agentmemory import MemoryStore
+
+memory = MemoryStore(agent_id="my-agent")
+memory.remember("PostgreSQL is our main database", importance=8)
+
+# Export to JSON file
+memory.export_json("backup.json")
+
+# Restore on another machine / new agent
+new_memory = MemoryStore(agent_id="new-agent")
+count = new_memory.import_json("backup.json")
+print(f"Imported {count} memories")
+
+# Merge instead of replacing
+new_memory.import_json("backup.json", merge=True)
+
+# Or work with the dict directly
+data = memory.export_json()   # no path → returns dict only
+new_memory.import_json(data)
+```
+
+---
+
+## Memory CLI
+
+Inspect and manage memories from the command line.
+
+```bash
+# Inspect stored memories
+agentmemory inspect --agent-id my-project
+
+# agentmemory — agent: my-project
+# ════════════════════════════════════════
+# EPISODIC MEMORY  (3 entries)
+# ────────────────────────────────────────
+#   #   IMP   Created              Content
+#   1    9    2026-02-28 14:23:01  We use PostgreSQL for relational...
+#   2    7    2026-02-27 09:14:55  payment/process_transaction.py h...
+#   3    5    2026-02-26 18:30:12  User prefers functional style ove...
+
+# Export memories to JSON
+agentmemory export --agent-id my-project --output memories.json
+
+# Import memories (restores; use --merge to add alongside existing)
+agentmemory import memories.json --agent-id new-project --merge
+```
+
+Install: `pip install agentcortex`  (the CLI is always included)
+
+---
+
+## Async Support
+
+Use agentmemory in FastAPI, aiohttp, or any async Python application.
+
+```python
+import asyncio
+from agentmemory import AsyncMemoryStore
+
+async def main():
+    # Identical API to MemoryStore — just add await
+    memory = AsyncMemoryStore(agent_id="my-async-agent")
+
+    await memory.remember("User prefers Python over JavaScript", importance=7)
+    results = await memory.recall("tech stack")
+    context = await memory.get_context("What do we know?")
+
+    # Export / import work the same way
+    data = await memory.export_json()
+    await memory.import_json(data)
+
+    memory.close()
+
+# Or use as an async context manager
+async def with_context_manager():
+    async with AsyncMemoryStore(agent_id="my-agent") as memory:
+        await memory.remember("Context manager closes executor automatically")
+        ctx = await memory.get_context()
+        print(ctx)
+
+asyncio.run(main())
+```
+
+Install: `pip install agentcortex`  (`AsyncMemoryStore` is always included)
+
+---
+
 ## Comparison
 
 | | MemGPT | LangChain Memory | **AgentMemory** |
@@ -311,11 +460,11 @@ Works with Claude Code, Cursor, and any MCP-compatible AI coding assistant.
 
 ## Roadmap
 
-- [ ] AutoGen adapter
-- [ ] Qdrant production backend examples
-- [ ] Memory export/import (JSON)
-- [ ] Memory visualization CLI (`agentmemory inspect`)
-- [ ] Async support (`AsyncMemoryStore`)
+- [x] AutoGen adapter (`pip install "agentcortex[autogen]"`)
+- [x] Qdrant production backend (`pip install "agentcortex[qdrant]"`)
+- [x] Memory export/import (JSON) — `memory.export_json()` / `memory.import_json()`
+- [x] Memory visualization CLI — `agentmemory inspect / export / import`
+- [x] Async support — `AsyncMemoryStore` with full `await` API
 - [x] MCP server integration (`pip install "agentcortex[mcp]"`)
 
 ---

agentmemory/__init__.py

@@ -12,16 +12,18 @@
 Works with LangChain, CrewAI, AutoGen, and raw Anthropic/OpenAI SDKs.
 """
 
+from .async_store import AsyncMemoryStore
 from .compression import ContextCompressor
 from .dedup import MemoryDeduplicator
 from .store import MemoryStore
 from .tiers.episodic import EpisodicMemory
 from .tiers.semantic import SemanticMemory
 from .tiers.working import WorkingMemory
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 __all__ = [
     "MemoryStore",
+    "AsyncMemoryStore",
     "EpisodicMemory",
     "SemanticMemory",
     "WorkingMemory",

agentmemory/adapters/__init__.py

@@ -1,4 +1,5 @@
 from .anthropic import MemoryAnthropic
+from .autogen import AutoGenMemoryHook, get_autogen_memory_context
 from .crewai import CrewMemoryCallback, get_memory_context_for_agent
 from .langchain import MemoryHistory, inject_memory_context
 from .openai import MemoryOpenAI
@@ -10,4 +11,6 @@
     "MemoryAnthropic",
     "CrewMemoryCallback",
     "get_memory_context_for_agent",
+    "AutoGenMemoryHook",
+    "get_autogen_memory_context",
 ]

agentmemory/adapters/autogen.py

@@ -0,0 +1,145 @@
+"""AutoGen adapter for agentmemory.
+
+Provides two things:
+  1. AutoGenMemoryHook  — a register_reply hook that captures agent messages
+                          and stores them in persistent memory.
+  2. get_autogen_memory_context — returns a memory context string ready to
+                                   inject into an AutoGen agent's system_message.
+
+No hard dependency on pyautogen — the module imports cleanly without it.
+pyautogen is only required if you actually run AutoGen agents.
+
+Usage:
+    from agentmemory import MemoryStore
+    from agentmemory.adapters.autogen import AutoGenMemoryHook, get_autogen_memory_context
+    import autogen
+
+    memory = MemoryStore(agent_id="my-agent")
+
+    # Inject past context into agent system_message
+    context = get_autogen_memory_context(memory, role="Research Assistant")
+
+    assistant = autogen.AssistantAgent(
+        name="assistant",
+        system_message=context + "\\nYou are a helpful research assistant.",
+    )
+
+    # Register the hook so replies are captured to memory
+    hook = AutoGenMemoryHook(memory)
+    assistant.register_reply(
+        trigger=autogen.ConversableAgent,
+        reply_func=hook.on_agent_reply,
+        position=0,
+    )
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from agentmemory.store import MemoryStore
+
+
+class AutoGenMemoryHook:
+    """
+    AutoGen register_reply hook that captures agent replies and stores them
+    in agentmemory for use across sessions.
+
+    This hook observes replies without intercepting them — it always returns
+    ``(False, None)`` so the normal reply chain continues unmodified.
+
+    Usage:
+        hook = AutoGenMemoryHook(memory_store, importance=6)
+        agent.register_reply(
+            trigger=autogen.ConversableAgent,
+            reply_func=hook.on_agent_reply,
+            position=0,
+        )
+    """
+
+    def __init__(self, memory_store: MemoryStore, importance: int = 6) -> None:
+        """
+        Args:
+            memory_store: The MemoryStore instance to write to.
+            importance:   Importance level 1-10 for stored memories (default 6).
+                          Use higher values for critical reasoning, lower for
+                          routine conversational turns.
+        """
+        self._store = memory_store
+        self._importance = importance
+
+    def on_agent_reply(
+        self,
+        recipient: Any,
+        messages: list[dict] | None,
+        sender: Any,
+        config: Any,
+    ) -> tuple[bool, None]:
+        """
+        AutoGen register_reply callback signature.
+
+        Reads the last message in the chain and stores its content to memory.
+        Returns ``(False, None)`` — does NOT intercept or modify the reply.
+
+        Args:
+            recipient: The agent receiving the message (unused).
+            messages:  Current message list.
+            sender:    The agent that sent the message (unused).
+            config:    AutoGen config dict (unused).
+        """
+        if messages:
+            last = messages[-1]
+            content = last.get("content", "")
+            if content and isinstance(content, str) and content.strip():
+                # Truncate very long messages to avoid storing noise
+                self._store.remember(content[:1000], importance=self._importance)
+        return False, None  # observe only — do not intercept
+
+    def on_message_received(self, message: str | dict) -> None:
+        """
+        Convenience method for manually storing a received message.
+
+        Args:
+            message: Raw message string or dict with a "content" key.
+        """
+        if isinstance(message, dict):
+            content = message.get("content", "")
+        else:
+            content = str(message)
+        if content and content.strip():
+            self._store.remember(content[:1000], importance=self._importance)
+
+
+def get_autogen_memory_context(
+    memory_store: MemoryStore,
+    role: str,
+    goal: str | None = None,
+    max_tokens: int = 400,
+) -> str:
+    """
+    Return a memory context string for injection into an AutoGen agent's
+    ``system_message``.
+
+    Retrieves relevant memories from agentmemory based on the agent's role and
+    optional goal, and returns them as a formatted context block. Prepend this
+    to the agent's system_message to give it codebase/task memory.
+
+    Args:
+        memory_store: The MemoryStore instance to query.
+        role:         Agent role name, e.g. "Research Assistant", "Code Reviewer".
+        goal:         Optional goal description to narrow memory retrieval.
+        max_tokens:   Maximum token budget for the returned context (default 400).
+
+    Returns:
+        A formatted context string, or an empty string if no memories exist yet.
+
+    Example:
+        context = get_autogen_memory_context(memory, "Research Assistant",
+                                             goal="literature review on LLMs")
+        agent = autogen.AssistantAgent(
+            name="researcher",
+            system_message=context + "\\nYou are a research assistant.",
+        )
+    """
+    query = f"{role} {goal or ''}".strip()
+    return memory_store.get_context(query=query, max_tokens=max_tokens)