@universal-mcp-toolkit/server-redis 0.1.0

package/.well-known/mcp-server.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://json.schemastore.org/json",
+  "name": "redis",
+  "title": "Redis MCP Server",
+  "description": "Key inspection and cache diagnostics tools for Redis.",
+  "version": "0.1.0",
+  "transports": [
+    "stdio",
+    "http+sse"
+  ],
+  "authentication": {
+    "mode": "environment-variables",
+    "required": [
+      "REDIS_URL"
+    ]
+  },
+  "capabilities": {
+    "tools": true,
+    "resources": true,
+    "prompts": true
+  },
+  "packageName": "@universal-mcp-toolkit/server-redis",
+  "homepage": "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit#readme",
+  "tools": [
+    "get-key",
+    "set-key",
+    "inspect-server-info"
+  ],
+  "resources": [
+    "cache-overview"
+  ],
+  "prompts": [
+    "cache-debug"
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 universal-mcp-toolkit
+
+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.

package/dist/index.d.ts

@@ -0,0 +1,78 @@
+import * as _universal_mcp_toolkit_core from '@universal-mcp-toolkit/core';
+import { ToolkitServer, ToolkitServerMetadata } from '@universal-mcp-toolkit/core';
+import { z } from 'zod';
+
+type JsonPrimitive = boolean | number | string | null;
+interface JsonObject {
+    [key: string]: JsonValue;
+}
+type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+declare const redisEnvShape: {
+    REDIS_URL: z.ZodString;
+    REDIS_ALLOW_WRITES: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "true" | "false">>;
+    REDIS_DEFAULT_TTL_SECONDS: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    REDIS_VALUE_SAMPLE_LIMIT: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    REDIS_RESOURCE_SCAN_PATTERN: z.ZodDefault<z.ZodString>;
+    REDIS_RESOURCE_KEY_LIMIT: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+};
+type RedisEnv = z.infer<z.ZodObject<typeof redisEnvShape>>;
+interface RedisInfoProperty {
+    name: string;
+    value: string;
+}
+interface RedisKeyInspection {
+    key: string;
+    exists: boolean;
+    keyType: string | null;
+    ttlSeconds: number | null;
+    value: JsonValue | null;
+    preview: string;
+    size: number | null;
+}
+interface RedisClient {
+    getKey(input: {
+        key: string;
+        sampleSize: number;
+    }): Promise<RedisKeyInspection>;
+    setKey(input: {
+        key: string;
+        serializedValue: string;
+        ttlSeconds: number | null;
+        onlyIfAbsent: boolean;
+    }): Promise<{
+        key: string;
+        stored: boolean;
+        ttlSeconds: number | null;
+    }>;
+    inspectServerInfo(input: {
+        section?: string;
+    }): Promise<{
+        section: string;
+        properties: RedisInfoProperty[];
+        raw: string;
+    }>;
+    listKeys(input: {
+        pattern: string;
+        limit: number;
+    }): Promise<string[]>;
+    close?(): Promise<void>;
+}
+declare const metadata: ToolkitServerMetadata;
+declare const serverCard: _universal_mcp_toolkit_core.ToolkitServerCard;
+declare class RedisServer extends ToolkitServer {
+    private readonly env;
+    private readonly client;
+    constructor(env: RedisEnv, client: RedisClient);
+    close(): Promise<void>;
+}
+interface CreateRedisServerOptions {
+    env?: RedisEnv;
+    client?: RedisClient;
+}
+declare function createServer(options?: CreateRedisServerOptions): RedisServer;
+declare function main(argv?: readonly string[]): Promise<void>;
+
+export { type CreateRedisServerOptions, type JsonObject, type JsonValue, type RedisClient, type RedisEnv, type RedisInfoProperty, type RedisKeyInspection, RedisServer, createServer, main, metadata, serverCard };

package/dist/index.js

@@ -0,0 +1,587 @@
+// src/index.ts
+import { pathToFileURL } from "url";
+import {
+  ExternalServiceError,
+  ToolkitServer,
+  ValidationError,
+  createServerCard,
+  defineTool,
+  loadEnv,
+  parseRuntimeOptions,
+  runToolkitServer
+} from "@universal-mcp-toolkit/core";
+import { createClient } from "redis";
+import { z } from "zod";
+var jsonValueSchema = z.lazy(
+  () => z.union([z.string(), z.number().finite(), z.boolean(), z.null(), z.array(jsonValueSchema), z.record(z.string(), jsonValueSchema)])
+);
+var jsonObjectSchema = z.record(z.string(), jsonValueSchema);
+var booleanFlag = z.enum(["true", "false"]).default("false").transform((value) => value === "true");
+var redisEnvShape = {
+  REDIS_URL: z.string().min(1),
+  REDIS_ALLOW_WRITES: booleanFlag,
+  REDIS_DEFAULT_TTL_SECONDS: z.coerce.number().int().nonnegative().max(604800).default(0),
+  REDIS_VALUE_SAMPLE_LIMIT: z.coerce.number().int().positive().max(100).default(10),
+  REDIS_RESOURCE_SCAN_PATTERN: z.string().min(1).default("*"),
+  REDIS_RESOURCE_KEY_LIMIT: z.coerce.number().int().positive().max(100).default(20)
+};
+var TOOL_NAMES = ["get-key", "inspect-server-info", "set-key"];
+var RESOURCE_NAMES = ["cache-overview"];
+var PROMPT_NAMES = ["cache-debug"];
+var metadata = {
+  id: "redis",
+  title: "Redis MCP Server",
+  description: "Key inspection and cache diagnostics tools for Redis.",
+  version: "0.1.0",
+  packageName: "@universal-mcp-toolkit/server-redis",
+  homepage: "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit#readme",
+  repositoryUrl: "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit",
+  envVarNames: ["REDIS_URL"],
+  transports: ["stdio", "sse"],
+  toolNames: TOOL_NAMES,
+  resourceNames: RESOURCE_NAMES,
+  promptNames: PROMPT_NAMES
+};
+var serverCard = createServerCard(metadata);
+function extractErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown Redis error.";
+}
+function sanitizeJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : String(value);
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeJsonValue(entry));
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value).toString("base64");
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+      result[key] = sanitizeJsonValue(entry);
+    }
+    return result;
+  }
+  return String(value);
+}
+function maskRedisUrl(urlValue) {
+  try {
+    const url = new URL(urlValue);
+    if (url.username || url.password) {
+      url.username = "***";
+      url.password = "***";
+    }
+    return url.toString();
+  } catch {
+    return urlValue.replace(/\/\/[^@/]+@/u, "//***:***@");
+  }
+}
+function truncateText(value, maxLength = 120) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength - 3)}...`;
+}
+function parseInteger(reply) {
+  if (typeof reply === "number" && Number.isFinite(reply)) {
+    return reply;
+  }
+  if (typeof reply === "string" && reply.length > 0) {
+    const parsed = Number(reply);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function parseStringArray(reply) {
+  if (!Array.isArray(reply)) {
+    return [];
+  }
+  return reply.map((entry) => String(entry));
+}
+function parseHashReply(reply) {
+  if (reply !== null && typeof reply === "object" && !Array.isArray(reply)) {
+    const result2 = {};
+    for (const [key, value] of Object.entries(reply)) {
+      result2[key] = sanitizeJsonValue(value);
+    }
+    return result2;
+  }
+  if (!Array.isArray(reply)) {
+    return {};
+  }
+  const result = {};
+  for (let index = 0; index < reply.length; index += 2) {
+    const key = reply[index];
+    const value = reply[index + 1];
+    if (key !== void 0) {
+      result[String(key)] = sanitizeJsonValue(value ?? null);
+    }
+  }
+  return result;
+}
+function parseZsetReply(reply) {
+  if (!Array.isArray(reply)) {
+    return [];
+  }
+  if (reply.every((entry) => Array.isArray(entry) && entry.length >= 2)) {
+    return reply.map((entry) => {
+      const pair = entry;
+      return {
+        member: String(pair[0]),
+        score: parseInteger(pair[1]) ?? String(pair[1] ?? "")
+      };
+    });
+  }
+  const result = [];
+  for (let index = 0; index < reply.length; index += 2) {
+    const member = reply[index];
+    const score = reply[index + 1];
+    if (member !== void 0) {
+      result.push({
+        member: String(member),
+        score: parseInteger(score) ?? String(score ?? "")
+      });
+    }
+  }
+  return result;
+}
+function parseStreamReply(reply) {
+  if (!Array.isArray(reply)) {
+    return [];
+  }
+  return reply.map((entry) => {
+    if (!Array.isArray(entry) || entry.length < 2) {
+      return {
+        raw: sanitizeJsonValue(entry)
+      };
+    }
+    const id = String(entry[0]);
+    const fields = parseHashReply(entry[1]);
+    return {
+      id,
+      fields
+    };
+  });
+}
+function parseInfoSection(raw) {
+  return raw.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#") && line.includes(":")).map((line) => {
+    const separatorIndex = line.indexOf(":");
+    return {
+      name: line.slice(0, separatorIndex),
+      value: line.slice(separatorIndex + 1)
+    };
+  });
+}
+function parseScanReply(reply) {
+  if (!Array.isArray(reply) || reply.length < 2) {
+    return {
+      cursor: "0",
+      keys: []
+    };
+  }
+  const cursor = String(reply[0]);
+  const keys = parseStringArray(reply[1]);
+  return {
+    cursor,
+    keys
+  };
+}
+var NodeRedisClient = class {
+  client;
+  constructor(url) {
+    this.client = createClient({ url });
+  }
+  async close() {
+    if (!this.client.isOpen) {
+      return;
+    }
+    await this.client.quit();
+  }
+  async getKey(input) {
+    const keyType = await this.execute(["TYPE", input.key]);
+    if (keyType === "none") {
+      return {
+        key: input.key,
+        exists: false,
+        keyType: null,
+        ttlSeconds: null,
+        value: null,
+        preview: "Key not found.",
+        size: null
+      };
+    }
+    const ttlReply = await this.execute(["TTL", input.key]);
+    const ttl = parseInteger(ttlReply);
+    const ttlSeconds = ttl === null || ttl < 0 ? null : ttl;
+    switch (keyType) {
+      case "string": {
+        const value = await this.execute(["GET", input.key]);
+        return {
+          key: input.key,
+          exists: true,
+          keyType,
+          ttlSeconds,
+          value,
+          preview: typeof value === "string" ? truncateText(value) : "null",
+          size: typeof value === "string" ? value.length : 0
+        };
+      }
+      case "hash": {
+        const value = parseHashReply(await this.execute(["HGETALL", input.key]));
+        return {
+          key: input.key,
+          exists: true,
+          keyType,
+          ttlSeconds,
+          value,
+          preview: `${Object.keys(value).length} hash field(s)`,
+          size: Object.keys(value).length
+        };
+      }
+      case "list": {
+        const value = parseStringArray(await this.execute(["LRANGE", input.key, "0", String(input.sampleSize - 1)]));
+        return {
+          key: input.key,
+          exists: true,
+          keyType,
+          ttlSeconds,
+          value,
+          preview: `${value.length} sampled list item(s)`,
+          size: value.length
+        };
+      }
+      case "set": {
+        const members = parseStringArray(await this.execute(["SMEMBERS", input.key])).slice(0, input.sampleSize);
+        return {
+          key: input.key,
+          exists: true,
+          keyType,
+          ttlSeconds,
+          value: members,
+          preview: `${members.length} sampled set member(s)`,
+          size: members.length
+        };
+      }
+      case "zset": {
+        const value = parseZsetReply(
+          await this.execute(["ZRANGE", input.key, "0", String(input.sampleSize - 1), "WITHSCORES"])
+        );
+        return {
+          key: input.key,
+          exists: true,
+          keyType,
+          ttlSeconds,
+          value,
+          preview: `${value.length} sampled sorted-set member(s)`,
+          size: value.length
+        };
+      }
+      case "stream": {
+        const value = parseStreamReply(
+          await this.execute(["XRANGE", input.key, "-", "+", "COUNT", String(input.sampleSize)])
+        );
+        return {
+          key: input.key,
+          exists: true,
+          keyType,
+          ttlSeconds,
+          value,
+          preview: `${value.length} sampled stream entr${value.length === 1 ? "y" : "ies"}`,
+          size: value.length
+        };
+      }
+      default:
+        return {
+          key: input.key,
+          exists: true,
+          keyType,
+          ttlSeconds,
+          value: null,
+          preview: `Key type '${keyType}' is not directly decoded by this server.`,
+          size: null
+        };
+    }
+  }
+  async setKey(input) {
+    const args = ["SET", input.key, input.serializedValue];
+    if (input.ttlSeconds !== null) {
+      args.push("EX", String(input.ttlSeconds));
+    }
+    if (input.onlyIfAbsent) {
+      args.push("NX");
+    }
+    const response = await this.execute(args);
+    return {
+      key: input.key,
+      stored: response === "OK",
+      ttlSeconds: input.ttlSeconds
+    };
+  }
+  async inspectServerInfo(input) {
+    const raw = await this.execute(input.section ? ["INFO", input.section] : ["INFO"]);
+    return {
+      section: input.section ?? "default",
+      properties: parseInfoSection(raw),
+      raw
+    };
+  }
+  async listKeys(input) {
+    const keys = [];
+    let cursor = "0";
+    do {
+      const reply = await this.execute(["SCAN", cursor, "MATCH", input.pattern, "COUNT", String(input.limit)]);
+      const parsed = parseScanReply(reply);
+      cursor = parsed.cursor;
+      for (const key of parsed.keys) {
+        if (keys.length >= input.limit) {
+          break;
+        }
+        keys.push(key);
+      }
+    } while (cursor !== "0" && keys.length < input.limit);
+    return keys;
+  }
+  async ensureConnected() {
+    if (this.client.isOpen) {
+      return;
+    }
+    try {
+      await this.client.connect();
+    } catch (error) {
+      throw new ExternalServiceError("Failed to connect to Redis.", {
+        details: extractErrorMessage(error)
+      });
+    }
+  }
+  async execute(args) {
+    await this.ensureConnected();
+    try {
+      return await this.client.sendCommand(args);
+    } catch (error) {
+      throw new ExternalServiceError(`Redis command failed: ${args[0]}.`, {
+        details: extractErrorMessage(error)
+      });
+    }
+  }
+};
+var RedisServer = class extends ToolkitServer {
+  constructor(env, client) {
+    super(metadata);
+    this.env = env;
+    this.client = client;
+    this.registerTool(
+      defineTool({
+        name: "get-key",
+        title: "Inspect Redis key",
+        description: "Fetch a Redis key with type-aware decoding and TTL metadata.",
+        inputSchema: {
+          key: z.string().min(1),
+          sampleSize: z.number().int().positive().max(100).default(10)
+        },
+        outputSchema: {
+          key: z.string(),
+          exists: z.boolean(),
+          keyType: z.string().nullable(),
+          ttlSeconds: z.number().int().nonnegative().nullable(),
+          value: jsonValueSchema.nullable(),
+          preview: z.string(),
+          size: z.number().int().nonnegative().nullable()
+        },
+        handler: async ({ key, sampleSize }, context) => {
+          await context.log("info", `Inspecting Redis key '${key}'.`);
+          return this.client.getKey({
+            key,
+            sampleSize: Math.min(sampleSize, this.env.REDIS_VALUE_SAMPLE_LIMIT)
+          });
+        },
+        renderText: (output) => output.exists ? `${output.key} (${output.keyType ?? "unknown"}) ttl=${output.ttlSeconds ?? "none"}` : `${output.key} was not found.`
+      })
+    );
+    this.registerTool(
+      defineTool({
+        name: "set-key",
+        title: "Set Redis key",
+        description: "Set a Redis key with an explicit write guard and optional TTL.",
+        inputSchema: {
+          key: z.string().min(1),
+          value: jsonValueSchema,
+          ttlSeconds: z.number().int().positive().max(604800).optional(),
+          onlyIfAbsent: z.boolean().default(false),
+          allowWrite: z.boolean().default(false)
+        },
+        outputSchema: {
+          key: z.string(),
+          stored: z.boolean(),
+          ttlSeconds: z.number().int().nonnegative().nullable(),
+          serialization: z.string()
+        },
+        handler: async ({ allowWrite, key, onlyIfAbsent, ttlSeconds, value }, context) => {
+          if (!this.env.REDIS_ALLOW_WRITES || !allowWrite) {
+            throw new ValidationError(
+              "Redis writes are disabled by default. Set REDIS_ALLOW_WRITES=true and pass allowWrite=true to set keys."
+            );
+          }
+          const resolvedTtlSeconds = ttlSeconds ?? (this.env.REDIS_DEFAULT_TTL_SECONDS > 0 ? this.env.REDIS_DEFAULT_TTL_SECONDS : null);
+          const serialization = typeof value === "string" ? value : JSON.stringify(value);
+          await context.log("warning", `Setting Redis key '${key}' with explicit write opt-in.`);
+          const result = await this.client.setKey({
+            key,
+            serializedValue: serialization,
+            ttlSeconds: resolvedTtlSeconds,
+            onlyIfAbsent
+          });
+          return {
+            key: result.key,
+            stored: result.stored,
+            ttlSeconds: result.ttlSeconds,
+            serialization
+          };
+        },
+        renderText: (output) => `${output.key} ${output.stored ? "stored" : "not written"}.`
+      })
+    );
+    this.registerTool(
+      defineTool({
+        name: "inspect-server-info",
+        title: "Inspect Redis server info",
+        description: "Read INFO output from Redis and parse it into name/value pairs.",
+        inputSchema: {
+          section: z.string().min(1).optional()
+        },
+        outputSchema: {
+          section: z.string(),
+          propertyCount: z.number().int().nonnegative(),
+          properties: z.array(
+            z.object({
+              name: z.string(),
+              value: z.string()
+            })
+          ),
+          raw: z.string()
+        },
+        handler: async ({ section }, context) => {
+          await context.log("info", `Inspecting Redis INFO ${section ?? "default"} section.`);
+          const request = {};
+          if (section) {
+            request.section = section;
+          }
+          const result = await this.client.inspectServerInfo(request);
+          return {
+            section: result.section,
+            propertyCount: result.properties.length,
+            properties: result.properties,
+            raw: result.raw
+          };
+        },
+        renderText: (output) => `${output.propertyCount} Redis INFO properties returned for ${output.section}.`
+      })
+    );
+    this.registerStaticResource(
+      "cache-overview",
+      "redis://cache-overview",
+      {
+        title: "Redis cache overview",
+        description: "Redis connection summary, INFO snapshot, and sampled keys.",
+        mimeType: "application/json"
+      },
+      async () => {
+        const info = await this.client.inspectServerInfo({ section: "server" });
+        const sampleKeys = await this.client.listKeys({
+          pattern: this.env.REDIS_RESOURCE_SCAN_PATTERN,
+          limit: this.env.REDIS_RESOURCE_KEY_LIMIT
+        });
+        return this.createJsonResource("redis://cache-overview", {
+          connection: maskRedisUrl(this.env.REDIS_URL),
+          writeEnabled: this.env.REDIS_ALLOW_WRITES,
+          defaultTtlSeconds: this.env.REDIS_DEFAULT_TTL_SECONDS > 0 ? this.env.REDIS_DEFAULT_TTL_SECONDS : null,
+          sampledPattern: this.env.REDIS_RESOURCE_SCAN_PATTERN,
+          sampleKeys,
+          info: info.properties.reduce((accumulator, property) => {
+            accumulator[property.name] = property.value;
+            return accumulator;
+          }, {})
+        });
+      }
+    );
+    this.registerPrompt(
+      "cache-debug",
+      {
+        title: "Redis cache debug",
+        description: "Generate a focused investigation plan for Redis cache issues.",
+        argsSchema: {
+          symptom: z.string().min(1),
+          keyPattern: z.string().min(1).optional(),
+          suspectedTtlIssue: z.boolean().default(false)
+        }
+      },
+      async ({ keyPattern, suspectedTtlIssue, symptom }) => this.createTextPrompt(
+        [
+          "Investigate the Redis caching issue described below.",
+          `Symptom: ${symptom}`,
+          `Key pattern: ${keyPattern ?? "not provided"}`,
+          `Suspected TTL issue: ${suspectedTtlIssue}`,
+          `Write operations enabled: ${this.env.REDIS_ALLOW_WRITES}`,
+          "Use the Redis tools to:",
+          "- inspect representative keys and their TTLs",
+          "- compare INFO output for memory, evictions, and persistence clues",
+          "- confirm whether serialization or key type mismatches are involved",
+          "- document the safest next step before modifying cache entries"
+        ].join("\n")
+      )
+    );
+  }
+  async close() {
+    await this.client.close?.();
+    await super.close();
+  }
+};
+function createServer(options = {}) {
+  const env = options.env ?? loadEnv(redisEnvShape);
+  const client = options.client ?? new NodeRedisClient(env.REDIS_URL);
+  return new RedisServer(env, client);
+}
+async function main(argv = process.argv.slice(2)) {
+  const env = loadEnv(redisEnvShape);
+  const runtimeOptions = parseRuntimeOptions(argv);
+  await runToolkitServer(
+    {
+      createServer: () => createServer({ env }),
+      serverCard
+    },
+    runtimeOptions
+  );
+}
+function isMainModule() {
+  const entryPoint = process.argv[1];
+  if (!entryPoint) {
+    return false;
+  }
+  return import.meta.url === pathToFileURL(entryPoint).href;
+}
+if (isMainModule()) {
+  void main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown startup error.";
+    console.error(`Failed to start Redis MCP server: ${message}`);
+    process.exitCode = 1;
+  });
+}
+export {
+  RedisServer,
+  createServer,
+  main,
+  metadata,
+  serverCard
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@universal-mcp-toolkit/server-redis",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Key inspection and cache diagnostics tools for Redis.",
+  "license": "MIT",
+  "bin": {
+    "server-redis": "./dist/index.js",
+    "umt-redis": "./dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Markgatcha/universal-mcp-toolkit.git"
+  },
+  "homepage": "https://github.com/Markgatcha/universal-mcp-toolkit#readme",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    ".well-known"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "developer-tools",
+    "typescript",
+    "redis",
+    "cache",
+    "kv-store",
+    "diagnostics"
+  ],
+  "dependencies": {
+    "@universal-mcp-toolkit/core": "0.1.0",
+    "redis": "^5.11.0",
+    "zod": "^4.3.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx watch src/index.ts",
+    "lint": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rimraf dist"
+  }
+}