agentify-core 0.2.0__tar.gz → 0.3.0__tar.gz

{agentify_core-0.2.0/agentify_core.egg-info → agentify_core-0.3.0}/PKG-INFO

@@ -1,19 +1,18 @@
 Metadata-Version: 2.4
 Name: agentify-core
-Version: 0.2.0
+Version: 0.3.0
 Summary: Framework-agnostic AI agent library for building single and multi-agent systems
-Author-email: Fabian M <fabian@example.com>
+Author-email: Fabian M <fabianmp_98@hotmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/fa8i/Agentify
 Project-URL: Repository, https://github.com/fa8i/Agentify
 Project-URL: Bug Tracker, https://github.com/fa8i/Agentify/issues
-Keywords: agent,multi-agent,ai,llm,openai,framework
+Keywords: agentify,agentify-core,agent,multi-agent,ai,llm,openai,framework
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 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
@@ -22,19 +21,25 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: openai>=1.0.0
-Requires-Dist: python-dotenv>=0.19.0
-Requires-Dist: Pillow>=9.0.0
+Requires-Dist: openai
+Requires-Dist: python-dotenv
+Requires-Dist: Pillow
 Provides-Extra: redis
 Requires-Dist: redis>=4.0.0; extra == "redis"
+Provides-Extra: elastic
+Requires-Dist: elasticsearch>=8.0.0; extra == "elastic"
 Provides-Extra: tools
 Requires-Dist: requests>=2.25.0; extra == "tools"
+Provides-Extra: mcp
+Requires-Dist: mcp; extra == "mcp"
 Provides-Extra: ui
 Requires-Dist: gradio==5.49.1; extra == "ui"
 Provides-Extra: all
 Requires-Dist: redis>=4.0.0; extra == "all"
+Requires-Dist: elasticsearch>=8.0.0; extra == "all"
 Requires-Dist: requests>=2.25.0; extra == "all"
 Requires-Dist: gradio==5.49.1; extra == "all"
+Requires-Dist: mcp; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -47,6 +52,7 @@ Dynamic: license-file
 
 # Agentify
 
+
 **Independent AI agent library based on the OpenAI SDK**
 
 Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It targets the OpenAI-compatible Chat Completions interface, enabling support for multiple providers through a configurable `base_url` (OpenAI, Azure OpenAI, DeepSeek, Gemini, etc.). Agentify offers a streamlined, independent set of primitives for memory, tools, and coordination so you can focus on product logic without being tied to heavy frameworks.

{agentify_core-0.2.0 → agentify_core-0.3.0}/README.md

@@ -1,40 +1,25 @@
 # Agentify
 
-**Independent AI agent library based on the OpenAI SDK**
-
-Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It targets the OpenAI-compatible Chat Completions interface, enabling support for multiple providers through a configurable `base_url` (OpenAI, Azure OpenAI, DeepSeek, Gemini, etc.). Agentify offers a streamlined, independent set of primitives for memory, tools, and coordination so you can focus on product logic without being tied to heavy frameworks.
-
+[![PyPI version](https://img.shields.io/pypi/v/agentify-core?color=orange)](https://pypi.org/project/agentify-core/)
+[![Downloads](https://img.shields.io/pepy/dt/agentify-core)](https://pepy.tech/project/agentify-core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/agentify-core)](https://pypi.org/project/agentify-core/)
 
-## Why Agentify?
+**Independent AI agent library based on the OpenAI SDK**
 
-- **Built for production**: clear abstractions, explicit configuration, error handling and extension points that map well to real deployments.
-- **Orchestration-first design**: a uniform `run()` interface for agents, teams, pipelines and hierarchies makes it straightforward to compose and refactor flows.
-- **Providers**: switch between OpenAI, Gemini, Azure OpenAI, DeepSeek, Claude and others without changing your agent code.
+Agentify is a Python library for building AI agents and multi-agent systems. Built on the OpenAI-compatible Chat Completions interface, it supports multiple providers (OpenAI, Azure, DeepSeek, Gemini, Claude) with clear abstractions for memory, tools, and orchestration—no heavy framework lock-in.
 
 
 ## Key Features
 
-- **Agents and multi-agent patterns**  
-  Single Agents with tools and memory, supervisor–worker Multi-Agent Teams, Sequential Pipelines where output flows from step to step, Hierarchical Structures for complex delegation, and Dynamic Flows where a controller decides at runtime which sub-agents or teams to invoke.
-
-- **Memory service and isolation**  
-  Pluggable backends (in-memory, Redis, …) with per-use-case policies (TTL, maximum messages, etc.), plus optional memory isolation so each agent can maintain its own conversation history for scalability and privacy.
-
-- **Reasoning Models**  
-  Configure the model's thinking depth, safely merge `model_kwargs`, automatically store
-  "Chain of Thought" in conversation history, and log reasoning steps in real-time for visibility.
-
-- **Tools and actions**  
-  Simple `@tool` decorator for creating tools from functions with automatic JSON Schema generation, or type-annotated tool interface for custom implementations.
-
-- **Observability hooks**  
-  Callback system for logging, monitoring and debugging agent behaviour across complex flows.
-
-- **I/O capabilities**  
-  Streaming support for real-time responses and vision/image models for multimodal interactions.
-
-- **Async & Parallel Execution**  
-  Built-in `async/await` support (`arun()`) for all agents and flows. Automatically executes independent tool calls in parallel (e.g., fetching data from 3 APIs simultaneously), significantly reducing latency.
+- **Multi-agent orchestration**: Teams, pipelines, hierarchies, and dynamic sub-agent spawning
+- **Memory service**: Pluggable backends (in-memory, SQLite, Redis, Elasticsearch) with policies (TTL, limits, token budgets)
+- **Tools**: `@tool` decorator for auto-schema generation, or custom tool classes. Built-in file I/O, planning, weather, and more
+- **MCP Integration**: Easy connection to MCP servers via StdIO (local) or SSE/HTTP (remote) to use external tools
+- **Reasoning models**: Configure thinking depth, store chain-of-thought, real-time reasoning logs
+- **Async & parallel**: `arun()` support with automatic parallel tool and agent execution
+- **Observability**: Callback system for monitoring and debugging
+- **Advanced capabilities**: Dynamic workflows, file/directory operations, complex state management
 
 
 ## Installation

{agentify_core-0.2.0 → agentify_core-0.3.0}/README_PYPI.md

@@ -1,5 +1,6 @@
 # Agentify
 
+
 **Independent AI agent library based on the OpenAI SDK**
 
 Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It targets the OpenAI-compatible Chat Completions interface, enabling support for multiple providers through a configurable `base_url` (OpenAI, Azure OpenAI, DeepSeek, Gemini, etc.). Agentify offers a streamlined, independent set of primitives for memory, tools, and coordination so you can focus on product logic without being tied to heavy frameworks.
@@ -112,4 +113,4 @@ MIT License - see the repository for details.
 
 ## Author
 
-**Fabian Melchor** - [fabianmp_98@hotmail.com](mailto:fabianmp_98@hotmail.com)
+**Fabian Melchor** - [fabianmp_98@hotmail.com](mailto:fabianmp_98@hotmail.com)

{agentify_core-0.2.0 → agentify_core-0.3.0}/agentify/__init__.py

@@ -11,7 +11,7 @@ from agentify.memory.service import MemoryService
 from agentify.memory.interfaces import MemoryAddress
 from agentify.memory.policies import MemoryPolicy
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 __all__ = [
     "BaseAgent",

agentify_core-0.3.0/agentify/mcp/__init__.py

@@ -0,0 +1,3 @@
+from agentify.mcp.client import MCPConnection
+
+__all__ = ["MCPConnection"]

agentify_core-0.3.0/agentify/mcp/adapter.py

@@ -0,0 +1,46 @@
+"""Adapter to convert MCP tools into Agentify Tool objects."""
+from typing import Any, Callable, List
+from mcp import ClientSession
+from agentify.core.tool import Tool
+
+
+async def convert_mcp_tools_to_agentify(
+    session: ClientSession,
+    mcp_tools: List[Any],
+) -> List[Tool]:
+    """Transforms MCP tools into Agentify-compatible Tool objects."""
+    agentify_tools: List[Tool] = []
+
+    for m_tool in mcp_tools:
+        schema = {
+            "name": m_tool.name,
+            "description": m_tool.description or "",
+            "parameters": m_tool.inputSchema,
+        }
+        wrapper = _create_tool_wrapper(session, m_tool.name)
+        agentify_tools.append(Tool(schema=schema, func=wrapper))
+
+    return agentify_tools
+
+
+def _create_tool_wrapper(session: ClientSession, tool_name: str) -> Callable[..., Any]:
+    """Creates an async wrapper function that calls the MCP server."""
+
+    async def _mcp_tool_wrapper(**kwargs: Any) -> Any:
+        result = await session.call_tool(tool_name, arguments=kwargs)
+
+        output_parts = []
+        if result.content:
+            for item in result.content:
+                if item.type == "text":
+                    output_parts.append(item.text)
+                elif item.type == "image":
+                    output_parts.append(f"[Image: {item.mimeType}]")
+                elif item.type == "resource":
+                    output_parts.append(f"[Resource: {item.resource.uri}]")
+
+        return "\n".join(output_parts)
+
+    _mcp_tool_wrapper.__name__ = tool_name
+    _mcp_tool_wrapper.__doc__ = f"MCP Tool: {tool_name}"
+    return _mcp_tool_wrapper

agentify_core-0.3.0/agentify/mcp/client.py

@@ -0,0 +1,141 @@
+"""Async Context Manager for MCP Client connections."""
+import os
+from enum import Enum, auto
+from typing import Any, Dict, List, Optional
+from contextlib import AbstractAsyncContextManager, AsyncExitStack
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from mcp.client.sse import sse_client
+
+from agentify.mcp.adapter import convert_mcp_tools_to_agentify
+from agentify.core.tool import Tool
+
+
+class _Transport(Enum):
+    """Internal enum for transport type."""
+    STDIO = auto()
+    SSE = auto()
+
+
+class MCPConnection(AbstractAsyncContextManager):
+    """Manages MCP server connections via StdIO or SSE transport.
+
+    Use the factory methods to create connections:
+        - `MCPConnection.stdio(...)` for local process servers
+        - `MCPConnection.sse(...)` for remote HTTP/SSE servers
+
+    Example (StdIO):
+        async with MCPConnection.stdio(command="uvx", args=["mcp-server-fetch"]) as mcp:
+            tools = await mcp.get_tools()
+
+    Example (SSE):
+        async with MCPConnection.sse(url="http://localhost:8080/sse") as mcp:
+            tools = await mcp.get_tools()
+    """
+
+    def __init__(self) -> None:
+        """Private constructor. Use factory methods instead."""
+        self._transport: Optional[_Transport] = None
+        self._session: Optional[ClientSession] = None
+        self._exit_stack: Optional[AsyncExitStack] = None
+        # StdIO params
+        self._stdio_params: Optional[StdioServerParameters] = None
+        # SSE params
+        self._sse_url: Optional[str] = None
+        self._sse_headers: Optional[Dict[str, Any]] = None
+        self._sse_timeout: float = 5.0
+        self._sse_read_timeout: float = 300.0
+
+    @classmethod
+    def stdio(
+        cls,
+        command: str,
+        args: List[str],
+        env: Optional[Dict[str, str]] = None
+    ) -> "MCPConnection":
+        """Create a connection to a local MCP server via StdIO.
+
+        Args:
+            command: The command to run (e.g., "python", "uvx").
+            args: Arguments to pass to the command.
+            env: Optional environment variables for the process.
+        """
+        instance = cls()
+        instance._transport = _Transport.STDIO
+        instance._stdio_params = StdioServerParameters(
+            command=command,
+            args=args,
+            env=env or os.environ.copy()
+        )
+        return instance
+
+    @classmethod
+    def sse(
+        cls,
+        url: str,
+        headers: Optional[Dict[str, Any]] = None,
+        timeout: float = 5.0,
+        sse_read_timeout: float = 300.0,
+    ) -> "MCPConnection":
+        """Create a connection to a remote MCP server via SSE/HTTP.
+
+        Args:
+            url: The SSE endpoint URL.
+            headers: Optional HTTP headers (e.g., for authentication).
+            timeout: HTTP timeout for regular operations.
+            sse_read_timeout: Timeout for SSE read operations.
+        """
+        instance = cls()
+        instance._transport = _Transport.SSE
+        instance._sse_url = url
+        instance._sse_headers = headers
+        instance._sse_timeout = timeout
+        instance._sse_read_timeout = sse_read_timeout
+        return instance
+
+    async def __aenter__(self) -> "MCPConnection":
+        self._exit_stack = AsyncExitStack()
+        try:
+            if self._transport == _Transport.STDIO:
+                read, write = await self._exit_stack.enter_async_context(
+                    stdio_client(self._stdio_params)
+                )
+            elif self._transport == _Transport.SSE:
+                read, write = await self._exit_stack.enter_async_context(
+                    sse_client(
+                        url=self._sse_url,
+                        headers=self._sse_headers,
+                        timeout=self._sse_timeout,
+                        sse_read_timeout=self._sse_read_timeout,
+                    )
+                )
+            else:
+                raise ValueError("Transport not configured. Use MCPConnection.stdio() or MCPConnection.sse().")
+
+            self._session = await self._exit_stack.enter_async_context(
+                ClientSession(read, write)
+            )
+            await self._session.initialize()
+            return self
+        except Exception:
+            await self.aclose()
+            raise
+
+    async def __aexit__(self, exc_type, exc_value, traceback) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        """Gracefully closes the MCP connection."""
+        if self._exit_stack:
+            await self._exit_stack.aclose()
+            self._exit_stack = None
+            self._session = None
+
+    async def get_tools(self) -> List[Tool]:
+        """Fetches tools from the MCP server and converts them to Agentify format."""
+        if not self._session:
+            raise RuntimeError("MCPConnection is not active. Use 'async with ...'")
+
+        result = await self._session.list_tools()
+        return await convert_mcp_tools_to_agentify(self._session, result.tools)

{agentify_core-0.2.0 → agentify_core-0.3.0}/agentify/memory/interfaces.py

@@ -17,8 +17,7 @@ class MemoryAddress:
     user_id: Optional[str] = None
     conversation_id: Optional[str] = None
     agent_id: Optional[str] = None
-    # extras lets you pass stable routing dimensions if needed.
-    extras: Tuple[Tuple[str, str], ...] = ()
+    extras: Tuple[Tuple[str, str], ...] = ()  # extras lets pass stable routing dimensions if needed.
 
     def as_tuple(self) -> Tuple:
         """Stable, hashable representation for keys and indexing."""
@@ -94,6 +93,7 @@ class ConversationStore(Protocol):
     def replace_messages(self, addr: MemoryAddress, messages: List[Message]) -> None: ...
     def delete_conversation(self, addr: MemoryAddress) -> None: ...
     def set_ttl(self, addr: MemoryAddress, seconds: int) -> None: ...
+    def list_conversations(self, limit: int = 100, offset: int = 0) -> List[MemoryAddress]: ...
 
 
 class TokenCounter(Protocol):

{agentify_core-0.2.0 → agentify_core-0.3.0}/agentify/memory/service.py

@@ -69,7 +69,7 @@ class MemoryService:
 
             color = role_colors.get(msg.role, Colors.RESET)
             
-            # Extract agent_id if available to show WHO is speaking
+            # Extract agent_id if available to show who is speaking
             agent_id = addr.agent_id if addr and addr.agent_id else "unknown"
             agent_tag = f"[{agent_id}]" if agent_id else ""
             
@@ -124,3 +124,7 @@ class MemoryService:
     def delete_history(self, addr: MemoryAddress) -> None:
         """Remove all messages for the given address."""
         self.store.delete_conversation(addr)
+
+    def list_conversations(self, limit: int = 100, offset: int = 0) -> List[MemoryAddress]:
+        """List active conversations from the underlying store."""
+        return self.store.list_conversations(limit=limit, offset=offset)

agentify_core-0.3.0/agentify/memory/stores/__init__.py

@@ -0,0 +1,10 @@
+"""Memory storage backends."""
+from .in_memory_store import InMemoryStore
+from .redis_store import RedisStore
+from .elastic_store import ElasticsearchStore
+from .sqlite_store import SQLiteStore
+
+__all__ = ["InMemoryStore", "RedisStore", "ElasticsearchStore", "SQLiteStore"]
+
+
+

agentify_core-0.3.0/agentify/memory/stores/elastic_store.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+import json
+import logging
+from typing import List, Optional, Any, Dict
+from datetime import datetime
+
+try:
+    from elasticsearch import Elasticsearch
+    from elasticsearch.helpers import bulk
+except ImportError:
+    Elasticsearch = None  # type: ignore
+    bulk = None  # type: ignore
+
+from ..interfaces import ConversationStore, MemoryAddress, Message
+
+logger = logging.getLogger(__name__)
+
+
+class ElasticsearchStore(ConversationStore):
+    """
+    Elasticsearch-backed store.
+    Stores messages as individual documents to enable advanced search.
+    """
+
+    def __init__(
+        self,
+        url: str = "http://localhost:9200",
+        api_key: Optional[str] = None,
+        index_name: str = "agentify-memory",
+        verify_certs: bool = True,
+    ) -> None:
+        if Elasticsearch is None:
+            raise ImportError(
+                "Elasticsearch is not installed. Please install agentify[elastic] or 'pip install elasticsearch'."
+            )
+
+        # Connection setup
+        options = {}
+        if api_key:
+            options["api_key"] = api_key
+        
+        self.client = Elasticsearch(
+            url,
+            verify_certs=verify_certs,
+            **options
+        )
+        self.index_name = index_name
+        self._ensure_index()
+
+    def _ensure_index(self) -> None:
+        """Create index with optimal mappings if it doesn't exist."""
+        if self.client.indices.exists(index=self.index_name):
+            return
+
+        mapping = {
+            "mappings": {
+                "properties": {
+                    # Address fields (Exact match)
+                    "api_version": {"type": "keyword"},
+                    "tenant_id": {"type": "keyword"},
+                    "user_id": {"type": "keyword"},
+                    "conversation_id": {"type": "keyword"},
+                    "agent_id": {"type": "keyword"},
+                    
+                    # Message fields
+                    "role": {"type": "keyword"},
+                    "content": {"type": "text"},  # Full-text searchable
+                    "name": {"type": "keyword"},
+                    "id": {"type": "keyword"},
+                    "ts": {"type": "date", "format": "epoch_second"},
+                    
+                    # Structured Objects 
+                    "metadata": {"type": "object", "enabled": True}, 
+                    "address_key": {"type": "keyword"}
+                }
+            }
+        }
+        try:
+            self.client.indices.create(index=self.index_name, body=mapping)
+            logger.info(f"Created Elasticsearch index: {self.index_name}")
+        except Exception as e:
+            logger.error(f"Failed to create index {self.index_name}: {e}")
+            raise
+
+    def _addr_to_doc(self, addr: MemoryAddress, msg: Message) -> Dict[str, Any]:
+        """Flatten address + message into a single document."""
+        base = msg.to_dict()
+        # Add filtering fields
+        base.update({
+            "api_version": addr.api_version,
+            "tenant_id": addr.tenant_id,
+            "user_id": addr.user_id,
+            "conversation_id": addr.conversation_id,
+            "agent_id": addr.agent_id,
+            "address_key": addr.key_str(),
+        })
+
+        return base
+
+    def _build_filter_query(self, addr: MemoryAddress) -> List[Dict[str, Any]]:
+        """Construct bool/filter clauses for the exact address."""
+        must = []
+        if addr.api_version:
+            must.append({"term": {"api_version": addr.api_version}})
+        if addr.tenant_id:
+            must.append({"term": {"tenant_id": addr.tenant_id}})
+        if addr.user_id:
+            must.append({"term": {"user_id": addr.user_id}})
+        if addr.conversation_id:
+            must.append({"term": {"conversation_id": addr.conversation_id}})
+        if addr.agent_id:
+            must.append({"term": {"agent_id": addr.agent_id}})
+        return must
+
+    def append_message(self, addr: MemoryAddress, msg: Message) -> None:
+        doc = self._addr_to_doc(addr, msg)
+        self.client.index(index=self.index_name, id=msg.id, document=doc, refresh=True) 
+        # refresh='true' makes it visible immediately (good for chat consistency, possibly slower for bulk)
+
+    def read_messages(self, addr: MemoryAddress, start: int = 0, end: int = -1) -> List[Message]:
+        must = self._build_filter_query(addr)
+        
+        # We need to fetch enough messages to support the slice.
+        # Since 'end' can be -1 (all), we might need a large size or scroll.
+        # For chat history, usually 100-1000 is enough.
+        size = 1000 if end == -1 else (end + 20)
+
+        query = {
+            "query": {"bool": {"filter": must}},
+            "sort": [{"ts": {"order": "asc"}}],
+            "size": size,
+            "from": start
+        }
+
+        resp = self.client.search(index=self.index_name, body=query)
+        hits = resp["hits"]["hits"]
+        
+        msgs = []
+        for h in hits:
+            src = h["_source"]
+            # Extract only message fields to reconstruct
+            m_kwargs = {
+                "role": src.get("role"),
+                "content": src.get("content"),
+                "name": src.get("name"),
+                "tool_call_id": src.get("tool_call_id"),
+                "metadata": src.get("metadata", {}),
+                "id": src.get("id"),
+                "ts": int(src.get("ts", 0))
+            }
+            msgs.append(Message(**m_kwargs))
+            
+        # Slice locally if specific end requested
+        if end != -1:
+            limit = end - start + 1
+            msgs = msgs[:limit]
+            
+        return msgs
+
+    def replace_messages(self, addr: MemoryAddress, messages: List[Message]) -> None:
+        # 1. Delete existing for this address
+        self.delete_conversation(addr)
+        
+        if not messages:
+            return
+
+        # 2. Bulk insert new
+        actions = []
+        for msg in messages:
+            doc = self._addr_to_doc(addr, msg)
+            actions.append({
+                "_index": self.index_name,
+                "_id": msg.id,
+                "_source": doc
+            })
+        
+        if actions:
+            bulk(self.client, actions, refresh=True)
+
+    def delete_conversation(self, addr: MemoryAddress) -> None:
+        must = self._build_filter_query(addr)
+        query = {"query": {"bool": {"filter": must}}}
+        self.client.delete_by_query(index=self.index_name, body=query, refresh=True)
+
+    def set_ttl(self, addr: MemoryAddress, seconds: int) -> None:
+        # Implementing TTL in ES usually requires Index Lifecycle Management (ILM) 
+        # or a separate cleanup job, as TTL is per-index or per-document requires setup.
+        # For simplicity, we log strictly: This is not natively supported per-conversation efficiently.
+        logger.warning("set_ttl is not fully supported in simple ElasticsearchStore yet.")
+
+    def list_conversations(self, limit: int = 100, offset: int = 0) -> List[MemoryAddress]:
+        """
+        List unique conversation addresses using aggregations.
+        Uses a terms aggregation on 'address_key'.
+        """
+        size = offset + limit
+        query = {
+            "size": 0,
+            "aggs": {
+                "unique_conversations": {
+                    "terms": {
+                        "field": "address_key",
+                        "size": size
+                    }
+                }
+            }
+        }
+        
+        resp = self.client.search(index=self.index_name, body=query)
+        buckets = resp["aggregations"]["unique_conversations"]["buckets"]
+        
+        # Apply offset/limit locally
+        buckets_slice = buckets[offset : offset + limit]
+        
+        results = []
+        for b in buckets_slice:
+            k = b["key"]
+            core = k
+            prefix_check = "mem:" 
+            if core.startswith(prefix_check):
+                core = core[len(prefix_check):]
+            
+            parts = core.split(":")
+            kwargs = {}
+            extras = []
+            
+            for part in parts:
+                if "=" not in part:
+                    continue
+                key, val = part.split("=", 1)
+                if key == "v": kwargs["api_version"] = val
+                elif key == "t": kwargs["tenant_id"] = val
+                elif key == "u": kwargs["user_id"] = val
+                elif key == "c": kwargs["conversation_id"] = val
+                elif key == "a": kwargs["agent_id"] = val
+                else:
+                    extras.append((key, val))
+            
+            if extras:
+                kwargs["extras"] = tuple(extras)
+                
+            results.append(MemoryAddress(**kwargs))
+            
+        return results

{agentify_core-0.2.0 → agentify_core-0.3.0}/agentify/memory/stores/in_memory_store.py

@@ -27,3 +27,9 @@ class InMemoryStore(ConversationStore):
 
     def set_ttl(self, addr: MemoryAddress, seconds: int) -> None:
         self._ttl[addr] = seconds  # not enforced in-memory
+
+    def list_conversations(self, limit: int = 100, offset: int = 0) -> List[MemoryAddress]:
+        keys = list(self._history.keys())
+        # Sort for stability
+        keys.sort(key=lambda k: k.key_str())
+        return keys[offset : offset + limit]