openvector_dev 0.1__tar.gz

openvector_dev-0.1/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.3
+Name: openvector_dev
+Version: 0.1
+Summary: 
+Author: p00ler
+Author-email: liveitspain@gmail.com
+Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+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)
+Description-Content-Type: text/markdown
+
+# Persona-Memory Subsystem
+
+## Назначение:
+Модуль памяти для диалогового ИИ-агента.
+
+Short-term: последние сообщения (RAM, deque).
+
+Long-term: Qdrant + архив (долговременные факты и истории).
+
+## Архитектура:
+ShortTermMemory — хранит последние сообщения.
+
+QdrantAdapter — async-слой для поиска/хранения чанков в Qdrant.
+
+MemoryManagerQdrant — бизнес-логика.
+
+EmbeddingProviderSentenceTransformer / Gemini — эмбеддинги.
+
+MemoryService (фасад) — единая точка для верхнего слоя.
+
+Chunk / ChunkPayload — pydantic-модели для хранения.
+
+## Пример рабочего цикла:
+```
+mem = MemoryService(short_term, memory_manager)
+mem.add_short("user", user_msg)
+emb = await embedder.get_embedding(user_msg)
+long_memories = await mem.get_long(user_id, emb, k=3)
+short_ctx = mem.get_short(10)
+mem.add_short("gf", answer)
+await mem.save_long(user_id, Chunk(
+    chunk_id=uuid4(), user_id=user_id, chunk_type="type0",
+    created_at=datetime.utcnow(), last_hit=datetime.utcnow(),
+    hit_count=0, text=answer, persistent=False
+))
+```
+
+## Установка и тесты:
+```
+poetry add ./vector-memory
+
+docker run -d --name qdrant -p 6333:6333 -v qdrant_data:/qdrant/storage qdrant/qdrant
+  
+pytest
+```
+
+## Конфигурация:
+```
+QDRANT_HOST, QDRANT_PORT
+QDRANT_COLLECTION
+VECTOR_SIZE (совпадает с embedding-моделью)
+GEMINI_API_KEY (Gemini Embedding-004)
+```
+
+## Перед релизом:
+- Все тесты проходят (pytest)
+- Размеры векторов и коллекции совпадают
+- Архивирование/restore, merge, фильтры работают
+- Нет deprecated-методов в adapter
+
+## Roadmap:
+- Redis-кеш для hit_count
+- Курсорный scroll для больших архивов
+- gRPC/gateway-адаптер
+
+## Test-Coverage
+```
+Name                              Stmts   Miss  Cover
+-----------------------------------------------------
+src\bases\memory_manager_abc.py      20      1    95%
+src\memory_manager_qdrant.py         54     11    80%
+src\memory_manager_ram.py            95     32    66%
+src\qdrant_adapter.py                46      8    83%
+src\schemas\chunk.py                 31      1    97%
+src\short_term.py                    26      1    96%
+-----------------------------------------------------
+TOTAL                               272     54    80%
+```
+
+

openvector_dev-0.1/README.md

@@ -0,0 +1,79 @@
+# Persona-Memory Subsystem
+
+## Назначение:
+Модуль памяти для диалогового ИИ-агента.
+
+Short-term: последние сообщения (RAM, deque).
+
+Long-term: Qdrant + архив (долговременные факты и истории).
+
+## Архитектура:
+ShortTermMemory — хранит последние сообщения.
+
+QdrantAdapter — async-слой для поиска/хранения чанков в Qdrant.
+
+MemoryManagerQdrant — бизнес-логика.
+
+EmbeddingProviderSentenceTransformer / Gemini — эмбеддинги.
+
+MemoryService (фасад) — единая точка для верхнего слоя.
+
+Chunk / ChunkPayload — pydantic-модели для хранения.
+
+## Пример рабочего цикла:
+```
+mem = MemoryService(short_term, memory_manager)
+mem.add_short("user", user_msg)
+emb = await embedder.get_embedding(user_msg)
+long_memories = await mem.get_long(user_id, emb, k=3)
+short_ctx = mem.get_short(10)
+mem.add_short("gf", answer)
+await mem.save_long(user_id, Chunk(
+    chunk_id=uuid4(), user_id=user_id, chunk_type="type0",
+    created_at=datetime.utcnow(), last_hit=datetime.utcnow(),
+    hit_count=0, text=answer, persistent=False
+))
+```
+
+## Установка и тесты:
+```
+poetry add ./vector-memory
+
+docker run -d --name qdrant -p 6333:6333 -v qdrant_data:/qdrant/storage qdrant/qdrant
+  
+pytest
+```
+
+## Конфигурация:
+```
+QDRANT_HOST, QDRANT_PORT
+QDRANT_COLLECTION
+VECTOR_SIZE (совпадает с embedding-моделью)
+GEMINI_API_KEY (Gemini Embedding-004)
+```
+
+## Перед релизом:
+- Все тесты проходят (pytest)
+- Размеры векторов и коллекции совпадают
+- Архивирование/restore, merge, фильтры работают
+- Нет deprecated-методов в adapter
+
+## Roadmap:
+- Redis-кеш для hit_count
+- Курсорный scroll для больших архивов
+- gRPC/gateway-адаптер
+
+## Test-Coverage
+```
+Name                              Stmts   Miss  Cover
+-----------------------------------------------------
+src\bases\memory_manager_abc.py      20      1    95%
+src\memory_manager_qdrant.py         54     11    80%
+src\memory_manager_ram.py            95     32    66%
+src\qdrant_adapter.py                46      8    83%
+src\schemas\chunk.py                 31      1    97%
+src\short_term.py                    26      1    96%
+-----------------------------------------------------
+TOTAL                               272     54    80%
+```
+

openvector_dev-0.1/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "openvector_dev"
+version = "0.1"
+description = ""
+authors = [
+    {name = "p00ler",email = "liveitspain@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.11"
+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)",
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.4.1"
+pytest-asyncio = "^1.0.0"
+pytest-cov = "^6.2.1"
+
+[tool.poetry]
+packages = [
+  { include = "lein_vector", from = "src" }
+]

openvector_dev-0.1/src/lein_vector/__init__.py

@@ -0,0 +1,11 @@
+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/src/lein_vector/api/__init__.py

@@ -0,0 +1 @@
+from facade import MemoryFacade as Memory

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

@@ -0,0 +1,136 @@
+from uuid import uuid4
+from datetime import datetime, UTC
+
+from src.lein_vector import ShortTermMemory, QdrantAdapter, MemoryManagerQdrant
+from src.lein_vector.schemas.chunk import Chunk
+from src.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"])
+        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)

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

@@ -0,0 +1,11 @@
+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/src/lein_vector/bases/memory_manager_abc.py

@@ -0,0 +1,33 @@
+from typing import List
+from uuid import UUID
+from src.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/src/lein_vector/memory_manager_qdrant.py

@@ -0,0 +1,100 @@
+from datetime import datetime, UTC
+from typing import List, Dict, Any
+from uuid import UUID
+
+from src.lein_vector.bases.memory_manager_abc import MemoryManagerABC
+from src.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")

openvector_dev-0.1/src/lein_vector/memory_manager_ram.py

@@ -0,0 +1,141 @@
+from typing import List
+from uuid import UUID
+from src.lein_vector.schemas.chunk import Chunk
+from src.lein_vector.bases.memory_manager_abc import MemoryManagerABC
+from uuid import uuid4
+from datetime import datetime, timezone
+
+class MemoryManagerRAM(MemoryManagerABC):
+    def __init__(self):
+        self._data: dict[int, dict[UUID, Chunk]] = {}
+        self._archive: dict[int, dict[UUID, Chunk]] = {}
+
+    async def upsert_chunk(self, user_id: int, chunk: Chunk) -> None:
+        if user_id not in self._data:
+            self._data[user_id] = {}
+        self._data[user_id][chunk.chunk_id] = chunk
+
+    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]:
+        user_chunks = self._data.get(user_id, {})
+        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]]:
+        raise NotImplementedError("Not implemented in RAM backend")
+
+    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]:
+        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)
+        return filtered[:topk]
+
+    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)
+        if not next_type:
+            return
+
+        candidates = [c for c in user_chunks.values() if c.chunk_type == chunk_type]
+        if len(candidates) < n:
+            return
+
+        candidates.sort(key=lambda c: c.created_at)
+        selected = candidates[:n]
+
+        merged_text = " | ".join([c.text for c in selected])  # mock summary
+
+        new_chunk = Chunk(
+            chunk_id=uuid4(),
+            user_id=user_id,
+            chunk_type=next_type,
+            created_at=datetime.now(timezone.utc),
+            last_hit=datetime.now(timezone.utc),
+            hit_count=0,
+            text=merged_text,
+            persistent=False,
+            summary_of=[c.chunk_id for c in selected],
+        )
+        for c in selected:
+            del user_chunks[c.chunk_id]
+        user_chunks[new_chunk.chunk_id] = new_chunk
+
+    async def archive_user(self, user_id: int) -> None:
+        if user_id in self._data:
+            self._archive[user_id] = self._data[user_id]
+            del self._data[user_id]
+
+    async def restore_user(self, user_id: int) -> None:
+        if user_id in self._archive:
+            self._data[user_id] = self._archive[user_id]
+            del self._archive[user_id]
+
+    async def increment_hit(self, user_id: int, chunk_id: UUID) -> None:
+        user_chunks = self._data.get(user_id, {})
+        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)
+
+    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 (старые — первые)
+        filtered.sort(key=lambda c: c.created_at)
+        # выбираем первые n
+        selected = filtered[:n]
+        # удаляем их из данных
+        for chunk in selected:
+            del self._data[user_id][chunk.chunk_id]
+        return selected
+
+    async def delete_oldest_nonpersistent(self, user_id: int, keep: int) -> None:
+        user_chunks = self._data.get(user_id, {})
+        nonpersistent = [c for c in user_chunks.values() if not c.persistent]
+        # сортировка по created_at (старые — первые)
+        nonpersistent.sort(key=lambda c: c.created_at)
+        # если их больше чем keep — удаляем лишние
+        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:
+        user_chunks = self._data.get(user_id, {})
+        for chunk_id in chunk_ids:
+            user_chunks.pop(chunk_id, None)
+
+    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]:
+        """Для тестов — все чанки пользователя."""
+        return list(self._data.get(user_id, {}).values())
+
+    def get_all_archive(self, user_id: int) -> List[Chunk]:
+        """Для тестов — все чанки в архиве."""
+        return list(self._archive.get(user_id, {}).values())
+
+    def clear(self):
+        """Очистка всех данных для тестов."""
+        self._data.clear()
+        self._archive.clear()

openvector_dev-0.1/src/lein_vector/qdrant_adapter.py

@@ -0,0 +1,98 @@
+from qdrant_client import AsyncQdrantClient
+from qdrant_client.http.models import MatchText
+from qdrant_client.models import (
+    PointStruct, Filter, FieldCondition, MatchValue, Range,
+    VectorParams, Distance
+)
+from src.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):
+        self.collection = collection
+        self.client = AsyncQdrantClient(host=host, port=port)
+        self.vector_size = vector_size
+
+    async def init_collection(self):
+        exists = await self.client.collection_exists(self.collection)
+        if not exists:
+            await self.client.create_collection(
+                collection_name=self.collection,
+                vectors_config=VectorParams(size=self.vector_size, distance=Distance.COSINE)
+            )
+
+    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()
+                )
+            ]
+        )
+
+    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()
+            )
+            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]:
+        # Пример фильтра {"user_id": 123, "chunk_type": "type1", "created_at_gt": "2024-01-01T00:00:00"}
+        conditions = []
+        for k, v in filter_.items():
+            if k.endswith("_gt"):
+                field = k[:-3]
+                conditions.append(FieldCondition(key=field, range=Range(gt=v)))
+            elif k.endswith("_lt"):
+                field = k[:-3]
+                conditions.append(FieldCondition(key=field, range=Range(lt=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)))
+        q_filter = Filter(must=conditions)
+        result = await self.client.query_points(
+            collection_name=self.collection,
+            query=embedding,
+            query_filter=q_filter,
+            limit=topk,
+        )
+        points = result.points
+        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)]
+        )
+
+    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]
+        )
+
+    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]:
+        q_filter = Filter(
+            must=[FieldCondition(key="user_id", match=MatchValue(value=user_id))]
+        )
+        scroll = await self.client.scroll(
+            collection_name=self.collection,
+            scroll_filter=q_filter,
+            limit=2048,
+        )
+        return [ChunkPayload(**p.payload) for p in scroll[0]]

openvector_dev-0.1/src/lein_vector/schemas/chunk.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict
+from datetime import datetime, UTC
+from uuid import UUID
+
+class Chunk(BaseModel):
+    chunk_id: UUID
+    user_id: int
+    chunk_type: str  # "type0" | "type1" | "fact"
+    created_at: datetime
+    last_hit: datetime
+    hit_count: int = 0
+    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)
+
+    def to_payload(self) -> ChunkPayload:
+        return ChunkPayload(**self.model_dump())
+
+
+class ChunkPayload(BaseModel):
+    chunk_id: UUID
+    user_id: int
+    chunk_type: str
+    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)
+
+    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)
+

openvector_dev-0.1/src/lein_vector/sentence_transformer.py

@@ -0,0 +1,68 @@
+import asyncio
+
+from google import genai
+from google.genai import types
+
+from src.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"):
+
+        self.client = genai.Client(api_key=api_key)
+        self.model = model_name
+
+    def _genai_embed(self, text: str | list) -> types.EmbedContentResponse:
+        return self.client.models.embed_content(
+            model=self.model,
+            contents=text,
+            config=types.EmbedContentConfig(task_type="SEMANTIC_SIMILARITY"),
+        )
+
+    async def get_embedding(self, text: str) -> list[float]:
+        # В Gemini SDK обычно нет async, значит — обёртка через run_in_executor:
+        import asyncio
+
+        loop = asyncio.get_running_loop()
+        # SDK call внутри executor
+        embedding = await loop.run_in_executor(None, lambda: self._genai_embed(text))
+        # Ответ — dict с 'embedding' или 'values'
+        return embedding.embeddings[0].values
+
+    async def get_embeddings(self, texts: list[str]) -> list[list[float]]:
+        import asyncio
+
+        loop = asyncio.get_running_loop()
+        result = await loop.run_in_executor(None, lambda: self._genai_embed(texts))
+        # Вернуть список эмбеддингов
+        return [e.values for e in result.embeddings]
+
+
+async def main():
+    embeding = EmbeddingProviderGemini(
+        api_key="AIzaSyDK_pkj25Cbb0iUujYm6N4K1k7xzeD_kss"
+    )
+    print(str(await embeding.get_embedding("test"))[:50] + "... TRIMMED]\n")
+    res = await embeding.get_embeddings(["test", "test2"])
+    print(len(res))
+    for e in res:
+        print(str(e)[:50] + "... TRIMMED]")
+
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

openvector_dev-0.1/src/lein_vector/short_term.py

@@ -0,0 +1,44 @@
+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:
+        """Добавить сообщение в память (роль, текст, ts - время, по умолчанию now)."""
+        if ts is None:
+            ts = datetime.now()
+        self._buffer.append({
+            "role": role,
+            "text": text,
+            "ts": ts
+        })
+
+    def window(self, n: Optional[int] = None) -> List[Dict]:
+        """Получить последние n сообщений (по умолчанию все)."""
+        if n is None or n > len(self._buffer):
+            return list(self._buffer)
+        return list(self._buffer)[-n:]
+
+    def clear(self) -> None:
+        """Очистить память."""
+        self._buffer.clear()
+
+    def load(self, history: List[Dict]) -> None:
+        """Инициализировать память списком сообщений."""
+        self._buffer.clear()
+        for msg in history[-self._buffer.maxlen:]:
+            self._buffer.append(msg)
+
+    def to_list(self) -> List[Dict]:
+        """Выгрузить всю память как список."""
+        return list(self._buffer)
+
+    def chunk_for_vector(self, chunk_size: int = 6) -> Optional[List[Dict]]:
+        """Сформировать чанк для векторной БД — N последних сообщений по хронологии."""
+        if len(self._buffer) < chunk_size:
+            return None
+        # Забираем chunk_size старейших, но не очищаем (внешний код решает)
+        return list(self._buffer)[-chunk_size:]