Mem0 ट्यूटोरियल: एआई अनुप्रयोगों के लिए पर्सिस्टेंट मेमोरी लेयर

आप अपने चैटबॉट से कहते हैं कि आप शाकाहारी हैं। अगले दिन, वह आपको स्टेक की रेसिपी सुझा देता है। यह कोई बग नहीं है—LLM ऐसे ही काम करते हैं। उनके पास सेशन के बीच मेमोरी नहीं होती; वे हर बातचीत को नए सिरे से शुरू मानते हैं।

आम उपयोग के लिए यह ठीक है। लेकिन यदि आप वास्तविक उपयोगकर्ताओं के साथ वास्तविक दुनिया के एप्लिकेशन बना रहे हैं, तो यह स्टेटलेस व्यवहार एक वास्तविक समस्या बन जाता है। आपके उपयोगकर्ता अपेक्षा करते हैं कि एआई उन्हें याद रखे।

Mem0 इसे किसी भी LLM में एक मेमोरी लेयर जोड़कर हल करता है। यह कई सेशनों में उपयोगकर्ताओं के बारे में जानकारी को स्टोर, रिट्रीव और अपडेट करता है, ताकि आपका एआई समय के साथ सचमुच सीख सके और अनुकूलित हो सके।

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

अगर आपने पहले इसका उपयोग नहीं किया है, तो OpenAI API के साथ काम करना सीखने के लिए यह कोर्स देखें: OpenAI API के साथ कैसे काम करें।

Mem0 क्या है?

Mem0 एक ओपन-सोर्स मेमोरी लेयर है जो आपके एप्लिकेशन और LLM के बीच बैठती है। यह वार्तालापों से प्रासंगिक जानकारी अपने-आप निकालती है, उसे स्टोर करती है, और ज़रूरत पड़ने पर रिट्रीव करती है। इस प्रोजेक्ट ने अक्टूबर 2025 में $24M जुटाए और यह किसी भी LLM प्रदाता के साथ काम करता है: OpenAI, Anthropic, Ollama, या आपके अपने मॉडल।

Mem0 यादों को तीन स्कोप में व्यवस्थित करता है:

• यूज़र मेमोरी: किसी विशेष व्यक्ति के साथ सभी वार्तालापों में बनी रहती है। यदि कोई बताता है कि उन्हें सुबह पढ़ना पसंद है, तो यह तथ्य भविष्य के हर सेशन में उपलब्ध रहता है। 

• सेशन मेमोरी: एक ही बातचीत के भीतर का संदर्भ ट्रैक करती है, जैसे वर्तमान में चर्चा की जा रही रेसिपी। 

• एजेंट मेमोरी: किसी विशेष एआई एजेंट इंस्टेंस से संबंधित जानकारी स्टोर करती है। 

आप इन स्कोप्स को मिलाकर जटिल एप्लिकेशन बना सकते हैं, जहाँ अलग-अलग एजेंट उपयोगकर्ताओं के बारे में अपनी जानकारी साझा करते हैं (या अलग रखते हैं)।

तीन मेमोरी स्कोप: यूज़र, सेशन, और एजेंट—उदाहरणों सहित।

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

जब आपके ऐप को संदर्भ की ज़रूरत होती है, तो Mem0 मौजूदा क्वेरी के आधार पर प्रासंगिक यादें लाता है और उन्हें प्रॉम्प्ट में इंजेक्ट कर देता है। यह हर रिक्वेस्ट में पूरी बातचीत का इतिहास ठूँसने के विकल्प से कहीं बेहतर है।

आप Mem0 को दो तरीकों से चला सकते हैं:

• प्लेटफ़ॉर्म: app.mem0.ai पर क्लाउड-आधारित मैनेज्ड सेवा, तेज़ सेटअप और API के साथ।

• सेल्फ-होस्टेड: आपको अपने इन्फ्रास्ट्रक्चर पर पूरा नियंत्रण देता है, जिससे आप अपना वेक्टर डेटाबेस और एम्बेडिंग मॉडल चुन सकते हैं। 

दोनों विकल्प एक ही Python SDK का उपयोग करते हैं, इसलिए इनके बीच स्विच करना आसान है।

प्रदर्शन लाभ वास्तविक हैं, जैसा कि Mem0 के शोध पत्र दिखाते हैं। LOCOMO बेंचमार्क पर, Mem0 ने OpenAI की बिल्ट-इन मेमोरी से 26% अधिक स्कोर किया। यह पूरी बातचीत का इतिहास प्रोसेस करने की बजाय केवल प्रासंगिक यादें चुनकर 91% तेज़ प्रतिक्रिया देता है। टोकन उपयोग पूरे-संदर्भ दृष्टिकोणों की तुलना में लगभग 90% तक घट जाता है।

अब जबकि आप जानते हैं कि Mem0 क्या करता है, आइए इसे सेट करें।

Mem0 के साथ शुरुआत

API कुंजियों को प्रबंधित करने के लिए python-dotenv के साथ पैकेज इंस्टॉल करें:

pip install mem0ai python-dotenvसंचालित द्वारा

app.mem0.ai पर साइन अप करें और डैशबोर्ड से अपना API की प्राप्त करें। अपने प्रोजेक्ट डायरेक्टरी में एक .env फ़ाइल बनाएँ:

MEM0_API_KEY=your-api-key-hereसंचालित द्वारा

अब, API की का उपयोग करके क्लाइंट इनिशियलाइज़ करें:

from mem0 import MemoryClient
from dotenv import load_dotenv
import os

load_dotenv()

client = MemoryClient(api_key=os.getenv("MEM0_API_KEY"))संचालित द्वारा

कोई मेमोरी स्टोर करने के लिए, बातचीत को OpenAI चैट फॉर्मेट में पास करें। user_id पैरामीटर यादों को किसी विशिष्ट उपयोगकर्ता तक सीमित करता है:

messages = [
	{"role": "user", "content": "I'm a vegetarian and allergic to nuts."},
	{"role": "assistant", "content": "Got it! I'll remember that."}
]
client.add(messages, user_id="user123")संचालित द्वारा

मेमोरी प्रोसेसिंग बैकग्राउंड में होती है। add() मेथड तुरंत पेंडिंग स्टेटस के साथ रिटर्न करता है, जब तक Mem0 प्रासंगिक तथ्यों को निकालकर स्टोर करता है।

यादें रिट्रीव करने के लिए, प्राकृतिक भाषा क्वेरी के साथ search() का उपयोग करें:

results = client.search("dietary restrictions", filters={"user_id": "user123"})संचालित द्वारा

रेस्पॉन्स में एक्सट्रैक्टेड मेमोरीज़ प्रासंगिकता स्कोर के साथ होती हैं:

{'results': [
	{'memory': 'User is allergic to nuts', 'user_id': 'user123', 'score': 0.66},
	{'memory': 'User is a vegetarian', 'user_id': 'user123', 'score': 0.65}
]}संचालित द्वारा

ध्यान दें कि Mem0 ने "vegetarian” और “allergic to nuts" को अपने-आप दो अलग-अलग तथ्यों में बाँट दिया। सिस्टम एक्सट्रैक्शन संभालता है, और जब आप सर्च करते हैं, तो यह सेमान्टिक समानता के आधार पर सबसे प्रासंगिक यादें लौटाता है।

बेसिक्स कवर हो गए—अब कुछ अधिक व्यावहारिक बनाते हैं।

Mem0 एआई एजेंट बनाना

बेसिक add/search वर्कफ़्लो उपयोगी है, पर वास्तविक एप्लिकेशनों को ज्यादा परिष्कार चाहिए। आइए एक लर्निंग साथी एजेंट बनाते हैं जो अपनी ओर से तय करता है कि कब यादें स्टोर, रिट्रीव और अपडेट करनी हैं। हम OpenAI Agents SDK का उपयोग करेंगे ताकि हमारे एजेंट को मेमोरी टूल्स मिलें जिन्हें वह स्वयं कॉल कर सके।

यदि आप LLMs के साथ एजेंट बनाना नए हैं, तो अवधारणाओं की पृष्ठभूमि के लिए हमारा LangChain एजेंट बनाने पर ट्यूटोरियल देखें। विशेष रूप से OpenAI Agents SDK में गहराई के लिए OpenAI Agents SDK ट्यूटोरियल देखें।

डिपेंडेंसी सेट करना

OpenAI Agents SDK को Mem0 के साथ इंस्टॉल करें:

pip install openai-agents mem0ai python-dotenvसंचालित द्वारा

अपनी OpenAI API कुंजी को .env फ़ाइल में जोड़ें:

MEM0_API_KEY=your-mem0-key
OPENAI_API_KEY=your-openai-keyसंचालित द्वारा

अब, दोनों क्लाइंट इनिशियलाइज़ करें और एक संदर्भ क्लास बनाएँ जो टूल्स को उपयोगकर्ता सूचना पास करे:

import os
from dataclasses import dataclass
from agents import Agent, Runner, function_tool, RunContextWrapper
from mem0 import MemoryClient
from dotenv import load_dotenv

load_dotenv()

mem0 = MemoryClient(api_key=os.getenv("MEM0_API_KEY"))

@dataclass
class UserContext:
	user_id: strसंचालित द्वारा

UserContext डेटाक्लास उन यूज़र-विशिष्ट डाटा को रखता है जो टूल्स को चाहिए। RunContextWrapper हमें यह संदर्भ किसी भी टूल तक पहुँचाने देता है जिसे एजेंट कॉल करता है।

मेमोरी टूल्स बनाना

एजेंट को तीन टूल चाहिए: सर्च, सेव, और अपडेट। इन्हें एजेंट को एक्सपोज़ करने के लिए हम @function_tool डेकोरेटर का उपयोग करते हैं।

पहले, सर्च टूल प्रासंगिक यादें रिट्रीव करता है। हम आउटपुट में मेमोरी IDs शामिल करते हैं ताकि एजेंट उन्हें अपडेट के लिए संदर्भित कर सके:

@function_tool
def search_memory(ctx: RunContextWrapper[UserContext], query: str) -> str:
	"""Search through past learning history and memories."""
	memories = mem0.search(
    	query,
    	filters={"user_id": ctx.context.user_id},
    	limit=5
	)
	if memories and memories.get("results"):
    	return "\n".join([
         	f"- [ID: {m['id']}] {m['memory']}" for m in memories["results"]
     	])
 	return "No relevant memories found."संचालित द्वारा

इसके बाद, सेव टूल नई जानकारी स्टोर करता है:

@function_tool
def save_memory(ctx: RunContextWrapper[UserContext], content: str) -> str:
 	"""Save new information about the user's learning journey."""
 	mem0.add(
     	[{"role": "user", "content": content}],
     	user_id=ctx.context.user_id
 	)
 	return "Memory saved successfully."संचालित द्वारा

अंत में, अपडेट टूल जानकारी बदलने पर मौजूदा यादों में संशोधन करता है:

@function_tool
def update_memory(ctx: RunContextWrapper[UserContext], memory_id: str, new_text: str) -> str:
 	"""Update an existing memory with new information."""
 	mem0.update(memory_id=memory_id, text=new_text)
 	return f"Memory {memory_id} updated."संचालित द्वारा

एजेंट परिभाषित करना

अब हम निर्देशों के साथ एजेंट बनाते हैं कि किस टूल का उपयोग कब करना है:

agent = Agent(
 	name="Learning Companion",
 	instructions="""You are a helpful learning companion with memory. 
            Use search_memory to recall what the user is learning and their level.
            Search results include memory IDs in format [ID: xxx].
            Use save_memory to store new topics, preferences, or progress.
            Use update_memory when information changes. First search to find the memory ID, then call update_memory with that ID and the new text.
            Always check memory before responding to personalize your answers.""",
 	tools=[search_memory, save_memory, update_memory],
 	model="gpt-4o"
)संचालित द्वारा

यहाँ हम gpt-4o का उपयोग कर रहे हैं, पर बेहतर टूल-यूज़ रीजनिंग के लिए मैं GPT-5 उपयोग करने की अनुशंसा करता/करती हूँ। इसकी नई क्षमताएँ देखने के लिए हमारा GPT-5 API ट्यूटोरियल देखें।

एजेंट चलाना

चैट फ़ंक्शन उपयोगकर्ता संदर्भ एजेंट को पास करता है:

def chat(user_input: str, user_id: str) -> str:
	result = Runner.run_sync(
     	agent,
     	user_input,
         context=UserContext(user_id=user_id)
	)
	return result.final_outputसंचालित द्वारा

Runner.run_sync() का हर कॉल अन्य सभी कॉल्स से पूरी तरह स्वतंत्र होता है। डिफ़ॉल्ट रूप से OpenAI Agents SDK कॉल्स के बीच वार्तालाप इतिहास नहीं रखता। 

हमारे डेमो के लिए यह जानबूझकर है: जब एजेंट कॉल्स के बीच उपयोगकर्ता जानकारी याद रखता है, तो वह मेमोरी किसी छिपी एजेंट स्टेट से नहीं बल्कि Mem0 से आनी चाहिए।

मेमोरी पर्सिस्टेंस का परीक्षण

ऐसी क्वेरीज़ से टेस्ट करें जिन्हें वास्तविक मेमोरी रिट्रीवल चाहिए। एजेंट स्टोर्ड जानकारी एक्सेस किए बिना उत्तर सही अनुमान नहीं लगा सकता।

पहले, कुछ उपयोगकर्ता जानकारी स्टोर करें:

response = chat(
	"My name is Alex. I am learning data visualization with matplotlib. "
	"I am at intermediate level.",
	"student_01"
)
print(response)संचालित द्वारा

Got it, Alex! You're learning data visualization with Matplotlib at an intermediate level. How can I assist you today?संचालित द्वारा

कुछ सेकंड असिंक्रोनस प्रोसेसिंग के लिए रुकने के बाद, रिकॉल टेस्ट करें:

response = chat("What is my name and what library am I learning?", "student_01")
print(response)संचालित द्वारा

Your name is Alex, and you're learning data visualization using Matplotlib at an intermediate level.संचालित द्वारा

अब, अपडेट फ़ंक्शनलिटी टेस्ट करें:

response = chat(
	"I switched from matplotlib to seaborn. Please update your memory.",
	"student_01"
)
print(response)संचालित द्वारा

Got it! I've updated your learning preference to Seaborn for data visualization at an intermediate level. If you need help with anything specific, just let me know!संचालित द्वारा

अपडेट काम कर गया, यह जाँचें:

response = chat("What visualization library am I using now?", "student_01")
print(response)संचालित द्वारा

You are currently using Seaborn for data visualization at an intermediate level.संचालित द्वारा

अंत में, अलग-अलग वार्तालापों में पर्सिस्टेंस जाँचें:

response = chat("Give me a summary of everything you know about me.", "student_01")
print(response)संचालित द्वारा

Here's what I know about you:

- Your name is Alex.
- You are learning data visualization with Seaborn at an intermediate level.

Is there anything else you'd like to update or add?संचालित द्वारा

हमारा Mem0 एजेंट कैसे काम करता है

एजेंट बातचीत के आधार पर तय करता है कि कौन सा टूल कॉल करना है। 

जब उपयोगकर्ता अपने प्रोफ़ाइल के बारे में पूछता है तो यह search_memory कॉल करता है। जब वे नई जानकारी साझा करते हैं, तो save_memory कॉल करता है। जब वे कहते हैं कि जानकारी बदल गई है, तो यह पहले मेमोरी ID पाने के लिए सर्च करता है, फिर update_memory कॉल करता है। 

हम इसे कभी स्पष्ट रूप से नहीं बताते कि हर संदेश के लिए कौन सा टूल उपयोग करना है।

यह सेक्शन 3 के मैनुअल add/search वर्कफ़्लो से अलग है। वहाँ, हमने स्पष्ट रूप से मेथड्स कॉल किए। यहाँ, एजेंट वे फ़ैसले खुद करता है। यह पैटर्न जटिल एप्लिकेशनों के लिए बेहतर स्केल होता है जहाँ आप हर इंटरैक्शन का प्रकार पहले से नहीं जान सकते।

स्केलेबिलिटी के लिए मैनुअल और एजेंट-चालित वर्कफ़्लो की तुलना

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

Mem0 के व्यवहार को फाइन-ट्यून करना

बेसिक एजेंट मेमोरी ऑपरेशंस संभालता है, लेकिन प्रोडक्शन एप्लिकेशनों को इस पर अधिक सूक्ष्म नियंत्रण चाहिए कि क्या स्टोर हो और कैसे रिट्रीव हो। Mem0 प्रोजेक्ट-स्तरीय सेटिंग्स देता है जो मेमोरी क्वालिटी में सुधार करती हैं—जिसमें संगठन के लिए कस्टम श्रेणियाँ, फ़िल्टरिंग के लिए यूज़र-परिभाषित निर्देश, लक्षित सर्च, और क्लीनअप ऑपरेशंस शामिल हैं।

लर्निंग डोमेन्स के लिए कस्टम श्रेणियाँ

डिफ़ॉल्ट रूप से, Mem0 खाद्य, यात्रा, और शौक जैसी सामान्य श्रेणियाँ उपयोग करता है। हमारे जैसे लर्निंग साथी एप्लिकेशन के लिए, ये बहुत मददगार नहीं होतीं। आप ऐसी अपनी श्रेणियाँ परिभाषित कर सकते हैं जो आपके डोमेन से मेल खाएँ:

client.project.update(custom_categories=[
	{"name": "topics", "description": "Programming languages, frameworks, or subjects"},
	{"name": "skill_levels", "description": "Proficiency: beginner, intermediate, advanced"},
	{"name": "goals", "description": "Learning objectives and targets"},
	{"name": "progress", "description": "Completed courses, chapters, or milestones"},
	{"name": "preferences", "description": "Learning style, schedule, or format preferences"}
])संचालित द्वारा

सेट होने के बाद, Mem0 का क्लासिफ़ायर आपकी श्रेणियों के साथ आने वाली यादों को अपने-आप टैग कर देता है। जब Alex कहता है, "I'm learning Python at a beginner level," तो सिस्टम इसे topics और skill_levels—दोनों से टैग करता है। आपको अपने एजेंट कोड में कुछ बदलने की ज़रूरत नहीं। कैटेगरीकरण मेमोरी एक्सट्रैक्शन के दौरान होता है।

चयनात्मक मेमोरी के लिए कस्टम निर्देश

कस्टम निर्देश आपको ठीक-ठीक नियंत्रित करने देते हैं कि वार्तालापों से क्या निकाला जाए। आप प्राकृतिक भाषा में दिशानिर्देश लिखते हैं, और Mem0 नई यादों को प्रोसेस करते समय उनका पालन करता है:

client.project.update(custom_instructions="""
Extract and remember:
- Programming topics and technologies mentioned
- Current skill level for each topic
- Learning goals and deadlines
- Progress updates and completions
- Preferred learning resources (videos, docs, exercises)

Do not store:
- Personal identifiers beyond the user_id
- Payment or financial information
- Off-topic conversation that isn't about learning
""")संचालित द्वारा

यह प्रोडक्शन ऐप्स के लिए महत्वपूर्ण है। बिना निर्देशों के, Mem0 अप्रासंगिक विवरण या संवेदनशील जानकारी स्टोर कर सकता है। कस्टम निर्देश एक फ़िल्टर की तरह काम करते हैं, यादों को उसी पर केंद्रित रखते हैं जिसकी आपके एप्लिकेशन को सच में ज़रूरत है। GDPR जैसी कंप्लायंस स्थितियों के लिए, आप व्यक्तिगत डाटा श्रेणियों को स्पष्ट रूप से बाहर कर सकते हैं।

श्रेणी के आधार पर फ़िल्टर की गई सर्च

श्रेणीबद्ध यादों के साथ, आपका सर्च टूल अधिक सटीक हो सकता है। सभी यादों में सर्च करने की बजाय, श्रेणी द्वारा फ़िल्टर करें ताकि आपको वही मिले जिसकी ज़रूरत है:

@function_tool
def search_memory(
	ctx: RunContextWrapper[UserContext],
	query: str,
	category: str = None
) -> str:
	"""Search learning history. Optionally filter by category."""
	filters = {"user_id": ctx.context.user_id}
	if category:
    	filters["categories"] = {"contains": category}

	memories = mem0.search(query, filters=filters, limit=5)
	if memories and memories.get("results"):
    	return "\n".join([
        	f"- [ID: {m['id']}] {m['memory']}" for m in memories["results"]
     	])
	return "No relevant memories found."संचालित द्वारा

जब एजेंट को उत्तर देना हो—"मैंने कौन-कौन से टॉपिक सीखे हैं?", तो वह category="topics" के साथ सर्च कर सकता है और प्राथमिकताओं या लक्ष्यों के बारे में असंबंधित यादों को छोड़ सकता है। एजेंट निर्देशों में इन श्रेणियों का उल्लेख होना चाहिए ताकि उसे पता रहे कि फ़िल्टर की गई सर्च कब उपयोग करनी है।

मेमोरी क्लीनअप और डिलीशन

उपयोगकर्ता पुरानी या गलत यादों को हटाना चाह सकते हैं। एजेंट को यह क्षमता देने के लिए एक डिलीट टूल जोड़ें:

@function_tool
def delete_memory(ctx: RunContextWrapper[UserContext], memory_id: str) -> str:
	"""Delete a specific memory by ID."""
	mem0.delete(memory_id=memory_id)
	return f"Memory {memory_id} deleted."संचालित द्वारा

बल्क ऑपरेशंस के लिए, आप किसी उपयोगकर्ता की सभी यादें सीधे साफ़ कर सकते हैं:

mem0.delete_all(user_id="student_01")संचालित द्वारा

डिलीशन तब उपयोगी है जब जानकारी पूरी तरह बदल जाती है न कि अपडेट होती है। यदि कोई उपयोगकर्ता कहे, "मेरे Python सीखने के बारे में सब कुछ भूल जाओ," तो एजेंट प्रासंगिक यादें ढूँढ़कर एक-एक करके डिलीट कर सकता है, या आप उनकी प्रोफ़ाइल पूरी तरह साफ़ करने का रीसेट विकल्प दे सकते हैं।

ये चार कॉन्फ़िगरेशन विकल्प एजेंट को डेमो से ऐसी स्थिति में ले जाते हैं जिसे आप शिप कर सकें। श्रेणियाँ यादों को अपने-आप व्यवस्थित करती हैं, निर्देश सुनिश्चित करते हैं कि केवल प्रासंगिक जानकारी स्टोर हो, फ़िल्टर की गई सर्च ठीक वही रिट्रीव करती है जिसकी ज़रूरत है, और डिलीशन क्लीनअप संभालता है। एजेंट कोड में बदलाव न्यूनतम हैं, क्योंकि अधिकतर काम प्रोजेक्ट कॉन्फ़िगरेशन स्तर पर होता है।

इन सुविधाओं के बारे में अधिक जानकारी के लिए आधिकारिक Mem0 दस्तावेज़ देखें।

ग्राफ़ मेमोरी के साथ संबंध ट्रैक करना

स्टैंडर्ड मेमोरी पृथक तथ्यों को स्टोर करती है, जैसे "Alex Seaborn सीख रहा है" और "Alex matplotlib जानता है।" लेकिन यह यह नहीं दर्शाती कि Alex ने पहले matplotlib सीखा, फिर Seaborn पर स्विच किया। ग्राफ़ मेमोरी यह संबंध लेयर जोड़ती है। जब क्रम, प्रगति, या संस्थाओं के बीच कनेक्शन मायने रखते हैं, तो ग्राफ़ मेमोरी आपके एजेंट को अधिक समृद्ध संदर्भ देती है।

नोट: ग्राफ़ मेमोरी केवल Pro प्लान ($249/माह) या उससे ऊपर पर उपलब्ध है।

ग्राफ़ मेमोरी चालू करना

आप प्रोजेक्ट स्तर पर ग्राफ़ मेमोरी सक्रिय कर सकते हैं:

client.project.update(enable_graph=True)संचालित द्वारा

दूसरा विकल्प यह है कि व्यक्तिगत रिक्वेस्ट पर enable_graph=True पास करें:

client.add(messages, user_id="student_01", enable_graph=True)संचालित द्वारा

एक्टिव होने के बाद, Mem0 प्राकृतिक बातचीत से अपने-आप एंटिटी (लोग, टॉपिक, टूल, तारीखें) और उनके बीच संबंध निकालता है।

ग्राफ़ सर्च कैसे काम करती है

जब आप ग्राफ़ मेमोरी के साथ सर्च करते हैं, तो Mem0 यादों के साथ-साथ एक relations ऐरे भी लौटाता है जो दिखाता है कि एंटिटी कैसे जुड़ी हैं:

results = client.search(
	"What has Alex learned?",
	filters={"user_id": "student_01"},
	enable_graph=True
)

# Results include both memories and relations
print(results.get("relations"))संचालित द्वारा

रिलेशन ऐसे कनेक्शन दिखाते हैं जैसे "Alex → learned → matplotlib" और "Alex → switched to → seaborn"। अब आपका एजेंट प्रगति संबंधी प्रश्नों के उत्तर दे सकता है, बिना कि आपको वे संबंध स्पष्ट रूप से स्टोर करने पड़ें।

ग्राफ़ मेमोरी कब उपयोग करें

ग्राफ़ मेमोरी प्रोसेसिंग ओवरहेड जोड़ती है, इसलिए इसे तभी उपयोग करें जब संबंध मायने रखते हों:

• कौशल प्रगति ट्रैक करने वाले लर्निंग प्लेटफ़ॉर्म

• कस्टमर सपोर्ट जो इंटरैक्शन इतिहास का विश्लेषण करता है

• प्रोजेक्ट प्रबंधन जहाँ टास्क निर्भरताएँ मैप करनी हों

• हेल्थकेयर जहाँ समय के साथ लक्षण और उपचार जोड़े जाते हैं

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

Mem0: प्लेटफ़ॉर्म बनाम ओपन सोर्स

Mem0 दो रूपों में आता है: प्लेटफ़ॉर्म और ओपन सोर्स। 

पूरे ट्यूटोरियल में, हमने प्लेटफ़ॉर्म संस्करण का उपयोग किया, जो MemoryClient और API की के साथ app.mem0.ai के ज़रिए एक्सेस की जाने वाली मैनेज्ड क्लाउड सेवा है। दोनों संस्करण मुख्य मेमोरी ऑपरेशंस (add(), search(), update(), delete()) साझा करते हैं, लेकिन सेटअप, प्राइसिंग और नियंत्रण में भिन्न हैं।

प्लेटफ़ॉर्म

प्लेटफ़ॉर्म Mem0 की होस्टेड सेवा है। आप साइन अप करते हैं, API की लेते हैं, और कुछ ही मिनटों में यादें जोड़ना शुरू कर देते हैं। Mem0 इन्फ्रास्ट्रक्चर, स्केलिंग, और सुरक्षा प्रमाणपत्र (जैसे SOC 2 Type II या GDPR) संभालता है।

चार प्राइसिंग टियर हैं:

• फ़्री: 10,000 यादें—प्रोटोटाइपिंग के लिए उपयुक्त।

• स्टार्टर: $19/माह, उच्च सीमाओं के साथ।

• Pro: $249/माह, प्रोडक्शन वर्कलोड्स के लिए।

• एंटरप्राइज़: समर्पित सपोर्ट के साथ कस्टम प्राइसिंग।

प्लेटफ़ॉर्म में वे सुविधाएँ शामिल हैं जो ओपन सोर्स में उपलब्ध नहीं: रिलेशनशिप ट्रैकिंग के लिए ग्राफ़ मेमोरी, रियल-टाइम नोटिफ़िकेशन के लिए वेबहुक, स्पीकर एट्रिब्यूशन के साथ ग्रुप चैट, और बिल्ट-इन एनालिटिक्स। 

आप उपयोग के अनुसार भुगतान करते हैं, लेकिन इन्फ्रास्ट्रक्चर और DevOps समय की बचत होती है।

ओपन सोर्स

ओपन सोर्स संस्करण आपके अपने सर्वर पर चलता है। आप mem0ai पैकेज इंस्टॉल करते हैं, अपना वेक्टर डेटाबेस कॉन्फ़िगर करते हैं, और डेप्लॉयमेंट स्वयं मैनेज करते हैं। इसमें अधिक सेटअप लगता है पर पूरा नियंत्रण मिलता है।

इन्फ्रास्ट्रक्चर के लिए कई विकल्प उपलब्ध हैं:

• वेक्टर डेटाबेस: 24+ विकल्प—Qdrant, Chroma, Pinecone, PostgreSQL (pgvector), और MongoDB सहित

• LLM प्रदाता: 16+ विकल्प—OpenAI, Anthropic, Ollama, Groq, और लोकल मॉडल सहित

• एम्बेडिंग मॉडल: OpenAI, HuggingFace, या कस्टम एम्बेडर

ओपन सोर्स में Memory क्लास का उपयोग होता है, MemoryClient के बजाय। 

आपकी लागतें वही होंगी जो आप इन्फ्रास्ट्रक्चर (क्लाउड VMs, डेटाबेस होस्टिंग, LLM प्रदाताओं को API कॉल्स) पर खर्च करते हैं। स्केल पर, यह प्लेटफ़ॉर्म प्राइसिंग से सस्ता हो सकता है, लेकिन मेंटेनेंस, बैकअप और कंप्लायंस की ज़िम्मेदारी आपकी होगी।

प्लेटफ़ॉर्म बनाम ओपन सोर्स—कब क्या चुनें

होस्टेड और ओपन-सोर्स संस्करणों की तुलना के लिए नीचे दी गई तालिका देखें:

मेरी सिफ़ारिश यह है कि तेज़ प्रोटोटाइपिंग, DevOps ओवरहेड के बिना प्रोडक्शन ऐप्स, या जब बिल्ट-इन कंप्लायंस चाहिए, तो प्लेटफ़ॉर्म चुनें। 

यदि आपका फ़ोकस डाटा संप्रभुता, कस्टम मॉडल कॉन्फ़िगरेशन, या उच्च वॉल्यूम पर लागत अनुकूलन है, तो ओपन सोर्स सही विकल्प है।

विस्तृत सेटअप गाइड के लिए प्लेटफ़ॉर्म क्विकस्टार्ट या ओपन सोर्स ओवरव्यू देखें।

निष्कर्ष

इस ट्यूटोरियल में Mem0 के साथ LLM एप्लिकेशनों में पर्सिस्टेंट मेमोरी जोड़ना कवर किया गया। आपने बेसिक मेमोरी ऑपरेशंस से शुरुआत की, फिर OpenAI Agents SDK का उपयोग करके एक लर्निंग साथी एजेंट बनाया जो अपनी मेमोरी खुद मैनेज करता है। इसके बाद आपने कस्टम श्रेणियाँ, निर्देश, और फ़िल्टर की गई सर्च के साथ मेमोरी व्यवहार कॉन्फ़िगर किया। अंत में, आपने प्लेटफ़ॉर्म और ओपन सोर्स डेप्लॉयमेंट विकल्पों की तुलना की।

प्रोडक्शन उपयोग के लिए, मेमोरी ऑपरेशंस के चारों ओर एरर हैंडलिंग जोड़ें और नई यादें सेव करने के बाद थोड़ी देरी का ध्यान रखें। यदि आप प्लेटफ़ॉर्म के फ़्री टियर पर हैं, तो रेट लिमिट्स पर विचार करें।

क्या आप अलग-अलग कंपोनेंट्स से आगे बढ़कर एआई एप्लिकेशन डेवलपमेंट का पूरा स्टैक मास्टर करने के लिए तैयार हैं? नामांकित हों AI Engineer for Developers करियर ट्랙 में।