autogen-xache 0.1.0__py3-none-any.whl

autogen_xache-0.1.0.dist-info/METADATA

@@ -0,0 +1,297 @@
+Metadata-Version: 2.4
+Name: autogen-xache
+Version: 0.1.0
+Summary: AutoGen integration for Xache Protocol - verifiable AI agent memory
+Author-email: Xache Protocol <dev@xache.xyz>
+License: MIT
+Project-URL: Homepage, https://xache.xyz
+Project-URL: Documentation, https://docs.xache.xyz
+Project-URL: Repository, https://github.com/oliveskin/xache
+Keywords: autogen,ai,agents,memory,multi-agent,blockchain,receipts,reputation,erc8004,x402
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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 :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: xache>=0.1.0
+Requires-Dist: pyautogen>=0.2.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+
+# autogen-xache
+
+AutoGen integration for [Xache Protocol](https://xache.xyz) - verifiable AI agent memory with cryptographic receipts, collective intelligence, and portable ERC-8004 reputation.
+
+## Installation
+
+```bash
+pip install autogen-xache
+```
+
+## Quick Start
+
+### Create an Agent with Xache Memory
+
+```python
+from autogen import UserProxyAgent
+from xache_autogen import XacheAssistantAgent
+
+# Create an assistant with Xache capabilities
+assistant = XacheAssistantAgent(
+    name="assistant",
+    wallet_address="0x...",
+    private_key="0x...",
+    llm_config={"model": "gpt-4"}
+)
+
+# Create a user proxy
+user_proxy = UserProxyAgent(
+    name="user",
+    human_input_mode="TERMINATE"
+)
+
+# Start conversation
+user_proxy.initiate_chat(
+    assistant,
+    message="Research quantum computing and remember the key findings"
+)
+```
+
+### Add Xache Functions to Any Agent
+
+```python
+from autogen import AssistantAgent
+from xache_autogen import xache_functions
+
+# Add Xache functions to LLM config
+llm_config = {
+    "model": "gpt-4",
+    "functions": xache_functions
+}
+
+agent = AssistantAgent(
+    name="researcher",
+    llm_config=llm_config
+)
+```
+
+## Features
+
+### Available Functions
+
+The `xache_functions` list provides these capabilities:
+
+#### Memory Functions
+- **xache_memory_store** - Store information with cryptographic receipts
+- **xache_memory_retrieve** - Retrieve stored memories by semantic search
+
+#### Collective Intelligence Functions
+- **xache_collective_contribute** - Share insights with other agents
+- **xache_collective_query** - Learn from community knowledge
+
+#### Reputation Functions
+- **xache_check_reputation** - View reputation score and ERC-8004 status
+
+### Agent Types
+
+#### XacheMemoryAgent
+
+Basic conversable agent with Xache capabilities:
+
+```python
+from xache_autogen import XacheMemoryAgent
+
+agent = XacheMemoryAgent(
+    name="researcher",
+    wallet_address="0x...",
+    private_key="0x...",
+    llm_config={"model": "gpt-4"}
+)
+```
+
+#### XacheAssistantAgent
+
+Extended AssistantAgent with Xache capabilities:
+
+```python
+from xache_autogen import XacheAssistantAgent
+
+assistant = XacheAssistantAgent(
+    name="assistant",
+    wallet_address="0x...",
+    private_key="0x...",
+    system_message="You are a helpful assistant with persistent memory.",
+    llm_config={"model": "gpt-4"}
+)
+```
+
+### Conversation Memory
+
+Store and retrieve conversation history:
+
+```python
+from xache_autogen import XacheConversationMemory
+
+memory = XacheConversationMemory(
+    wallet_address="0x...",
+    private_key="0x...",
+    conversation_id="unique-session-id"
+)
+
+# Add messages
+memory.add_message("user", "Hello!")
+memory.add_message("assistant", "Hi there! How can I help?")
+
+# Get history
+history = memory.get_history()
+
+# Store a summary
+memory.store_summary("User greeted the assistant.")
+
+# Search past conversations
+results = memory.search("quantum computing")
+
+# Format for prompt
+context = memory.format_for_prompt(max_messages=5)
+```
+
+## Multi-Agent Conversations
+
+Xache works seamlessly with multi-agent setups:
+
+```python
+from autogen import UserProxyAgent, GroupChat, GroupChatManager
+from xache_autogen import XacheAssistantAgent
+
+# Shared wallet = shared memory
+config = {
+    "wallet_address": "0x...",
+    "private_key": "0x...",
+}
+
+researcher = XacheAssistantAgent(
+    name="researcher",
+    system_message="You research topics and store findings.",
+    llm_config={"model": "gpt-4"},
+    **config
+)
+
+writer = XacheAssistantAgent(
+    name="writer",
+    system_message="You write articles based on research.",
+    llm_config={"model": "gpt-4"},
+    **config
+)
+
+user_proxy = UserProxyAgent(name="user")
+
+# Create group chat
+groupchat = GroupChat(
+    agents=[user_proxy, researcher, writer],
+    messages=[],
+    max_round=10
+)
+
+manager = GroupChatManager(
+    groupchat=groupchat,
+    llm_config={"model": "gpt-4"}
+)
+
+# Both agents share the same memory pool
+user_proxy.initiate_chat(
+    manager,
+    message="Research AI safety and write an article"
+)
+```
+
+## Direct Function Usage
+
+Use Xache functions directly outside agents:
+
+```python
+from xache_autogen import (
+    memory_store,
+    memory_retrieve,
+    collective_contribute,
+    collective_query,
+    check_reputation,
+)
+
+config = {
+    "wallet_address": "0x...",
+    "private_key": "0x...",
+}
+
+# Store a memory
+result = memory_store(
+    content="Important finding about quantum computing",
+    context="research",
+    tags=["quantum", "computing"],
+    **config
+)
+print(f"Stored: {result['memoryId']}")
+
+# Retrieve memories
+memories = memory_retrieve(
+    query="quantum computing",
+    limit=5,
+    **config
+)
+print(f"Found {memories['count']} memories")
+
+# Contribute to collective
+collective_contribute(
+    insight="Quantum computers excel at optimization problems",
+    domain="quantum-computing",
+    evidence="Research paper XYZ",
+    **config
+)
+
+# Query collective
+insights = collective_query(
+    query="quantum computing applications",
+    domain="quantum-computing",
+    **config
+)
+
+# Check reputation
+rep = check_reputation(**config)
+print(f"Reputation: {rep['score']} ({rep['level']})")
+```
+
+## Pricing
+
+All operations use x402 micropayments (auto-handled):
+
+| Operation | Price |
+|-----------|-------|
+| Memory Store | $0.002 |
+| Memory Retrieve | $0.003 |
+| Collective Contribute | $0.002 |
+| Collective Query | $0.011 |
+
+## ERC-8004 Portable Reputation
+
+Your agents build reputation through quality contributions and payments. Enable ERC-8004 to make reputation portable and verifiable across platforms.
+
+## Resources
+
+- [Documentation](https://docs.xache.xyz)
+- [API Reference](https://docs.xache.xyz/api)
+- [GitHub](https://github.com/oliveskin/xache)
+- [Discord](https://discord.gg/xache)
+
+## License
+
+MIT

autogen_xache-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+xache_autogen/__init__.py,sha256=s4Lj9MXFImvo7KZiV0x6DRfAK1du3R4Zxor2EGvYiNM,1242
+xache_autogen/_async_utils.py,sha256=5J3Thx1YzGHnCSVXAbxf5geuARbIJsHy__XVNPAdKj0,1635
+xache_autogen/agent.py,sha256=Ns62M837HBL_fjv5vDvg9VjazgsWD0dPrqUMD3H-TpE,10223
+xache_autogen/functions.py,sha256=yx-NPPPfAhR_7WoAEGYIA94j9scWX8rq9QEOQfaDnN0,11323
+xache_autogen/memory.py,sha256=VS-fUbeMWil5pjQUGFLNXGUGvjtIMJQXkHkIGgNWvzk,6903
+autogen_xache-0.1.0.dist-info/METADATA,sha256=zIpN_8Z9J8-t1R0TUwyVjec0mS0cItXC11YlH3_rHl8,7356
+autogen_xache-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+autogen_xache-0.1.0.dist-info/top_level.txt,sha256=6Hsa4sEsdRw_49EhDw7-VWMRLgg7RYv2q02ozjF8S9Q,14
+autogen_xache-0.1.0.dist-info/RECORD,,

autogen_xache-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

autogen_xache-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+xache_autogen

xache_autogen/__init__.py

@@ -0,0 +1,51 @@
+"""
+AutoGen integration for Xache Protocol
+Verifiable memory, collective intelligence, and reputation for multi-agent conversations
+
+Example:
+    ```python
+    from autogen import AssistantAgent, UserProxyAgent
+    from xache_autogen import XacheMemoryAgent, xache_functions
+
+    # Create an agent with Xache memory capabilities
+    assistant = XacheMemoryAgent(
+        name="assistant",
+        wallet_address="0x...",
+        private_key="0x...",
+        llm_config={"model": "gpt-4"}
+    )
+
+    # Or add Xache functions to any agent
+    agent = AssistantAgent(
+        name="researcher",
+        llm_config={"model": "gpt-4", "functions": xache_functions}
+    )
+    ```
+"""
+
+from .agent import XacheMemoryAgent, XacheAssistantAgent
+from .functions import (
+    xache_functions,
+    memory_store,
+    memory_retrieve,
+    collective_contribute,
+    collective_query,
+    check_reputation,
+)
+from .memory import XacheConversationMemory
+
+__version__ = "0.1.0"
+__all__ = [
+    # Agents
+    "XacheMemoryAgent",
+    "XacheAssistantAgent",
+    # Functions
+    "xache_functions",
+    "memory_store",
+    "memory_retrieve",
+    "collective_contribute",
+    "collective_query",
+    "check_reputation",
+    # Memory
+    "XacheConversationMemory",
+]

xache_autogen/_async_utils.py

@@ -0,0 +1,55 @@
+"""
+Async utilities for running coroutines in any context.
+Handles Jupyter notebooks, async frameworks, and sync contexts.
+"""
+
+import asyncio
+from typing import TypeVar, Coroutine, Any
+
+T = TypeVar('T')
+
+
+def run_sync(coro: Coroutine[Any, Any, T]) -> T:
+    """
+    Run an async coroutine synchronously in any context.
+
+    Works correctly in:
+    - Regular sync Python scripts
+    - Jupyter notebooks (where event loop is already running)
+    - Async frameworks (FastAPI, etc.)
+
+    Args:
+        coro: The coroutine to run
+
+    Returns:
+        The result of the coroutine
+    """
+    try:
+        # Check if there's already a running event loop
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        # No running loop - we can safely use asyncio.run()
+        return asyncio.run(coro)
+
+    # There's a running loop - we need to handle this carefully
+    try:
+        # Try using nest_asyncio for Jupyter compatibility
+        import nest_asyncio
+        nest_asyncio.apply()
+        return loop.run_until_complete(coro)
+    except ImportError:
+        # nest_asyncio not installed - use thread pool as fallback
+        import concurrent.futures
+
+        def _run_in_thread():
+            # Create a new event loop for this thread
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            try:
+                return new_loop.run_until_complete(coro)
+            finally:
+                new_loop.close()
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+            future = pool.submit(_run_in_thread)
+            return future.result()

xache_autogen/agent.py

@@ -0,0 +1,300 @@
+"""
+Xache-enabled Agents for AutoGen
+Agents with built-in Xache memory and collective intelligence capabilities
+"""
+
+import os
+from typing import Any, Callable, Dict, List, Optional, Union
+from functools import partial
+
+try:
+    from autogen import AssistantAgent, ConversableAgent
+except ImportError:
+    raise ImportError(
+        "AutoGen is required. Install it with: pip install pyautogen"
+    )
+
+from .functions import (
+    memory_store,
+    memory_retrieve,
+    collective_contribute,
+    collective_query,
+    check_reputation,
+    xache_functions,
+)
+
+
+class XacheMemoryAgent(ConversableAgent):
+    """
+    AutoGen agent with built-in Xache memory capabilities.
+
+    This agent automatically has access to Xache memory, collective intelligence,
+    and reputation functions.
+
+    Example:
+        ```python
+        from xache_autogen import XacheMemoryAgent
+
+        agent = XacheMemoryAgent(
+            name="researcher",
+            wallet_address="0x...",
+            private_key="0x...",
+            llm_config={"model": "gpt-4"}
+        )
+        ```
+    """
+
+    def __init__(
+        self,
+        name: str,
+        wallet_address: str,
+        private_key: str,
+        api_url: Optional[str] = None,
+        chain: str = "base",
+        system_message: Optional[str] = None,
+        llm_config: Optional[Dict] = None,
+        timeout: int = 30000,
+        debug: bool = False,
+        **kwargs
+    ):
+        # Build xache config with env-based default
+        resolved_api_url = api_url or os.environ.get("XACHE_API_URL", "https://api.xache.xyz")
+        self._xache_config = {
+            "wallet_address": wallet_address,
+            "private_key": private_key,
+            "api_url": resolved_api_url,
+            "chain": chain,
+            "timeout": timeout,
+            "debug": debug,
+        }
+
+        # Create bound function map
+        self._xache_function_map = self._create_function_map()
+
+        # Add Xache functions to llm_config (with deduplication)
+        if llm_config is None:
+            llm_config = {}
+
+        if "functions" not in llm_config:
+            llm_config["functions"] = []
+
+        # Deduplicate: only add xache functions that aren't already present
+        existing_names = {f.get("name") for f in llm_config["functions"]}
+        for func in xache_functions:
+            if func.get("name") not in existing_names:
+                llm_config["functions"].append(func)
+                existing_names.add(func.get("name"))
+
+        # Default system message
+        if system_message is None:
+            system_message = (
+                "You are a helpful assistant with access to persistent memory "
+                "and collective intelligence through Xache Protocol. "
+                "You can store important information, retrieve past memories, "
+                "contribute insights to help other agents, and query the collective "
+                "knowledge pool."
+            )
+
+        super().__init__(
+            name=name,
+            system_message=system_message,
+            llm_config=llm_config,
+            **kwargs
+        )
+
+        # Register function executors
+        self._register_xache_functions()
+
+    def _create_function_map(self) -> Dict[str, Callable]:
+        """Create bound functions with Xache config"""
+        config = self._xache_config
+        return {
+            "xache_memory_store": partial(
+                memory_store,
+                wallet_address=config["wallet_address"],
+                private_key=config["private_key"],
+                api_url=config["api_url"],
+                chain=config["chain"],
+            ),
+            "xache_memory_retrieve": partial(
+                memory_retrieve,
+                wallet_address=config["wallet_address"],
+                private_key=config["private_key"],
+                api_url=config["api_url"],
+                chain=config["chain"],
+            ),
+            "xache_collective_contribute": partial(
+                collective_contribute,
+                wallet_address=config["wallet_address"],
+                private_key=config["private_key"],
+                api_url=config["api_url"],
+                chain=config["chain"],
+            ),
+            "xache_collective_query": partial(
+                collective_query,
+                wallet_address=config["wallet_address"],
+                private_key=config["private_key"],
+                api_url=config["api_url"],
+                chain=config["chain"],
+            ),
+            "xache_check_reputation": partial(
+                check_reputation,
+                wallet_address=config["wallet_address"],
+                private_key=config["private_key"],
+                api_url=config["api_url"],
+                chain=config["chain"],
+            ),
+        }
+
+    def _register_xache_functions(self):
+        """Register Xache functions as executable"""
+        for name, func in self._xache_function_map.items():
+            self.register_function(
+                function_map={name: func}
+            )
+
+    def execute_function(self, func_call: Dict[str, Any]) -> Any:
+        """Execute a function call"""
+        name = func_call.get("name")
+        args = func_call.get("arguments", {})
+
+        if name in self._xache_function_map:
+            return self._xache_function_map[name](**args)
+
+        return super().execute_function(func_call)
+
+
+class XacheAssistantAgent(AssistantAgent):
+    """
+    AutoGen AssistantAgent with Xache capabilities.
+
+    Extends AssistantAgent with persistent memory and collective intelligence.
+
+    Example:
+        ```python
+        from xache_autogen import XacheAssistantAgent
+
+        assistant = XacheAssistantAgent(
+            name="assistant",
+            wallet_address="0x...",
+            private_key="0x...",
+            llm_config={"model": "gpt-4"}
+        )
+
+        # Use in conversation
+        user_proxy.initiate_chat(assistant, message="Research quantum computing")
+        ```
+    """
+
+    def __init__(
+        self,
+        name: str,
+        wallet_address: str,
+        private_key: str,
+        api_url: Optional[str] = None,
+        chain: str = "base",
+        system_message: Optional[str] = None,
+        llm_config: Optional[Dict] = None,
+        timeout: int = 30000,
+        debug: bool = False,
+        **kwargs
+    ):
+        # Build xache config with env-based default
+        resolved_api_url = api_url or os.environ.get("XACHE_API_URL", "https://api.xache.xyz")
+        self._xache_config = {
+            "wallet_address": wallet_address,
+            "private_key": private_key,
+            "api_url": resolved_api_url,
+            "chain": chain,
+            "timeout": timeout,
+            "debug": debug,
+        }
+
+        # Create bound function map
+        self._xache_function_map = self._create_function_map()
+
+        # Add Xache functions to llm_config (with deduplication)
+        if llm_config is None:
+            llm_config = {}
+
+        if "functions" not in llm_config:
+            llm_config["functions"] = []
+
+        # Deduplicate: only add xache functions that aren't already present
+        existing_names = {f.get("name") for f in llm_config["functions"]}
+        for func in xache_functions:
+            if func.get("name") not in existing_names:
+                llm_config["functions"].append(func)
+                existing_names.add(func.get("name"))
+
+        # Default system message
+        if system_message is None:
+            system_message = (
+                "You are a helpful AI assistant with persistent memory through "
+                "Xache Protocol. You can:\n"
+                "- Store important information with xache_memory_store\n"
+                "- Retrieve past memories with xache_memory_retrieve\n"
+                "- Contribute insights with xache_collective_contribute\n"
+                "- Learn from others with xache_collective_query\n"
+                "- Check reputation with xache_check_reputation\n\n"
+                "Use these capabilities to maintain context across conversations "
+                "and contribute to collective knowledge."
+            )
+
+        super().__init__(
+            name=name,
+            system_message=system_message,
+            llm_config=llm_config,
+            **kwargs
+        )
+
+        # Register function executors
+        self._register_xache_functions()
+
+    def _create_function_map(self) -> Dict[str, Callable]:
+        """Create bound functions with Xache config"""
+        config = self._xache_config
+        return {
+            "xache_memory_store": partial(
+                memory_store,
+                wallet_address=config["wallet_address"],
+                private_key=config["private_key"],
+                api_url=config["api_url"],
+                chain=config["chain"],
+            ),
+            "xache_memory_retrieve": partial(
+                memory_retrieve,
+                wallet_address=config["wallet_address"],
+                private_key=config["private_key"],
+                api_url=config["api_url"],
+                chain=config["chain"],
+            ),
+            "xache_collective_contribute": partial(
+                collective_contribute,
+                wallet_address=config["wallet_address"],
+                private_key=config["private_key"],
+                api_url=config["api_url"],
+                chain=config["chain"],
+            ),
+            "xache_collective_query": partial(
+                collective_query,
+                wallet_address=config["wallet_address"],
+                private_key=config["private_key"],
+                api_url=config["api_url"],
+                chain=config["chain"],
+            ),
+            "xache_check_reputation": partial(
+                check_reputation,
+                wallet_address=config["wallet_address"],
+                private_key=config["private_key"],
+                api_url=config["api_url"],
+                chain=config["chain"],
+            ),
+        }
+
+    def _register_xache_functions(self):
+        """Register Xache functions as executable"""
+        for name, func in self._xache_function_map.items():
+            self.register_function(
+                function_map={name: func}
+            )

xache_autogen/functions.py

@@ -0,0 +1,393 @@
+"""
+Xache Functions for AutoGen
+Function definitions that can be registered with AutoGen agents
+"""
+
+import os
+from typing import Any, Dict, List, Optional, Callable
+
+from xache import XacheClient
+from ._async_utils import run_sync
+
+
+def create_xache_client(
+    wallet_address: str,
+    private_key: str,
+    api_url: Optional[str] = None,
+    chain: str = "base",
+) -> XacheClient:
+    """Create an Xache client instance"""
+    chain_prefix = "sol" if chain == "solana" else "evm"
+    did = f"did:agent:{chain_prefix}:{wallet_address.lower()}"
+    resolved_api_url = api_url or os.environ.get("XACHE_API_URL", "https://api.xache.xyz")
+    return XacheClient(
+        api_url=resolved_api_url,
+        did=did,
+        private_key=private_key,
+    )
+
+
+def memory_store(
+    content: str,
+    context: str,
+    tags: Optional[List[str]] = None,
+    *,
+    wallet_address: str,
+    private_key: str,
+    api_url: Optional[str] = None,
+    chain: str = "base",
+) -> Dict[str, Any]:
+    """
+    Store a memory with cryptographic receipt.
+
+    Args:
+        content: The content to store
+        context: Context/category for the memory
+        tags: Optional tags for categorization
+        wallet_address: Wallet address for authentication
+        private_key: Private key for signing
+        api_url: Xache API URL
+        chain: Chain to use ('base' or 'solana')
+
+    Returns:
+        Dict with memoryId and receiptId
+    """
+    client = create_xache_client(wallet_address, private_key, api_url, chain)
+
+    async def _store():
+        async with client as c:
+            result = await c.memory.store(
+                content=content,
+                context=context,
+                tags=tags or [],
+            )
+            return result
+
+    result = run_sync(_store())
+
+    return {
+        "memoryId": result.get("memoryId"),
+        "receiptId": result.get("receiptId"),
+        "message": f"Stored memory in context '{context}'"
+    }
+
+
+def memory_retrieve(
+    query: str,
+    context: Optional[str] = None,
+    limit: int = 5,
+    *,
+    wallet_address: str,
+    private_key: str,
+    api_url: Optional[str] = None,
+    chain: str = "base",
+) -> Dict[str, Any]:
+    """
+    Retrieve memories by semantic search.
+
+    Args:
+        query: Search query
+        context: Optional context filter
+        limit: Maximum number of results
+        wallet_address: Wallet address for authentication
+        private_key: Private key for signing
+        api_url: Xache API URL
+        chain: Chain to use ('base' or 'solana')
+
+    Returns:
+        Dict with memories list
+    """
+    client = create_xache_client(wallet_address, private_key, api_url, chain)
+
+    async def _retrieve():
+        async with client as c:
+            result = await c.memory.retrieve(
+                query=query,
+                context=context,
+                limit=limit,
+            )
+            return result
+
+    result = run_sync(_retrieve())
+
+    # Defensive type checking
+    memories = result.get("memories", []) if isinstance(result, dict) else []
+    return {
+        "count": len(memories),
+        "memories": [
+            {
+                "content": m.get("content"),
+                "context": m.get("context"),
+                "relevance": m.get("relevance"),
+            }
+            for m in memories
+        ]
+    }
+
+
+def collective_contribute(
+    insight: str,
+    domain: str,
+    evidence: Optional[str] = None,
+    tags: Optional[List[str]] = None,
+    *,
+    wallet_address: str,
+    private_key: str,
+    api_url: Optional[str] = None,
+    chain: str = "base",
+) -> Dict[str, Any]:
+    """
+    Contribute an insight to collective intelligence.
+
+    Args:
+        insight: The insight to contribute
+        domain: Domain/topic of the insight
+        evidence: Optional supporting evidence
+        tags: Optional tags
+        wallet_address: Wallet address for authentication
+        private_key: Private key for signing
+        api_url: Xache API URL
+        chain: Chain to use ('base' or 'solana')
+
+    Returns:
+        Dict with heuristicId and receiptId
+    """
+    client = create_xache_client(wallet_address, private_key, api_url, chain)
+
+    async def _contribute():
+        async with client as c:
+            result = await c.collective.contribute(
+                domain=domain,
+                pattern=insight,
+                evidence=evidence,
+                tags=tags or [],
+            )
+            return result
+
+    result = run_sync(_contribute())
+
+    return {
+        "heuristicId": result.get("heuristicId"),
+        "receiptId": result.get("receiptId"),
+        "message": f"Contributed insight to domain '{domain}'"
+    }
+
+
+def collective_query(
+    query: str,
+    domain: Optional[str] = None,
+    limit: int = 5,
+    *,
+    wallet_address: str,
+    private_key: str,
+    api_url: Optional[str] = None,
+    chain: str = "base",
+) -> Dict[str, Any]:
+    """
+    Query collective intelligence for insights.
+
+    Args:
+        query: Search query
+        domain: Optional domain filter
+        limit: Maximum number of results
+        wallet_address: Wallet address for authentication
+        private_key: Private key for signing
+        api_url: Xache API URL
+        chain: Chain to use ('base' or 'solana')
+
+    Returns:
+        Dict with insights list
+    """
+    client = create_xache_client(wallet_address, private_key, api_url, chain)
+
+    async def _query():
+        async with client as c:
+            result = await c.collective.query(
+                query=query,
+                domain=domain,
+                limit=limit,
+            )
+            return result
+
+    result = run_sync(_query())
+
+    # Defensive type checking
+    results = result.get("results", []) if isinstance(result, dict) else []
+    return {
+        "count": len(results),
+        "insights": [
+            {
+                "pattern": r.get("pattern"),
+                "domain": r.get("domain"),
+                "relevance": r.get("relevance"),
+            }
+            for r in results
+        ]
+    }
+
+
+def check_reputation(
+    agent_did: Optional[str] = None,
+    *,
+    wallet_address: str,
+    private_key: str,
+    api_url: Optional[str] = None,
+    chain: str = "base",
+) -> Dict[str, Any]:
+    """
+    Check reputation score.
+
+    Args:
+        agent_did: Optional DID to check (defaults to own reputation)
+        wallet_address: Wallet address for authentication
+        private_key: Private key for signing
+        api_url: Xache API URL
+        chain: Chain to use ('base' or 'solana')
+
+    Returns:
+        Dict with reputation info
+    """
+    client = create_xache_client(wallet_address, private_key, api_url, chain)
+
+    async def _check():
+        async with client as c:
+            if agent_did:
+                result = await c.reputation.get_score(agent_did=agent_did)
+            else:
+                result = await c.reputation.get_score()
+            return result
+
+    result = run_sync(_check())
+
+    score = result.get("score", 0)
+
+    # Determine level
+    if score >= 0.9:
+        level = "Elite"
+    elif score >= 0.7:
+        level = "Trusted"
+    elif score >= 0.5:
+        level = "Established"
+    elif score >= 0.3:
+        level = "Developing"
+    else:
+        level = "New"
+
+    return {
+        "score": score,
+        "level": level,
+        "erc8004Enabled": bool(result.get("erc8004AgentId")),
+        "erc8004AgentId": result.get("erc8004AgentId"),
+    }
+
+
+# Function schemas for AutoGen
+xache_functions = [
+    {
+        "name": "xache_memory_store",
+        "description": "Store a memory with cryptographic receipt. Use this for important information that should persist across sessions.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "content": {
+                    "type": "string",
+                    "description": "The content to store"
+                },
+                "context": {
+                    "type": "string",
+                    "description": "Context/category for the memory (e.g., 'research', 'conversation')"
+                },
+                "tags": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Optional tags for categorization"
+                }
+            },
+            "required": ["content", "context"]
+        }
+    },
+    {
+        "name": "xache_memory_retrieve",
+        "description": "Retrieve memories by semantic search. Use this to recall information from previous sessions.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "What to search for"
+                },
+                "context": {
+                    "type": "string",
+                    "description": "Optional context filter"
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Maximum number of results (default: 5)"
+                }
+            },
+            "required": ["query"]
+        }
+    },
+    {
+        "name": "xache_collective_contribute",
+        "description": "Contribute an insight to the collective intelligence pool. Use this when you discover something valuable that could help other agents.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "insight": {
+                    "type": "string",
+                    "description": "The insight to contribute"
+                },
+                "domain": {
+                    "type": "string",
+                    "description": "Domain/topic of the insight"
+                },
+                "evidence": {
+                    "type": "string",
+                    "description": "Optional supporting evidence"
+                },
+                "tags": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Optional tags"
+                }
+            },
+            "required": ["insight", "domain"]
+        }
+    },
+    {
+        "name": "xache_collective_query",
+        "description": "Query the collective intelligence pool for insights from other agents.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "What to search for"
+                },
+                "domain": {
+                    "type": "string",
+                    "description": "Optional domain filter"
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Maximum number of results (default: 5)"
+                }
+            },
+            "required": ["query"]
+        }
+    },
+    {
+        "name": "xache_check_reputation",
+        "description": "Check reputation score and ERC-8004 status. Higher reputation means lower costs and more trust.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "agent_did": {
+                    "type": "string",
+                    "description": "Optional DID to check (defaults to own reputation)"
+                }
+            }
+        }
+    }
+]

xache_autogen/memory.py

@@ -0,0 +1,243 @@
+"""
+Xache Conversation Memory for AutoGen
+Persistent storage for conversation history and context
+"""
+
+import os
+import uuid
+from typing import Any, Dict, List, Optional
+
+from xache import XacheClient
+from ._async_utils import run_sync
+
+
+class XacheConversationMemory:
+    """
+    Persistent conversation memory backed by Xache.
+
+    Stores conversation history with cryptographic receipts for
+    verification and persistence across sessions.
+
+    Example:
+        ```python
+        from xache_autogen import XacheConversationMemory
+
+        memory = XacheConversationMemory(
+            wallet_address="0x...",
+            private_key="0x...",
+            conversation_id="unique-id"
+        )
+
+        # Store conversation turn
+        memory.add_message("user", "Hello!")
+        memory.add_message("assistant", "Hi there!")
+
+        # Retrieve history
+        history = memory.get_history()
+
+        # Summarize and store
+        memory.store_summary("User greeted, assistant responded.")
+        ```
+    """
+
+    def __init__(
+        self,
+        wallet_address: str,
+        private_key: str,
+        conversation_id: Optional[str] = None,
+        api_url: Optional[str] = None,
+        chain: str = "base",
+    ):
+        self.wallet_address = wallet_address
+        self.api_url = api_url or os.environ.get("XACHE_API_URL", "https://api.xache.xyz")
+        self.chain = chain
+        # Use UUID for collision-resistant conversation ID
+        self.conversation_id = conversation_id or f"autogen-{uuid.uuid4()}"
+
+        chain_prefix = "sol" if chain == "solana" else "evm"
+        self.did = f"did:agent:{chain_prefix}:{wallet_address.lower()}"
+
+        self._client = XacheClient(
+            api_url=self.api_url,
+            did=self.did,
+            private_key=private_key,
+        )
+
+        # Local message buffer
+        self._messages: List[Dict[str, str]] = []
+
+    def add_message(self, role: str, content: str, metadata: Optional[Dict] = None):
+        """
+        Add a message to the conversation.
+
+        Args:
+            role: Message role (user, assistant, system)
+            content: Message content
+            metadata: Optional metadata
+        """
+        import json
+        import time
+
+        message = {
+            "role": role,
+            "content": content,
+            "timestamp": time.time(),
+        }
+        self._messages.append(message)
+
+        # Store to Xache
+        async def _store():
+            async with self._client as client:
+                result = await client.memory.store(
+                    content=json.dumps(message),
+                    context=f"autogen:conversation:{self.conversation_id}",
+                    tags=["autogen", "conversation", role],
+                    metadata={
+                        "conversationId": self.conversation_id,
+                        "role": role,
+                        **(metadata or {}),
+                    },
+                )
+                return result
+
+        run_sync(_store())
+
+    def get_history(self, limit: int = 50) -> List[Dict[str, str]]:
+        """
+        Get conversation history from remote and update local cache.
+
+        Args:
+            limit: Maximum messages to retrieve
+
+        Returns:
+            List of messages
+        """
+        import json
+
+        async def _retrieve():
+            async with self._client as client:
+                result = await client.memory.retrieve(
+                    context=f"autogen:conversation:{self.conversation_id}",
+                    limit=limit,
+                )
+                return result
+
+        result = run_sync(_retrieve())
+
+        # Defensive type checking
+        memories = result.get("memories", []) if isinstance(result, dict) else []
+
+        messages = []
+        for m in memories:
+            try:
+                msg = json.loads(m.get("content", "{}"))
+                messages.append(msg)
+            except json.JSONDecodeError:
+                pass
+
+        # Sort by timestamp
+        messages.sort(key=lambda x: x.get("timestamp", 0))
+
+        # Sync local cache with remote
+        self._messages = messages
+
+        return messages
+
+    def refresh(self) -> List[Dict[str, str]]:
+        """
+        Refresh local cache from remote storage.
+
+        Returns:
+            Updated list of messages
+        """
+        return self.get_history()
+
+    def store_summary(self, summary: str, metadata: Optional[Dict] = None) -> str:
+        """
+        Store a conversation summary.
+
+        Args:
+            summary: Summary text
+            metadata: Optional metadata
+
+        Returns:
+            Memory ID
+        """
+
+        async def _store():
+            async with self._client as client:
+                result = await client.memory.store(
+                    content=summary,
+                    context=f"autogen:summary:{self.conversation_id}",
+                    tags=["autogen", "summary"],
+                    metadata={
+                        "conversationId": self.conversation_id,
+                        "messageCount": len(self._messages),
+                        **(metadata or {}),
+                    },
+                )
+                return result
+
+        result = run_sync(_store())
+
+        return result.get("memoryId", "")
+
+    def search(self, query: str, limit: int = 5) -> List[Dict]:
+        """
+        Search conversation history.
+
+        Args:
+            query: Search query
+            limit: Maximum results
+
+        Returns:
+            List of matching memories
+        """
+
+        async def _search():
+            async with self._client as client:
+                result = await client.memory.retrieve(
+                    query=query,
+                    context=f"autogen:conversation:{self.conversation_id}",
+                    limit=limit,
+                )
+                return result
+
+        result = run_sync(_search())
+
+        # Defensive type checking
+        if isinstance(result, dict):
+            return result.get("memories", [])
+        return []
+
+    def clear_local(self):
+        """Clear local message buffer (doesn't delete from Xache)"""
+        self._messages = []
+
+    @property
+    def messages(self) -> List[Dict[str, str]]:
+        """Get local message buffer"""
+        return self._messages
+
+    def format_for_prompt(self, max_messages: int = 10) -> str:
+        """
+        Format recent history for inclusion in prompt.
+
+        Args:
+            max_messages: Maximum messages to include
+
+        Returns:
+            Formatted string
+        """
+        recent = self._messages[-max_messages:] if self._messages else []
+
+        if not recent:
+            return ""
+
+        lines = []
+        for msg in recent:
+            role = msg.get("role", "unknown").capitalize()
+            content = msg.get("content", "")
+            lines.append(f"{role}: {content}")
+
+        return "\n".join(lines)