Remove deprecated ensure_search_index_exists function

The VectorStore adapter creates the index automatically when needed,
making this function unnecessary. Removed all calls to it from:
- API server startup (main.py)
- MCP server startup (mcp.py)
- CLI commands (cli.py)
- Long-term memory compaction (long_term_memory.py)

Updated rebuild_index CLI command to use the vectorstore adapter directly.
Updated tests to match new behavior.

Author: abrookins

agent_memory_server/cli.py

@@ -21,7 +21,7 @@
     migrate_add_memory_hashes_1,
     migrate_add_memory_type_3,
 )
-from agent_memory_server.utils.redis import ensure_search_index_exists, get_redis_conn
+from agent_memory_server.utils.redis import get_redis_conn
 
 
 logger = get_logger(__name__)
@@ -46,11 +46,26 @@ def rebuild_index():
     """Rebuild the search index."""
     import asyncio
 
+    from agent_memory_server.vectorstore_adapter import RedisVectorStoreAdapter
+    from agent_memory_server.vectorstore_factory import get_vectorstore_adapter
+
     configure_logging()
 
     async def setup_and_run():
-        redis = await get_redis_conn()
-        await ensure_search_index_exists(redis, overwrite=True)
+        # Get the vectorstore adapter
+        adapter = await get_vectorstore_adapter()
+
+        # Only Redis adapter supports index rebuilding
+        if isinstance(adapter, RedisVectorStoreAdapter):
+            index = adapter.vectorstore.index
+            logger.info(f"Dropping and recreating index '{index.name}'")
+            index.create(overwrite=True)
+            logger.info("Index rebuilt successfully")
+        else:
+            logger.error(
+                "Index rebuilding is only supported for Redis vectorstore. "
+                "Current vectorstore does not support this operation."
+            )
 
     asyncio.run(setup_and_run())
 
@@ -200,8 +215,8 @@ def schedule_task(task_path: str, args: list[str]):
             sys.exit(1)
 
     async def setup_and_run_task():
-        redis = await get_redis_conn()
-        await ensure_search_index_exists(redis)
+        # Initialize Redis connection
+        await get_redis_conn()
 
         # Import the task function
         module_path, function_name = task_path.rsplit(".", 1)
@@ -269,14 +284,10 @@ async def _ensure_stream_and_group():
                 raise
 
     async def _run_worker():
-        # Ensure Redis stream/consumer group and search index exist before starting worker
+        # Ensure Redis stream/consumer group exists before starting worker
+        # Index will be created automatically when needed
         await _ensure_stream_and_group()
-        try:
-            redis = await get_redis_conn()
-            # Don't overwrite if an index already exists; just ensure it's present
-            await ensure_search_index_exists(redis, overwrite=False)
-        except Exception as e:
-            logger.warning(f"Failed to ensure search index exists: {e}")
+        await get_redis_conn()
         await Worker.run(
             docket_name=settings.docket_name,
             url=settings.redis_url,

agent_memory_server/long_term_memory.py

@@ -49,10 +49,7 @@
     rerank_with_recency,
     update_memory_hash_if_text_changed,
 )
-from agent_memory_server.utils.redis import (
-    ensure_search_index_exists,
-    get_redis_conn,
-)
+from agent_memory_server.utils.redis import get_redis_conn
 from agent_memory_server.vectorstore_factory import get_vectorstore_adapter
 
 
@@ -614,18 +611,8 @@ async def compact_long_term_memories(
         index_name = Keys.search_index_name()
         logger.info(f"Using index '{index_name}' for semantic duplicate compaction.")
 
-        # Check if the index exists before proceeding
-        try:
-            await redis_client.execute_command(f"FT.INFO {index_name}")
-        except Exception as info_e:
-            if "unknown index name" in str(info_e).lower():
-                logger.info(f"Search index {index_name} doesn't exist, creating it")
-                # Ensure 'get_search_index' is called with the correct name to create it if needed
-                await ensure_search_index_exists(redis_client, index_name=index_name)
-            else:
-                logger.warning(
-                    f"Error checking index '{index_name}': {info_e} - attempting to proceed."
-                )
+        # Index will be created automatically when we add memories if it doesn't exist
+        # No need to check or create it explicitly
 
         # Get all memories using the vector store adapter
         try:

agent_memory_server/main.py

@@ -14,7 +14,6 @@
 from agent_memory_server.logging import get_logger
 from agent_memory_server.utils.redis import (
     _redis_pool as connection_pool,
-    ensure_search_index_exists,
     get_redis_conn,
 )
 
@@ -75,29 +74,10 @@ async def lifespan(app: FastAPI):
             "Long-term memory requires OpenAI for embeddings, but OpenAI API key is not set"
         )
 
-    # Set up RediSearch index if long-term memory is enabled
+    # Set up Redis connection if long-term memory is enabled
+    # The VectorStore adapter will create the index automatically when needed
     if settings.long_term_memory:
-        redis = await get_redis_conn()
-
-        # Get embedding dimensions from model config
-        embedding_model_config = MODEL_CONFIGS.get(settings.embedding_model)
-        vector_dimensions = (
-            str(embedding_model_config.embedding_dimensions)
-            if embedding_model_config
-            else "1536"
-        )
-        distance_metric = "COSINE"
-
-        try:
-            await ensure_search_index_exists(
-                redis,
-                index_name=settings.redisvl_index_name,
-                vector_dimensions=vector_dimensions,
-                distance_metric=distance_metric,
-            )
-        except Exception as e:
-            logger.error(f"Failed to ensure RediSearch index: {e}")
-            raise
+        await get_redis_conn()
 
     # Initialize Docket for background tasks if enabled
     if settings.use_docket:

agent_memory_server/mcp.py

@@ -158,14 +158,11 @@ async def call_tool(self, name, arguments):
         return await super().call_tool(name, arguments)
 
     async def run_sse_async(self):
-        """Ensure Redis search index exists before starting SSE server."""
-        from agent_memory_server.utils.redis import (
-            ensure_search_index_exists,
-            get_redis_conn,
-        )
+        """Start SSE server. Index will be created automatically when needed."""
+        from agent_memory_server.utils.redis import get_redis_conn
 
-        redis = await get_redis_conn()
-        await ensure_search_index_exists(redis)
+        # Initialize Redis connection
+        await get_redis_conn()
 
         # Run the SSE server using our custom implementation
         import uvicorn
@@ -176,14 +173,11 @@ async def run_sse_async(self):
         ).serve()
 
     async def run_stdio_async(self):
-        """Ensure Redis search index exists before starting STDIO MCP server."""
-        from agent_memory_server.utils.redis import (
-            ensure_search_index_exists,
-            get_redis_conn,
-        )
+        """Start STDIO MCP server. Index will be created automatically when needed."""
+        from agent_memory_server.utils.redis import get_redis_conn
 
-        redis = await get_redis_conn()
-        await ensure_search_index_exists(redis)
+        # Initialize Redis connection
+        await get_redis_conn()
         return await super().run_stdio_async()
 
 

agent_memory_server/utils/redis.py

@@ -4,17 +4,12 @@
 from typing import Any
 
 from redis.asyncio import Redis
-from redis.exceptions import ResponseError
-from redisvl.index import AsyncSearchIndex
 
 from agent_memory_server.config import settings
-from agent_memory_server.vectorstore_adapter import RedisVectorStoreAdapter
-from agent_memory_server.vectorstore_factory import get_vectorstore_adapter
 
 
 logger = logging.getLogger(__name__)
 _redis_pool: Redis | None = None
-_index: AsyncSearchIndex | None = None
 
 
 async def get_redis_conn(url: str = settings.redis_url, **kwargs) -> Redis:
@@ -36,53 +31,6 @@ async def get_redis_conn(url: str = settings.redis_url, **kwargs) -> Redis:
     return _redis_pool
 
 
-async def ensure_search_index_exists(
-    redis: Redis,
-    index_name: str = settings.redisvl_index_name,
-    vector_dimensions: str = settings.redisvl_vector_dimensions,
-    distance_metric: str = settings.redisvl_distance_metric,
-    overwrite: bool = True,
-) -> None:
-    """
-    Ensure that the async search index exists, create it if it doesn't.
-    This function is deprecated and only exists for compatibility.
-    The VectorStore adapter now handles index creation automatically.
-
-    Args:
-        redis: A Redis client instance
-        vector_dimensions: Dimensions of the embedding vectors
-        distance_metric: Distance metric to use (default: COSINE)
-        index_name: The name of the index
-    """
-    # If this is Redis, creating the adapter will create the index.
-    adapter = await get_vectorstore_adapter()
-
-    if overwrite:
-        if isinstance(adapter, RedisVectorStoreAdapter):
-            index = adapter.vectorstore.index
-            if index is not None:
-                try:
-                    index.create(overwrite=True)
-                except ResponseError as e:
-                    # Index already exists is not an error condition
-                    error_msg = str(e)
-                    if "Index already exists" in error_msg:
-                        logger.info(
-                            f"Index '{index.name}' already exists, skipping creation"
-                        )
-                    elif "no such index" in error_msg:
-                        # Index doesn't exist yet, create it without overwrite
-                        logger.info(f"Index '{index.name}' does not exist, creating it")
-                        index.create(overwrite=False)
-                    else:
-                        raise
-        else:
-            logger.warning(
-                "Overwriting the search index is only supported for RedisVectorStoreAdapter. "
-                "Consult your vector store's documentation to learn how to recreate the index."
-            )
-
-
 def safe_get(doc: Any, key: str, default: Any | None = None) -> Any:
     """Get a value from a Document, returning a default if the key is not present.
 

tests/test_cli.py

@@ -36,21 +36,30 @@ def test_version_command(self):
 class TestRebuildIndex:
     """Tests for the rebuild_index command."""
 
-    @patch("agent_memory_server.cli.ensure_search_index_exists")
-    @patch("agent_memory_server.cli.get_redis_conn")
-    def test_rebuild_index_command(self, mock_get_redis_conn, mock_ensure_index):
+    @patch("agent_memory_server.vectorstore_factory.get_vectorstore_adapter")
+    def test_rebuild_index_command(self, mock_get_adapter):
         """Test rebuild_index command execution."""
-        # Use AsyncMock which returns completed awaitables
-        mock_redis = Mock()
-        mock_get_redis_conn.return_value = mock_redis
-        mock_ensure_index.return_value = None
+        from agent_memory_server.vectorstore_adapter import RedisVectorStoreAdapter
+
+        # Create a mock adapter with a mock index
+        mock_index = Mock()
+        mock_index.name = "test_index"
+        mock_index.create = Mock()
+
+        mock_vectorstore = Mock()
+        mock_vectorstore.index = mock_index
+
+        mock_adapter = Mock(spec=RedisVectorStoreAdapter)
+        mock_adapter.vectorstore = mock_vectorstore
+
+        mock_get_adapter.return_value = mock_adapter
 
         runner = CliRunner()
         result = runner.invoke(rebuild_index)
 
         assert result.exit_code == 0
-        mock_get_redis_conn.assert_called_once()
-        mock_ensure_index.assert_called_once_with(mock_redis, overwrite=True)
+        mock_get_adapter.assert_called_once()
+        mock_index.create.assert_called_once_with(overwrite=True)
 
 
 class TestMigrateMemories:
@@ -440,7 +449,6 @@ def test_schedule_task_argument_parsing(self):
 class TestTaskWorker:
     """Tests for the task_worker command."""
 
-    @patch("agent_memory_server.cli.ensure_search_index_exists")
     @patch("agent_memory_server.cli.get_redis_conn")
     @patch("docket.Worker.run")
     @patch("agent_memory_server.cli.settings")
@@ -449,7 +457,6 @@ def test_task_worker_success(
         mock_settings,
         mock_worker_run,
         mock_get_redis_conn,
-        mock_ensure_index,
         redis_url,
     ):
         """Test successful task worker start."""
@@ -460,7 +467,6 @@ def test_task_worker_success(
         mock_worker_run.return_value = None
         mock_redis = AsyncMock()
         mock_get_redis_conn.return_value = mock_redis
-        mock_ensure_index.return_value = None
 
         runner = CliRunner()
         result = runner.invoke(
@@ -481,7 +487,6 @@ def test_task_worker_docket_disabled(self, mock_settings):
         assert result.exit_code == 1
         assert "Docket is disabled in settings" in result.output
 
-    @patch("agent_memory_server.cli.ensure_search_index_exists")
     @patch("agent_memory_server.cli.get_redis_conn")
     @patch("docket.Worker.run")
     @patch("agent_memory_server.cli.settings")
@@ -490,7 +495,6 @@ def test_task_worker_default_params(
         mock_settings,
         mock_worker_run,
         mock_get_redis_conn,
-        mock_ensure_index,
         redis_url,
     ):
         """Test task worker with default parameters."""
@@ -501,7 +505,6 @@ def test_task_worker_default_params(
         mock_worker_run.return_value = None
         mock_redis = AsyncMock()
         mock_get_redis_conn.return_value = mock_redis
-        mock_ensure_index.return_value = None
 
         runner = CliRunner()
         result = runner.invoke(task_worker)

tests/test_memory_compaction.py

@@ -126,10 +126,7 @@ async def test_hash_deduplication_integration(
     # Clear all data to ensure clean test environment
     await async_redis_client.flushdb()
 
-    # Ensure index exists after flush
-    from agent_memory_server.utils.redis import ensure_search_index_exists
-
-    await ensure_search_index_exists(async_redis_client)
+    # Index will be created automatically when we add memories
 
     # Stub merge to return first memory unchanged
     async def dummy_merge(memories, llm_client=None):
@@ -229,10 +226,7 @@ async def test_semantic_deduplication_integration(
     # Clear all data to ensure clean test environment
     await async_redis_client.flushdb()
 
-    # Ensure index exists after flush
-    from agent_memory_server.utils.redis import ensure_search_index_exists
-
-    await ensure_search_index_exists(async_redis_client)
+    # Index will be created automatically when we add memories
 
     # Stub merge to return first memory
     async def dummy_merge(memories, llm_client=None):
@@ -308,10 +302,7 @@ async def test_full_compaction_integration(
     # Clear all data to ensure clean test environment
     await async_redis_client.flushdb()
 
-    # Ensure index exists after flush
-    from agent_memory_server.utils.redis import ensure_search_index_exists
-
-    await ensure_search_index_exists(async_redis_client)
+    # Index will be created automatically when we add memories
 
     async def dummy_merge(memories, llm_client=None):
         memory = memories[0]