openvector_dev 0.1.3__tar.gz → 0.1.5__tar.gz

{openvector_dev-0.1.3 → openvector_dev-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openvector_dev
-Version: 0.1.3
+Version: 0.1.5
 Summary: 
 Author: p00ler
 Author-email: liveitspain@gmail.com
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: aiohttp (>=3.12.13,<4.0.0)
 Requires-Dist: google-genai[aiohttp] (>=1.21.1,<2.0.0)
 Requires-Dist: qdrant-client (>=1.14.3,<2.0.0)
+Requires-Dist: redis (>=6.2.0,<7.0.0)
 Description-Content-Type: text/markdown
 
 # Persona-Memory Subsystem

{openvector_dev-0.1.3 → openvector_dev-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openvector_dev"
-version = "0.1.3"
+version = "0.1.5"
 description = ""
 authors = [
     {name = "p00ler",email = "liveitspain@gmail.com"}
@@ -11,6 +11,7 @@ dependencies = [
     "qdrant-client (>=1.14.3,<2.0.0)",
     "aiohttp (>=3.12.13,<4.0.0)",
     "google-genai[aiohttp] (>=1.21.1,<2.0.0)",
+    "redis (>=6.2.0,<7.0.0)",
 ]
 
 

openvector_dev-0.1.5/src/lein_vector/__init__.py

@@ -0,0 +1,17 @@
+from . import api, bases, schemas
+from .memory_manager_qdrant import MemoryManagerQdrant
+from .qdrant_adapter import QdrantAdapter
+from .redis_short_term import RedisShortTermMemory
+from .sentence_transformer import EmbeddingProviderGemini as EmbeddingProvider
+from .short_term import ShortTermMemory
+
+__all__ = [
+    "EmbeddingProvider",
+    "MemoryManagerQdrant",
+    "QdrantAdapter",
+    "RedisShortTermMemory",
+    "ShortTermMemory",
+    "api",
+    "bases",
+    "schemas",
+]

openvector_dev-0.1.5/src/lein_vector/api/facade.py

@@ -0,0 +1,227 @@
+from collections.abc import Sequence
+from datetime import UTC, datetime
+from uuid import uuid4
+
+import redis.asyncio as aioredis
+
+from lein_vector import MemoryManagerQdrant, QdrantAdapter, RedisShortTermMemory
+from lein_vector.schemas.chunk import Chunk, ChunkPayload
+from lein_vector.sentence_transformer import EmbeddingProviderGemini
+
+
+class Memory:
+    def __init__(self, short_term, memory_manager, embedder, merge_n: int = 5):
+        """
+        :param short_term: Кратковременное хранилище сообщений пользователя (RedisShortTermMemory).
+        :param memory_manager: Менеджер долговременной памяти (MemoryManagerQdrant).
+        :param embedder: Провайдер эмбеддингов (EmbeddingProviderGemini).
+        :param merge_n: Количество чанков для слияния при мердже.
+        """
+        self.short = short_term
+        self.long = memory_manager
+        self.embed = embedder
+        self._msg_no: dict[int, int] = {}
+        self.merge_n = merge_n
+
+    @classmethod
+    async def from_qdrant(
+        cls,
+        host: str,
+        port: int,
+        collection: str,
+        vector_size: int = 768,
+        api_key: str | None = None,
+        short_maxlen: int = 20,
+    ) -> "Memory":
+        """
+        Создаёт MemoryFacade со всеми зависимостями
+        :param host: Адрес Qdrant.
+        :param port: Порт Qdrant.
+        :param collection: Название коллекции Qdrant.
+        :param vector_size: Размерность векторного пространства.
+        :param api_key: Ключ для эмбеддера (если требуется).
+        :param short_maxlen: Максимальная длина окна кратковременной памяти.
+        :returns: Экземпляр Memory с инициализированными зависимостями.
+        """
+        _redis = aioredis.from_url("redis://localhost:6379", decode_responses=True)
+        short_mem = RedisShortTermMemory(_redis, maxlen=short_maxlen)
+        embedder = EmbeddingProviderGemini(api_key=api_key)
+        adapter = QdrantAdapter(host, port, collection, vector_size)
+        await adapter.init_collection()
+        long_mem = MemoryManagerQdrant(adapter, embedder)
+        return cls(short_mem, long_mem, embedder)
+
+    async def step_user(
+        self, *, bot: str, user_id: int, user_msg: str, topk: int = 3, history_n: int = 20
+    ):
+        """
+        :param bot: Идентификатор бота.
+        :param user_id: Идентификатор пользователя.
+        :param user_msg: Текст сообщения пользователя.
+        :param topk: Количество релевантных чанков из долговременной памяти.
+        :param history_n: Размер окна кратковременной памяти.
+        :returns: Словарь с short_term и long_term сообщениями.
+        """
+        key = (user_id, bot)
+        curr_no = self._msg_no.get(key, 0) + 1
+        self._msg_no[key] = curr_no
+        await self.short.add(
+            bot=bot,
+            user_id=user_id,
+            role="user",
+            text=user_msg,
+            extra={"msg_no": curr_no},
+        )
+        embedding = await self.embed.get_embedding(user_msg)
+        long_memories = await self.long.retrieve_by_embedding(
+            user_id=user_id,
+            embedding=embedding,
+            topk=topk,
+            filter_={"bot": bot},
+            score_threshold=0.7
+        )
+        short_ctx = await self.short.window(user_id, history_n)
+        return {"short_term": short_ctx, "long_term": long_memories}
+
+    async def step_user_oai(
+        self,
+        user_id: int,
+        user_msg: str,
+        bot: str,
+        *,
+        topk: int = 3,
+        history_n: int = 20,
+    ) -> dict:
+        """
+        :param user_id: Идентификатор пользователя.
+        :param user_msg: Текст сообщения пользователя.
+        :param bot: Идентификатор бота.
+        :param topk: Количество релевантных чанков из долговременной памяти.
+        :param history_n: Размер окна кратковременной памяти.
+        :returns: Данные short_term и long_term в формате OpenAI-совместимого вывода.
+        """
+        data = await self.step_user(user_id, bot, user_msg, topk=topk, history_n=history_n)
+        data["short_term"] = self._to_openai(data["short_term"])
+        data["long_term"] = self._chunk_texts(data["long_term"])
+        return data
+
+    @staticmethod
+    def _to_openai(msgs: list[dict]) -> list[dict]:
+        """
+        :param msgs: Список сообщений внутреннего формата.
+        :returns: Список сообщений в формате OpenAI (role, content).
+        """
+        role_map = {"gf": "assistant"}  # «gf» → OpenAI «assistant»
+        return [
+            {"role": role_map.get(m["role"], m["role"]), "content": m["text"]}
+            for m in msgs
+        ]
+
+    async def step_gf(
+        self,
+        user_id: int,
+        gf_msg: str,
+        bot: str,
+        *,
+        block_size: int = 4,
+        save_pair: bool = True,
+    ):
+        """
+        :param user_id: Идентификатор пользователя.
+        :param gf_msg: Сообщение от gf (assistant).
+        :param bot: Идентификатор бота.
+        :param block_size: Размер блока для сохранения в долговременной памяти.
+        :param save_pair: Флаг, сохранять ли пару сообщений при достижении block_size.
+        """
+        key = (user_id, bot)
+        curr_no = self._msg_no.get(key, 0) + 1
+        self._msg_no[key] = curr_no
+        ts = datetime.now(UTC).timestamp()
+        await self.short.add(
+            bot=bot,
+            user_id=user_id,
+            role="gf",
+            text=str(gf_msg),
+            extra={"msg_no": curr_no, "ts": ts},
+        )
+
+        if save_pair and curr_no % block_size == 0:
+            last_block = await self.short.window(user_id, block_size)
+
+            block_text = "\n".join(f'{m["role"]}: {m["text"]}' for m in last_block)
+
+            vector = await self.embed.get_embedding(block_text)
+
+            new_chunk = Chunk(
+                chunk_id=uuid4(),
+                bot=bot,
+                user_id=user_id,
+                chunk_type="type0",
+                created_at=datetime.now(UTC),
+                last_hit=datetime.now(UTC),
+                hit_count=0,
+                text=block_text,
+                persistent=False,
+                extra={"msg_no": curr_no},
+            )
+            await self.long.upsert_chunk_with_vector(new_chunk, vector)
+            # self.short.clear_until(block_size)
+
+        if curr_no % 40 == 0:
+            await self.long.merge_old_chunks(user_id, "type0", n=self.merge_n)
+
+    async def _get_short_term(self, n=10) -> list:
+        """
+        :param n: Количество последних сообщений кратковременной памяти.
+        :returns: Список сообщений.
+        """
+        return await self.short.window(n)
+
+    async def _get_long_term(
+        self, user_id: int, embedding: list[float], topk: int = 3
+    ) -> list:
+        """
+        :param user_id: Идентификатор пользователя.
+        :param embedding: Вектор эмбеддинга для поиска.
+        :param topk: Количество возвращаемых чанков.
+        :returns: Список чанков.
+        """
+        return await self.long.retrieve_by_embedding(user_id, embedding, topk)
+
+    async def get_memories(self, user_id: int, search_terms: list[str], topk: int = 3) -> list:
+        """
+        :param user_id: Идентификатор пользователя.
+        :param search_terms: Список поисковых запросов (строк).
+        :param topk: Количество возвращаемых чанков на запрос.
+        :returns: Список релевантных чанков.
+        """
+        search_terms = [await self.embed.get_embedding(term) for term in search_terms]
+        return await self.long.retrieve_by_embeddings(user_id, search_terms, topk)
+
+    async def _add_to_short(self, role: str, text: str) -> None:
+        """
+        :param role: Роль сообщения.
+        :param text: Текст сообщения.
+        """
+        await self.short.add(role, text)
+
+    async def _add_to_long(self, user_id: int, chunk: Chunk) -> None:
+        """
+        :param user_id: Идентификатор пользователя.
+        :param chunk: Экземпляр Chunk для сохранения.
+        """
+        await self.long.upsert_chunk(user_id, chunk)
+
+    async def delete_memory(self, user_id: int) -> None:
+        """
+        :param user_id: Идентификатор пользователя.
+        """
+        await self.long.delete_all(user_id)
+
+    @staticmethod
+    def _chunk_texts(chunks: Sequence[Chunk | ChunkPayload]) -> list[str]:
+        """
+        :param chunks: Последовательность Chunk или ChunkPayload.
+        :returns: Список текстов из чанков.
+        """
+        return [c.text for c in chunks]

openvector_dev-0.1.5/src/lein_vector/bases/embeding_provider_abc.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+
+class EmbeddingProviderABC(ABC):
+    @abstractmethod
+    async def get_embedding(self, text: str) -> list[float]: ...
+
+    @abstractmethod
+    async def get_embeddings(self, texts: list[str]) -> list[list[float]]: ...

openvector_dev-0.1.5/src/lein_vector/bases/memory_manager_abc.py

@@ -0,0 +1,31 @@
+from uuid import UUID
+from lein_vector.schemas.chunk import Chunk
+
+class MemoryManagerABC:
+    async def upsert_chunk(self, user_id: int, bot: str, chunk: Chunk) -> None: ...
+    async def upsert_chunks(self, user_id: int, bot: str, chunks: list[Chunk]) -> None: ...
+    async def retrieve_by_embedding(
+        self, user_id: int, bot: str, embedding: list[float], topk: int = 3
+    ) -> list[Chunk]: ...
+    async def retrieve_by_embedding_batch(
+        self, user_id: int, bot: str, embeddings: list[list[float]], topk: int = 3
+    ) -> list[list[Chunk]]:
+        raise NotImplementedError("Not implemented in this backend")
+
+    async def retrieve_by_type(
+        self, user_id: int, bot: str, chunk_type: str, topk: int = 3
+    ) -> list[Chunk]: ...
+    async def retrieve_by_text(
+        self, user_id: int, bot: str, query: str, topk: int = 3
+    ) -> list[Chunk]: ...
+    async def merge_old_chunks(self, user_id: int, bot: str, chunk_type: str) -> None: ...
+    async def archive_user(self, user_id: int, bot: str) -> None: ...
+    async def restore_user(self, user_id: int, bot: str) -> None: ...
+    async def increment_hit(self, user_id: int, bot: str, chunk_id: UUID) -> None: ...
+    async def pop_first_n(
+        self, user_id: int, bot: str, chunk_type: str, n: int
+    ) -> list[Chunk]: ...
+    async def delete_oldest_nonpersistent(self, user_id: int, bot: str, keep: int) -> None: ...
+    async def delete_chunk(self, user_id: int, bot: str, chunk_id: UUID) -> None: ...
+    async def delete_chunks(self, user_id: int, bot: str, chunk_ids: list[UUID]) -> None: ...
+    async def delete_all(self, user_id: int, bot: str) -> None: ...

openvector_dev-0.1.5/src/lein_vector/memory_manager_qdrant.py

@@ -0,0 +1,155 @@
+import asyncio
+from datetime import UTC, datetime
+from typing import Any
+from uuid import UUID
+
+from lein_vector.bases.memory_manager_abc import MemoryManagerABC
+from lein_vector.schemas.chunk import Chunk, ChunkPayload
+
+
+class MemoryManagerQdrant(MemoryManagerABC):
+    def __init__(self, qdrant_adapter, embedding_provider, archive_storage=None):
+        self.qdrant = qdrant_adapter
+        self.embed = embedding_provider
+        self.archive = archive_storage  # твой модуль S3/minio (интерфейс: save(user_id, List[ChunkPayload]), load(user_id) -> List[ChunkPayload])
+
+    async def upsert_chunk(self, user_id: int, bot: str, chunk: Chunk) -> None:
+        assert chunk.bot == bot
+        embedding = await self.embed.get_embedding(chunk.text)
+        await self.qdrant.upsert(chunk.chunk_id, embedding, chunk.to_payload())
+
+    async def upsert_chunk_with_vector(
+        self, chunk: Chunk, embedding: list[float]
+    ) -> None:
+        await self.qdrant.upsert(chunk.chunk_id, embedding, chunk.to_payload())
+
+    async def upsert_chunks(self, user_id: int, bot: str, chunks: list[Chunk]) -> None:
+        for c in chunks:
+            if c.bot != bot:
+                raise ValueError(f"chunk.bot ({c.bot}) != bot ({bot})")
+        texts = [c.text for c in chunks]
+        embeddings = await self.embed.get_embeddings(texts)
+        points = [
+            {"point_id": c.chunk_id, "embedding": emb, "payload": c.to_payload()}
+            for c, emb in zip(chunks, embeddings)
+        ]
+        await self.qdrant.upsert_batch(points)
+
+    async def retrieve_by_embedding(
+        self,
+        user_id: int,
+        embedding: list[float],
+        *,
+        bot: str,
+        topk: int = 3,
+        filter_: dict[str, Any] = None,
+        score_threshold: float | None = None,
+    ) -> list[ChunkPayload]:
+        q_filter = {"user_id": user_id, "bot": bot}
+        if filter_:
+            q_filter.update(filter_)
+        return await self.qdrant.search(embedding, q_filter, topk, score_threshold)
+
+    async def retrieve_by_embeddings(
+        self,
+        user_id: int,
+        embeddings: list[list[float]],
+        *,
+        bot: str,
+        topk: int = 3,
+        filter_: dict[str, Any] | None = None,
+        score_threshold: float | None = None,
+    ) -> list[list[ChunkPayload]]:
+        """
+        Возвращает список результатов для каждого Embedding.
+        На выходе: [[ChunkPayload, …] для emb-0, [ChunkPayload, …] для emb-1, …]
+        """
+        q_filter = {"user_id": user_id, "bot": bot}
+        if filter_:
+            q_filter.update(filter_)
+
+        if hasattr(self.qdrant, "search_batch"):
+            return await self.qdrant.search_batch(
+                query_vectors=embeddings,
+                query_filter=q_filter,
+                topk=topk,
+                score_threshold=score_threshold,
+            )
+
+        async def _one(e):
+            return await self.qdrant.search(
+                e, q_filter, topk, score_threshold
+            )
+
+        return await asyncio.gather(*[_one(e) for e in embeddings])
+
+    #ToDO: filter
+    async def retrieve_by_type(
+        self, user_id: int, bot: str, chunk_type: str, topk: int = 3
+    ) -> list[ChunkPayload]:
+        # Лучше использовать scroll по фильтру
+        filter_ = {"user_id": user_id, "bot": bot, "chunk_type": chunk_type}
+        return await self.qdrant.get_all_chunks_with_filter(filter_)
+
+    async def merge_old_chunks(self, user_id: int, bot: str, chunk_type: str, n: int = 5) -> None:
+        chunks = await self.qdrant.get_n_oldest_chunks(user_id, bot, chunk_type, n)
+        if len(chunks) < n:
+            return
+        merged_text = " | ".join([c.text for c in chunks])
+        from datetime import datetime
+        from uuid import uuid4
+
+        # ToDo: LLM summary
+        summary_chunk = Chunk(
+            chunk_id=uuid4(),
+            user_id=user_id,
+            bot=bot,
+            chunk_type=self._next_type(chunk_type),
+            created_at=datetime.now(UTC),
+            last_hit=datetime.now(UTC),
+            hit_count=0,
+            text=merged_text,
+            persistent=False,
+            summary_of=[c.chunk_id for c in chunks],
+        )
+        await self.upsert_chunk(user_id, bot, summary_chunk)
+
+        await self.delete_chunks(user_id, bot, [c.chunk_id for c in chunks])
+
+    async def archive_user(self, user_id: int, bot: str) -> None:
+        all_chunks = await self.qdrant.get_all_chunks(user_id, bot)
+        await self.archive.save(user_id, bot, all_chunks)
+        await self.delete_all(user_id, bot)
+
+    async def restore_user(self, user_id: int, bot: str) -> None:
+        chunks = await self.archive.load(user_id, bot)
+        await self.upsert_chunks(
+            user_id,
+            [
+                Chunk(**c.dict(), last_hit=datetime.now(UTC), hit_count=0, bot=bot)
+                for c in chunks
+            ],
+        )
+
+    async def delete_chunk(self, user_id: int, bot: str, chunk_id: UUID) -> None:
+        await self.qdrant.delete(chunk_id)
+
+    async def delete_chunks(self, user_id: int, bot: str, chunk_ids: list[UUID]) -> None:
+        await self.qdrant.delete_batch(chunk_ids)
+
+    async def delete_all(self, user_id: int, bot: str) -> None:
+        all_chunks = await self.qdrant.get_all_chunks(user_id, bot)
+        await self.delete_chunks(user_id, bot, [c.chunk_id for c in all_chunks])
+
+    async def retrieve_filtered(
+        self, user_id: int, bot: str, filter_: dict[str, Any], topk: int = 10
+    ) -> list[ChunkPayload]:
+        q_filter = {"user_id": user_id, "bot": bot}
+        q_filter.update(filter_)
+        return await self.qdrant.get_all_chunks_with_filter(q_filter, topk=topk)
+
+    @staticmethod
+    def _next_type(chunk_type: str) -> str:
+        # Логика типа next_type
+        mapping = {"type0": "type1", "type1": "type2"}
+        return mapping.get(chunk_type, "summary")

{openvector_dev-0.1.3 → openvector_dev-0.1.5}/src/lein_vector/memory_manager_ram.py

@@ -1,9 +1,9 @@
-from typing import List
-from uuid import UUID
-from lein_vector.schemas.chunk import Chunk
+from datetime import UTC, datetime
+from uuid import UUID, uuid4
+
 from lein_vector.bases.memory_manager_abc import MemoryManagerABC
-from uuid import uuid4
-from datetime import datetime, timezone
+from lein_vector.schemas.chunk import Chunk
+
 
 class MemoryManagerRAM(MemoryManagerABC):
     def __init__(self):
@@ -15,27 +15,37 @@ class MemoryManagerRAM(MemoryManagerABC):
             self._data[user_id] = {}
         self._data[user_id][chunk.chunk_id] = chunk
 
-    async def upsert_chunks(self, user_id: int, chunks: List[Chunk]) -> None:
+    async def upsert_chunks(self, user_id: int, chunks: list[Chunk]) -> None:
         if user_id not in self._data:
             self._data[user_id] = {}
         for chunk in chunks:
             self._data[user_id][chunk.chunk_id] = chunk
 
-    async def retrieve_by_embedding(self, user_id: int, embedding: List[float], topk: int = 3) -> List[Chunk]:
+    async def retrieve_by_embedding(
+        self, user_id: int, embedding: list[float], topk: int = 3
+    ) -> list[Chunk]:
         user_chunks = self._data.get(user_id, {})
-        sorted_chunks = sorted(user_chunks.values(), key=lambda c: c.created_at, reverse=True)
+        sorted_chunks = sorted(
+            user_chunks.values(), key=lambda c: c.created_at, reverse=True
+        )
         return sorted_chunks[:topk]
 
-    async def retrieve_by_embedding_batch(self, user_id: int, embeddings: List[List[float]], topk: int = 3) -> List[List[Chunk]]:
+    async def retrieve_by_embedding_batch(
+        self, user_id: int, embeddings: list[list[float]], topk: int = 3
+    ) -> list[list[Chunk]]:
         raise NotImplementedError("Not implemented in RAM backend")
 
-    async def retrieve_by_type(self, user_id: int, chunk_type: str, topk: int = 3) -> List[Chunk]:
+    async def retrieve_by_type(
+        self, user_id: int, chunk_type: str, topk: int = 3
+    ) -> list[Chunk]:
         user_chunks = self._data.get(user_id, {})
         filtered = [c for c in user_chunks.values() if c.chunk_type == chunk_type]
         filtered.sort(key=lambda c: c.created_at, reverse=True)
         return filtered[:topk]
 
-    async def retrieve_by_text(self, user_id: int, query: str, topk: int = 3) -> List[Chunk]:
+    async def retrieve_by_text(
+        self, user_id: int, query: str, topk: int = 3
+    ) -> list[Chunk]:
         user_chunks = self._data.get(user_id, {})
         filtered = [c for c in user_chunks.values() if query.lower() in c.text.lower()]
         filtered.sort(key=lambda c: c.created_at, reverse=True)
@@ -43,10 +53,7 @@ class MemoryManagerRAM(MemoryManagerABC):
 
     async def merge_old_chunks(self, user_id: int, chunk_type: str, n: int = 5) -> None:
         user_chunks = self._data.get(user_id, {})
-        next_type = {
-            "type0": "type1",
-            "type1": "type2"
-        }.get(chunk_type)
+        next_type = {"type0": "type1", "type1": "type2"}.get(chunk_type)
         if not next_type:
             return
 
@@ -63,8 +70,8 @@ class MemoryManagerRAM(MemoryManagerABC):
             chunk_id=uuid4(),
             user_id=user_id,
             chunk_type=next_type,
-            created_at=datetime.now(timezone.utc),
-            last_hit=datetime.now(timezone.utc),
+            created_at=datetime.now(UTC),
+            last_hit=datetime.now(UTC),
             hit_count=0,
             text=merged_text,
             persistent=False,
@@ -89,10 +96,11 @@ class MemoryManagerRAM(MemoryManagerABC):
         chunk = user_chunks.get(chunk_id)
         if chunk is not None:
             chunk.hit_count += 1
-            from datetime import datetime, timezone
-            chunk.last_hit = datetime.now(timezone.utc)
+            from datetime import datetime
+
+            chunk.last_hit = datetime.now(UTC)
 
-    async def pop_first_n(self, user_id: int, chunk_type: str, n: int) -> List[Chunk]:
+    async def pop_first_n(self, user_id: int, chunk_type: str, n: int) -> list[Chunk]:
         user_chunks = self._data.get(user_id, {})
         filtered = [c for c in user_chunks.values() if c.chunk_type == chunk_type]
         # сортировка по created_at (старые — первые)
@@ -113,13 +121,11 @@ class MemoryManagerRAM(MemoryManagerABC):
         for chunk in nonpersistent[:-keep]:
             del self._data[user_id][chunk.chunk_id]
 
-
     async def delete_chunk(self, user_id: int, chunk_id: UUID) -> None:
         user_chunks = self._data.get(user_id, {})
         user_chunks.pop(chunk_id, None)
 
-
-    async def delete_chunks(self, user_id: int, chunk_ids: List[UUID]) -> None:
+    async def delete_chunks(self, user_id: int, chunk_ids: list[UUID]) -> None:
         user_chunks = self._data.get(user_id, {})
         for chunk_id in chunk_ids:
             user_chunks.pop(chunk_id, None)
@@ -127,11 +133,11 @@ class MemoryManagerRAM(MemoryManagerABC):
     async def delete_all(self, user_id: int) -> None:
         self._data.pop(user_id, None)
 
-    def get_all_chunks(self, user_id: int) -> List[Chunk]:
+    def get_all_chunks(self, user_id: int) -> list[Chunk]:
         """Для тестов — все чанки пользователя."""
         return list(self._data.get(user_id, {}).values())
 
-    def get_all_archive(self, user_id: int) -> List[Chunk]:
+    def get_all_archive(self, user_id: int) -> list[Chunk]:
         """Для тестов — все чанки в архиве."""
         return list(self._archive.get(user_id, {}).values())
 

{openvector_dev-0.1.3 → openvector_dev-0.1.5}/src/lein_vector/qdrant_adapter.py

@@ -1,16 +1,29 @@
+from typing import Any
+from uuid import UUID
+
 from qdrant_client import AsyncQdrantClient
 from qdrant_client.http.models import MatchText
 from qdrant_client.models import (
-    PointStruct, Filter, FieldCondition, MatchValue, Range,
-    VectorParams, Distance
+    Distance,
+    FieldCondition,
+    Filter,
+    MatchValue,
+    PointStruct,
+    Range,
+    VectorParams,
 )
+
 from lein_vector.schemas.chunk import ChunkPayload
-from typing import List, Dict, Any
-from uuid import UUID
 
 
 class QdrantAdapter:
-    def __init__(self, host: str, port: int, collection: str = "persona_mem", vector_size: int = 768):
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        collection: str = "persona_mem",
+        vector_size: int = 768,
+    ):
         self.collection = collection
         self.client = AsyncQdrantClient(host=host, port=port)
         self.vector_size = vector_size
@@ -20,33 +33,41 @@ class QdrantAdapter:
         if not exists:
             await self.client.create_collection(
                 collection_name=self.collection,
-                vectors_config=VectorParams(size=self.vector_size, distance=Distance.COSINE)
+                vectors_config=VectorParams(
+                    size=self.vector_size, distance=Distance.COSINE
+                ),
             )
 
-    async def upsert(self, point_id: UUID, embedding: List[float], payload: ChunkPayload) -> None:
+    async def upsert(
+        self, point_id: UUID, embedding: list[float], payload: ChunkPayload
+    ) -> None:
         await self.client.upsert(
             collection_name=self.collection,
             points=[
                 PointStruct(
-                    id=str(point_id),
-                    vector=embedding,
-                    payload=payload.model_dump()
+                    id=str(point_id), vector=embedding, payload=payload.model_dump()
                 )
-            ]
+            ],
         )
 
-    async def upsert_batch(self, points: List[Dict[str, Any]]) -> None:
+    async def upsert_batch(self, points: list[dict[str, Any]]) -> None:
         structs = [
             PointStruct(
                 id=str(point["point_id"]),
                 vector=point["embedding"],
-                payload=point["payload"].dict()
+                payload=point["payload"].dict(),
             )
             for point in points
         ]
         await self.client.upsert(collection_name=self.collection, points=structs)
 
-    async def search(self, embedding: List[float], filter_: Dict[str, Any], topk: int) -> List[ChunkPayload]:
+    async def search(
+        self,
+        embedding: list[float],
+        filter_: dict[str, Any],
+        topk: int,
+        score_threshold: float | None = None,
+    ) -> list[ChunkPayload]:
         # Пример фильтра {"user_id": 123, "chunk_type": "type1", "created_at_gt": "2024-01-01T00:00:00"}
         conditions = []
         for k, v in filter_.items():
@@ -56,37 +77,39 @@ class QdrantAdapter:
             elif k.endswith("_lt"):
                 field = k[:-3]
                 conditions.append(FieldCondition(key=field, range=Range(lt=v)))
+            elif isinstance(v, str):
+                conditions.append(FieldCondition(key=k, match=MatchText(text=v)))
             else:
-                if isinstance(v, str):
-                    conditions.append(FieldCondition(key=k, match=MatchText(text=v)))
-                else:
-                    conditions.append(FieldCondition(key=k, match=MatchValue(value=v)))
+                conditions.append(FieldCondition(key=k, match=MatchValue(value=v)))
         q_filter = Filter(must=conditions)
         result = await self.client.query_points(
             collection_name=self.collection,
             query=embedding,
             query_filter=q_filter,
             limit=topk,
+            score_threshold=score_threshold,
         )
         points = result.points
+        if len(points) > 0:
+            for chunk in points:
+                print(chunk.score)
         return [ChunkPayload(**point.payload) for point in points]
 
     async def delete(self, point_id: UUID) -> None:
         await self.client.delete(
-            collection_name=self.collection,
-            points_selector=[str(point_id)]
+            collection_name=self.collection, points_selector=[str(point_id)]
         )
 
-    async def delete_batch(self, point_ids: List[UUID]) -> None:
+    async def delete_batch(self, point_ids: list[UUID]) -> None:
         await self.client.delete(
             collection_name=self.collection,
-            points_selector=[str(pid) for pid in point_ids]
+            points_selector=[str(pid) for pid in point_ids],
         )
 
     async def delete_collection(self) -> None:
         await self.client.delete_collection(collection_name=self.collection)
 
-    async def get_all_chunks(self, user_id: int) -> List[ChunkPayload]:
+    async def get_all_chunks(self, user_id: int) -> list[ChunkPayload]:
         q_filter = Filter(
             must=[FieldCondition(key="user_id", match=MatchValue(value=user_id))]
         )
@@ -95,4 +118,4 @@ class QdrantAdapter:
             scroll_filter=q_filter,
             limit=2048,
         )
-        return [ChunkPayload(**p.payload) for p in scroll[0]]
+        return [ChunkPayload(**p.payload) for p in scroll[0]]

openvector_dev-0.1.5/src/lein_vector/redis_short_term.py

@@ -0,0 +1,92 @@
+import json
+import logging
+from datetime import UTC, datetime
+
+import redis.asyncio as aioredis
+
+
+class RedisShortTermMemory:
+    """
+    Хранит окно последних сообщений пользователя в Redis-списке.
+    Формат элемента — JSON-строка с полями role / text / ts / extra…
+    Ключ для пользователя:  {codename}:{user_id}:short_term
+    """
+
+    def __init__(self, redis: aioredis.Redis, maxlen: int = 20):
+        self.r = redis
+        self.maxlen = maxlen
+
+    @staticmethod
+    def _key(user_id: int, bot: str) -> str:
+        return f"{bot}:{user_id}:short_term"
+
+    @staticmethod
+    def _dump(msg: dict) -> str:
+        # datetime => iso
+        if isinstance(msg.get("ts"), datetime):
+            msg = {**msg, "ts": msg["ts"].isoformat()}
+        return json.dumps(msg, ensure_ascii=False)
+
+    async def add(
+        self,
+        user_id: int,
+        bot: str,
+        role: str,
+        text: str,
+        ts: datetime | None = None,
+        **extra,
+    ) -> None:
+        if ts is None:
+            ts = datetime.now(UTC)
+
+        msg = self._dump({"role": role, "text": text, "ts": ts, **extra})
+        key = self._key(user_id, bot=bot)
+
+        pipe = self.r.pipeline()
+        await pipe.rpush(key, msg)
+        await pipe.ltrim(key, -self.maxlen, -1)
+        await pipe.execute()
+
+    @staticmethod
+    def _load(raw: str | bytes) -> dict:
+        if isinstance(raw, bytes):
+            raw = raw.decode("utf-8")
+        d = json.loads(raw)
+        if "ts" in d:
+            try:
+                d["ts"] = datetime.fromisoformat(d["ts"])
+            except ValueError:
+                logging.error("Invalid timestamp: %s", d["ts"])
+        return d
+
+    async def window(self, user_id: int, bot: str, n: int | None = None) -> list[dict]:
+        n = n or self.maxlen
+        raw = await self.r.lrange(self._key(user_id, bot=bot), -n, -1)
+        return [self._load(r) for r in raw]
+
+    async def clear(self, bot: str, user_id: int) -> None:
+        await self.r.delete(self._key(user_id, bot=bot))
+
+    async def load(self, user_id: int, bot: str, history: list[dict]) -> None:
+        history = history[-self.maxlen :]
+        if not history:
+            await self.clear(user_id)
+            return
+        key = self._key(user_id, bot=bot)
+        pipe = self.r.pipeline()
+        await pipe.delete(key)
+        await pipe.rpush(key, *[self._dump(m) for m in history])
+        await pipe.execute()
+
+    async def to_list(self, user_id: int, bot: str) -> list[dict]:
+        raw = await self.r.lrange(self._key(user_id, bot=bot), 0, -1)
+        return [self._load(r) for r in raw]
+
+    async def chunk_for_vector(
+        self, user_id: int, bot: str, chunk_size: int = 6
+    ) -> list[dict] | None:
+        raw_len = await self.r.llen(self._key(user_id, bot=bot))
+        if raw_len < chunk_size:
+            return None
+        raw = await self.r.lrange(self._key(user_id, bot=bot), -chunk_size, -1)
+        return [self._load(r) for r in raw]

{openvector_dev-0.1.3 → openvector_dev-0.1.5}/src/lein_vector/schemas/chunk.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
-from pydantic import BaseModel, Field
-from typing import List, Optional, Dict
-from datetime import datetime, UTC
+from datetime import UTC, datetime
 from uuid import UUID
 
+from pydantic import BaseModel, Field
+
+
 class Chunk(BaseModel):
     chunk_id: UUID
     user_id: int
+    bot: str
     chunk_type: str  # "type0" | "type1" | "fact"
     created_at: datetime
     last_hit: datetime
@@ -15,9 +17,9 @@ class Chunk(BaseModel):
     text: str
     persistent: bool = False
 
-    summary_of: Optional[List[UUID]] = None        # для type1
-    source_chunk_id: Optional[UUID] = None         # для fact
-    extra: Optional[Dict] = Field(default_factory=dict)
+    summary_of: list[UUID] | None = None  # для type1
+    source_chunk_id: UUID | None = None  # для fact
+    extra: dict | None = Field(default_factory=dict)
 
     def to_payload(self) -> ChunkPayload:
         return ChunkPayload(**self.model_dump())
@@ -30,9 +32,13 @@ class ChunkPayload(BaseModel):
     created_at: datetime
     text: str
     persistent: bool = False
-    summary_of: Optional[List[UUID]] = None
-    source_chunk_id: Optional[UUID] = None
-    extra: Optional[Dict] = Field(default_factory=dict)
+    summary_of: list[UUID] | None = None
+    source_chunk_id: UUID | None = None
+    extra: dict | None = Field(default_factory=dict)
 
     def to_chunk(self, last_hit: datetime = None, hit_count: int = 0) -> Chunk:
-        return Chunk(**self.model_dump(), last_hit=last_hit or datetime.now(UTC), hit_count=hit_count)
+        return Chunk(
+            **self.model_dump(),
+            last_hit=last_hit or datetime.now(UTC),
+            hit_count=hit_count,
+        )

{openvector_dev-0.1.3 → openvector_dev-0.1.5}/src/lein_vector/sentence_transformer.py

@@ -6,20 +6,6 @@ from google.genai import types
 from lein_vector.bases.embeding_provider_abc import EmbeddingProviderABC
 
 
-class EmbeddingProviderSentenceTransformer(EmbeddingProviderABC):
-    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
-        self.model = None
-        raise NotImplementedError
-
-    async def get_embedding(self, text: str) -> list[float]:
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, self.model.encode, text)
-
-    async def get_embeddings(self, texts: list[str]) -> list[list[float]]:
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, self.model.encode, texts)
-
-
 class EmbeddingProviderGemini(EmbeddingProviderABC):
     def __init__(self, api_key: str, model_name: str = "models/embedding-001"):
 
@@ -63,6 +49,5 @@ async def main():
         print(str(e)[:50] + "... TRIMMED]")
 
 
-
 if __name__ == "__main__":
     asyncio.run(main())

{openvector_dev-0.1.3 → openvector_dev-0.1.5}/src/lein_vector/short_term.py

@@ -1,22 +1,26 @@
 from collections import deque
-from typing import List, Dict, Optional
 from datetime import datetime
 
+
 class ShortTermMemory:
     def __init__(self, maxlen: int = 10):
         self._buffer: deque = deque(maxlen=maxlen)
 
-    def add(self, role: str, text: str, ts: Optional[datetime] = None) -> None:
+    def add(
+        self,
+        codename: str,
+        user_id: int,
+        role: str,
+        text: str,
+        ts: datetime | None = None,
+        **extra
+    ) -> None:
         """Добавить сообщение в память (роль, текст, ts - время, по умолчанию now)."""
         if ts is None:
             ts = datetime.now()
-        self._buffer.append({
-            "role": role,
-            "text": text,
-            "ts": ts
-        })
+        self._buffer.append({"role": role, "text": text, "ts": ts, **extra})
 
-    def window(self, n: Optional[int] = None) -> List[Dict]:
+    def window(self, n: int | None = None) -> list[dict]:
         """Получить последние n сообщений (по умолчанию все)."""
         if n is None or n > len(self._buffer):
             return list(self._buffer)
@@ -26,17 +30,17 @@ class ShortTermMemory:
         """Очистить память."""
         self._buffer.clear()
 
-    def load(self, history: List[Dict]) -> None:
+    def load(self, history: list[dict]) -> None:
         """Инициализировать память списком сообщений."""
         self._buffer.clear()
-        for msg in history[-self._buffer.maxlen:]:
+        for msg in history[-self._buffer.maxlen :]:
             self._buffer.append(msg)
 
-    def to_list(self) -> List[Dict]:
+    def to_list(self) -> list[dict]:
         """Выгрузить всю память как список."""
         return list(self._buffer)
 
-    def chunk_for_vector(self, chunk_size: int = 6) -> Optional[List[Dict]]:
+    def chunk_for_vector(self, chunk_size: int = 6) -> list[dict] | None:
         """Сформировать чанк для векторной БД — N последних сообщений по хронологии."""
         if len(self._buffer) < chunk_size:
             return None

openvector_dev-0.1.3/src/lein_vector/__init__.py

@@ -1,11 +0,0 @@
-from . import api, bases, schemas
-from .memory_manager_qdrant import MemoryManagerQdrant
-from .qdrant_adapter        import QdrantAdapter
-from .sentence_transformer  import EmbeddingProviderGemini as EmbeddingProvider
-from .short_term            import ShortTermMemory
-
-__all__ = [
-    "api", "bases", "schemas",
-    "MemoryManagerQdrant",
-    "QdrantAdapter", "EmbeddingProvider", "ShortTermMemory"
-]

openvector_dev-0.1.3/src/lein_vector/api/facade.py

@@ -1,142 +0,0 @@
-from typing import Sequence, Union
-from uuid import uuid4
-from datetime import datetime, UTC
-
-from lein_vector import ShortTermMemory, QdrantAdapter, MemoryManagerQdrant
-from lein_vector.schemas.chunk import Chunk, ChunkPayload
-from lein_vector.sentence_transformer import EmbeddingProviderGemini
-
-class MemoryFacade:
-    def __init__(self, short_term, memory_manager, embedder):
-        self.short = short_term
-        self.long = memory_manager
-        self.embed = embedder
-        self._msg_no: dict[int, int] = {}
-
-    @classmethod
-    async def from_qdrant(
-        cls,
-        host: str,
-        port: int,
-        collection: str,
-        vector_size: int = 768,
-        api_key: str | None = None,
-        short_maxlen: int = 20,
-    ) -> "MemoryFacade":
-        """
-        Создаёт MemoryFacade со всеми зависимостями:
-        - ShortTermMemory(maxlen=short_maxlen)
-        - EmbeddingProviderGemini(api_key)
-        - QdrantAdapter(host, port, collection, vector_size) + init_collection()
-        - MemoryManagerQdrant(adapter, embedder)
-        """
-        # 1. short-term
-        short_mem = ShortTermMemory(maxlen=short_maxlen)
-
-        # 2. эмбеддер
-        embedder = EmbeddingProviderGemini(api_key=api_key)
-
-        # 3. адаптер Qdrant
-        adapter = QdrantAdapter(host, port, collection, vector_size)
-        await adapter.init_collection()
-
-        # 4. менеджер долгой памяти
-        long_mem = MemoryManagerQdrant(adapter, embedder)
-
-        # 5. возвращаем фасад
-        return cls(short_mem, long_mem, embedder)
-
-    async def step_user(self, user_id: int, user_msg: str, topk: int = 3, history_n: int = 20):
-        self.short.add("user", user_msg)
-        embedding = await self.embed.get_embedding(user_msg)
-        long_memories = await self.long.retrieve_by_embedding(user_id, embedding, topk=topk)
-        short_ctx = self.short.window(history_n)
-        return {
-            "short_term": short_ctx,
-            "long_term": long_memories
-        }
-
-    async def step_user_oai(
-        self,
-        user_id: int,
-        user_msg: str,
-        *,
-        topk: int = 3,
-        history_n: int = 20,
-    ) -> dict:
-        """
-        Полный шаг для OpenAI-совместимого вывода:
-        1. Записывает сообщение пользователя в short-term.
-        2. Достаёт релевантные чанки из long-term.
-        3. Возвращает short-term уже в формате OpenAI.
-        """
-        data = await self.step_user(user_id, user_msg, topk=topk, history_n=history_n)
-        data["short_term"] = self._to_openai(data["short_term"])
-        data["long_term"] = self._chunk_texts(data["long_term"])
-        return data
-
-    @staticmethod
-    def _to_openai(msgs: list[dict]) -> list[dict]:
-        role_map = {"gf": "assistant"}          # «gf» → OpenAI «assistant»
-        return [
-            {"role": role_map.get(m["role"], m["role"]), "content": m["text"]}
-            for m in msgs
-        ]
-
-    async def step_gf(
-            self,
-            user_id: int,
-            gf_msg: str,
-            *,
-            block_size: int = 8,
-            save_pair: bool = True,
-    ):
-        # 1) кладём ответ в short-term
-        curr_no = self._msg_no.get(user_id, 0) + 1
-        self._msg_no[user_id] = curr_no
-        self.short.add("gf", gf_msg, extra={"msg_no": curr_no})
-
-        # 2) если блок из 'block_size' сообщений готов → формируем long-term чанк
-        if save_pair and len(self.short.window()) >= block_size:
-            last_block = self.short.window(block_size)  # последние 8 сообщений
-            block_text = "\n".join(m["text"] for m in last_block)
-
-            # считаем embedding один раз
-            vector = await self.embed.get_embedding(block_text)
-
-            new_chunk = Chunk(
-                chunk_id=uuid4(),
-                user_id=user_id,
-                chunk_type="type0",
-                created_at=datetime.now(UTC),
-                last_hit=datetime.now(UTC),
-                hit_count=0,
-                text=block_text,
-                persistent=False,
-                extra={"msg_no": curr_no},
-            )
-            await self.long.upsert_chunk_with_vector(user_id, new_chunk, vector)
-
-            # (необязательно) можешь очистить short-term, если maxlen маленький
-            # self.short.clear_until(block_size)  ← если нужен скользящий сдвиг
-
-        # 3) при необходимости запускаем merge / maintenance
-        if curr_no % 40 == 0:  # каждые 40 сообщений
-            await self.long.merge_old_chunks(user_id, "type0", n=5)
-
-    def get_short_term(self, n=10) -> list:
-        return self.short.window(n)
-
-    async def get_long_term(self, user_id: int, embedding: list[float], topk: int = 3) -> list:
-        return await self.long.retrieve_by_embedding(user_id, embedding, topk)
-
-    def add_to_short(self, role: str, text: str) -> None:
-        self.short.add(role, text)
-
-    async def add_to_long(self, user_id: int, chunk: Chunk) -> None:
-        await self.long.upsert_chunk(user_id, chunk)
-
-    @staticmethod
-    def _chunk_texts(chunks: Sequence[Union[Chunk, ChunkPayload]]) -> list[str]:
-        """Вернуть список текстов из любых Chunk/ChunkPayload."""
-        return [c.text for c in chunks]

openvector_dev-0.1.3/src/lein_vector/bases/embeding_provider_abc.py

@@ -1,11 +0,0 @@
-from typing import List
-from abc import ABC, abstractmethod
-
-class EmbeddingProviderABC(ABC):
-    @abstractmethod
-    async def get_embedding(self, text: str) -> List[float]:
-        ...
-
-    @abstractmethod
-    async def get_embeddings(self, texts: List[str]) -> List[List[float]]:
-        ...

openvector_dev-0.1.3/src/lein_vector/bases/memory_manager_abc.py

@@ -1,33 +0,0 @@
-from typing import List
-from uuid import UUID
-from lein_vector.schemas.chunk import Chunk
-
-
-class MemoryManagerABC:
-    async def upsert_chunk(self, user_id: int, chunk: Chunk) -> None: ...
-    async def upsert_chunks(self, user_id: int, chunks: List[Chunk]) -> None: ...
-    async def retrieve_by_embedding(
-        self, user_id: int, embedding: List[float], topk: int = 3
-    ) -> List[Chunk]: ...
-    async def retrieve_by_embedding_batch(
-        self, user_id: int, embeddings: List[List[float]], topk: int = 3
-    ) -> List[List[Chunk]]:
-        raise NotImplementedError("Not implemented in this backend")
-
-    async def retrieve_by_type(
-        self, user_id: int, chunk_type: str, topk: int = 3
-    ) -> List[Chunk]: ...
-    async def retrieve_by_text(
-        self, user_id: int, query: str, topk: int = 3
-    ) -> List[Chunk]: ...
-    async def merge_old_chunks(self, user_id: int, chunk_type: str) -> None: ...
-    async def archive_user(self, user_id: int) -> None: ...
-    async def restore_user(self, user_id: int) -> None: ...
-    async def increment_hit(self, user_id: int, chunk_id: UUID) -> None: ...
-    async def pop_first_n(
-        self, user_id: int, chunk_type: str, n: int
-    ) -> List[Chunk]: ...
-    async def delete_oldest_nonpersistent(self, user_id: int, keep: int) -> None: ...
-    async def delete_chunk(self, user_id: int, chunk_id: UUID) -> None: ...
-    async def delete_chunks(self, user_id: int, chunk_ids: List[UUID]) -> None: ...
-    async def delete_all(self, user_id: int) -> None: ...

openvector_dev-0.1.3/src/lein_vector/memory_manager_qdrant.py

@@ -1,100 +0,0 @@
-from datetime import datetime, UTC
-from typing import List, Dict, Any
-from uuid import UUID
-
-from lein_vector.bases.memory_manager_abc import MemoryManagerABC
-from lein_vector.schemas.chunk import Chunk, ChunkPayload
-
-class MemoryManagerQdrant(MemoryManagerABC):
-    def __init__(self, qdrant_adapter, embedding_provider, archive_storage=None):
-        self.qdrant = qdrant_adapter
-        self.embed = embedding_provider
-        self.archive = archive_storage  # твой модуль S3/minio (интерфейс: save(user_id, List[ChunkPayload]), load(user_id) -> List[ChunkPayload])
-
-    async def upsert_chunk(self, user_id: int, chunk: Chunk) -> None:
-        embedding = await self.embed.get_embedding(chunk.text)
-        await self.qdrant.upsert(chunk.chunk_id, embedding, chunk.to_payload())
-
-    async def upsert_chunk_with_vector(
-            self,
-            user_id: int,
-            chunk: Chunk,
-            embedding: list[float]
-    ) -> None:
-        await self.qdrant.upsert(chunk.chunk_id, embedding, chunk.to_payload())
-
-    async def upsert_chunks(self, user_id: int, chunks: List[Chunk]) -> None:
-        texts = [c.text for c in chunks]
-        embeddings = await self.embed.get_embeddings(texts)
-        points = [
-            {"point_id": c.chunk_id, "embedding": emb, "payload": c.to_payload()}
-            for c, emb in zip(chunks, embeddings)
-        ]
-        await self.qdrant.upsert_batch(points)
-
-    async def retrieve_by_embedding(self, user_id: int, embedding: List[float], topk: int = 3, filter_: Dict[str, Any] = None) -> List[ChunkPayload]:
-        # Фильтр по user_id + кастомные условия
-        filter_ = filter_ or {}
-        filter_["user_id"] = user_id
-        return await self.qdrant.search(embedding, filter_, topk)
-
-    async def retrieve_by_type(self, user_id: int, chunk_type: str, topk: int = 3) -> List[ChunkPayload]:
-        # Заглушка embedding (пустой вектор не сработает, нужно реальный запрос!):
-        # Лучше использовать scroll по фильтру
-        filter_ = {"user_id": user_id, "chunk_type": chunk_type}
-        return await self.qdrant.get_all_chunks_with_filter(filter_)
-
-    async def merge_old_chunks(self, user_id: int, chunk_type: str, n: int = 5) -> None:
-        # 1. Получить n старых чанков нужного типа
-        chunks = await self.qdrant.get_n_oldest_chunks(user_id, chunk_type, n)
-        if len(chunks) < n:
-            return
-        # 2. Суммаризация (mock или через LLM)
-        merged_text = " | ".join([c.text for c in chunks])
-        from uuid import uuid4
-        from datetime import datetime
-        summary_chunk = Chunk(
-            chunk_id=uuid4(),
-            user_id=user_id,
-            chunk_type=self._next_type(chunk_type),
-            created_at=datetime.now(UTC),
-            last_hit=datetime.now(UTC),
-            hit_count=0,
-            text=merged_text,
-            persistent=False,
-            summary_of=[c.chunk_id for c in chunks],
-        )
-        await self.upsert_chunk(user_id, summary_chunk)
-        # 3. Удалить исходники
-        await self.delete_chunks(user_id, [c.chunk_id for c in chunks])
-
-    async def archive_user(self, user_id: int) -> None:
-        all_chunks = await self.qdrant.get_all_chunks(user_id)
-        await self.archive.save(user_id, all_chunks)
-        await self.delete_all(user_id)
-
-    async def restore_user(self, user_id: int) -> None:
-        chunks = await self.archive.load(user_id)
-        await self.upsert_chunks(
-            user_id,
-            [Chunk(**c.dict(), last_hit=datetime.now(UTC), hit_count=0) for c in chunks]
-        )
-
-    async def delete_chunk(self, user_id: int, chunk_id: UUID) -> None:
-        await self.qdrant.delete(chunk_id)
-
-    async def delete_chunks(self, user_id: int, chunk_ids: List[UUID]) -> None:
-        await self.qdrant.delete_batch(chunk_ids)
-
-    async def delete_all(self, user_id: int) -> None:
-        all_chunks = await self.qdrant.get_all_chunks(user_id)
-        await self.delete_chunks(user_id, [c.chunk_id for c in all_chunks])
-
-    # Доп. методы поиска (по времени, hit_count, last_hit)
-    async def retrieve_filtered(self, user_id: int, filter_: Dict[str, Any], topk: int = 10) -> List[ChunkPayload]:
-        return await self.qdrant.get_all_chunks_with_filter({"user_id": user_id, **filter_}, topk=topk)
-
-    def _next_type(self, chunk_type: str) -> str:
-        # Логика типа next_type
-        mapping = {"type0": "type1", "type1": "type2"}
-        return mapping.get(chunk_type, "summary")