Hướng dẫn Mem0: Lớp bộ nhớ bền vững cho ứng dụng AI

Bạn nói với chatbot rằng bạn ăn chay. Ngày hôm sau, nó lại gợi ý món bít tết. Đây không phải là lỗi. Đơn giản đó là cách LLM hoạt động. Chúng không có bộ nhớ giữa các phiên, coi mỗi cuộc trò chuyện như một tờ giấy trắng.

Với việc sử dụng thông thường, điều này ổn. Nhưng nếu bạn đang xây dựng ứng dụng thực tế cho người dùng thật, tính vô trạng thái này trở thành vấn đề lớn. Người dùng kỳ vọng AI sẽ nhớ về họ.

Mem0 giải quyết điều đó bằng cách thêm một lớp bộ nhớ cho bất kỳ LLM nào. Nó lưu trữ, truy xuất và cập nhật thông tin về người dùng xuyên suốt các phiên, để AI của bạn thực sự có thể học hỏi và thích ứng theo thời gian.

Trong hướng dẫn này, bạn sẽ xây dựng một trợ lý AI cá nhân có thể ghi nhớ sở thích người dùng, theo dõi lịch sử hội thoại và trở nên thông minh hơn sau mỗi tương tác. Chúng tôi sẽ trình bày cả thiết lập đám mây và tự lưu trữ để bạn chọn phương án phù hợp với dự án.

Nếu bạn chưa dùng trước đó, hãy học khóa học này để biết cách làm việc với OpenAI API.

Mem0 là gì?

Mem0 là một lớp bộ nhớ mã nguồn mở nằm giữa ứng dụng và LLM của bạn. Nó tự động trích xuất thông tin liên quan từ hội thoại, lưu trữ và truy xuất khi cần. Dự án đã gọi vốn 24 triệu đô vào tháng 10/2025 và hoạt động với mọi nhà cung cấp LLM: OpenAI, Anthropic, Ollama hoặc mô hình của riêng bạn.

Mem0 tổ chức bộ nhớ theo ba phạm vi:

• Bộ nhớ người dùng: Tồn tại xuyên suốt mọi cuộc trò chuyện với một người cụ thể. Nếu ai đó nói họ thích học vào buổi sáng, thông tin đó sẽ luôn sẵn có ở mọi phiên sau.

• Bộ nhớ phiên: Theo dõi ngữ cảnh trong một cuộc trò chuyện đơn lẻ, như công thức nấu ăn hiện đang thảo luận.

• Bộ nhớ tác nhân: Lưu trữ thông tin dành riêng cho một phiên bản tác nhân AI cụ thể.

Bạn có thể kết hợp các phạm vi này để xây dựng ứng dụng phức tạp nơi các tác nhân khác nhau chia sẻ (hoặc cách ly) những gì họ biết về người dùng.

Ba phạm vi bộ nhớ: người dùng, phiên và tác nhân, kèm ví dụ.

Bên dưới, Mem0 kết hợp tìm kiếm vector với quan hệ đồ thị. Khi bạn thêm hội thoại vào bộ nhớ, nó tự động trích xuất các phần quan trọng. Bạn không cần gắn nhãn thủ công những gì nên ghi nhớ.

Khi ứng dụng cần ngữ cảnh, Mem0 sẽ lấy các ký ức phù hợp dựa trên truy vấn hiện tại và đưa chúng vào prompt. Điều này tốt hơn việc nhồi toàn bộ lịch sử hội thoại vào mọi yêu cầu.

Bạn có thể chạy Mem0 theo hai cách:

• Nền tảng (Platform): Dịch vụ đám mây được quản lý tại app.mem0.ai cung cấp thiết lập nhanh và API.

• Tự lưu trữ: Cho bạn toàn quyền kiểm soát hạ tầng, cho phép chọn cơ sở dữ liệu vector và mô hình embedding.

Cả hai dùng cùng SDK Python, nên chuyển đổi giữa chúng rất đơn giản.

Lợi ích hiệu năng là có thật, như bài báo nghiên cứu của Mem0 cho thấy. Trên bộ chuẩn LOCOMO, Mem0 đạt điểm cao hơn 26% so với tính năng bộ nhớ tích hợp của OpenAI. Nó cũng phản hồi nhanh hơn 91% nhờ chỉ truy xuất ký ức liên quan thay vì xử lý toàn bộ lịch sử hội thoại. Lượng token giảm khoảng 90% so với cách đưa vào toàn bộ ngữ cảnh.

Giờ bạn đã biết Mem0 làm gì, hãy thiết lập nó.

Bắt đầu với Mem0

Cài đặt gói cùng python-dotenv để quản lý khóa API:

pip install mem0ai python-dotenvĐược hỗ trợ bởi

Đăng ký tại app.mem0.ai và lấy khóa API từ bảng điều khiển. Tạo tệp .env trong thư mục dự án của bạn:

MEM0_API_KEY=your-api-key-hereĐược hỗ trợ bởi

Giờ hãy khởi tạo client bằng khóa API:

from mem0 import MemoryClient
from dotenv import load_dotenv
import os

load_dotenv()

client = MemoryClient(api_key=os.getenv("MEM0_API_KEY"))Được hỗ trợ bởi

Để lưu một ký ức, hãy truyền một hội thoại theo định dạng chat của OpenAI. Tham số user_id giúp giới hạn ký ức theo một người dùng cụ thể:

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")Được hỗ trợ bởi

Xử lý bộ nhớ diễn ra nền. Phương thức add() trả về ngay lập tức với trạng thái chờ trong khi Mem0 trích xuất và lưu các thông tin liên quan.

Để truy xuất ký ức, dùng search() với truy vấn ngôn ngữ tự nhiên:

results = client.search("dietary restrictions", filters={"user_id": "user123"})Được hỗ trợ bởi

Phản hồi chứa các ký ức đã trích xuất kèm điểm liên quan:

{'results': [
	{'memory': 'User is allergic to nuts', 'user_id': 'user123', 'score': 0.66},
	{'memory': 'User is a vegetarian', 'user_id': 'user123', 'score': 0.65}
]}Được hỗ trợ bởi

Lưu ý Mem0 tự động tách "vegetarian” và “allergic to nuts" thành hai sự kiện riêng. Hệ thống xử lý việc trích xuất và khi bạn tìm kiếm, nó trả về các ký ức liên quan nhất dựa trên tương đồng ngữ nghĩa.

Khi đã nắm cơ bản, hãy xây dựng thứ gì đó thực tiễn hơn.

Xây dựng một tác nhân AI dùng Mem0

Quy trình thêm/tìm kiếm cơ bản hữu ích, nhưng ứng dụng thực tế cần tinh vi hơn. Hãy xây dựng một tác nhân bạn học biết tự quyết định khi nào lưu, truy xuất và cập nhật ký ức. Chúng ta sẽ dùng OpenAI Agents SDK để cung cấp cho tác nhân các công cụ bộ nhớ mà nó có thể tự gọi.

Nếu bạn mới bắt đầu xây tác nhân với LLM, hãy xem hướng dẫn về xây dựng tác nhân LangChain để nắm khái niệm. Để tìm hiểu sâu hơn về OpenAI Agents SDK, xem hướng dẫn OpenAI Agents SDK.

Thiết lập phụ thuộc

Cài đặt OpenAI Agents SDK cùng với Mem0:

pip install openai-agents mem0ai python-dotenvĐược hỗ trợ bởi

Thêm khóa API OpenAI vào tệp .env:

MEM0_API_KEY=your-mem0-key
OPENAI_API_KEY=your-openai-keyĐược hỗ trợ bởi

Giờ hãy khởi tạo cả hai client và tạo một lớp ngữ cảnh để truyền thông tin người dùng cho các công cụ:

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Được hỗ trợ bởi

Dataclass UserContext giữ dữ liệu cụ thể theo người dùng mà công cụ cần. RunContextWrapper cho phép chúng ta truyền ngữ cảnh này đến bất kỳ công cụ nào tác nhân gọi.

Tạo các công cụ bộ nhớ

Tác nhân cần ba công cụ: tìm kiếm, lưu và cập nhật. Chúng ta dùng decorator @function_tool để lộ các công cụ này cho tác nhân.

Đầu tiên, công cụ tìm kiếm truy xuất ký ức liên quan. Chúng ta đưa ID ký ức vào đầu ra để tác nhân có thể tham chiếu khi cập nhật:

@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."Được hỗ trợ bởi

Tiếp theo, công cụ lưu trữ thông tin mới:

@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."Được hỗ trợ bởi

Cuối cùng, công cụ cập nhật sửa đổi các ký ức hiện có khi thông tin thay đổi:

@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."Được hỗ trợ bởi

Định nghĩa tác nhân

Giờ chúng ta tạo tác nhân với hướng dẫn về thời điểm dùng mỗi công cụ:

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"
)Được hỗ trợ bởi

Chúng ta dùng gpt-4o ở đây, nhưng để cải thiện khả năng suy luận khi dùng công cụ, tôi khuyên dùng GPT-5. Hãy xem hướng dẫn API GPT-5 để thấy các tính năng mới hoạt động.

Chạy tác nhân

Hàm chat truyền ngữ cảnh người dùng cho tác nhân:

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Được hỗ trợ bởi

Mỗi lần gọi Runner.run_sync() là hoàn toàn độc lập với các lần gọi khác. Mặc định OpenAI Agents SDK không duy trì lịch sử hội thoại giữa các lần gọi.

Điều này là chủ ý cho bản demo: khi tác nhân nhớ thông tin người dùng giữa các lần gọi, ký ức đó phải đến từ Mem0, không phải từ trạng thái ẩn nào của tác nhân.

Kiểm thử tính bền vững của bộ nhớ

Hãy kiểm thử với các truy vấn đòi hỏi truy xuất ký ức thật sự. Tác nhân không thể đoán đúng nếu không truy cập thông tin đã lưu.

Trước tiên, lưu một số thông tin người dùng:

response = chat(
	"My name is Alex. I am learning data visualization with matplotlib. "
	"I am at intermediate level.",
	"student_01"
)
print(response)Được hỗ trợ bởi

Got it, Alex! You're learning data visualization with Matplotlib at an intermediate level. How can I assist you today?Được hỗ trợ bởi

Sau khi đợi vài giây để xử lý bất đồng bộ, kiểm thử việc ghi nhớ:

response = chat("What is my name and what library am I learning?", "student_01")
print(response)Được hỗ trợ bởi

Your name is Alex, and you're learning data visualization using Matplotlib at an intermediate level.Được hỗ trợ bởi

Giờ kiểm thử chức năng cập nhật:

response = chat(
	"I switched from matplotlib to seaborn. Please update your memory.",
	"student_01"
)
print(response)Được hỗ trợ bởi

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!Được hỗ trợ bởi

Xác minh việc cập nhật đã thành công:

response = chat("What visualization library am I using now?", "student_01")
print(response)Được hỗ trợ bởi

You are currently using Seaborn for data visualization at an intermediate level.Được hỗ trợ bởi

Cuối cùng, kiểm thử tính bền vững giữa các cuộc trò chuyện:

response = chat("Give me a summary of everything you know about me.", "student_01")
print(response)Được hỗ trợ bởi

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?Được hỗ trợ bởi

Cách tác nhân Mem0 của chúng ta hoạt động

Tác nhân chọn công cụ để gọi dựa trên cuộc trò chuyện.

Khi người dùng hỏi về hồ sơ của họ, nó gọi search_memory. Khi họ chia sẻ thông tin mới, nó gọi save_memory. Khi họ nói thông tin đã thay đổi, nó tìm kiếm trước để lấy ID ký ức, rồi gọi update_memory.

Chúng ta không bao giờ chỉ định rõ tác nhân phải dùng công cụ nào cho từng tin nhắn.

Điều này khác với quy trình thêm/tìm kiếm thủ công ở Mục 3. Ở đó, chúng ta gọi phương thức một cách tường minh. Ở đây, tác nhân tự quyết định. Mẫu này mở rộng tốt hơn cho ứng dụng phức tạp nơi bạn không thể dự đoán mọi kiểu tương tác.

So sánh quy trình thủ công và do tác nhân điều khiển về khả năng mở rộng

Một lưu ý quan trọng: xử lý bộ nhớ là bất đồng bộ. Sau khi gọi save_memory, sẽ có một khoảng trễ ngắn trước khi ký ức mới có thể tìm kiếm được. Trong môi trường sản xuất, bạn nên tính đến điều này trong giao diện người dùng.

Tinh chỉnh hành vi của Mem0

Tác nhân cơ bản xử lý thao tác bộ nhớ, nhưng ứng dụng sản xuất cần kiểm soát chi tiết hơn về những gì được lưu và cách truy xuất. Mem0 cung cấp thiết lập cấp dự án để cải thiện chất lượng bộ nhớ, gồm danh mục tùy chỉnh để tổ chức, hướng dẫn do người dùng định nghĩa để lọc, tìm kiếm có mục tiêu và thao tác dọn dẹp.

Danh mục tùy chỉnh cho các miền học tập

Mặc định, Mem0 dùng các danh mục chung như ẩm thực, du lịch, sở thích. Với ứng dụng đặc thù như bạn học của chúng ta, những danh mục này không hữu ích lắm. Bạn có thể định nghĩa danh mục riêng phù hợp với miền của mình:

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"}
])Được hỗ trợ bởi

Sau khi thiết lập, bộ phân loại của Mem0 sẽ tự động gắn thẻ các ký ức mới bằng danh mục của bạn. Khi Alex nói, "I'm learning Python at a beginner level," hệ thống sẽ gắn thẻ với cả topics và skill_levels. Bạn không cần đổi mã của tác nhân. Việc phân loại diễn ra trong quá trình trích xuất ký ức.

Hướng dẫn tùy chỉnh để chọn lọc ký ức

Hướng dẫn tùy chỉnh cho phép bạn kiểm soát chính xác những gì được trích xuất từ hội thoại. Bạn viết hướng dẫn bằng ngôn ngữ tự nhiên và Mem0 làm theo khi xử lý ký ức mới:

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
""")Được hỗ trợ bởi

Điều này rất quan trọng cho ứng dụng sản xuất. Nếu không có hướng dẫn, Mem0 có thể lưu trữ chi tiết không liên quan hoặc thông tin nhạy cảm. Hướng dẫn tùy chỉnh hoạt động như bộ lọc, giữ cho ký ức tập trung vào những gì ứng dụng của bạn thực sự cần. Với các yêu cầu tuân thủ như GDPR, bạn có thể loại trừ rõ ràng các loại dữ liệu cá nhân.

Tìm kiếm có lọc theo danh mục

Với các ký ức đã được phân loại, công cụ tìm kiếm của bạn có thể chính xác hơn. Thay vì tìm trong tất cả ký ức, hãy lọc theo danh mục để lấy đúng thứ bạn cần:

@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."Được hỗ trợ bởi

Khi tác nhân cần trả lời "Tôi đã học những chủ đề nào?", nó có thể tìm với category="topics" và bỏ qua các ký ức không liên quan về sở thích hay mục tiêu. Hướng dẫn cho tác nhân nên đề cập các danh mục này để nó biết khi nào dùng tìm kiếm có lọc.

Dọn dẹp và xóa ký ức

Người dùng có thể muốn xóa các ký ức lỗi thời hoặc sai. Thêm một công cụ xóa để trao cho tác nhân khả năng này:

@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."Được hỗ trợ bởi

Với thao tác hàng loạt, bạn có thể xóa toàn bộ ký ức của một người dùng trực tiếp:

mem0.delete_all(user_id="student_01")Được hỗ trợ bởi

Xóa hữu ích khi thông tin thay đổi hoàn toàn thay vì cập nhật. Nếu người dùng nói, "quên mọi thứ về việc học Python của tôi," tác nhân có thể tìm các ký ức liên quan và xóa từng cái, hoặc bạn có thể cung cấp tùy chọn đặt lại để xóa toàn bộ hồ sơ.

Bốn tùy chọn cấu hình này đưa tác nhân từ bản demo đến mức có thể triển khai. Danh mục giúp tổ chức ký ức tự động, hướng dẫn đảm bảo chỉ lưu thông tin liên quan, tìm kiếm có lọc truy xuất chính xác điều cần, và xóa hỗ trợ dọn dẹp. Thay đổi mã tác nhân là tối thiểu vì phần lớn diễn ra ở cấu hình dự án.

Để biết thêm chi tiết về các tính năng này, xem tài liệu Mem0 chính thức.

Theo dõi quan hệ với bộ nhớ đồ thị

Bộ nhớ tiêu chuẩn lưu các sự kiện rời rạc, như "Alex đang học Seaborn" và "Alex biết matplotlib." Nhưng nó không nắm bắt được việc Alex học matplotlib trước, rồi chuyển sang Seaborn. Bộ nhớ đồ thị thêm lớp quan hệ này. Khi thứ tự, tiến trình hoặc kết nối giữa các thực thể quan trọng, bộ nhớ đồ thị cung cấp ngữ cảnh phong phú hơn cho tác nhân.

Lưu ý: Bộ nhớ đồ thị chỉ có trong gói Pro (249 đô/tháng) trở lên.

Bật bộ nhớ đồ thị

Bạn có thể kích hoạt bộ nhớ đồ thị ở cấp dự án:

client.project.update(enable_graph=True)Được hỗ trợ bởi

Một tùy chọn khác là truyền enable_graph=True trong từng yêu cầu riêng lẻ:

client.add(messages, user_id="student_01", enable_graph=True)Được hỗ trợ bởi

Khi đã bật, Mem0 tự động trích xuất thực thể (người, chủ đề, công cụ, ngày tháng) và quan hệ giữa chúng từ hội thoại tự nhiên.

Tìm kiếm đồ thị hoạt động thế nào

Khi bạn tìm kiếm với bộ nhớ đồ thị, Mem0 trả về cả ký ức và một mảng relations hiển thị cách các thực thể kết nối:

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"))Được hỗ trợ bởi

Các quan hệ thể hiện kết nối như "Alex → learned → matplotlib" và "Alex → switched to → seaborn." Tác nhân của bạn giờ có thể trả lời câu hỏi về tiến trình mà không cần bạn lưu trữ các quan hệ đó một cách tường minh.

Khi nào nên dùng bộ nhớ đồ thị

Bộ nhớ đồ thị tăng chi phí xử lý, nên dùng khi quan hệ là quan trọng:

• Nền tảng học tập theo dõi tiến trình kỹ năng

• Hỗ trợ khách hàng phân tích lịch sử tương tác

• Quản lý dự án lập bản đồ phụ thuộc nhiệm vụ

• Y tế kết nối triệu chứng và điều trị theo thời gian

Với việc ghi nhớ sự kiện đơn giản, bộ nhớ tiêu chuẩn nhanh hơn. Bật bộ nhớ đồ thị khi tác nhân cần suy luận về chuỗi hoặc kết nối giữa thông tin đã lưu.

Mem0: Nền tảng so với mã nguồn mở

Mem0 có hai phiên bản: Nền tảng và mã nguồn mở.

Xuyên suốt hướng dẫn này, chúng ta dùng phiên bản Nền tảng, là dịch vụ đám mây được quản lý truy cập qua MemoryClient và một khóa API từ app.mem0.ai. Cả hai phiên bản chia sẻ các thao tác bộ nhớ cốt lõi (add(), search(), update(), delete()), nhưng khác nhau ở thiết lập, giá và quyền kiểm soát.

Nền tảng

Nền tảng là dịch vụ được lưu trữ của Mem0. Bạn đăng ký, lấy khóa API và bắt đầu thêm ký ức trong vài phút. Mem0 xử lý hạ tầng, mở rộng và chứng chỉ bảo mật (như SOC 2 Type II hoặc GDPR).

Có bốn mức giá:

• Miễn phí: 10.000 ký ức, phù hợp để thử nghiệm.

• Starter: $19/tháng, giới hạn cao hơn.

• Pro: $249/tháng, cho khối lượng sản xuất.

• Enterprise: Giá tùy chỉnh với hỗ trợ chuyên biệt.

Nền tảng bao gồm các tính năng không có ở mã nguồn mở: bộ nhớ đồ thị để theo dõi quan hệ, webhooks để thông báo theo thời gian thực, chat nhóm với gán người nói và phân tích tích hợp.

Bạn trả theo mức sử dụng nhưng tiết kiệm thời gian hạ tầng và DevOps.

Mã nguồn mở

Phiên bản mã nguồn mở chạy trên máy chủ của bạn. Bạn cài gói mem0ai, cấu hình cơ sở dữ liệu vector và tự quản lý triển khai. Việc này cần nhiều thiết lập hơn nhưng cho bạn toàn quyền kiểm soát.

Có nhiều lựa chọn cho hạ tầng:

• Cơ sở dữ liệu vector: Hơn 24 lựa chọn gồm Qdrant, Chroma, Pinecone, PostgreSQL (pgvector) và MongoDB

• Nhà cung cấp LLM: Hơn 16 lựa chọn gồm OpenAI, Anthropic, Ollama, Groq và mô hình cục bộ

• Mô hình embedding: OpenAI, HuggingFace hoặc embedders tùy chỉnh

Mã nguồn mở dùng lớp Memory thay vì MemoryClient.

Chi phí của bạn là chi phí hạ tầng (máy ảo đám mây, lưu trữ cơ sở dữ liệu, các cuộc gọi API đến nhà cung cấp LLM). Ở quy mô lớn, điều này có thể rẻ hơn giá Nền tảng, nhưng bạn sẽ chịu trách nhiệm về bảo trì, sao lưu và tuân thủ.

Khi nào chọn Nền tảng so với mã nguồn mở

Tham khảo bảng sau để so sánh giữa phiên bản được lưu trữ và mã nguồn mở của Mem0:

Khuyến nghị của tôi là chọn Nền tảng để dựng thử nhanh, ứng dụng sản xuất không cần gánh nặng DevOps, hoặc khi bạn cần tuân thủ tích hợp sẵn.

Nếu bạn chú trọng chủ quyền dữ liệu, cấu hình mô hình tùy chỉnh hoặc tối ưu chi phí ở khối lượng lớn, mã nguồn mở là lựa chọn phù hợp.

Để có hướng dẫn thiết lập chi tiết, xem quickstart của Nền tảng hoặc tổng quan mã nguồn mở.

Kết luận

Hướng dẫn này trình bày cách thêm bộ nhớ bền vững vào ứng dụng LLM với Mem0. Bạn bắt đầu với thao tác bộ nhớ cơ bản, sau đó xây dựng một tác nhân bạn học tự quản lý bộ nhớ bằng OpenAI Agents SDK. Tiếp đó, bạn cấu hình hành vi bộ nhớ với danh mục tùy chỉnh, hướng dẫn và tìm kiếm có lọc. Cuối cùng, bạn so sánh các phương án triển khai Nền tảng và mã nguồn mở.

Trong môi trường sản xuất, hãy thêm xử lý lỗi quanh các thao tác bộ nhớ và tính đến độ trễ ngắn sau khi lưu ký ức mới. Cân nhắc giới hạn tốc độ nếu bạn ở gói miễn phí của Nền tảng.

Sẵn sàng vượt ra ngoài từng thành phần riêng lẻ và làm chủ full stack phát triển ứng dụng AI? Hãy đăng ký vào lộ trình nghề nghiệp AI Engineer for Developers ngay.