YourMemory

आपकी AI की याददाश्त सुनहरी मछली जैसी है। अब ऐसा नहीं होगा।

AI एजेंटों के लिए स्थायी, स्व-सुधार करने वाली मेमोरी — मनुष्य याद रखने के विज्ञान पर आधारित।

▶ लाइव इंटरेक्टिव डेमो आज़माएं · वेबसाइट · बेंचमार्क

समस्या

हर सुबह आपका AI एजेंट आपको एक अजनबी की तरह ट्रीट करता है। वही संदर्भ फिर से समझाया जाता है। वही प्राथमिकताएँ भूल जाती हैं। हर सत्र शून्य से शुरू होता है।

अधिकांश "मेमोरी" उपकरण एक वेक्टर डेटाबेस को एक एजेंट से जोड़कर उसे तैयार मान लेते हैं — लेकिन वह तो बस भंडारण है। वह हर लगभग-डुप्लिकेट को जमा करता रहता है जब तक कि रिट्रीवल शोर में डूब न जाए। बड़े कटोरे में सुनहरी मछली।

YourMemory अलग है: मेमोरी जो मस्तिष्क की तरह काम करती है, डेटाबेस की तरह नहीं।

flowchart LR
    A["🧠 आप अपनी<br/>AI को कुछ बताते हैं"] --> B["स्थायी तथ्य<br/>निकालें"]
    B --> C["डीडुप + एम्बेड<br/>+ ग्राफ-लिंक"]
    C --> D[("मेमोरी<br/>स्टोर")]
    D -->|"संबंधित तथ्य जमा होते हैं"| E["✨ समेकित करें<br/>N → 1 सारांश"]
    D -->|"पुराना + उपयोग नहीं हुआ"| F["📉 क्षय<br/>+ छाँटना"]
    D -->|"नया सत्र"| G["♻️ स्मरण<br/>हाइब्रिड + ग्राफ"]
    E --> D
    G --> H["🤖 आपका एजेंट<br/>वहीं से शुरू करता है<br/>जहाँ छोड़ा था"]
    style D fill:#0a2540,stroke:#19cdff,color:#fff
    style E fill:#0c2b3a,stroke:#5eead4,color:#fff
    style H fill:#0c2b3a,stroke:#19cdff,color:#fff

✨ यह कैसे अलग है

स्थापित करने का एक कमांड। डिफ़ॉल्ट रूप से DuckDB (शून्य सेटअप), टीमों के लिए Postgres + pgvector।

विषय-सूची

• 🏆 बेंचमार्क
• 🚀 त्वरित आरंभ
• 🧠 मेमोरी कैसे काम करती है
  • समेकन
  • क्षय
  • हाइब्रिड रिट्रीवल
• 🔒 विश्वास और ऑडिट ट्रेल
• 👥 टीम मेमोरी पूल
• 🛡️ डेटा अधिकार और अनुपालन
• 🎛️ डैशबोर्ड
• 🔧 MCP उपकरण
• ⚡ LLM कॉल के बिना पूछें
• 🔀 API प्रॉक्सी — गारंटीड मेमोरी
• 🏗️ आर्किटेक्चर और स्टैक
• 🩺 समस्या निवारण
• 🤝 योगदान

🏆 बेंचमार्क

तीन बाहरी डेटासेट। हर संख्या स्वतंत्र रूप से पुन: प्रस्तुत करने योग्य — बेंचमार्क कोड रिपॉजिटरी में है। पूर्ण कार्यप्रणाली BENCHMARKS.md में।

LoCoMo-10 — बहु-सत्र संवादी मेमोरी

xychart-beta
    title "Recall@5 · LoCoMo-10 (अधिक बेहतर)"
    x-axis ["Mem0", "Zep Cloud", "Supermemory", "YourMemory"]
    y-axis "Recall@5 प्रतिशत" 0 --> 70
    bar [18, 28, 31, 59]

Zep Cloud से 2× बेहतर रिकॉल सभी 10 नमूनों पर। *Supermemory और Mem0 मध्य-बेंचमार्क में मुफ्त-स्तरीय कोटा समाप्त कर चुके थे; स्कोर पूर्ण 1,534 जोड़ियों पर गणना किए गए।

LongMemEval-S — 500 प्रश्न, ~53 डिस्ट्रैक्टर सत्र प्रत्येक

दीर्घकालिक मेमोरी के लिए सबसे कठिन मानक बेंचमार्क। प्रत्येक प्रश्न ~53 सत्रों में दबा हुआ है।

HotpotQA — 200 मल्टी-हॉप प्रश्न

एंटिटी ग्राफ एज +12 pp जोड़ते हैं — वे तथ्य 1 से तथ्य 2 तक जाते हैं भले ही तथ्य 2 की एम्बेडिंग समानता क्वेरी से कम हो।

लेखन: मैंने AI एजेंटों के लिए एबिंगहॉस भूलने की वक्र का उपयोग करके मेमोरी क्षय बनाया

🚀 त्वरित आरंभ

Python 3.11–3.14. कोई Docker नहीं, कोई डेटाबेस सेटअप नहीं। सभी मेमोरी स्थानीय रूप से ~/.yourmemory/ में संग्रहीत होती है।

pip install yourmemory
yourmemory-register <your-token>
yourmemory-setup

अपना टोकन प्राप्त करें: yourmemoryai.xyz पर जाएं → अपना ईमेल दर्ज करें → 6 अंकों के कोड से सत्यापित करें → अपना टोकन कॉपी करें।

yourmemory-setup स्वचालित रूप से Claude Code, Claude Desktop, Cursor, Windsurf, और Cline का पता लगाता है और उन्हें जोड़ता है, फिर पूछता है कि कौन सा बैकएंड उपयोग करना है:

• DuckDB — शून्य सेटअप, एकल स्थानीय फ़ाइल (डिफ़ॉल्ट)
• Postgres — साझा/उत्पादन; आप एक DATABASE_URL प्रदान करें (इसे pgvector एक्सटेंशन की आवश्यकता है)

वैकल्पिक — अधिक स्मार्ट स्थानीय निष्कर्षण: YourMemory अंतर्निर्मित अनुमानों के साथ बॉक्स से बाहर काम करता है। उच्च गुणवत्ता, पूरी तरह से स्थानीय तथ्य निष्कर्षण के लिए Ollama स्थापित करें और yourmemory-setup मॉडल (qwen2.5:7b, ~4.7 GB) को स्वचालित रूप से खींच लेता है। क्लाउड पसंद है? YOURMEMORY_EXTRACT_BACKEND=anthropic सेट करें।

या बाइनरी से स्थापित करें — Python की आवश्यकता नहीं

pip को छूना नहीं चाहते? नवीनतम रिलीज़ से अपने प्लेटफॉर्म के लिए स्टैंडअलोन बाइनरी लें:

# macOS / Linux — डाउनलोड करें, निकालें, चलाएं
tar -xzf yourmemory-macos-arm64.tar.gz
./yourmemory-macos-arm64 register <your-token>
./yourmemory-macos-arm64 setup
./yourmemory-macos-arm64            # सर्वर शुरू करें

एक निष्पादक हर कमांड को संभालता है: register, setup, ask "<question>", path, और (बिना आर्ग के) सर्वर शुरू करता है।

पूरी तरह से स्व-निहित और ऑफ़लाइन — बाइनरी Python, प्रत्येक निर्भरता, और दोनों ML मॉडल (एम्बेडिंग मॉडल + spaCy) को बंडल करता है। पहली बार उपयोग पर कुछ भी डाउनलोड नहीं होता। इसकी कीमत आकार (~2 GB) है। एक ही कमांड से अपना खुद का बनाएं — ./build-binary.sh — और मल्टी-प्लेटफॉर्म रिलीज़ बाइनरी बिल्ड वर्कफ़्लो द्वारा स्वचालित रूप से तैयार की जाती हैं।

🧠 मेमोरी कैसे काम करती है

YourMemory मेमोरी को एक जीवित प्रणाली के रूप में मानता है — यह बढ़ती है, समेकित होती है, भूलती है, और जुड़ती है, जैसे मस्तिष्क करता है।

समेकन — N → 1

अधिकांश मेमोरी उपकरण बस बढ़ते रहते हैं। YourMemory संबंधित तथ्यों के क्लस्टर पर नज़र रखता है और, जब पर्याप्त जमा हो जाते हैं, तो उन्हें एक एकल साफ सारांश में संपीड़ित करता है — मूल को संग्रहीत करता है (कभी हटाता नहीं, इसलिए कुछ भी खोता नहीं)।

flowchart LR
    subgraph before [संबंधित तथ्य जमा होते हैं]
        A1["रेलवे Nixpacks का उपयोग करता है"]
        A2["रेलवे Pro योजना पर"]
        A3["रेलवे env vars में<br/>Postgres URL है"]
        A4["रेलवे पर Postgres के<br/>साथ डिप्लॉय करता है"]
    end
    before --> C{"क्लस्टर +<br/>LLM सारांश"}
    C --> S["✨ सारांश<br/>रेलवे (Pro, Nixpacks) पर Postgres<br/>env vars के माध्यम से डिप्लॉय करता है"]
    C -.->|"संग्रहीत, पुनर्प्राप्ति योग्य"| ARC[("संग्रह")]
    style S fill:#0a2540,stroke:#5eead4,color:#fff
    style C fill:#0c2b3a,stroke:#19cdff,color:#fff

एक उत्पादन स्टोर से वास्तविक उदाहरण: 444 मेमोरी → 16 सारांश — समान ज्ञान, शोर का एक अंश। समेकन इवेंट-संचालित है (जब संबंधित मेमोरी जमा होती है तब ट्रिगर होता है), अंधी रात्रिकालीन कार्य नहीं।

क्षय — भूलने की वक्र

मेमोरी शक्ति तेजी से घटती है। महत्व और स्मरण आवृत्ति उस क्षय को धीमा करते हैं:

effective_λ  = base_λ × (1 − importance × 0.8)
strength     = clamp(importance × e^(−effective_λ × active_days) × (1 + recall_count × 0.2), 0, 1)

active_days केवल उन दिनों की गणना करता है जब आप सक्रिय थे — छुट्टियाँ मेमोरी हानि का कारण नहीं बनतीं। 0.05 से कम शक्ति वाली मेमोरी स्वचालित रूप से हटा दी जाती है। प्रत्येक श्रेणी अपनी दर से पुरानी होती है:

श्रृंखला-जागरूक छँटाई: एक क्षयकारी मेमोरी तब तक जीवित रखी जाती है जब तक कोई ग्राफ पड़ोसी अभी भी मजबूत है — भार वहन करने वाला संदर्भ बच जाता है भले ही सीधे क्वेरी न किया गया हो।

हाइब्रिड रिट्रीवल — वेक्टर + BM25 + ग्राफ

स्मरण दो राउंड में चलता है ताकि यह दोनों को सतह पर ला सके: आपने जो मांगा और जो आप मांगना भूल गए:

flowchart LR
    Q["क्वेरी"] --> R1["वेक्टर + BM25<br/>हाइब्रिड खोज"]
    R1 --> R2["ग्राफ विस्तार<br/>(जो आप पूछना भूल गए)"]
    R2 --> S["समानता × शक्ति<br/>द्वारा रैंक करें"]
    S --> OUT["🎯 रैंक की गई मेमोरी"]
    style OUT fill:#0a2540,stroke:#19cdff,color:#fff

विषय-जागरूक डीडुप्लिकेशन प्रत्येक भंडारण से पहले चलता है — यह प्रत्येक वाक्य के विषय को एम्बेड करता है ताकि "सचित DuckDB का उपयोग करता है" और "YourMemory DuckDB का उपयोग करता है" अलग रहें (विभिन्न संस्थाएं), जबकि "YourMemory DuckDB का उपयोग करता है" और "YourMemory DuckDB में डेटा संग्रहीत करता है" मर्ज हो जाएं (एक ही संस्था)। कोई हार्डकोडेड शब्द सूची नहीं; किसी भी भाषा में सामान्यीकरण।

🔒 विश्वास और ऑडिट ट्रेल

उद्यम किसी अपारदर्शी ब्लैक बॉक्स को अपना डेटा संग्रहीत नहीं करने देंगे। इसलिए प्रत्येक संक्रिया — पढ़ना, लिखना, अद्यतन, हटाना, समेकन — को हैश-चेन, छेड़छाड़-स्पष्ट ऑडिट लॉग में जोड़ा जाता है।

flowchart LR
    E0["GENESIS"] --> E1
    subgraph E1 [घटना 1]
        H1["row_hash =<br/>sha256(prev + data)"]
    end
    E1 --> E2
    subgraph E2 [घटना 2]
        H2["row_hash =<br/>sha256(#1.hash + data)"]
    end
    E2 --> E3
    subgraph E3 [घटना 3]
        H3["row_hash =<br/>sha256(#2.hash + data)"]
    end
    E3 --> V{"GET /audit/verify"}
    V -->|श्रृंखला बरकरार| OK["✅ सत्यापित"]
    V -->|कोई भी पंक्ति बदली| BAD["❌ श्रृंखला टूटती है<br/>उस पंक्ति पर"]
    style OK fill:#0a2540,stroke:#5eead4,color:#fff
    style BAD fill:#3a0c14,stroke:#fb7185,color:#fff

प्रत्येक पंक्ति टाइमस्टैम्प, अभिनेता उपयोगकर्ता + एजेंट, क्रिया, संक्रिया, लक्ष्य मेमोरी, स्रोत (http बनाम mcp), और पिछली पंक्ति का हैश रिकॉर्ड करती है। किसी भी ऐतिहासिक रिकॉर्ड को बदलें और verify_chain() ठीक वहीं इंगित करता है जहाँ श्रृंखला टूटी।

GET  /audit            # ट्रेल ब्राउज़ करें (उपयोगकर्ता/क्रिया/संक्रिया द्वारा फ़िल्टर)
GET  /audit/verify     # क्रिप्टोग्राफिक रूप से सत्यापित करें कि श्रृंखला अछेती है
POST /audit/prune      # प्रतिधारण-आधारित सफाई (90 दिन न्यूनतम, कभी कम नहीं)

ऑडिट लॉगिंग फेल-ओपन है — यह कभी मेमोरी संक्रिया को ब्लॉक नहीं करता — और डैशबोर्ड के स्वयं के रेंडर लूप से पढ़ने/सूचीबद्ध करने की घटनाओं को बाहर रखा गया है, ताकि ट्रेल सिग्नल बना रहे, शोर नहीं।

👥 टीम मेमोरी पूल

पूरी टीम के एजेंटों को एक साझा मस्तिष्क दें — बिना किसी के निजी संदर्भ को लीक किए। मेमोरी या तो साझा (पूल को दृश्यमान) या निजी (केवल उनके मालिक को दृश्यमान) होती है।

flowchart TB
    P(("🧠 टीम पूल<br/>साझा मेमोरी"))
    A["एलिस का एजेंट"] <-->|साझा| P
    B["बॉब का एजेंट"] <-->|साझा| P
    C["कैरल का एजेंट"] <-->|साझा| P
    A -. निजी .-> AP["🔒 केवल-एलिस"]
    B -. निजी .-> BP["🔒 केवल-बॉब"]
    style P fill:#0a2540,stroke:#19cdff,color:#fff
    style AP fill:#0c1424,stroke:#5a6b80,color:#8294a8
    style BP fill:#0c1424,stroke:#5a6b80,color:#8294a8

भूमिका-आधारित पहुंच प्रति एजेंट लागू की जाती है — एक इंजीनियर का एजेंट जो सीखता है, पूरी टीम को तुरंत लाभ होता है; संवेदनशील संदर्भ अपने मालिक तक ही सीमित रहता है।

POST   /pools                          # पूल बनाएं
POST   /pools/{id}/members             # सदस्य जोड़ें (भूमिका के साथ)
POST   /pools/{id}/memories            # साझा मेमोरी योगदान करें
POST   /pools/{id}/retrieve            # पूल में स्मरण करें

🛡️ डेटा अधिकार और अनुपालन

क्योंकि वास्तविक डेटा संग्रहीत करने वाली मेमोरी को इसके साथ भरोसा किए जाने के लिए नियंत्रण की आवश्यकता होती है:

हैश-चेन ऑडिट ट्रेल और 90-दिन प्रतिधारण मंजिल के साथ मिलकर, ये सीधे SECURITY.md (SOC 2-संरेखित) में प्रलेखित नियंत्रणों पर मैप होते हैं।

🎛️ डैशबोर्ड

दो अंतर्निर्मित ब्राउज़र UI — कोई अतिरिक्त सेटअप नहीं, वे सर्वर के साथ स्वचालित रूप से शुरू होते हैं।

मेमोरी डैशबोर्ड — http://localhost:3033/ui

मेमोरी · ऑडिट · पूल टैब के साथ एक पूर्ण रीड/राइट दृश्य: स्टैट बार (मजबूत / फीकी / लगभग-हटाने योग्य), प्रति-एजेंट टैब, लाइव शक्ति पट्टियों वाले मेमोरी कार्ड, श्रेणी फ़िल्टर, ऑडिट ट्रेल, और पूल प्रबंधन।

ग्राफ़ विज़ुअलाइज़र — http://localhost:3033/graph

एक इंटरेक्टिव बल-निर्देशित मानचित्र कि मेमोरी कैसे जुड़ती है — मूल मेमोरी एक चमकीले नोड के रूप में, पड़ोसी श्रेणी के अनुसार रंग-कोडित, एज मोटाई = कनेक्शन शक्ति। खींचें, ज़ूम करें, और पूर्ण सामग्री के लिए किसी भी नोड पर क्लिक करें।

http://localhost:3033/graph?memoryId=42&userId=alex&depth=2

🔧 MCP उपकरण

तीन उपकरण, आपकी AI द्वारा स्वचालित रूप से बुलाए जाते हैं।

# स्थानिक संदर्भ के साथ संग्रहीत करें
store_memory(
    "एलेक्स Python में spaces के ऊपर tabs पसंद करता है",
    importance=0.9, category="fact",
    context_paths=["/projects/backend"],
)

# अगला सत्र — उस निर्देशिका में काम करते समय स्थानिक बढ़ावा सक्रिय होता है
recall_memory("Python formatting", current_path="/projects/backend")
# → {"content": "एलेक्स Python में spaces के ऊपर tabs पसंद करता है", "strength": 0.87}

⚡ LLM कॉल के बिना पूछें

एकमात्र मेमोरी सिस्टम जो कोई LLM API कॉल किए बिना प्रश्नों का उत्तर दे सकता है:

yourmemory ask "यह प्रोजेक्ट किस डेटाबेस का उपयोग करता है"
# → YourMemory स्थानीय रूप से DuckDB और उत्पादन में Postgres का उपयोग करता है।

yourmemory ask "मैं kubernetes डिप्लॉयमेंट कैसे ठीक करूं"
# → LLM के बिना उत्तर देने के लिए पर्याप्त मेमोरी संदर्भ नहीं।

जब मेमोरी पर्याप्त मजबूत होती है तो यह तुरंत उत्तर देती है — शून्य टोकन, शून्य क्लाउड लागत, शून्य विलंबता। जब नहीं, तो यह मतिभ्रम करने के बजाय साफ इनकार करती है। आपकी क्वेरी कभी आपकी मशीन नहीं छोड़ती।

🔀 API प्रॉक्सी — गारंटीड मेमोरी

MCP उपकरण AI के विवेक पर बुलाए जाते हैं। API प्रॉक्सी उस अनिश्चितता को समाप्त करता है — यह हर LLM कॉल को इंटरसेप्ट करता है, स्वचालित रूप से प्रासंगिक मेमोरी इंजेक्ट करता है, और बिना किसी मॉडल कॉन्फ़िगरेशन के store_memory/update_memory को संभालता है।

सर्वर शुरू करें (yourmemory), फिर अपने क्लाइंट को localhost:3033 पर पॉइंट करें:

from anthropic import Anthropic

client = Anthropic(
    api_key="sk-ant-...",
    base_url="http://localhost:3033/proxy/anthropic",
    default_headers={"X-YourMemory-User": "alex"},  # प्रति-उपयोगकर्ता मेमोरी
)

# मेमोरी स्वचालित रूप से इंजेक्ट की जाती है — किसी अन्य परिवर्तन की आवश्यकता नहीं
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[{"role": "user", "content": "मैं किस डेटाबेस का उपयोग करता हूं?"}],
)

OpenAI base_url="http://localhost:3033/proxy/openai" के माध्यम से समान रूप से काम करता है।

🏗️ आर्किटेक्चर और स्टैक

flowchart LR
    C["आपका AI क्लाइंट<br/>Claude · Cursor · कोई भी MCP"] <--> Y["🧠 YourMemory"]
    Y --> M[("मेमोरी<br/>स्टोर")]
    Y --> A[("ऑडिट<br/>लेज़र")]
    style Y fill:#0a2540,stroke:#19cdff,color:#fff
    style M fill:#0c1a2c,stroke:#5eead4,color:#fff
    style A fill:#0c1a2c,stroke:#5eead4,color:#fff

🩺 समस्या निवारण

लिखना हैंग / टाइम आउट (DuckDB एकल-लेखक लॉक)। यदि MCP सर्वर और HTTP सर्वर दोनों एक साथ चलते हैं, तो वे DuckDB लिखने वाले लॉक के लिए प्रतिस्पर्धा करते हैं। समाधान:

pkill -f yourmemory 2>/dev/null || true
rm -f ~/.yourmemory/memories.duckdb.wal ~/.yourmemory/memories.duckdb.lock 2>/dev/null || true
# अपने क्लाइंट को पुनरारंभ करें

क्लॉड डेस्कटॉप (MCP) और क्लॉड कोड (हुक) एक साथ चला रहे हैं? इसके बजाय SQLite का उपयोग करें — यह समवर्ती पाठकों/लेखकों को साफ-सुथरा संभालता है: DATABASE_URL=sqlite:///~/.yourmemory/memories.db

🤝 योगदान

PR स्वागत योग्य हैं — CONTRIBUTORS.md देखें।

📚 डेटासेट संदर्भ

• LoCoMo — Maharana et al. (2024)
• LongMemEval — Wu et al. (2024)
• HotpotQA — Yang et al. (2018)

📄 लाइसेंस

कॉपीराइट 2026 Sachit Misra — CC-BY-NC-4.0 के तहत लाइसेंस प्राप्त।

निःशुल्क व्यक्तिगत उपयोग, शिक्षा, अकादमिक शोध, और खुले स्रोत परियोजनाओं के लिए। व्यावसायिक उपयोग के लिए एक अलग लिखित समझौता आवश्यक है → [email protected]