new defaults for vector tools, added rename key tool, README docs

Author: mortensi

README.md

@@ -1,7 +1,12 @@
 # Redis MCP Server
 
 ## Overview
-The Redis MCP Server is a **natural language interface** designed for agentic applications to efficiently manage and search data in Redis. It integrates seamlessly with **MCP (Model Content Protocol) clients**, enabling AI-driven workflows to interact with structured and unstructured data in Redis.
+The Redis MCP Server is a **natural language interface** designed for agentic applications to efficiently manage and search data in Redis. It integrates seamlessly with **MCP (Model Content Protocol) clients**, enabling AI-driven workflows to interact with structured and unstructured data in Redis. Using this MCP Server, you can ask questions like:
+
+- "Store the entire conversation in a stream"
+- "Cache this item"
+- "Store the session with an expiration time"
+- "Index and search this vector"
 
 ## Features
 - **Natural Language Queries**: Enables AI agents to query and update Redis using natural language.
@@ -10,6 +15,25 @@ The Redis MCP Server is a **natural language interface** designed for agentic ap
 - **Search & Filtering**: Supports efficient data retrieval and searching in Redis.
 - **Scalable & Lightweight**: Designed for **high-performance** data operations.
 
+## Tools
+
+This MCP Server provides tools to manage the data stored in Redis.
+
+- `string` tools to set, get strings with expiration. Useful for storing simple configuration values, session data, or caching responses.
+- `hash` tools to store field-value pairs within a single key. The hash can store vector embeddings. Useful for representing objects with multiple attributes, user profiles, or product information where fields can be accessed individually.
+- `list` tools with common operations to append and pop items. Useful for queues, message brokers, or maintaining a list of most recent actions.
+- `set` tools to add, remove and list set members. Useful for tracking unique values like user IDs or tags, and for performing set operations like intersection.
+- `sorted set` tools to manage data for e.g. leaderboards, priority queues, or time-based analytics with score-based ordering.
+- `pub/sub` functionality to publish messages to channels and subscribe to receive them. Useful for real-time notifications, chat applications, or distributing updates to multiple clients.
+- `streams` tools to add, read, and delete from data streams. Useful for event sourcing, activity feeds, or sensor data logging with consumer groups support.
+- `JSON` tools to store, retrieve, and manipulate JSON documents in Redis. Useful for complex nested data structures, document databases, or configuration management with path-based access.
+
+Additional tools.
+
+- `query engine` tools to manage vector indexes and perform vector search
+- `server management` tool to retrieve information about the database
+
+
 ## Installation
 ```sh
 # Clone the repository

src/tools/hash.py

@@ -100,12 +100,12 @@ async def hexists(name: str, key: str) -> bool:
         return f"Error checking existence of field '{key}' in hash '{name}': {str(e)}"
 
 @mcp.tool()
-async def set_vector_in_hash(name: str, key: str, vector: list) -> bool:
+async def set_vector_in_hash(name: str, vector: list, vector_field: str = "vector") -> bool:
     """Store a vector as a field in a Redis hash.
 
     Args:
         name: The Redis hash key.
-        key: The field name inside the hash.
+        vector_field: The field name inside the hash. Unless specifically required, use the default field name
         vector: The vector (list of numbers) to store in the hash.
 
     Returns:
@@ -118,19 +118,19 @@ async def set_vector_in_hash(name: str, key: str, vector: list) -> bool:
         vector_array = np.array(vector, dtype=np.float32)
         binary_blob = vector_array.tobytes()
 
-        r.hset(name, key, binary_blob)
+        r.hset(name, vector_field, binary_blob)
         return True
     except RedisError as e:
-        return f"Error storing vector in hash '{name}' with key '{key}': {str(e)}"
+        return f"Error storing vector in hash '{name}' with field '{vector_field}': {str(e)}"
 
 
 @mcp.tool()
-async def get_vector_from_hash(name: str, key: str):
+async def get_vector_from_hash(name: str, vector_field: str = "vector"):
     """Retrieve a vector from a Redis hash and convert it back from binary blob.
 
     Args:
         name: The Redis hash key.
-        key: The field name inside the hash.
+        vector_field: The field name inside the hash. Unless specifically required, use the default field name
 
     Returns:
         The vector as a list of floats, or an error message if retrieval fails.
@@ -139,14 +139,14 @@ async def get_vector_from_hash(name: str, key: str):
         r = RedisConnectionManager.get_connection(decode_responses=False)
 
         # Retrieve the binary blob stored in the hash
-        binary_blob = r.hget(name, key)
+        binary_blob = r.hget(name, vector_field)
 
         if binary_blob:
             # Convert the binary blob back to a NumPy array (assuming it's stored as float32)
             vector_array = np.frombuffer(binary_blob, dtype=np.float32)
             return vector_array.tolist()
         else:
-            return f"Field '{key}' not found in hash '{name}'."
+            return f"Field '{vector_field}' not found in hash '{name}'."
 
     except RedisError as e:
         return f"Error retrieving vector from hash '{name}' with key '{key}': {str(e)}"

src/tools/misc.py

@@ -17,4 +17,55 @@ async def get_key_info(key: str) -> Dict[str, Any]:
 
         return info
     except RedisError as e:
-        return {'error': str(e)}
+        return {'error': str(e)}
+
+
+@mcp.tool()
+async def expire(name: str, expire_seconds: int) -> str:
+    """Set an expiration time for a Redis key.
+
+    Args:
+        name: The Redis key.
+        expire_seconds: Time in seconds after which the key should expire.
+
+    Returns:
+        A success message or an error message.
+    """
+    try:
+        r = RedisConnectionManager.get_connection()
+        success = r.expire(name, expire_seconds)
+        return f"Expiration set to {expire_seconds} seconds for '{name}'." if success else f"Key '{name}' does not exist."
+    except RedisError as e:
+        return f"Error setting expiration for key '{name}': {str(e)}"
+
+
+@mcp.tool()
+async def rename_key(old_key: str, new_key: str) -> Dict[str, Any]:
+    """
+    Renames a Redis key from old_key to new_key.
+
+    Args:
+        old_key (str): The current name of the Redis key to rename.
+        new_key (str): The new name to assign to the key.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the result of the operation.
+            On success: {"status": "success", "message": "..."}
+            On error: {"error": "..."}
+    """
+    try:
+        r = RedisConnectionManager.get_connection()
+
+        # Check if the old key exists
+        if not r.exists(old_key):
+            return {"error": f"Key '{old_key}' does not exist."}
+
+        # Rename the key
+        r.rename(old_key, new_key)
+        return {
+            "status": "success",
+            "message": f"Renamed key '{old_key}' to '{new_key}'"
+        }
+
+    except RedisError as e:
+        return {"error": str(e)}

src/tools/redis_query_engine.py

@@ -53,7 +53,7 @@ async def get_indexed_keys_number(index_name: str) -> str:
 
 
 @mcp.tool()
-async def create_vector_index_hash(index_name: str,
+async def create_vector_index_hash(index_name: str = "vector_index",
                        prefix: str = "doc:",
                        vector_field: str = "vector",
                        dim: int = 1536,
@@ -65,9 +65,9 @@ async def create_vector_index_hash(index_name: str,
     search using the HNSW algorithm and float32 vector embeddings.
 
     Args:
-        index_name: The name of the Redis index to create.
-        prefix: The key prefix used to identify documents to index (e.g., 'doc:').
-        vector_field: The name of the vector field to be indexed for similarity search.
+        index_name: The name of the Redis index to create. Unless specifically required, use the default name for the index.
+        prefix: The key prefix used to identify documents to index (e.g., 'doc:'). Unless specifically required, use the default prefix.
+        vector_field: The name of the vector field to be indexed for similarity search. Unless specifically required, use the default field name
         dim: The dimensionality of the vectors stored under the vector_field.
         distance_metric: The distance function to use (e.g., 'COSINE', 'L2', 'IP').
 
@@ -97,18 +97,18 @@ async def create_vector_index_hash(index_name: str,
 
 
 @mcp.tool()
-async def vector_search_hash(index_name: str,
-                            query_vector: list,
+async def vector_search_hash(query_vector: list,
+                            index_name: str = "vector_index",
                             vector_field: str = "vector",
                             k: int = 5,
                             return_fields: list = None) -> list:
     """
     Perform a KNN vector similarity search using Redis 8 or later version on vectors stored in hash data structures.
 
     Args:
-        index_name: Name of the Redis index.
-        vector_field: Name of the indexed vector field.
         query_vector: List of floats to use as the query vector.
+        index_name: Name of the Redis index. Unless specifically specified, use the default index name.
+        vector_field: Name of the indexed vector field. Unless specifically required, use the default field name
         k: Number of nearest neighbors to return.
         return_fields: List of fields to return (optional).
 

src/tools/set.py

@@ -64,21 +64,3 @@ async def smembers(name: str) -> list:
     except RedisError as e:
         return f"Error retrieving members of set '{name}': {str(e)}"
 
-
-@mcp.tool()
-async def sexpire(name: str, expire_seconds: int) -> str:
-    """Set an expiration time for a Redis set.
-
-    Args:
-        name: The Redis set key.
-        expire_seconds: Time in seconds after which the set should expire.
-
-    Returns:
-        A success message or an error message.
-    """
-    try:
-        r = RedisConnectionManager.get_connection()
-        success = r.expire(name, expire_seconds)
-        return f"Expiration set to {expire_seconds} seconds for set '{name}'." if success else f"Set '{name}' does not exist."
-    except RedisError as e:
-        return f"Error setting expiration for set '{name}': {str(e)}"