Remove environment variable logging and simplify configuration

- Remove set_redis_env_from_config function that was logging 'Setting REDIS_*' messages
- Simplify configuration by using REDIS_CFG dictionary directly instead of environment variables
- Remove MCP transport configuration options (MCP_TRANSPORT, MCP_HOST, MCP_PORT)
- Update CLI to use stdio transport only
- Refactor configuration management for better maintainability

Author: mortensi

.env.example

@@ -9,5 +9,4 @@ REDIS_SSL_KEYFILE=/path/to/key.pem
 REDIS_SSL_CERTFILE=/path/to/cert.pem
 REDIS_CERT_REQS=required
 REDIS_CA_CERTS=/path/to/ca_certs.pem
-REDIS_CLUSTER_MODE=False
-MCP_TRANSPORT=stdio
+REDIS_CLUSTER_MODE=False

.idea/AugmentWebviewStateStore.xml

@@ -118,9 +118,6 @@ uvx --from git+https://github.com/redis/mcp-redis.git@feature/uvx-cli-support re
 - `--ssl-keyfile` - Path to SSL key file
 - `--ssl-certfile` - Path to SSL certificate file
 - `--cluster-mode` - Enable Redis cluster mode
-- `--mcp-transport` - MCP transport method (stdio, streamable-http, sse)
-- `--mcp-host` - MCP server host (default: 127.0.0.1)
-- `--mcp-port` - MCP server port (default: 8000)
 
 ### Configuration via Environment Variables
 
@@ -140,9 +137,7 @@ When running the server directly (`uv run src/main.py`) or for legacy compatibil
 | `REDIS_CERT_REQS`    | Whether the client should verify the server's certificate | `"required"`  |
 | `REDIS_CA_CERTS`     | Path to the trusted CA certificates file                  | None          |
 | `REDIS_CLUSTER_MODE` | Enable Redis Cluster mode                                 | `False`       |
-| `MCP_TRANSPORT`      | Use the `stdio`, `streamable-http` or `sse` transport     | `stdio`       |
-| `MCP_HOST`           | Server host when `streamable-http` or `sse` are set       | `127.0.0.1`   |
-| `MCP_PORT`           | Server port when `streamable-http` or `sse` are set       | `8000`        |
+
 
 
 There are several ways to set environment variables:
@@ -170,71 +165,6 @@ OR,
   ```
   This method is useful for temporary overrides or quick testing.
 
-## Transports
-
-This MCP server can be configured to handle requests locally, running as a process and communicating with the MCP client via `stdin` and `stdout`.
-This is the default configuration, `stdio`. The `streamable-http` and `sse` (deprecated) transports are also configurable, which make the server available over the network.
-Configure the `MCP_TRANSPORT` variable accordingly.
-
-> Authentication has not yet been implemented, and [attackers could use DNS rebinding](https://modelcontextprotocol.io/docs/concepts/transports#security-considerations) to access the server.
-
-### Streamable HTTP
-
-```commandline
-export MCP_TRANSPORT="streamable-http"
-```
-
-Then start the server.
-
-```commandline
-uv run src/main.py
-```
-
-Configure in GitHub Copilot
-
-```commandline
-"mcp": {
-    "servers": {
-        "redis-mcp": {
-            "type": "http",
-            "url": "http://127.0.0.1:8000/mcp/"
-        },
-    }
-},
-```
-
-### SSE (deprecated)
-
-```commandline
-export MCP_TRANSPORT="sse"
-```
-
-Then start the server.
-
-```commandline
-uv run src/main.py
-```
-
-Test the server:
-
-```commandline
-curl -i http://127.0.0.1:8000/sse
-HTTP/1.1 200 OK
-```
-
-Integrate with your favorite tool or client. The VS Code configuration for GitHub Copilot is:
-
-```commandline
-"mcp": {
-    "servers": {
-        "redis-mcp": {
-            "type": "sse",
-            "url": "http://127.0.0.1:8000/sse"
-        },
-    }
-},
-```
-
 
 ## Integration with OpenAI Agents SDK
 

README.md

@@ -1,36 +1,23 @@
+import sys
+
 from dotenv import load_dotenv
 import os
 import urllib.parse
 
 load_dotenv()
 
-MCP_TRANSPORT = os.getenv('MCP_TRANSPORT', 'stdio')
-MCP_HOST = os.getenv('MCP_HOST', '127.0.0.1')
-MCP_PORT = os.getenv('MCP_PORT', 8000)
-
-def _load_redis_config():
-    """Load Redis configuration from environment variables."""
-    return {"host": os.getenv('REDIS_HOST', '127.0.0.1'),
-            "port": int(os.getenv('REDIS_PORT',6379)),
-            "username": os.getenv('REDIS_USERNAME', None),
-            "password": os.getenv('REDIS_PWD',''),
-            "ssl": os.getenv('REDIS_SSL', False) in ('true', '1', 't'),
-            "ssl_ca_path": os.getenv('REDIS_SSL_CA_PATH', None),
-            "ssl_keyfile": os.getenv('REDIS_SSL_KEYFILE', None),
-            "ssl_certfile": os.getenv('REDIS_SSL_CERTFILE', None),
-            "ssl_cert_reqs": os.getenv('REDIS_SSL_CERT_REQS', 'required'),
-            "ssl_ca_certs": os.getenv('REDIS_SSL_CA_CERTS', None),
-            "cluster_mode": os.getenv('REDIS_CLUSTER_MODE', False) in ('true', '1', 't'),
-            "db": int(os.getenv('REDIS_DB', 0))}
-
-REDIS_CFG = _load_redis_config()
-
-
-def reload_redis_config():
-    """Reload Redis configuration from environment variables."""
-    global REDIS_CFG
-    REDIS_CFG = _load_redis_config()
-
+REDIS_CFG = {"host": os.getenv('REDIS_HOST', '127.0.0.1'),
+             "port": int(os.getenv('REDIS_PORT',6379)),
+             "username": os.getenv('REDIS_USERNAME', None),
+             "password": os.getenv('REDIS_PWD',''),
+             "ssl": os.getenv('REDIS_SSL', False) in ('true', '1', 't'),
+             "ssl_ca_path": os.getenv('REDIS_SSL_CA_PATH', None),
+             "ssl_keyfile": os.getenv('REDIS_SSL_KEYFILE', None),
+             "ssl_certfile": os.getenv('REDIS_SSL_CERTFILE', None),
+             "ssl_cert_reqs": os.getenv('REDIS_SSL_CERT_REQS', 'required'),
+             "ssl_ca_certs": os.getenv('REDIS_SSL_CA_CERTS', None),
+             "cluster_mode": os.getenv('REDIS_CLUSTER_MODE', False) in ('true', '1', 't'),
+             "db": int(os.getenv('REDIS_DB', 0))}
 
 def parse_redis_uri(uri: str) -> dict:
     """Parse a Redis URI and return connection parameters."""
@@ -81,7 +68,12 @@ def parse_redis_uri(uri: str) -> dict:
         if 'ssl_certfile' in query_params:
             config['ssl_certfile'] = query_params['ssl_certfile'][0]
 
-        # Handle other parameters
+        # Handle other parameters. According to https://www.iana.org/assignments/uri-schemes/prov/redis,
+        # The database number to use for the Redis SELECT command comes from
+        #   either the "db-number" portion of the URI (described in the previous
+        #   section) or the value from the key-value pair from the "query" URI
+        #   field with the key "db".  If neither of these are present, the
+        #   default database number is 0.
         if 'db' in query_params:
             try:
                 config['db'] = int(query_params['db'][0])
@@ -91,27 +83,8 @@ def parse_redis_uri(uri: str) -> dict:
     return config
 
 
-def set_redis_env_from_config(config: dict):
-    """Set environment variables from Redis configuration."""
-    env_mapping = {
-        'host': 'REDIS_HOST',
-        'port': 'REDIS_PORT',
-        'db': 'REDIS_DB',
-        'username': 'REDIS_USERNAME',
-        'password': 'REDIS_PWD',
-        'ssl': 'REDIS_SSL',
-        'ssl_ca_path': 'REDIS_SSL_CA_PATH',
-        'ssl_keyfile': 'REDIS_SSL_KEYFILE',
-        'ssl_certfile': 'REDIS_SSL_CERTFILE',
-        'ssl_cert_reqs': 'REDIS_SSL_CERT_REQS',
-        'ssl_ca_certs': 'REDIS_SSL_CA_CERTS',
-        'cluster_mode': 'REDIS_CLUSTER_MODE'
-    }
-
-    for key, env_var in env_mapping.items():
-        if key in config:
-            value = config[key]
-            if isinstance(value, bool):
-                value = 'true' if value else 'false'
-            os.environ[env_var] = str(value)
-            print(f"Setting {env_var} to {value}")
+def set_redis_config_from_cli(config: dict):
+    for key, value in config.items():
+        if isinstance(value, bool):
+            value = 'true' if value else 'false'
+        REDIS_CFG[key] = str(value)

src/common/config.py

@@ -32,7 +32,6 @@ def get_connection(cls, decode_responses=True) -> Redis:
                         "max_connections_per_node": 10 
                     }
                 else:
-                    print("Redis config:", REDIS_CFG, file=sys.stderr)
                     redis_class: Type[Union[Redis, RedisCluster]] = redis.Redis
                     connection_params = {
                         "host": REDIS_CFG["host"],

src/common/connection.py

@@ -1,12 +1,8 @@
 from mcp.server.fastmcp import FastMCP
 
-from src.common.config import MCP_PORT, MCP_HOST
-
 # Initialize FastMCP server
 mcp = FastMCP(
     "Redis MCP Server",
-    host=MCP_HOST,
-    port=MCP_PORT,
     dependencies=["redis", "dotenv", "numpy"]
 )
 

src/common/server.py

@@ -1,32 +1,27 @@
 import sys
-import os
 import click
-
+from src.common.connection import RedisConnectionManager
 from src.common.server import mcp
-from src.common.config import MCP_TRANSPORT, parse_redis_uri, set_redis_env_from_config, reload_redis_config
-
-
-def _import_tools():
-    """Import all tool modules after configuration is set up."""
-    import src.tools.server_management
-    import src.tools.misc
-    import src.tools.redis_query_engine
-    import src.tools.hash
-    import src.tools.list
-    import src.tools.string
-    import src.tools.json
-    import src.tools.sorted_set
-    import src.tools.set
-    import src.tools.stream
-    import src.tools.pub_sub
+from src.common.config import parse_redis_uri, set_redis_config_from_cli
+import src.tools.server_management
+import src.tools.misc
+import src.tools.redis_query_engine
+import src.tools.hash
+import src.tools.list
+import src.tools.string
+import src.tools.json
+import src.tools.sorted_set
+import src.tools.set
+import src.tools.stream
+import src.tools.pub_sub
 
 
 class RedisMCPServer:
     def __init__(self):
         print("Starting the Redis MCP Server", file=sys.stderr)
 
     def run(self):
-        mcp.run(transport=MCP_TRANSPORT)
+        mcp.run()
 
 
 @click.command()
@@ -43,20 +38,16 @@ def run(self):
 @click.option('--ssl-cert-reqs', default='required', help='SSL certificate requirements')
 @click.option('--ssl-ca-certs', help='Path to CA certificates file')
 @click.option('--cluster-mode', is_flag=True, help='Enable Redis cluster mode')
-@click.option('--mcp-transport', default='stdio', type=click.Choice(['stdio', 'streamable-http', 'sse']), help='MCP transport method')
-@click.option('--mcp-host', default='127.0.0.1', help='MCP server host (for http/sse transport)')
-@click.option('--mcp-port', default=8000, type=int, help='MCP server port (for http/sse transport)')
 def cli(url, host, port, db, username, password,
         ssl, ssl_ca_path, ssl_keyfile, ssl_certfile,
-        ssl_cert_reqs, ssl_ca_certs, cluster_mode,
-        mcp_transport, mcp_host, mcp_port):
+        ssl_cert_reqs, ssl_ca_certs, cluster_mode):
     """Redis MCP Server - Model Context Protocol server for Redis."""
 
     # Handle Redis URI if provided
     if url:
         try:
             uri_config = parse_redis_uri(url)
-            set_redis_env_from_config(uri_config)
+            set_redis_config_from_cli(uri_config)
         except ValueError as e:
             click.echo(f"Error parsing Redis URI: {e}", err=True)
             sys.exit(1)
@@ -85,18 +76,9 @@ def cli(url, host, port, db, username, password,
         if ssl_ca_certs:
             config['ssl_ca_certs'] = ssl_ca_certs
 
-        set_redis_env_from_config(config)
-
-    # Reload Redis configuration to pick up the new environment variables
-    reload_redis_config()
-
-    # Import tools after configuration is set up (ensures Redis connection uses new config)
-    _import_tools()
+        set_redis_config_from_cli(config)
 
-    # Set MCP transport settings
-    os.environ['MCP_TRANSPORT'] = mcp_transport
-    os.environ['MCP_HOST'] = mcp_host
-    os.environ['MCP_PORT'] = str(mcp_port)
+    # RedisConnectionManager.get_connection().ping()
 
     # Start the server
     server = RedisMCPServer()
@@ -105,8 +87,6 @@ def cli(url, host, port, db, username, password,
 
 def main():
     """Legacy main function for backward compatibility."""
-    # Import tools (uses default environment variables)
-    _import_tools()
     server = RedisMCPServer()
     server.run()