tribalmemory 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

tribalmemory/services/session_store.py

@@ -0,0 +1,412 @@
+"""Session transcript indexing service.
+
+Indexes conversation transcripts as chunked embeddings for contextual recall.
+Supports delta-based ingestion and retention-based cleanup.
+"""
+
+import logging
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from ..interfaces import IEmbeddingService, IVectorStore
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SessionMessage:
+    """A single message in a conversation transcript.
+    
+    Attributes:
+        role: Message role (user, assistant, system)
+        content: Message content
+        timestamp: When the message was sent
+    """
+    role: str
+    content: str
+    timestamp: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+@dataclass
+class SessionChunk:
+    """A chunk of conversation transcript with embedding.
+    
+    Attributes:
+        chunk_id: Unique identifier for this chunk
+        session_id: ID of the session this chunk belongs to
+        instance_id: Which agent instance processed this session
+        content: The actual conversation content (multiple messages)
+        embedding: Vector embedding of the content
+        start_time: Timestamp of first message in chunk
+        end_time: Timestamp of last message in chunk
+        chunk_index: Sequential index within session (0, 1, 2...)
+    """
+    chunk_id: str
+    session_id: str
+    instance_id: str
+    content: str
+    embedding: list[float]
+    start_time: datetime
+    end_time: datetime
+    chunk_index: int
+
+
+class SessionStore:
+    """Service for indexing and searching session transcripts.
+    
+    Usage:
+        store = SessionStore(
+            instance_id="clawdio-1",
+            embedding_service=embedding_service,
+            vector_store=vector_store,
+        )
+        
+        # Ingest a session transcript
+        messages = [
+            SessionMessage("user", "What is Docker?", datetime.now(timezone.utc)),
+            SessionMessage("assistant", "Docker is a container platform", datetime.now(timezone.utc)),
+        ]
+        await store.ingest("session-123", messages)
+        
+        # Search across all sessions
+        results = await store.search("Docker setup error")
+        
+        # Search within specific session
+        results = await store.search("Docker", session_id="session-123")
+    """
+    
+    # Chunking parameters
+    TARGET_CHUNK_TOKENS = 400  # Target size for each chunk
+    WORDS_PER_TOKEN = 0.75     # Approximate tokens per word
+    OVERLAP_TOKENS = 50        # Overlap between chunks for context
+    
+    def __init__(
+        self,
+        instance_id: str,
+        embedding_service: IEmbeddingService,
+        vector_store: IVectorStore,
+    ):
+        self.instance_id = instance_id
+        self.embedding_service = embedding_service
+        self.vector_store = vector_store
+        
+        # Track last ingested index per session for delta ingestion
+        self._session_state: dict[str, int] = {}
+    
+    async def ingest(
+        self,
+        session_id: str,
+        messages: list[SessionMessage],
+        instance_id: Optional[str] = None,
+    ) -> dict:
+        """Ingest session messages with delta-based processing.
+        
+        Only processes new messages since last ingestion for this session.
+        
+        Args:
+            session_id: Unique identifier for the session
+            messages: List of conversation messages
+            instance_id: Override instance ID (defaults to self.instance_id)
+        
+        Returns:
+            Dict with keys: success, chunks_created, messages_processed
+        """
+        if not messages:
+            return {
+                "success": True,
+                "chunks_created": 0,
+                "messages_processed": 0,
+            }
+        
+        # Delta ingestion: only process new messages
+        last_index = self._session_state.get(session_id, 0)
+        new_messages = messages[last_index:]
+        
+        if not new_messages:
+            return {
+                "success": True,
+                "chunks_created": 0,
+                "messages_processed": 0,
+            }
+        
+        try:
+            # Create chunks from new messages
+            chunks = await self._chunk_messages(
+                new_messages,
+                session_id,
+                instance_id or self.instance_id,
+            )
+            
+            # Store chunks in vector store
+            for chunk in chunks:
+                await self._store_chunk(chunk)
+            
+            # Update state
+            self._session_state[session_id] = len(messages)
+            
+            return {
+                "success": True,
+                "chunks_created": len(chunks),
+                "messages_processed": len(new_messages),
+            }
+        
+        except Exception as e:
+            logger.exception(f"Failed to ingest session {session_id}: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+            }
+    
+    async def search(
+        self,
+        query: str,
+        session_id: Optional[str] = None,
+        limit: int = 5,
+        min_relevance: float = 0.0,
+    ) -> list[dict]:
+        """Search session transcripts by semantic similarity.
+        
+        Args:
+            query: Natural language search query
+            session_id: Optional filter to specific session
+            limit: Maximum number of results to return
+            min_relevance: Minimum similarity score (0.0 to 1.0)
+        
+        Returns:
+            List of dicts with keys: chunk_id, session_id, instance_id,
+            content, similarity_score, start_time, end_time, chunk_index
+        """
+        try:
+            # Generate query embedding
+            query_embedding = await self.embedding_service.embed(query)
+            
+            # Search chunks
+            results = await self._search_chunks(
+                query_embedding,
+                session_id,
+                limit,
+                min_relevance,
+            )
+            
+            return results
+        
+        except Exception as e:
+            logger.exception(f"Failed to search sessions: {e}")
+            return []
+    
+    async def cleanup(self, retention_days: int = 30) -> int:
+        """Delete session chunks older than retention period.
+        
+        Args:
+            retention_days: Number of days to retain chunks
+        
+        Returns:
+            Number of chunks deleted
+        """
+        try:
+            cutoff_time = datetime.now(timezone.utc) - timedelta(days=retention_days)
+            
+            # Find and delete expired chunks
+            deleted = await self._delete_chunks_before(cutoff_time)
+            
+            return deleted
+        
+        except Exception as e:
+            logger.exception(f"Failed to cleanup sessions: {e}")
+            return 0
+    
+    async def get_stats(self) -> dict:
+        """Get statistics about indexed sessions.
+        
+        Returns:
+            Dict with keys: total_chunks, total_sessions,
+            earliest_chunk, latest_chunk
+        """
+        try:
+            chunks = await self._get_all_chunks()
+            
+            if not chunks:
+                return {
+                    "total_chunks": 0,
+                    "total_sessions": 0,
+                    "earliest_chunk": None,
+                    "latest_chunk": None,
+                }
+            
+            session_ids = set()
+            timestamps = []
+            
+            for chunk in chunks:
+                session_ids.add(chunk["session_id"])
+                timestamps.append(chunk["start_time"])
+            
+            return {
+                "total_chunks": len(chunks),
+                "total_sessions": len(session_ids),
+                "earliest_chunk": min(timestamps) if timestamps else None,
+                "latest_chunk": max(timestamps) if timestamps else None,
+            }
+        
+        except Exception as e:
+            logger.exception(f"Failed to get stats: {e}")
+            return {
+                "total_chunks": 0,
+                "total_sessions": 0,
+                "earliest_chunk": None,
+                "latest_chunk": None,
+            }
+    
+    async def _chunk_messages(
+        self,
+        messages: list[SessionMessage],
+        session_id: str,
+        instance_id: str,
+    ) -> list[SessionChunk]:
+        """Chunk messages into ~400 token windows with overlap.
+        
+        Uses a simple word-count approximation: words / 0.75 ≈ tokens.
+        """
+        chunks = []
+        chunk_index = 0
+        
+        # Convert messages to text with timestamps
+        message_texts = []
+        for msg in messages:
+            text = f"{msg.role}: {msg.content}"
+            message_texts.append((text, msg.timestamp))
+        
+        # Estimate tokens
+        target_words = int(self.TARGET_CHUNK_TOKENS * self.WORDS_PER_TOKEN)
+        overlap_words = int(self.OVERLAP_TOKENS * self.WORDS_PER_TOKEN)
+        
+        i = 0
+        while i < len(message_texts):
+            chunk_messages = []
+            chunk_word_count = 0
+            start_time = message_texts[i][1]
+            end_time = start_time
+            
+            # Collect messages until we reach target size
+            while i < len(message_texts) and chunk_word_count < target_words:
+                text, timestamp = message_texts[i]
+                words = len(text.split())
+                chunk_messages.append(text)
+                chunk_word_count += words
+                end_time = timestamp
+                i += 1
+            
+            # Create chunk
+            if chunk_messages:
+                content = "\n".join(chunk_messages)
+                embedding = await self.embedding_service.embed(content)
+                
+                chunk = SessionChunk(
+                    chunk_id=str(uuid.uuid4()),
+                    session_id=session_id,
+                    instance_id=instance_id,
+                    content=content,
+                    embedding=embedding,
+                    start_time=start_time,
+                    end_time=end_time,
+                    chunk_index=chunk_index,
+                )
+                chunks.append(chunk)
+                chunk_index += 1
+            
+            # Backtrack for overlap
+            if i < len(message_texts):
+                # Calculate how many messages to backtrack
+                overlap_word_target = 0
+                backtrack = 0
+                while (backtrack < len(chunk_messages) and 
+                       overlap_word_target < overlap_words):
+                    backtrack += 1
+                    overlap_word_target += len(chunk_messages[-backtrack].split())
+                
+                i -= min(backtrack, 2)  # Backtrack at most 2 messages
+                i = max(i, 0)
+        
+        return chunks
+    
+    async def _store_chunk(self, chunk: SessionChunk) -> None:
+        """Store a session chunk in memory.
+        
+        Note: Currently uses in-memory list storage. This is intentional for v0.2.0
+        to keep the initial implementation simple and testable. Data does not persist
+        across restarts. A future version will integrate with LanceDB for persistent
+        storage in a separate 'session_chunks' table. See issue #38 follow-up.
+        """
+        if not hasattr(self, '_chunks'):
+            self._chunks = []
+        
+        self._chunks.append({
+            "chunk_id": chunk.chunk_id,
+            "session_id": chunk.session_id,
+            "instance_id": chunk.instance_id,
+            "content": chunk.content,
+            "embedding": chunk.embedding,
+            "start_time": chunk.start_time,
+            "end_time": chunk.end_time,
+            "chunk_index": chunk.chunk_index,
+        })
+    
+    async def _search_chunks(
+        self,
+        query_embedding: list[float],
+        session_id: Optional[str],
+        limit: int,
+        min_relevance: float,
+    ) -> list[dict]:
+        """Search for chunks by similarity."""
+        if not hasattr(self, '_chunks'):
+            return []
+        
+        # Calculate similarities
+        results = []
+        for chunk in self._chunks:
+            # Filter by session_id if provided
+            if session_id and chunk["session_id"] != session_id:
+                continue
+            
+            similarity = self.embedding_service.similarity(
+                query_embedding,
+                chunk["embedding"],
+            )
+            
+            if similarity >= min_relevance:
+                results.append({
+                    "chunk_id": chunk["chunk_id"],
+                    "session_id": chunk["session_id"],
+                    "instance_id": chunk["instance_id"],
+                    "content": chunk["content"],
+                    "similarity_score": similarity,
+                    "start_time": chunk["start_time"],
+                    "end_time": chunk["end_time"],
+                    "chunk_index": chunk["chunk_index"],
+                })
+        
+        # Sort by similarity
+        results.sort(key=lambda x: x["similarity_score"], reverse=True)
+        
+        return results[:limit]
+    
+    async def _delete_chunks_before(self, cutoff_time: datetime) -> int:
+        """Delete chunks older than cutoff time."""
+        if not hasattr(self, '_chunks'):
+            return 0
+        
+        initial_count = len(self._chunks)
+        self._chunks = [
+            chunk for chunk in self._chunks
+            if chunk["end_time"] >= cutoff_time
+        ]
+        
+        return initial_count - len(self._chunks)
+    
+    async def _get_all_chunks(self) -> list[dict]:
+        """Get all stored chunks."""
+        if not hasattr(self, '_chunks'):
+            return []
+        return self._chunks

tribalmemory/services/vector_store.py

@@ -252,7 +252,63 @@ class LanceDBVectorStore(IVectorStore):
     async def count(self, filters: Optional[dict] = None) -> int:
         entries = await self.list(limit=100000, filters=filters)
         return len(entries)
-    
+
+    async def get_stats(self) -> dict:
+        """Compute stats natively over LanceDB rows.
+
+        Iterates rows in pages to avoid loading all embeddings into
+        RAM. Only the metadata columns are read.
+        """
+        await self._ensure_initialized()
+
+        by_source: dict[str, int] = {}
+        by_instance: dict[str, int] = {}
+        by_tag: dict[str, int] = {}
+        total = 0
+        corrections = 0
+
+        page_size = 1000
+        offset = 0
+        while True:
+            rows = (
+                self._table.search()
+                .where("deleted = false")
+                .select(["source_type", "source_instance", "tags",
+                         "supersedes"])
+                .limit(page_size + offset)
+                .to_list()
+            )
+            page = rows[offset:]
+            if not page:
+                break
+
+            for row in page:
+                total += 1
+                src = row.get("source_type", "unknown")
+                by_source[src] = by_source.get(src, 0) + 1
+
+                inst = row.get("source_instance", "unknown")
+                by_instance[inst] = by_instance.get(inst, 0) + 1
+
+                tags = json.loads(row.get("tags", "[]"))
+                for tag in tags:
+                    by_tag[tag] = by_tag.get(tag, 0) + 1
+
+                if row.get("supersedes"):
+                    corrections += 1
+
+            if len(page) < page_size:
+                break
+            offset += page_size
+
+        return {
+            "total_memories": total,
+            "by_source_type": by_source,
+            "by_tag": by_tag,
+            "by_instance": by_instance,
+            "corrections": corrections,
+        }
+
     def _row_to_entry(self, row: dict) -> MemoryEntry:
         return MemoryEntry(
             id=row["id"],
@@ -358,3 +414,32 @@ class InMemoryVectorStore(IVectorStore):
     async def count(self, filters: Optional[dict] = None) -> int:
         entries = await self.list(limit=100000, filters=filters)
         return len(entries)
+
+    async def get_stats(self) -> dict:
+        """Compute stats in a single pass over in-memory entries."""
+        by_source: dict[str, int] = {}
+        by_instance: dict[str, int] = {}
+        by_tag: dict[str, int] = {}
+        total = 0
+        corrections = 0
+
+        for entry in self._store.values():
+            if entry.id in self._deleted:
+                continue
+            total += 1
+            src = entry.source_type.value
+            by_source[src] = by_source.get(src, 0) + 1
+            inst = entry.source_instance
+            by_instance[inst] = by_instance.get(inst, 0) + 1
+            for tag in entry.tags:
+                by_tag[tag] = by_tag.get(tag, 0) + 1
+            if entry.supersedes:
+                corrections += 1
+
+        return {
+            "total_memories": total,
+            "by_source_type": by_source,
+            "by_tag": by_tag,
+            "by_instance": by_instance,
+            "corrections": corrections,
+        }

{tribalmemory-0.1.0.dist-info → tribalmemory-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tribalmemory
-Version: 0.1.0
+Version: 0.2.0
 Summary: Shared memory infrastructure for multi-instance AI agents
 Author-email: Joe <joe@example.com>
 License: Apache-2.0
@@ -48,12 +48,48 @@ Dynamic: license-file
 
 One memory store, many agents. Teach Claude Code something — Codex already knows it. That's not just persistence — it's **cross-agent intelligence**.
 
+<p align="center">
+  <img src="docs/assets/one-brain-two-agents.gif" alt="One Brain, Two Agents — Claude Code stores memories, Codex recalls them" width="700">
+  <br>
+  <em>Claude Code stores architecture decisions → Codex recalls them instantly</em>
+</p>
+
+[![asciinema demo](https://img.shields.io/badge/demo-asciinema-d40000)](https://asciinema.org/a/ZM74iIXzM07SV21P)
+[![PyPI](https://img.shields.io/pypi/v/tribalmemory)](https://pypi.org/project/tribalmemory/)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue)](LICENSE)
+
 ## Why
 
 Every AI coding assistant starts fresh. Claude Code doesn't know what you told Codex. Codex doesn't know what you told Claude. You repeat yourself constantly.
 
 Tribal Memory is a shared memory server that any AI agent can connect to. Store a memory from one agent, recall it from another. It just works.
 
+## Install
+
+**macOS:**
+```bash
+# Install uv (https://docs.astral.sh/uv/)
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Restart your terminal, or run:
+source ~/.zshrc
+
+# Install tribalmemory
+uv tool install tribalmemory
+```
+
+> **Why uv?** macOS blocks `pip install` into the system Python with "externally-managed-environment" errors. `uv tool install` handles isolated environments automatically.
+
+**Linux:**
+```bash
+pip install tribalmemory
+
+# Or with uv:
+# curl -LsSf https://astral.sh/uv/install.sh | sh
+# source ~/.bashrc
+# uv tool install tribalmemory
+```
+
 ## Quick Start
 
 ### Option A: Local Mode (Zero Cloud, Zero Cost)
@@ -61,8 +97,6 @@ Tribal Memory is a shared memory server that any AI agent can connect to. Store
 No API keys. No cloud. Everything runs on your machine.
 
 ```bash
-pip install tribalmemory
-
 # Set up with local Ollama embeddings
 tribalmemory init --local
 
@@ -76,8 +110,6 @@ tribalmemory serve
 ### Option B: OpenAI Embeddings
 
 ```bash
-pip install tribalmemory
-
 # Set up with OpenAI
 export OPENAI_API_KEY=sk-...
 tribalmemory init
@@ -224,19 +256,40 @@ await service.correct(
 )
 ```
 
+## Demo
+
+See cross-agent memory sharing in action:
+
+```bash
+# Start the server
+tribalmemory serve
+
+# Run the interactive demo
+./demo.sh
+```
+
+See [docs/demo-output.md](docs/demo-output.md) for example output.
+
 ## HTTP API
 
+All endpoints are under the `/v1` prefix.
+
 ```bash
 # Store a memory
-curl -X POST http://localhost:18790/memories \
+curl -X POST http://localhost:18790/v1/remember \
   -H "Content-Type: application/json" \
   -d '{"content": "The database uses Postgres 16", "tags": ["infra"]}'
 
 # Search memories
-curl "http://localhost:18790/memories/search?query=what+database&limit=5"
+curl -X POST http://localhost:18790/v1/recall \
+  -H "Content-Type: application/json" \
+  -d '{"query": "what database", "limit": 5}'
 
 # Get stats
-curl http://localhost:18790/stats
+curl http://localhost:18790/v1/stats
+
+# Health check
+curl http://localhost:18790/v1/health
 ```
 
 ## OpenClaw Integration

{tribalmemory-0.1.0.dist-info → tribalmemory-0.2.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 tribalmemory/__init__.py,sha256=DNgC_ZT0lrhxsPdhXu4oeG_UdrLstYQHeKwR-U2toeY,104
-tribalmemory/cli.py,sha256=QYpHt0E-hRWK35YttlJks-xuV6kDfc6O4FrxChvZaxU,9043
-tribalmemory/interfaces.py,sha256=W2BNYyYlY-RHTbnJn8-u1wbhfcUK5egzjUzrGexxyB0,9966
+tribalmemory/cli.py,sha256=wbVsgMst4NEuWkwA2dily_qC8AP6jvAHKwHgE3B-TG8,15960
+tribalmemory/interfaces.py,sha256=d3uFTBG9mDtB69cVSMipE5Qi3JDGZGUAYmhhAagT3rM,11430
 tribalmemory/utils.py,sha256=aei7xR6OVMGkllPySA2boeHyI3D1JsHTUX1YeaZdkMY,696
 tribalmemory/a21/__init__.py,sha256=u1793uKzbWGKwiAVmCxEO9_3rdTL7QKTLhQQB8Umsl4,1181
 tribalmemory/a21/system.py,sha256=gGFVWBTckSTFv8ZciEUc05HYjwxZP22UpIqbxXD6giM,9185
@@ -19,7 +19,7 @@ tribalmemory/a21/providers/openai.py,sha256=MxFJXph8rVFAqkVMCS3vxdqwBB8_MhoqqGg6
 tribalmemory/a21/providers/timestamp.py,sha256=T1sJkaQSixRip2C0AUPnljWP0u5w4iHoIcVRmG8FgPo,2994
 tribalmemory/mcp/__init__.py,sha256=r7CzTwzAnSgox8_cBNZgtXDjMGxC7o8polptSvB-AvY,262
 tribalmemory/mcp/__main__.py,sha256=GX6mNmM_Lpq4EyuTr__awVTf1btCi7TpEkNtMTkgas0,115
-tribalmemory/mcp/server.py,sha256=otmDaFe2sXlHNyPorLgUIvkaM6F01EQ-1OdiyhqGDoU,15458
+tribalmemory/mcp/server.py,sha256=4YyY0Wl0RZRKFNkxc2kaFbkt4HWcVP6eryrABKfFKZQ,21029
 tribalmemory/performance/__init__.py,sha256=truSiOqk2WuzatOrzVQICwF8pxLxMlCD8R9O-uqiX3I,55
 tribalmemory/performance/benchmarks.py,sha256=2MVfML04Y-05YpmHCsU-SLtS05-H38oJ7a6DCk2qGIc,8985
 tribalmemory/performance/corpus_generator.py,sha256=ovln1d-7JGd5fJbdSRsdxlA0uaqLCVM3Lo_1SDGRkA0,5894
@@ -27,25 +27,28 @@ tribalmemory/portability/__init__.py,sha256=_USwXZyUKn9idsItv94AAzxKv1wqURYf68Iz
 tribalmemory/portability/embedding_metadata.py,sha256=uT_f9jc_vpemY2WxK_UhP3kOAWgZLMRShKKxh3OzzPM,10478
 tribalmemory/server/__init__.py,sha256=2YYwVr1IEr93MVa_7BKCX43bC82-ySnAfwypUw_nQJQ,238
 tribalmemory/server/__main__.py,sha256=Uk2_8MH-aQ65QWDg_XMe5i-hdaQB-yJApLT8YUaIdEs,116
-tribalmemory/server/app.py,sha256=P4QrOaw35t8NQvrJjYCXMEEFMuH2MrIibCyB2uwpvVU,4836
-tribalmemory/server/config.py,sha256=4BCRUjTnkVCEGPNUK5UiOFXyO91BxwxXsCuEG0lnVh4,3552
-tribalmemory/server/models.py,sha256=bY6IBn6_AW7PnGunQGa0W7LgKym0-KW05lGMztLbhY0,5652
-tribalmemory/server/routes.py,sha256=8-Ie0Ib7t_tUT_kZvsb1QUuNQZ2Dd6rOTlI0d2CoiAk,11403
+tribalmemory/server/app.py,sha256=Ku2UOJ2cnh-RIhtLBaKuZvOx8tjNVbOplhn1U2ePbBM,6796
+tribalmemory/server/config.py,sha256=UHiUIdonPdnsjdZh1vE0C6aOVbP4gS5Bxh7YGJgHh2U,5484
+tribalmemory/server/models.py,sha256=-Y8l5uJ7ij_oiwNtAnLRbmXE9oQlwcBsrCRgnYp14N0,7719
+tribalmemory/server/routes.py,sha256=O2qYpiFYFXY5akTAYcHYmv6AZNqyz3NwnxGPx7GPHFw,13842
 tribalmemory/services/__init__.py,sha256=htv8HuG_r_lYJwP5Q1bwO-oir436U0NfJrOxk9mB7kU,468
 tribalmemory/services/deduplication.py,sha256=E8PaIDB6g24H28tKHrB5rMBJaKGGT3pFTDepXQThvcc,3679
 tribalmemory/services/embeddings.py,sha256=0kY1uPyCg81AlRTNg5QhXbRLDv8hN9khKR4JDGF2sik,10005
+tribalmemory/services/fts_store.py,sha256=5-SBGmzDeQR0-8aDMMO-zZuo8M7VK_tlKYUVDNAitV4,8424
 tribalmemory/services/import_export.py,sha256=KfEl5EXAFcuyDmhOYJZfjiIRtJYY4qQlvxv2ePJQHaA,15095
-tribalmemory/services/memory.py,sha256=UDypOGf8fAfN4iepkncrJn9v3QWvQx5lmItSZfwLUGg,9438
-tribalmemory/services/vector_store.py,sha256=8oq1V-pedIW4A7FXvqHY91L5DK56YdGlZUC3qjDtugo,12703
+tribalmemory/services/memory.py,sha256=R7p3K73VXebNWLIMeJUQNH3SvyYisydslei4FCF_y2k,15943
+tribalmemory/services/reranker.py,sha256=0RSvQFHB609aWcxBl92fiwxIbAYILTqNL9MaAp0lQ74,8720
+tribalmemory/services/session_store.py,sha256=wkVF9pNJOqkVXIYOkyvABSaRxaLoHDldT8KTZGThDU0,13818
+tribalmemory/services/vector_store.py,sha256=fL8YgnHiCLPqxqV64pQ_rMLIzdJc6ohN2c4wgGz0buw,15364
 tribalmemory/testing/__init__.py,sha256=XVS3uy0BjABCErgZohaqtj5MF20NKmj1KmtJfRiI_XI,524
 tribalmemory/testing/embedding_utils.py,sha256=E40lSAU7cz-ow2hzKLSaZmafIlOP8d9gakP8R2DTlGM,3705
 tribalmemory/testing/fixtures.py,sha256=_zDyUVm6CQqXK1Us8CN6A95tJcmo1D7LFDktIvjOmwM,3584
 tribalmemory/testing/metrics.py,sha256=X1n84dJDNQXsfGV-i-MzhsWKnFgqHWIcIaQB-BUp0e0,8711
 tribalmemory/testing/mocks.py,sha256=sjLy-pq3D_T21rEvWWKM_bqw7xnchRPGLARZNfKkpGU,19788
 tribalmemory/testing/semantic_expansions.py,sha256=AbbJIXYN4EJT8WKJ7UmIlNRlv63VejbcnbzBy2z2Ofk,2953
-tribalmemory-0.1.0.dist-info/licenses/LICENSE,sha256=M8D9Xf3B6C6DFiCgAAhKcXeTscaC4cw1fhr3LHUrALU,10774
-tribalmemory-0.1.0.dist-info/METADATA,sha256=l-vV4rYIt3WFbe6Jbtzot4fZ3yTuzQA_yEXcmzdVJXs,7804
-tribalmemory-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-tribalmemory-0.1.0.dist-info/entry_points.txt,sha256=9Pep7JNCk9ifdFP4WbeCugDOjMrLVegGJ5iuvbcZ9e8,103
-tribalmemory-0.1.0.dist-info/top_level.txt,sha256=kX36ZpH4W7EWcInV4MrIudicusdz5hfkezKMZ3HCMQs,13
-tribalmemory-0.1.0.dist-info/RECORD,,
+tribalmemory-0.2.0.dist-info/licenses/LICENSE,sha256=M8D9Xf3B6C6DFiCgAAhKcXeTscaC4cw1fhr3LHUrALU,10774
+tribalmemory-0.2.0.dist-info/METADATA,sha256=q-7NnUqHid7QR-8QW3o_BI3OSUDzSIHXlW8APe6xc7g,9239
+tribalmemory-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tribalmemory-0.2.0.dist-info/entry_points.txt,sha256=9Pep7JNCk9ifdFP4WbeCugDOjMrLVegGJ5iuvbcZ9e8,103
+tribalmemory-0.2.0.dist-info/top_level.txt,sha256=kX36ZpH4W7EWcInV4MrIudicusdz5hfkezKMZ3HCMQs,13
+tribalmemory-0.2.0.dist-info/RECORD,,