mcp-persist 0.1.0__tar.gz

mcp_persist-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Armaan Sandhu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_persist-0.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: mcp-persist
+Version: 0.1.0
+Summary: Production-grade persistence backends for the MCP Python SDK
+Project-URL: Homepage, https://github.com/Ar-maan05/mcp-persist
+Project-URL: Repository, https://github.com/Ar-maan05/mcp-persist
+Project-URL: Issues, https://github.com/Ar-maan05/mcp-persist/issues
+Author: Armaan Sandhu
+License: MIT
+License-File: LICENSE
+Keywords: eventstore,mcp,model-context-protocol,redis,resumability,sse
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.0.0
+Provides-Extra: dev
+Requires-Dist: anyio>=4.9; extra == 'dev'
+Requires-Dist: fakeredis>=2.26.0; extra == 'dev'
+Requires-Dist: pyright>=1.1.400; extra == 'dev'
+Requires-Dist: pytest-anyio; extra == 'dev'
+Requires-Dist: pytest>=8.3.4; extra == 'dev'
+Requires-Dist: ruff>=0.8.5; extra == 'dev'
+Provides-Extra: redis
+Requires-Dist: redis>=4.2.0; extra == 'redis'
+Description-Content-Type: text/markdown
+
+# mcp-persist
+
+Production-grade persistence backends for the [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk).
+
+The MCP SDK ships an `EventStore` interface but only an in-memory reference implementation. `mcp-persist` provides backends for real deployments where you need durability across process restarts and multi-worker environments.
+
+## Backends
+
+| Backend | Extra | Use case |
+|---|---|---|
+| `RedisEventStore` | `redis` | Multi-process / multi-worker SSE resumability |
+
+## Installation
+
+```bash
+pip install "mcp-persist[redis]"
+```
+
+## Quickstart
+
+```python
+import redis.asyncio as aioredis
+from mcp_persist import RedisEventStore
+from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
+
+redis_client = aioredis.from_url("redis://localhost:6379")
+store = RedisEventStore(redis_client, ttl=3600)  # 1 hour TTL
+
+session_manager = StreamableHTTPSessionManager(
+    app=mcp_server,
+    event_store=store,
+)
+```
+
+## RedisEventStore
+
+Stores MCP SSE events in Redis so clients can resume interrupted streams — even across worker restarts or load-balanced deployments.
+
+### How it works
+
+Redis data layout:
+
+```
+{prefix}counter                 — atomic INCR source for monotonic event IDs
+{prefix}event:{event_id}        — HASH: stream_id + serialized payload
+{prefix}stream:{stream_id}      — ZSET: event IDs sorted by score for O(log N) range queries
+```
+
+- **Atomic monotonic IDs** via Redis `INCR` — collision-free across concurrent workers
+- **O(log N) replay** via sorted set `ZRANGEBYSCORE`
+- **TTL support** — automatic key expiry to prevent unbounded memory growth
+- **Multi-tenant isolation** via configurable `key_prefix`
+- **Priming event handling** — sentinel empty-string payloads are stored but never replayed to clients
+
+### Configuration
+
+```python
+RedisEventStore(
+    redis,                  # redis.asyncio.Redis instance
+    key_prefix="mcp:",      # isolate multiple servers on one Redis instance
+    ttl=3600,               # seconds; None = never expire (not recommended)
+)
+```
+
+**TTL guidance:** Set `ttl` to at least 2× your session idle timeout. If you leave it as `None`, a warning is logged and events accumulate indefinitely.
+
+### Multi-tenant deployments
+
+If multiple MCP servers share a Redis instance, use different prefixes:
+
+```python
+store_a = RedisEventStore(redis_client, key_prefix="server-a:")
+store_b = RedisEventStore(redis_client, key_prefix="server-b:")
+```
+
+## Development
+
+```bash
+git clone https://github.com/Ar-maan05/mcp-persist
+cd mcp-persist
+pip install -e ".[redis,dev]"
+pytest tests/
+```
+
+Tests use [fakeredis](https://github.com/cunla/fakeredis-py) — no external Redis server required.
+
+## License
+
+MIT

mcp_persist-0.1.0/README.md

@@ -0,0 +1,89 @@
+# mcp-persist
+
+Production-grade persistence backends for the [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk).
+
+The MCP SDK ships an `EventStore` interface but only an in-memory reference implementation. `mcp-persist` provides backends for real deployments where you need durability across process restarts and multi-worker environments.
+
+## Backends
+
+| Backend | Extra | Use case |
+|---|---|---|
+| `RedisEventStore` | `redis` | Multi-process / multi-worker SSE resumability |
+
+## Installation
+
+```bash
+pip install "mcp-persist[redis]"
+```
+
+## Quickstart
+
+```python
+import redis.asyncio as aioredis
+from mcp_persist import RedisEventStore
+from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
+
+redis_client = aioredis.from_url("redis://localhost:6379")
+store = RedisEventStore(redis_client, ttl=3600)  # 1 hour TTL
+
+session_manager = StreamableHTTPSessionManager(
+    app=mcp_server,
+    event_store=store,
+)
+```
+
+## RedisEventStore
+
+Stores MCP SSE events in Redis so clients can resume interrupted streams — even across worker restarts or load-balanced deployments.
+
+### How it works
+
+Redis data layout:
+
+```
+{prefix}counter                 — atomic INCR source for monotonic event IDs
+{prefix}event:{event_id}        — HASH: stream_id + serialized payload
+{prefix}stream:{stream_id}      — ZSET: event IDs sorted by score for O(log N) range queries
+```
+
+- **Atomic monotonic IDs** via Redis `INCR` — collision-free across concurrent workers
+- **O(log N) replay** via sorted set `ZRANGEBYSCORE`
+- **TTL support** — automatic key expiry to prevent unbounded memory growth
+- **Multi-tenant isolation** via configurable `key_prefix`
+- **Priming event handling** — sentinel empty-string payloads are stored but never replayed to clients
+
+### Configuration
+
+```python
+RedisEventStore(
+    redis,                  # redis.asyncio.Redis instance
+    key_prefix="mcp:",      # isolate multiple servers on one Redis instance
+    ttl=3600,               # seconds; None = never expire (not recommended)
+)
+```
+
+**TTL guidance:** Set `ttl` to at least 2× your session idle timeout. If you leave it as `None`, a warning is logged and events accumulate indefinitely.
+
+### Multi-tenant deployments
+
+If multiple MCP servers share a Redis instance, use different prefixes:
+
+```python
+store_a = RedisEventStore(redis_client, key_prefix="server-a:")
+store_b = RedisEventStore(redis_client, key_prefix="server-b:")
+```
+
+## Development
+
+```bash
+git clone https://github.com/Ar-maan05/mcp-persist
+cd mcp-persist
+pip install -e ".[redis,dev]"
+pytest tests/
+```
+
+Tests use [fakeredis](https://github.com/cunla/fakeredis-py) — no external Redis server required.
+
+## License
+
+MIT

mcp_persist-0.1.0/__init__.py

@@ -0,0 +1,15 @@
+"""mcp-persist: Production-grade persistence backends for the MCP Python SDK.
+
+Currently ships:
+    RedisEventStore — Redis-backed EventStore for SSE stream resumability
+                      across multi-process/multi-worker deployments.
+
+Usage:
+    pip install "mcp-persist[redis]"
+
+    from mcp_persist import RedisEventStore
+"""
+
+from mcp_persist.redis import RedisEventStore
+
+__all__ = ["RedisEventStore"]

mcp_persist-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[project]
+name = "mcp-persist"
+version = "0.1.0"
+description = "Production-grade persistence backends for the MCP Python SDK"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Armaan Sandhu", github = "Ar-maan05" }]
+keywords = ["mcp", "model-context-protocol", "redis", "eventstore", "sse", "resumability"]
+license = { text = "MIT" }
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "mcp>=1.0.0",
+]
+
+[project.optional-dependencies]
+redis = ["redis>=4.2.0"]
+dev = [
+    "pytest>=8.3.4",
+    "anyio>=4.9",
+    "fakeredis>=2.26.0",
+    "pytest-anyio",
+    "pyright>=1.1.400",
+    "ruff>=0.8.5",
+]
+
+[project.urls]
+Homepage = "https://github.com/Ar-maan05/mcp-persist"
+Repository = "https://github.com/Ar-maan05/mcp-persist"
+Issues = "https://github.com/Ar-maan05/mcp-persist/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcp_persist"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+addopts = "--color=yes -p anyio"
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]

mcp_persist-0.1.0/redis.py

@@ -0,0 +1,169 @@
+"""Redis-backed EventStore for MCP SSE stream resumability.
+
+Requires the redis extra:
+    pip install "mcp-persist[redis]"
+
+Quickstart:
+    import redis.asyncio as aioredis
+    from mcp_persist import RedisEventStore
+    from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
+
+    redis_client = aioredis.from_url("redis://localhost:6379")
+    store = RedisEventStore(redis_client, ttl=3600)
+
+    session_manager = StreamableHTTPSessionManager(
+        app=mcp_server,
+        event_store=store,
+    )
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from mcp.server.streamable_http import (
+    EventCallback,
+    EventId,
+    EventMessage,
+    EventStore,
+    StreamId,
+)
+from mcp.types import JSONRPCMessage, jsonrpc_message_adapter
+
+if TYPE_CHECKING:
+    pass
+
+logger = logging.getLogger(__name__)
+
+
+class RedisEventStore(EventStore):
+    """EventStore backed by Redis for production multi-process deployments.
+
+    Redis data layout:
+        {prefix}counter                — STRING, atomic INCR source for EventIds
+        {prefix}event:{event_id}       — HASH, fields: stream_id + payload
+        {prefix}stream:{stream_id}     — ZSET, members: event_ids, scores: int(event_id)
+
+    Args:
+        redis:      An already-connected redis.asyncio.Redis instance.
+        key_prefix: Prefix for all Redis keys. Use different prefixes when
+                    multiple MCP servers share one Redis instance.
+                    Default: "mcp:".
+        ttl:        Seconds after which keys expire automatically.
+                    None means keys never expire — strongly discouraged in
+                    production. Recommended: at least 2× session_idle_timeout.
+    """
+
+    def __init__(
+        self,
+        redis: Any,  # redis.asyncio.Redis at runtime
+        *,
+        key_prefix: str = "mcp:",
+        ttl: int | None = None,
+    ) -> None:
+        self._redis = redis
+        self._prefix = key_prefix
+        self._ttl = ttl
+
+        if ttl is None:
+            logger.warning(
+                "RedisEventStore created with ttl=None. "
+                "Events will accumulate indefinitely in Redis. "
+                "Set ttl= to a positive number of seconds "
+                "(recommended: at least 2× your session_idle_timeout)."
+            )
+
+    # Key helpers
+
+    def _counter_key(self) -> str:
+        return f"{self._prefix}counter"
+
+    def _event_key(self, event_id: EventId) -> str:
+        return f"{self._prefix}event:{event_id}"
+
+    def _stream_key(self, stream_id: StreamId) -> str:
+        return f"{self._prefix}stream:{stream_id}"
+
+    # EventStore interface
+
+    async def store_event(
+        self,
+        stream_id: StreamId,
+        message: JSONRPCMessage | None,
+    ) -> EventId:
+        """Store an event and return its unique, monotonically increasing ID."""
+        event_id_int: int = await self._redis.incr(self._counter_key())
+        event_id: EventId = str(event_id_int)
+
+        if message is None:
+            payload = ""
+        else:
+            payload = jsonrpc_message_adapter.dump_json(
+                message,
+                by_alias=True,
+                exclude_none=True,
+            ).decode("utf-8")
+
+        await self._redis.hset(
+            self._event_key(event_id),
+            mapping={
+                "stream_id": stream_id,
+                "payload": payload,
+            },
+        )
+
+        await self._redis.zadd(
+            self._stream_key(stream_id),
+            {event_id: event_id_int},
+        )
+
+        if self._ttl is not None:
+            await self._redis.expire(self._event_key(event_id), self._ttl)
+            await self._redis.expire(self._stream_key(stream_id), self._ttl)
+            await self._redis.expire(self._counter_key(), self._ttl)
+
+        return event_id
+
+    async def replay_events_after(
+        self,
+        last_event_id: EventId,
+        send_callback: EventCallback,
+    ) -> StreamId | None:
+        """Replay all events on the same stream that occurred after last_event_id."""
+        stream_id_raw: bytes | None = await self._redis.hget(
+            self._event_key(last_event_id), "stream_id"
+        )
+
+        if stream_id_raw is None:
+            return None
+
+        stream_id: StreamId = stream_id_raw.decode("utf-8")
+
+        last_int = int(last_event_id)
+        raw_ids: list[bytes] = await self._redis.zrangebyscore(
+            self._stream_key(stream_id),
+            min=last_int + 1,
+            max="+inf",
+        )
+
+        for eid_bytes in raw_ids:
+            eid: EventId = eid_bytes.decode("utf-8")
+
+            payload_raw: bytes | None = await self._redis.hget(
+                self._event_key(eid), "payload"
+            )
+
+            if payload_raw is None:
+                logger.debug("Event %s payload missing during replay (expired?)", eid)
+                continue
+
+            payload_str = payload_raw.decode("utf-8")
+
+            if not payload_str:
+                continue
+
+            message = jsonrpc_message_adapter.validate_json(payload_str)
+            await send_callback(EventMessage(message=message, event_id=eid))
+
+        return stream_id

mcp_persist-0.1.0/test_redis_event_store.py

@@ -0,0 +1,326 @@
+# pyright: reportUnknownParameterType=false
+# pyright: reportMissingParameterType=false
+# pyright: reportUnknownArgumentType=false
+# pyright: reportUnknownVariableType=false
+# pyright: reportUnknownMemberType=false
+"""Tests for RedisEventStore.
+
+Uses fakeredis — no external Redis server required.
+All tests are async (anyio/asyncio backend).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+
+import fakeredis.aioredis as fakeredis
+import pytest
+
+from mcp_persist import RedisEventStore
+from mcp.server.streamable_http import EventId, EventMessage, StreamId
+from mcp.types import JSONRPCRequest
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+SAMPLE_MSG = JSONRPCRequest(jsonrpc="2.0", id="1", method="tools/list")
+
+
+@pytest.fixture
+async def redis_client():
+    client = fakeredis.FakeRedis()
+    try:
+        yield client
+    finally:
+        try:
+            await client.aclose()
+        except AttributeError:
+            await client.close()
+
+
+@pytest.fixture
+def store(redis_client, recwarn):
+    return RedisEventStore(redis_client, key_prefix="test:", ttl=None)
+
+
+@pytest.fixture
+def store_with_ttl(redis_client):
+    return RedisEventStore(redis_client, key_prefix="test:", ttl=60)
+
+
+# ── Shared helper ─────────────────────────────────────────────────────────────
+
+
+async def collect_events(
+    store: RedisEventStore,
+    last_event_id: EventId,
+) -> tuple[list[EventMessage], StreamId | None]:
+    captured: list[EventMessage] = []
+
+    async def cb(event: EventMessage) -> None:
+        captured.append(event)
+
+    stream_id = await store.replay_events_after(last_event_id, cb)
+    return captured, stream_id
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# store_event tests
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+@pytest.mark.anyio
+async def test_store_event_returns_string_integer(store):
+    id1 = await store.store_event("stream-A", SAMPLE_MSG)
+    assert isinstance(id1, str)
+    assert id1.isdigit()
+
+
+@pytest.mark.anyio
+async def test_store_event_ids_are_monotonically_increasing(store):
+    id1 = await store.store_event("stream-A", SAMPLE_MSG)
+    id2 = await store.store_event("stream-A", SAMPLE_MSG)
+    id3 = await store.store_event("stream-B", SAMPLE_MSG)
+
+    assert int(id1) < int(id2) < int(id3)
+    assert id1 == "1"
+
+
+@pytest.mark.anyio
+async def test_store_priming_event_writes_empty_payload(store, redis_client):
+    event_id = await store.store_event("stream-A", None)
+
+    raw = await redis_client.hget(f"test:event:{event_id}", "payload")
+    assert raw == b""
+
+
+@pytest.mark.anyio
+async def test_store_event_writes_stream_id_to_hash(store, redis_client):
+    event_id = await store.store_event("my-stream", SAMPLE_MSG)
+
+    raw_stream = await redis_client.hget(f"test:event:{event_id}", "stream_id")
+    assert raw_stream == b"my-stream"
+
+
+@pytest.mark.anyio
+async def test_store_event_adds_to_sorted_set(store, redis_client):
+    id1 = await store.store_event("stream-A", SAMPLE_MSG)
+    id2 = await store.store_event("stream-A", SAMPLE_MSG)
+
+    members = await redis_client.zrange("test:stream:stream-A", 0, -1)
+    decoded = [m.decode() for m in members]
+    assert id1 in decoded
+    assert id2 in decoded
+    assert decoded.index(id1) < decoded.index(id2)
+
+
+@pytest.mark.anyio
+async def test_concurrent_store_event_produces_unique_ids(store):
+    tasks = [asyncio.create_task(store.store_event("stream-X", SAMPLE_MSG)) for _ in range(50)]
+    ids = await asyncio.gather(*tasks)
+
+    assert len(set(ids)) == 50
+    assert all(id_.isdigit() for id_ in ids)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# replay_events_after tests
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+@pytest.mark.anyio
+async def test_replay_unknown_id_returns_none(store):
+    events, stream_id = await collect_events(store, "9999")
+    assert stream_id is None
+    assert events == []
+
+
+@pytest.mark.anyio
+async def test_replay_returns_correct_stream_id(store):
+    anchor = await store.store_event("my-stream", SAMPLE_MSG)
+
+    events, stream_id = await collect_events(store, anchor)
+    assert stream_id == "my-stream"
+    assert events == []
+
+
+@pytest.mark.anyio
+async def test_replay_skips_priming_events(store):
+    anchor = await store.store_event("stream-A", SAMPLE_MSG)
+    _ = await store.store_event("stream-A", None)
+    id3 = await store.store_event("stream-A", SAMPLE_MSG)
+
+    events, _ = await collect_events(store, anchor)
+
+    assert len(events) == 1
+    assert events[0].event_id == id3
+
+
+@pytest.mark.anyio
+async def test_replay_skips_expired_event_payloads(store, redis_client):
+    anchor = await store.store_event("stream-A", SAMPLE_MSG)
+    id2 = await store.store_event("stream-A", SAMPLE_MSG)
+    id3 = await store.store_event("stream-A", SAMPLE_MSG)
+
+    await redis_client.delete(f"test:event:{id2}")
+
+    events, _ = await collect_events(store, anchor)
+
+    assert len(events) == 1
+    assert events[0].event_id == id3
+
+
+@pytest.mark.anyio
+async def test_replay_events_are_in_ascending_order(store):
+    anchor = await store.store_event("stream-A", SAMPLE_MSG)
+    id2 = await store.store_event("stream-A", SAMPLE_MSG)
+    id3 = await store.store_event("stream-A", SAMPLE_MSG)
+
+    events, _ = await collect_events(store, anchor)
+
+    assert len(events) == 2
+    assert events[0].event_id == id2
+    assert events[1].event_id == id3
+
+
+@pytest.mark.anyio
+async def test_replay_excludes_anchor_event_itself(store):
+    anchor = await store.store_event("stream-A", SAMPLE_MSG)
+    id2 = await store.store_event("stream-A", SAMPLE_MSG)
+
+    events, _ = await collect_events(store, anchor)
+
+    event_ids = [e.event_id for e in events]
+    assert anchor not in event_ids
+    assert id2 in event_ids
+
+
+@pytest.mark.anyio
+async def test_replay_stream_isolation(store):
+    anchor = await store.store_event("stream-A", SAMPLE_MSG)
+
+    _ = await store.store_event("stream-B", SAMPLE_MSG)
+    _ = await store.store_event("stream-B", SAMPLE_MSG)
+
+    id4 = await store.store_event("stream-A", SAMPLE_MSG)
+
+    events, stream_id = await collect_events(store, anchor)
+
+    assert stream_id == "stream-A"
+    assert len(events) == 1
+    assert events[0].event_id == id4
+
+
+@pytest.mark.anyio
+async def test_replay_message_content_round_trips(store):
+    original = JSONRPCRequest(jsonrpc="2.0", id="99", method="resources/list")
+    anchor = await store.store_event("stream-A", original)
+    await store.store_event("stream-A", original)
+
+    events, _ = await collect_events(store, anchor)
+
+    assert len(events) == 1
+    replayed = events[0].message
+    assert isinstance(replayed, JSONRPCRequest)
+    assert replayed.method == "resources/list"
+    assert replayed.id == "99"
+
+
+@pytest.mark.anyio
+async def test_replay_event_id_is_attached_to_event_message(store):
+    anchor = await store.store_event("stream-A", SAMPLE_MSG)
+    id2 = await store.store_event("stream-A", SAMPLE_MSG)
+
+    events, _ = await collect_events(store, anchor)
+
+    assert events[0].event_id == id2
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# TTL tests
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+@pytest.mark.anyio
+async def test_event_key_has_ttl_when_configured(store_with_ttl, redis_client):
+    event_id = await store_with_ttl.store_event("stream-A", SAMPLE_MSG)
+
+    ttl = await redis_client.ttl(f"test:event:{event_id}")
+    assert 0 < ttl <= 60
+
+
+@pytest.mark.anyio
+async def test_stream_key_has_ttl_when_configured(store_with_ttl, redis_client):
+    await store_with_ttl.store_event("stream-A", SAMPLE_MSG)
+
+    ttl = await redis_client.ttl("test:stream:stream-A")
+    assert 0 < ttl <= 60
+
+
+@pytest.mark.anyio
+async def test_counter_key_has_ttl_when_configured(store_with_ttl, redis_client):
+    await store_with_ttl.store_event("stream-A", SAMPLE_MSG)
+
+    ttl = await redis_client.ttl("test:counter")
+    assert 0 < ttl <= 60
+
+
+@pytest.mark.anyio
+async def test_no_ttl_on_keys_when_not_configured(store, redis_client):
+    event_id = await store.store_event("stream-A", SAMPLE_MSG)
+
+    event_ttl = await redis_client.ttl(f"test:event:{event_id}")
+    stream_ttl = await redis_client.ttl("test:stream:stream-A")
+    counter_ttl = await redis_client.ttl("test:counter")
+
+    assert event_ttl == -1
+    assert stream_ttl == -1
+    assert counter_ttl == -1
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Key prefix test
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+@pytest.mark.anyio
+async def test_custom_key_prefix_isolates_two_stores(redis_client, recwarn):
+    store_a = RedisEventStore(redis_client, key_prefix="server-a:", ttl=None)
+    store_b = RedisEventStore(redis_client, key_prefix="server-b:", ttl=None)
+
+    id_a = await store_a.store_event("stream-1", SAMPLE_MSG)
+    id_b = await store_b.store_event("stream-1", SAMPLE_MSG)
+
+    assert id_a == "1"
+    assert id_b == "1"
+
+    a_keys = [k.decode() for k in await redis_client.keys("server-a:*")]
+    b_keys = [k.decode() for k in await redis_client.keys("server-b:*")]
+
+    assert all("server-b:" not in k for k in a_keys)
+    assert all("server-a:" not in k for k in b_keys)
+
+    events_a, stream_id_a = await collect_events(store_a, id_a)
+    assert stream_id_a == "stream-1"
+    assert events_a == []
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Warning / logging tests
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+@pytest.mark.anyio
+async def test_no_ttl_emits_log_warning(redis_client, caplog):
+    with caplog.at_level(logging.WARNING, logger="mcp_persist.redis"):
+        RedisEventStore(redis_client, ttl=None)
+
+    assert any("ttl=None" in record.message for record in caplog.records)
+
+
+@pytest.mark.anyio
+async def test_with_ttl_no_warning_emitted(redis_client, caplog):
+    with caplog.at_level(logging.WARNING, logger="mcp_persist.redis"):
+        RedisEventStore(redis_client, ttl=3600)
+
+    assert not any("ttl" in record.message.lower() for record in caplog.records)