Redis MCP: अपने AI एजेंट को अपने डेटाबेस से जोड़ें

Redis MCP की मदद से AI क्लाइंट ऐसे टूल कॉल कर सकता है जो आपके Redis डेटाबेस का डेटा पढ़ते और बदलते हैं। अपना डेटाबेस जोड़ने के लिए आधिकारिक redis-mcp-server चलाएँ, उसे Redis का पता और सीमित अधिकारों वाला क्रेडेंशियल दें, फिर उस प्रोसेस को Cursor या Claude Desktop में रजिस्टर करें।

यह गाइड दो छोटी डेमो कीज़ के साथ यह कनेक्शन चालू करती है। आप एक string और एक hash पढ़ेंगे, एक TTL देखेंगे और जांचेंगे कि Redis राइट को रिजेक्ट करता है। आप अपने कंप्यूटर पर शुरू कर सकते हैं, फिर यही तरीका Lizard में डेडिकेटेड Managed Redis इंस्टेंस के साथ इस्तेमाल कर सकते हैं।

27 सितंबर 2026 को टेस्ट किया गया (दुबई समय): Python 3.12.10, Redis 8.8.0, redis-mcp-server 0.5.1, MCP Python SDK 1.30.0 और redis-py 8.1.0। डाउनलोड किए जा सकने वाले टेस्ट ने stdio पर MCP के ज़रिए एक अलग लोकल Redis प्रोसेस पर 14 जांच पास कीं। इसमें होस्टेड डेटाबेस, TLS या Cursor और Claude Desktop के इंटरफ़ेस टेस्ट नहीं किए गए। उनके सेटअप स्टेप लिंक किए गए प्रोडक्ट डॉक्यूमेंटेशन पर आधारित हैं। यह गाइड AI की मदद से तैयार की गई है; टेस्ट स्क्रिप्ट और नतीजे नीचे उपलब्ध हैं।

वह Redis MCP सर्वर चुनें जो डेटा तक पहुंचता है

आधिकारिक Redis MCP सर्वर एक Redis एंडपॉइंट से जुड़ता है। इसके टूल्स में string और hash पढ़ना, राइट करना, कीज़ की जांच और सर्वर की जानकारी शामिल है। Redis आपके दिए गए क्रेडेंशियल की परमिशन लागू करता है।

नाम में MCP वाले कई Redis टूल हैं:

हम पहले वाले का इस्तेमाल करते हैं। डॉक्यूमेंटेशन कनेक्शन से आपके एजेंट को आपकी कीज़ तक पहुंच नहीं मिलेगी। Redis यह अंतर अपनी एजेंट सेटअप गाइड में बताता है।

MCP प्रोसेस उसी कंप्यूटर पर चलता है जिस पर आपका क्लाइंट है, और स्टैंडर्ड इनपुट और आउटपुट यानी stdio के ज़रिए बात करता है। Redis के लिए यह अलग नेटवर्क कनेक्शन खोलता है। इस सेटअप में MCP के लिए किसी पब्लिक HTTP एंडपॉइंट की ज़रूरत नहीं होती। क्लाइंट में हरा कनेक्शन इंडिकेटर सिर्फ़ इतना बताता है कि MCP प्रोसेस शुरू हो गया; Redis ऑथेंटिकेशन और डेटा एक्सेस काम कर रहे हैं, यह किसी टूल कॉल से ही साबित होगा।

1. एक छोटा Redis डेटाबेस तैयार करें

सिंथेटिक डेटा वाला एक अलग लर्निंग इंस्टेंस इस्तेमाल करें। आपको Python 3.10 या उसके बाद का वर्ज़न, uv और किसी Redis सर्वर तक पहुंच चाहिए। लोकल तरीके के लिए आपके PATH में redis-server भी होना चाहिए।

ये फ़ाइलें एक नई डेमो डायरेक्टरी में डाउनलोड करें:

• requirements.txt: पिन किए गए Python पैकेज।
• setup.py: दो कीज़ और सीमित अधिकारों वाला रीडर बनाता है, फिर MCP कॉन्फ़िगरेशन लिखता है।
• verify.py: अपना लोकल Redis प्रोसेस शुरू करता है और MCP कनेक्शन टेस्ट करता है।
• validation.json: इस गाइड के टेस्ट रन के नतीजे।

macOS या Linux पर Python एनवायरनमेंट बनाएँ:

uv venv .venv --python 3.12
uv pip install --python .venv/bin/python -r requirements.txt

एक अलग टर्मिनल में अस्थायी Redis इंस्टेंस शुरू करें:

redis-server --bind 127.0.0.1 --port 6391 --save "" --appendonly no

वह टर्मिनल चलता रहने दें। इस लोकल इंस्टेंस में कोई पर्सिस्टेंस नहीं है और यह सिर्फ़ loopback पर सुनता है। काम पूरा होने पर Ctrl+C से इसे बंद करें। अगर पोर्ट 6391 पहले से किसी दूसरे प्रोसेस के पास है, तो कोई खाली पोर्ट चुनें और setup चलाने से पहले ADMIN_REDIS_URL को उसी के हिसाब से सेट करें।

अपनी डेमो डायरेक्टरी में चलाएँ:

.venv/bin/python setup.py

setup स्क्रिप्ट डिफ़ॉल्ट रूप से redis://127.0.0.1:6391/0 से जुड़ती है। यह ये चीज़ें बनाती है:

यह रैंडम पासवर्ड के साथ mcp_reader यूज़र भी बनाती है। यह किसी मौजूदा यूज़र या डेमो कीज़ को बदलने से इनकार करती है, इसलिए उसी इंस्टेंस पर दोबारा चलाने पर यह वजह बताकर रुक जाती है।

स्क्रिप्ट mcp.local.json सेव करती है, जिसमें इंस्टॉल किए गए MCP सर्वर का पूरा (absolute) पाथ होता है। इस फ़ाइल में रीडर का पासवर्ड होता है। इसे प्राइवेट रखें और कुछ भी कमिट करने से पहले ये पाथ डेमो प्रोजेक्ट की .gitignore में जोड़ें:

.venv/
.env
mcp.local.json
.cursor/mcp.json
test-runs/

Windows पर Python कमांड के लिए .venv\Scripts\python.exe इस्तेमाल करें। स्क्रिप्ट जनरेट किए गए कॉन्फ़िगरेशन के लिए सही एक्ज़ीक्यूटेबल पाथ खुद चुनती है। इस गाइड का ऑटोमेटेड रन macOS पर किया गया था।

2. रीडर की परमिशन समझें

स्क्रिप्ट यह Redis ACL नीति लागू करती है। यह Redis कमांड सिंटैक्स है, जिसमें पासवर्ड की जगह प्लेसहोल्डर है; असली पासवर्ड setup स्क्रिप्ट आपके लिए जनरेट करती है:

ACL SETUSER mcp_reader reset on >REPLACE_WITH_RANDOM_PASSWORD ~mcpdemo:* -@all +ping +get +hget +hgetall +type +ttl

ये नियम mcpdemo:* के तहत जानी-पहचानी strings और hashes को पढ़ने, साथ ही टाइप और TTL जांचने की अनुमति देते हैं। ये राइट्स, एडमिनिस्ट्रेशन कमांड, pub/sub और कीज़ की लिस्टिंग (enumeration) को रोकते हैं। Redis ACL रेफ़रेंस हर नियम को समझाता है।

रीड-ओनली प्रॉम्प्ट से रीड-ओनली एक्सेस लागू नहीं होता। यह काम डेटाबेस क्रेडेंशियल करता है। MCP सर्वर फिर भी राइट टूल्स की लिस्ट दिखा सकता है; इस यूज़र के लिए Redis को उन्हें चलाने से रोकना चाहिए। क्लाइंट के अप्रूवल प्रॉम्प्ट चालू रखें, ताकि कौन-से कॉल चलेंगे, इस पर एक और जांच रहे।

नीति SCAN की अनुमति क्यों नहीं देती

ACL की पैटर्न कीज़ की वैल्यू तक पहुंच को सीमित करता है। इससे SCAN सिर्फ़ उस पैटर्न वाली कीज़ के नाम नहीं लौटाता। हमारे टेस्ट में +scan देने पर mcp_reader को private:sentinel नाम पता चल गया, जबकि वह उस की की वैल्यू नहीं पढ़ सकता था। SCAN वापस लेने पर लिस्टिंग फिर से ब्लॉक हो गई।

जानी-पहचानी डेमो कीज़ से शुरू करें। अगर आप बाद में किसी ऐसे अलग इंस्टेंस पर ब्राउज़िंग की अनुमति देते हैं जिसमें कोई असंबंधित डेटा नहीं है, तो scan_keys को छोटे-छोटे हिस्सों में चलाएँ और लौटाए गए कर्सर को तब तक फ़ॉलो करें जब तक वह शून्य न हो जाए। COUNT सिर्फ़ इस बात का संकेत है कि कितना काम करना है, नतीजों की सख़्त सीमा नहीं। SCAN रेफ़रेंस देखें। ट्यूटोरियल की डिफ़ॉल्ट नीति जानबूझकर scan_keys और scan_all_keys, दोनों को रिजेक्ट करती है।

3. Cursor या Claude Desktop में Redis MCP जोड़ें

जनरेट की गई mcp.local.json को लोकल रूप से खोलें। इसका फ़ॉर्मैट ऐसा है:

{
  "mcpServers": {
    "redis-demo": {
      "command": "/ABSOLUTE/PATH/redis-mcp-demo/.venv/bin/redis-mcp-server",
      "args": ["--host", "127.0.0.1", "--port", "6391", "--db", "0"],
      "env": {
        "REDIS_USERNAME": "mcp_reader",
        "REDIS_PWD": "YOUR_GENERATED_READER_PASSWORD"
      }
    }
  }
}

ऊपर दिए प्लेसहोल्डर नहीं, बल्कि असली जनरेट की गई फ़ाइल इस्तेमाल करें। redis-demo एंट्री को अपने क्लाइंट के मौजूदा mcpServers ऑब्जेक्ट में मर्ज करें; वहां पहले से मौजूद दूसरे सर्वर बने रहने दें।

Cursor: डेमो प्रोजेक्ट में .cursor/mcp.json इस्तेमाल करें, या यूज़र-लेवल सेटअप के लिए ~/.cursor/mcp.json। क्लाइंट की MCP सेटिंग्स में सर्वर देखें और उसे प्रोजेक्ट के लिए चालू करें। Cursor ने फ़ाइलों की जगहें अपनी MCP इंटीग्रेशन गाइड में बताई हैं।

Claude Desktop: एंट्री को claude_desktop_config.json में मर्ज करें। macOS पर यह फ़ाइल ~/Library/Application Support/Claude/ में होती है। सेव करने के बाद ऐप रीस्टार्ट करें। क्लाइंट के मौजूदा स्टेप्स के लिए Redis क्लाइंट कॉन्फ़िगरेशन गाइड फ़ॉलो करें।

यह गाइड होस्ट, पोर्ट और डेटाबेस को साफ़ आर्गुमेंट के रूप में पास करती है। टेस्ट किए गए 0.5.1 कमांड-लाइन एंट्री पॉइंट में, अगर आप सिर्फ़ एनवायरनमेंट वेरिएबल देते हैं, तो डिफ़ॉल्ट CLI वैल्यू उन सेटिंग्स को ओवरराइट कर देती हैं। इसलिए सिर्फ़ REDIS_HOST देने पर प्रोसेस फिर भी 127.0.0.1 से जुड़ने की कोशिश कर सकता है। ऊपर के कॉन्फ़िगरेशन में यूज़रनेम और पासवर्ड सपोर्टेड REDIS_USERNAME और REDIS_PWD वेरिएबल से दिए गए हैं।

4. साबित करें कि कनेक्शन काम करता है

अपने क्लाइंट से साफ़ तौर पर Redis टूल्स इस्तेमाल करने को कहें। मांगे गए रीड को अप्रूव करें और मॉडल के सारांश पर भरोसा करने से पहले टूल का आउटपुट देखें।

Use redis-demo to get mcpdemo:status. Then use hgetall on
mcpdemo:session:42 and type on that same key. Report the raw
tool results and the remaining TTL. Do not change any data.

अपेक्षित नतीजे:

• get ready लौटाता है।
• hgetall दो सिंथेटिक फ़ील्ड लौटाता है।
• type hash लौटाता है और 3,600 सेकंड से कम का पॉज़िटिव TTL देता है।

आधिकारिक type टूल अपने रिस्पॉन्स में TTL भी देता है। हमारे रन में इसने यह लौटाया:

{
  "key": "mcpdemo:session:42",
  "type": "hash",
  "ttl": 3591
}

आपकी संख्या अलग होगी। TTL -2 का मतलब है कि की मौजूद नहीं है; -1 का मतलब है कि की मौजूद है, लेकिन उसकी कोई एक्सपायरी नहीं है। अगर एक घंटे से ज़्यादा बीत गया है, तो डेमो डेटा एक्सपायर हो सकता है। अधिकार रखने वाला एडमिनिस्ट्रेटर कीज़ को फिर से सीड कर सकता है, या आप नया लोकल इंस्टेंस शुरू करके setup दोबारा चला सकते हैं।

इसके बाद, डिस्पोज़ेबल डेमो पर पाबंदी की जांच करें:

Use redis-demo to try setting mcpdemo:status to changed once.
Report the exact tool result. Then read mcpdemo:status again.
Do not retry with other tools or credentials.

हमारे MCP कॉल ने User mcp_reader has no permissions to run the 'set' command लौटाया, और अलग से किए गए रीड ने अब भी ready लौटाया। इससे इनकार और बिना बदली वैल्यू, दोनों की पुष्टि होती है। कुछ Redis MCP टूल्स एरर को टेक्स्ट के रूप में लौटाते हैं, इसलिए MCP कॉल पूरा होने पर भी रिस्पॉन्स का कंटेंट ज़रूर देखें।

आप मॉडल API की के बिना भी नीचे के प्रोटोकॉल चेक दोहरा सकते हैं:

.venv/bin/python verify.py

स्क्रिप्ट किसी खाली loopback पोर्ट पर अपना Redis प्रोसेस शुरू करती है। यह आपके डेटाबेस का URL स्वीकार नहीं करती। यह ऑथेंटिकेशन, MCP स्टार्टअप, दिखाए गए टूल्स, रीड्स, TTL, ब्लॉक हुए राइट्स, बिना बदला डेटा, दूसरा की प्रीफ़िक्स, मौजूद न होने वाली कीज़ और ऊपर बताए गए SCAN व्यवहार की जांच करती है। यह सिर्फ़ अपने बनाए प्रोसेस को रोकती है और validation.json को स्क्रिप्ट के बगल में सेव करती है।

5. डेडिकेटेड Managed Redis इंस्टेंस कनेक्ट करें

शेयर किए गए एप्लिकेशन डेटाबेस के लिए प्रोजेक्ट डैशबोर्ड में Managed Redis बनाएँ और कनेक्शन गाइड फ़ॉलो करें। इस एक्सरसाइज़ के लिए अलग लर्निंग इंस्टेंस इस्तेमाल करें। इसका कनेक्शन URL ADMIN_REDIS_URL नाम से एक प्राइवेट लोकल .env फ़ाइल में कॉपी करें; यह एडमिनिस्ट्रेटर क्रेडेंशियल कभी भी AI चैट में पेस्ट न करें।

अपनी भरोसेमंद फ़ाइल लोड करें और डेमो डायरेक्टरी से setup चलाएँ:

set -a
. ./.env
set +a
.venv/bin/python setup.py
unset ADMIN_REDIS_URL

setup स्क्रिप्ट इस क्रेडेंशियल से सिंथेटिक कीज़ और रीडर बनाती है। इसके जनरेट किए गए MCP कॉन्फ़िगरेशन में सिर्फ़ नया रीडर क्रेडेंशियल होता है। यह URL से होस्ट, पोर्ट और डेटाबेस निकालती है, और rediss:// एंडपॉइंट के लिए TLS सर्टिफ़िकेट वेरिफ़िकेशन चालू करती है। क्वेरी पैरामीटर और कस्टम सर्टिफ़िकेट पाथ के लिए अलग कॉन्फ़िगरेशन चाहिए; स्क्रिप्ट अंदाज़ा लगाने के बजाय रुक जाती है।

एंडपॉइंट उस कंप्यूटर से पहुंच में होना चाहिए जिस पर MCP चल रहा है। सादे redis:// URL में कोई ट्रांसपोर्ट एन्क्रिप्शन नहीं होता। जहां उपलब्ध हो, भरोसेमंद प्राइवेट रूट या वेरिफ़ाइड TLS एंडपॉइंट इस्तेमाल करें; URL का प्रीफ़िक्स बदलने से सर्वर में TLS सपोर्ट नहीं आ जाता। मौजूदा Managed Redis गाइड redis:// कनेक्शन दिखाती है, इसलिए यह न मानें कि यह पब्लिक TLS एंडपॉइंट देता है।

ACL यूज़र बनाने के लिए प्रोवाइडर को ACL SETUSER की अनुमति भी देनी होगी। अगर प्रोवाइडर इसकी अनुमति नहीं देता, तो एजेंट को कनेक्ट करने से पहले उसके सपोर्टेड यूज़र-मैनेजमेंट कंट्रोल इस्तेमाल करें। वर्कअराउंड के तौर पर एडमिनिस्ट्रेटर पासवर्ड MCP कॉन्फ़िगरेशन में न डालें।

रनटाइम पर किए गए Redis ACL बदलावों को Redis रीस्टार्ट के बाद बनाए रखने के लिए पर्सिस्टेंस मैकेनिज़्म चाहिए। मौजूदा Managed Redis स्टार्टअप कॉन्फ़िगरेशन में कोई ACL फ़ाइल नहीं दी गई है, इसलिए इस डेमो यूज़र को अस्थायी मानें और हर रीस्टार्ट के बाद इसे जांचें। यह न मानें कि AOF पर्सिस्टेंस ACL यूज़र्स को सेव करता है। टेस्ट की गई परमिशन अपनी setup प्रोसेस में रखें और सर्विस की दूसरी सीमाओं के लिए स्टोरेज और रिकवरी गाइड देखें।

Redis MCP के आम कनेक्शन एरर ठीक करें

कनेक्शन काम करने के बाद क्या बनाएँ

इस सेटअप से आप सिंथेटिक सेशन की जांच कर सकते हैं, कैश एंट्री की लाइफ़टाइम देख सकते हैं या एजेंट के सेव किए गए कॉन्टेक्स्ट को डीबग कर सकते हैं। टूल के नतीजे आपकी मॉडल बातचीत में पहुंच सकते हैं, इसलिए असली एप्लिकेशन कनेक्ट करने से पहले तय करें कि एजेंट कौन-सा डेटा पढ़ सकता है।

अगर आप चाहते हैं कि एप्लिकेशन मेमोरी अपने-आप सेव करे, तो Redis के साथ AI एजेंट मेमोरी पर आगे बढ़ें। अगर आपके एजेंट को रिलेशनल डेटा चाहिए, तो Postgres MCP में बताई गई अलग रीडर भूमिका इस्तेमाल करें।

Managed Redis से शुरू करें, सीमित अधिकारों वाले रीडर को कनेक्ट करें, और टूल्स बढ़ाने से पहले एक सफल रीड और एक रोके गए राइट की पुष्टि करें।