Simple

SimpleChatStore

Bases: BaseChatStore

简单的聊天存储。

Source code in llama_index/core/storage/chat_store/simple_chat_store.py

class SimpleChatStore(BaseChatStore):
    """简单的聊天存储。"""

    store: Dict[str, List[ChatMessage]] = Field(default_factory=dict)

    @classmethod
    def class_name(cls) -> str:
        """获取类名。"""
        return "SimpleChatStore"

    def set_messages(self, key: str, messages: List[ChatMessage]) -> None:
        """为一个键设置消息。"""
        self.store[key] = messages

    def get_messages(self, key: str) -> List[ChatMessage]:
        """获取特定键的消息。"""
        return self.store.get(key, [])

    def add_message(
        self, key: str, message: ChatMessage, idx: Optional[int] = None
    ) -> None:
        """为键添加一条消息。"""
        if idx is None:
            self.store.setdefault(key, []).append(message)
        else:
            self.store.setdefault(key, []).insert(idx, message)

    def delete_messages(self, key: str) -> Optional[List[ChatMessage]]:
        """删除指定键的消息。"""
        if key not in self.store:
            return None
        return self.store.pop(key)

    def delete_message(self, key: str, idx: int) -> Optional[ChatMessage]:
        """删除特定键的消息。"""
        if key not in self.store:
            return None
        if idx >= len(self.store[key]):
            return None
        return self.store[key].pop(idx)

    def delete_last_message(self, key: str) -> Optional[ChatMessage]:
        """删除指定键的最后一条消息。"""
        if key not in self.store:
            return None
        return self.store[key].pop()

    def get_keys(self) -> List[str]:
        """获取所有的键。"""
        return list(self.store.keys())

    def persist(
        self,
        persist_path: str = "chat_store.json",
        fs: Optional[fsspec.AbstractFileSystem] = None,
    ) -> None:
        """将文档存储持久化到文件中。"""
        fs = fs or fsspec.filesystem("file")
        dirpath = os.path.dirname(persist_path)
        if not fs.exists(dirpath):
            fs.makedirs(dirpath)

        with fs.open(persist_path, "w") as f:
            f.write(json.dumps(self.json()))

    @classmethod
    def from_persist_path(
        cls,
        persist_path: str = "chat_store.json",
        fs: Optional[fsspec.AbstractFileSystem] = None,
    ) -> "SimpleChatStore":
        """从持久路径创建一个SimpleChatStore。"""
        fs = fs or fsspec.filesystem("file")
        if not fs.exists(persist_path):
            return cls()
        with fs.open(persist_path, "r") as f:
            data = json.load(f)
        return cls.parse_raw(data)

class_name classmethod

class_name() -> str

获取类名。

Source code in llama_index/core/storage/chat_store/simple_chat_store.py

@classmethod
def class_name(cls) -> str:
    """获取类名。"""
    return "SimpleChatStore"

set_messages

set_messages(key: str, messages: List[ChatMessage]) -> None

为一个键设置消息。

Source code in llama_index/core/storage/chat_store/simple_chat_store.py

def set_messages(self, key: str, messages: List[ChatMessage]) -> None:
    """为一个键设置消息。"""
    self.store[key] = messages

get_messages

get_messages(key: str) -> List[ChatMessage]

获取特定键的消息。

Source code in llama_index/core/storage/chat_store/simple_chat_store.py

def get_messages(self, key: str) -> List[ChatMessage]:
    """获取特定键的消息。"""
    return self.store.get(key, [])

add_message

add_message(
    key: str,
    message: ChatMessage,
    idx: Optional[int] = None,
) -> None

为键添加一条消息。

Source code in llama_index/core/storage/chat_store/simple_chat_store.py

def add_message(
    self, key: str, message: ChatMessage, idx: Optional[int] = None
) -> None:
    """为键添加一条消息。"""
    if idx is None:
        self.store.setdefault(key, []).append(message)
    else:
        self.store.setdefault(key, []).insert(idx, message)

delete_messages

delete_messages(key: str) -> Optional[List[ChatMessage]]

删除指定键的消息。

Source code in llama_index/core/storage/chat_store/simple_chat_store.py

def delete_messages(self, key: str) -> Optional[List[ChatMessage]]:
    """删除指定键的消息。"""
    if key not in self.store:
        return None
    return self.store.pop(key)

delete_message

delete_message(key: str, idx: int) -> Optional[ChatMessage]

删除特定键的消息。

Source code in llama_index/core/storage/chat_store/simple_chat_store.py

def delete_message(self, key: str, idx: int) -> Optional[ChatMessage]:
    """删除特定键的消息。"""
    if key not in self.store:
        return None
    if idx >= len(self.store[key]):
        return None
    return self.store[key].pop(idx)

delete_last_message

delete_last_message(key: str) -> Optional[ChatMessage]

删除指定键的最后一条消息。

Source code in llama_index/core/storage/chat_store/simple_chat_store.py

def delete_last_message(self, key: str) -> Optional[ChatMessage]:
    """删除指定键的最后一条消息。"""
    if key not in self.store:
        return None
    return self.store[key].pop()

get_keys

get_keys() -> List[str]

获取所有的键。

Source code in llama_index/core/storage/chat_store/simple_chat_store.py

def get_keys(self) -> List[str]:
    """获取所有的键。"""
    return list(self.store.keys())

persist

persist(
    persist_path: str = "chat_store.json",
    fs: Optional[AbstractFileSystem] = None,
) -> None

将文档存储持久化到文件中。

Source code in llama_index/core/storage/chat_store/simple_chat_store.py

def persist(
    self,
    persist_path: str = "chat_store.json",
    fs: Optional[fsspec.AbstractFileSystem] = None,
) -> None:
    """将文档存储持久化到文件中。"""
    fs = fs or fsspec.filesystem("file")
    dirpath = os.path.dirname(persist_path)
    if not fs.exists(dirpath):
        fs.makedirs(dirpath)

    with fs.open(persist_path, "w") as f:
        f.write(json.dumps(self.json()))

from_persist_path classmethod

from_persist_path(
    persist_path: str = "chat_store.json",
    fs: Optional[AbstractFileSystem] = None,
) -> SimpleChatStore

从持久路径创建一个SimpleChatStore。

Source code in llama_index/core/storage/chat_store/simple_chat_store.py

@classmethod
def from_persist_path(
    cls,
    persist_path: str = "chat_store.json",
    fs: Optional[fsspec.AbstractFileSystem] = None,
) -> "SimpleChatStore":
    """从持久路径创建一个SimpleChatStore。"""
    fs = fs or fsspec.filesystem("file")
    if not fs.exists(persist_path):
        return cls()
    with fs.open(persist_path, "r") as f:
        data = json.load(f)
    return cls.parse_raw(data)