Giới thiệu

Trong thời đại công nghệ hiện nay, việc xây dựng các ứng dụng trò chuyện, trợ lý AI hay giao diện hội thoại thông minh là cực kỳ quan trọng. Bài viết này được thiết kế dành cho các nhà phát triển muốn tích hợp khả năng ghi nhớ vào ứng dụng của họ. Dù bạn đang xây dựng bot hỗ trợ khách hàng, trợ lý cá nhân hay hệ thống gợi ý, bạn sẽ học cách giúp agents của mình nhớ được ngữ cảnh, sở thích và lịch sử trò chuyện của người dùng. Thông qua những ví dụ thực tiễn và đoạn mã được cung cấp, bạn có thể tích hợp những tính năng ghi nhớ này vào các ứng dụng dựa trên LlamaIndex của mình chỉ trong vài giờ.

Bộ nhớ là yếu tố cơ bản của trí thông minh con người—nó hình thành nên bản sắc của chúng ta, cho phép học hỏi từ những trải nghiệm, và xây dựng các mối quan hệ có ý nghĩa. Trong các hệ thống phần mềm truyền thống, bộ nhớ thường chỉ được phân loại thành RAM để xử lý tạm thời và lưu trữ đĩa để đảm bảo tính bền vững. Khi bạn gửi một tin nhắn cho một người bạn, nó sẽ được xử lý trong bộ nhớ và sau đó được lưu trữ trong cơ sở dữ liệu để tham khảo trong tương lai.

Tuy nhiên, sự xuất hiện của các Mô hình Ngôn ngữ Lớn (LLMs) đang thay đổi cách mà chúng ta tương tác với công nghệ. Người dùng ngày càng mong đợi những giao diện hội thoại tự nhiên, nơi họ có thể nói "hỏi Bob xem anh ấy có muốn đi xem phim Batman không" và hệ thống sẽ hiểu được ngữ cảnh, ý định và những sắc thái. Điều này đòi hỏi một cách tiếp cận tinh vi hơn về bộ nhớ—một cách tiếp cận không chỉ đơn thuần là lưu trữ dữ liệu mà còn hiểu và ghi nhớ sở thích, lịch sử trò chuyện, và các mẫu hành vi của người dùng.

Trong bài viết này, chúng ta sẽ khám phá cách triển khai các hệ thống bộ nhớ thông minh trong các agents trò chuyện sử dụng LlamaIndex. Chúng ta sẽ đề cập đến ba loại bộ nhớ thiết yếu:

1. Bộ nhớ ngắn hạn: Lưu trữ các tương tác gần đây và ngữ cảnh trò chuyện
2. Bộ nhớ tĩnh: Duy trì thông tin hồ sơ người dùng bền vững
3. Bộ nhớ động: Trích xuất và lưu trữ các mẫu hành vi và sở thích của người dùng

Sau khi đọc xong bài viết này, bạn sẽ hiểu cách tạo ra các agents trò chuyện nhớ được ai là người dùng của bạn, những gì họ đã thảo luận, và cách họ thích tương tác—khiến mỗi cuộc trò chuyện trở nên cá nhân hóa và nhạy bén hơn về ngữ cảnh.

Các loại bộ nhớ trong LlamaIndex

LlamaIndex cung cấp một khung linh hoạt để triển khai nhiều loại bộ nhớ trong các agents trò chuyện. Hãy cùng tìm hiểu ba thành phần bộ nhớ chính mà bạn có thể tận dụng:

1. Bộ nhớ ngắn hạn: Memory.from_defaults

Bộ nhớ ngắn hạn là rất quan trọng để theo dõi các tương tác gần đây và duy trì ngữ cảnh trò chuyện. Lớp Memory.from_defaults trong LlamaIndex cho phép bạn lưu trữ thông tin theo từng người dùng, sử dụng một ID người dùng duy nhất (UID) để truy xuất. Theo mặc định, thông tin này được lưu trữ trong cơ sở dữ liệu trên bộ nhớ, nhưng bạn có thể cấu hình nó để sử dụng bất kỳ URI cơ sở dữ liệu nào mà bạn chọn.

2. Bộ nhớ tĩnh: StaticMemoryBlock

Bộ nhớ tĩnh được sử dụng để lưu trữ thông tin hồ sơ người dùng bền vững, chẳng hạn như tên, tuổi và vị trí. Thay vì nhúng thông tin này vào trong prompt hệ thống (mà không được thiết kế cho dữ liệu người dùng cụ thể), bạn có thể sử dụng StaticMemoryBlock. Khối bộ nhớ chuyên dụng này có thể lưu trữ hướng dẫn hệ thống, dữ liệu đã định nghĩa trước của người dùng, và các thông tin khác mà cần được truy cập dễ dàng trong suốt cuộc trò chuyện.

3. Bộ nhớ động: FactExtractionMemoryBlock

Bộ nhớ động cho phép trích xuất và lưu trữ các mẫu hành vi và sở thích của người dùng. Ví dụ, một người dùng có thể thích phản hồi có emoji, một người khác có thể thích chi tiết kỹ thuật, và một người khác nữa có thể thích những câu đùa. FactExtractionMemoryBlock trong LlamaIndex cho phép bạn trích xuất thông tin quan trọng từ các cuộc trò chuyện bằng cách sử dụng các prompt và lưu trữ nó dưới dạng các sự thật.

Bộ nhớ động đặc biệt mạnh mẽ vì nó thích ứng với sở thích cá nhân của người dùng theo thời gian. Tuy nhiên, cho đến nay, LlamaIndex không cung cấp hỗ trợ tích hợp để lưu trữ các sự thật này trong cơ sở dữ liệu—bạn sẽ cần tự triển khai chức năng này.

So sánh các loại bộ nhớ

Dưới đây là bảng so sánh nhanh về khi nào nên sử dụng từng loại bộ nhớ:

Ví dụ: Bộ nhớ trong hành động

Ví dụ, nếu một người dùng nói, "Chào! Tên tôi là raghav," hệ thống sẽ chuyển sang người dùng đó và thông tin sau sẽ được thêm vào tin nhắn của người dùng:

<memory>
<core_info>
Tôi là raghav, một nhà khoa học dữ liệu 30 tuổi từ Bangalore.
</core_info>
<extracted_info>
<fact>Tên người dùng là Raghav.</fact>
</extracted_info>
</memory>

Tại đây, <core_info> đại diện cho thông tin tĩnh về người dùng, và <extracted_info> chứa các sự thật được trích xuất từ cuộc trò chuyện. Mặc dù sự thật đã có trong bộ nhớ tĩnh, đây chỉ là để minh họa—chúng ta có thể chỉ định các hướng dẫn để trích xuất thông tin khác như sở thích, sở thích cá nhân, v.v.

Bất kỳ tin nhắn theo dõi nào từ người dùng sẽ có khối bộ nhớ này được thêm vào. Dưới đây là phản hồi từ bot:

Triển khai hoàn chỉnh

Dưới đây là ví dụ hoàn chỉnh minh họa tất cả ba loại bộ nhớ:

"""
Blog Bộ nhớ LlamaIndex - Agent Trò chuyện với Bộ nhớ Bền vững
Minh họa việc trích xuất sự thật và tính bền vững với SQLite
"""

import asyncio
import sqlite3
import json
import os
from llama_index.core.memory import StaticMemoryBlock, FactExtractionMemoryBlock, Memory
from llama_index.core.agent.workflow import FunctionAgent
import model
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# =============================================================================
# CẤU HÌNH
# =============================================================================

# Cấu hình LLM
LLM = OpenAI()
EMBED_MODEL = OpenAIEmbedding()

# Dữ liệu cụ thể theo người dùng:
user_data = {
    "raghav": {
        "name": "raghav",
        "age": 30,
        "profession": "Nhà khoa học dữ liệu",
        "location": "Bangalore",
    },
    "pavan": {
        "name": "pavan",
        "age": 25,
        "profession": "Kỹ sư kiểm thử",
        "location": "Hyderabad",
    }
}

# Trạng thái toàn cầu
agent_dict = {}
agent = FunctionAgent(tools=[], llm=LLM)

def create_memory(user_id: str) -> Memory:
    """Tạo một phiên bản bộ nhớ mới cho một người dùng"""

    STATIC_BLOCK = StaticMemoryBlock(
        name="core_info", 
        static_content=f"Tôi là {user_data[user_id]['name']}, một {user_data[user_id]['age']}-tuổi {user_data[user_id]['profession']} từ {user_data[user_id]['location']}.", 
        priority=0
    )

    fact_extraction_block = FactExtractionMemoryBlock(
        name="extracted_info", 
        llm=LLM, 
        max_facts=50, 
        priority=1
    )

    return Memory.from_defaults(
        session_id=user_id,
        token_limit=300,
        chat_history_token_ratio=0.0002,
        token_flush_size=500,
        memory_blocks=[STATIC_BLOCK, fact_extraction_block],
        insert_method="user",
        async_database_uri="sqlite+aiosqlite:///data/chat_memory.db",
        table_name="chat_sessions",
    )

def get_agent(user_id: str) -> Memory:
    """Lấy hoặc tạo bộ nhớ cho một người dùng"""
    if user_id not in agent_dict:
        agent_dict[user_id] = create_memory(user_id)
    return agent_dict[user_id]

# =============================================================================
# ỨNG DỤNG CHÍNH
# =============================================================================

async def main():
    """Vòng lặp ứng dụng chính"""
    print("🤖 Blog Bộ nhớ LlamaIndex - Agent Trò chuyện")
    print("Lệnh:")
    print("  'message:user_id' - Trò chuyện với người dùng cụ thể")
    print("  'exit' - Thoát khỏi ứng dụng")
    print("=" * 50)

    memory = None

    while True:
        try:
            user_message = input("\nNgười dùng: ").strip()

            if user_message == "exit":
                print("👋 Tạm biệt!")
                break

            elif ":" in user_message:
                user_id = user_message.split(":")[-1].strip()
                memory = get_agent(user_id)
                print(f"💭 Đã chuyển sang người dùng: {user_id}")

            if memory is None:
                print("⚠️  Vui lòng chỉ định một ID người dùng trước bằng định dạng 'message:user_id'")
                continue

            # Xử lý tin nhắn
            response = await agent.run(user_msg=user_message, memory=memory)
            chat_messages = memory.get()
            print(f"🤖 Phản hồi: {response}")

        except KeyboardInterrupt:
            print("\n👋 Tạm biệt!")
            break
        except Exception as e:
            print(f"❌ Lỗi: {e}")

if __name__ == "__main__":
    asyncio.run(main())

Kết luận

Hầu hết các tổ chức đã có quyền truy cập vào thông tin người dùng thiết yếu. Cung cấp những thông tin này cho các agents trò chuyện, được điều chỉnh theo nhu cầu kinh doanh cụ thể, có thể nâng cao đáng kể sự hiểu biết về ngữ cảnh và cá nhân hóa. Mặc dù có nhiều phức tạp khác cần xem xét, bài viết này tập trung vào các thành phần bộ nhớ cốt lõi trong LlamaIndex, giúp bạn phát triển các agents trò chuyện thông minh và phản ứng nhanh hơn.

Để biết thêm thông tin chi tiết, hãy tham khảo bài viết gốc trên blog LlamaIndex.

Bạn nghĩ loại bộ nhớ nào sẽ có giá trị nhất cho trường hợp sử dụng agent trò chuyện của bạn? Chia sẻ ý kiến của bạn trong phần bình luận bên dưới!