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

tribalmemory/interfaces.py

@@ -7,9 +7,12 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
-from typing import Optional
+from typing import Literal, Optional
 import uuid
 
+# Valid retrieval methods for RecallResult
+RetrievalMethod = Literal["vector", "graph", "hybrid", "entity"]
+
 
 class MemorySource(Enum):
     """Source of a memory entry."""
@@ -69,13 +72,21 @@ class MemoryEntry:
 
 @dataclass
 class RecallResult:
-    """Result of a memory recall query."""
+    """Result of a memory recall query.
+    
+    Attributes:
+        memory: The recalled memory entry.
+        similarity_score: Relevance score (0.0-1.0 for vector, 1.0 for exact entity match).
+        retrieval_time_ms: Time taken for retrieval.
+        retrieval_method: How this result was found (see RetrievalMethod type).
+    """
     memory: MemoryEntry
     similarity_score: float
     retrieval_time_ms: float
+    retrieval_method: RetrievalMethod = "vector"
     
     def __repr__(self) -> str:
-        return f"RecallResult(score={self.similarity_score:.3f}, memory_id={self.memory.id[:8]}...)"
+        return f"RecallResult(score={self.similarity_score:.3f}, method={self.retrieval_method}, memory_id={self.memory.id[:8]}...)"
 
 
 @dataclass
@@ -315,6 +326,7 @@ class IMemoryService(ABC):
         limit: int = 5,
         min_relevance: float = 0.7,
         tags: Optional[list[str]] = None,
+        graph_expansion: bool = True,
     ) -> list[RecallResult]:
         """Recall relevant memories for a query.
         
@@ -323,6 +335,13 @@ class IMemoryService(ABC):
             limit: Maximum results
             min_relevance: Minimum similarity score
             tags: Filter by tags (e.g., ["work", "preferences"])
+            graph_expansion: Expand candidates via entity graph (default True)
+        
+        Returns:
+            List of RecallResult objects with retrieval_method indicating source:
+            - "vector": Vector similarity search
+            - "hybrid": Vector + BM25 merge
+            - "graph": Entity graph traversal
         """
         pass
     

tribalmemory/mcp/server.py

@@ -412,6 +412,118 @@ def create_server() -> FastMCP:
 
         return json.dumps(stats)
 
+    @mcp.tool()
+    async def tribal_recall_entity(
+        entity_name: str,
+        hops: int = 1,
+        limit: int = 10,
+    ) -> str:
+        """Recall memories associated with an entity and its connections.
+
+        Enables entity-centric queries like:
+        - "Tell me everything about auth-service"
+        - "What do we know about PostgreSQL?"
+        - "What services connect to the user database?"
+
+        Args:
+            entity_name: Name of the entity to query (required).
+                Examples: "auth-service", "PostgreSQL", "user-db"
+            hops: Number of relationship hops to traverse (default 1).
+                1 = direct connections only
+                2 = connections of connections
+            limit: Maximum number of results (1-50, default 10)
+
+        Returns:
+            JSON with: results (list of memories), entity, hops, count
+        """
+        if not entity_name or not entity_name.strip():
+            return json.dumps({
+                "results": [],
+                "entity": entity_name,
+                "hops": hops,
+                "count": 0,
+                "error": "Entity name cannot be empty",
+            })
+
+        hops = max(1, min(10, hops))  # Clamp to reasonable range
+        limit = max(1, min(50, limit))
+
+        service = await get_memory_service()
+        
+        if not service.graph_enabled:
+            return json.dumps({
+                "results": [],
+                "entity": entity_name,
+                "hops": hops,
+                "count": 0,
+                "error": "Graph search not enabled. Requires db_path for persistent storage.",
+            })
+
+        results = await service.recall_entity(
+            entity_name=entity_name,
+            hops=hops,
+            limit=limit,
+        )
+
+        return json.dumps({
+            "results": [
+                {
+                    "memory_id": r.memory.id,
+                    "content": r.memory.content,
+                    "source_type": r.memory.source_type.value,
+                    "source_instance": r.memory.source_instance,
+                    "tags": r.memory.tags,
+                    "created_at": r.memory.created_at.isoformat(),
+                }
+                for r in results
+            ],
+            "entity": entity_name,
+            "hops": hops,
+            "count": len(results),
+        })
+
+    @mcp.tool()
+    async def tribal_entity_graph(
+        entity_name: str,
+        hops: int = 2,
+    ) -> str:
+        """Get the relationship graph around an entity.
+
+        Useful for understanding how concepts/services/technologies
+        are connected in your project knowledge base.
+
+        Args:
+            entity_name: Name of the entity to explore (required)
+            hops: How many relationship hops to include (default 2)
+
+        Returns:
+            JSON with: entities (list with name/type), relationships (list with source/target/type)
+        """
+        if not entity_name or not entity_name.strip():
+            return json.dumps({
+                "entities": [],
+                "relationships": [],
+                "error": "Entity name cannot be empty",
+            })
+
+        hops = max(1, min(5, hops))  # Clamp to reasonable range
+
+        service = await get_memory_service()
+        
+        if not service.graph_enabled:
+            return json.dumps({
+                "entities": [],
+                "relationships": [],
+                "error": "Graph search not enabled. Requires db_path for persistent storage.",
+            })
+
+        graph = service.get_entity_graph(
+            entity_name=entity_name,
+            hops=hops,
+        )
+
+        return json.dumps(graph)
+
     @mcp.tool()
     async def tribal_export(
         tags: Optional[list[str]] = None,

tribalmemory/services/graph_store.py

@@ -0,0 +1,627 @@
+"""Graph-enriched memory storage for entity and relationship tracking.
+
+Provides a lightweight graph layer alongside vector search to enable:
+- Entity-centric queries ("tell me everything about auth-service")
+- Relationship traversal ("what does auth-service connect to?")
+- Multi-hop reasoning ("what framework does the service that handles auth use?")
+
+Uses SQLite for local-first, zero-cloud constraint.
+"""
+
+import re
+import sqlite3
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# Constants
+MIN_ENTITY_NAME_LENGTH = 3
+MAX_HOP_ITERATIONS = 100  # Safety limit for graph traversal
+
+
+@dataclass
+class Entity:
+    """An extracted entity from memory text."""
+    
+    name: str
+    entity_type: str  # service, technology, data, concept, person, etc.
+    metadata: dict = field(default_factory=dict)
+
+
+@dataclass
+class Relationship:
+    """A relationship between two entities."""
+    
+    source: str  # Entity name
+    target: str  # Entity name
+    relation_type: str  # uses, stores, connects_to, depends_on, etc.
+    metadata: dict = field(default_factory=dict)
+
+
+class EntityExtractor:
+    """Extract entities and relationships from text.
+    
+    Uses pattern-based extraction for common software architecture terms.
+    Can be upgraded to spaCy NER or LLM extraction later.
+    
+    Attributes:
+        SERVICE_PATTERN: Regex for service-like names (kebab-case with suffix or 8+ chars).
+        TECHNOLOGIES: Set of known technology names for exact matching.
+        RELATIONSHIP_PATTERNS: List of (pattern, relation_type) tuples for extraction.
+    """
+    
+    # Patterns for common entity types
+    # Matches: kebab-case identifiers that look like service/component names
+    # - Must have at least one hyphen (kebab-case)
+    # - Either ends with known suffix OR has 3+ segments OR is 8+ chars
+    # - Excludes common false positives via MIN_ENTITY_NAME_LENGTH
+    SERVICE_PATTERN = re.compile(
+        r'\b('
+        r'[a-z][a-z0-9]*-(?:[a-z0-9]+-)*(?:service|api|worker|db|cache|server|client|gateway|proxy|database)'  # Known suffix
+        r'|'
+        r'[a-z][a-z0-9]*(?:-[a-z0-9]+){2,}'  # 3+ segments
+        r'|'
+        r'[a-z][a-z0-9]*-[a-z0-9]{4,}'  # 2 segments, second is 4+ chars
+        r')\b',
+        re.IGNORECASE
+    )
+    
+    # Known technology names (case-insensitive matching)
+    TECHNOLOGIES = {
+        'postgresql', 'postgres', 'mysql', 'mongodb', 'redis', 'memcached',
+        'elasticsearch', 'kafka', 'rabbitmq', 'nginx', 'docker', 'kubernetes',
+        'aws', 'gcp', 'azure', 'terraform', 'ansible', 'jenkins', 'github',
+        'python', 'javascript', 'typescript', 'rust', 'go', 'java', 'node',
+        'react', 'vue', 'angular', 'django', 'flask', 'fastapi', 'express',
+        'graphql', 'rest', 'grpc', 'websocket', 'http', 'https',
+        'sqlite', 'lancedb', 'chromadb', 'pinecone', 'weaviate',
+        'openai', 'anthropic', 'ollama', 'huggingface',
+        'pgbouncer', 'haproxy', 'traefik', 'envoy',
+    }
+    
+    # Relationship patterns: (pattern, relation_type)
+    RELATIONSHIP_PATTERNS = [
+        (re.compile(r'(\S+)\s+uses\s+(\S+)', re.IGNORECASE), 'uses'),
+        (re.compile(r'(\S+)\s+connects?\s+to\s+(\S+)', re.IGNORECASE), 'connects_to'),
+        (re.compile(r'(\S+)\s+stores?\s+(?:data\s+)?in\s+(\S+)', re.IGNORECASE), 'stores_in'),
+        (re.compile(r'(\S+)\s+depends?\s+on\s+(\S+)', re.IGNORECASE), 'depends_on'),
+        (re.compile(r'(\S+)\s+talks?\s+to\s+(\S+)', re.IGNORECASE), 'connects_to'),
+        (re.compile(r'(\S+)\s+calls?\s+(\S+)', re.IGNORECASE), 'calls'),
+        (re.compile(r'(\S+)\s+handles?\s+(\S+)', re.IGNORECASE), 'handles'),
+        (re.compile(r'(\S+)\s+for\s+(?:the\s+)?(\S+)', re.IGNORECASE), 'serves'),
+    ]
+    
+    def extract(self, text: str) -> list[Entity]:
+        """Extract entities from text.
+        
+        Args:
+            text: Input text to extract entities from.
+            
+        Returns:
+            List of extracted Entity objects.
+        """
+        if not text or not text.strip():
+            return []
+        
+        entities = []
+        seen_names: set[str] = set()
+        
+        # Extract service-like names (kebab-case identifiers)
+        for match in self.SERVICE_PATTERN.finditer(text):
+            name = match.group(1)
+            if name and name.lower() not in seen_names and len(name) >= MIN_ENTITY_NAME_LENGTH:
+                seen_names.add(name.lower())
+                entities.append(Entity(
+                    name=name,
+                    entity_type=self._infer_service_type(name)
+                ))
+        
+        # Extract known technology names
+        words = re.findall(r'\b\w+\b', text)
+        for word in words:
+            word_lower = word.lower()
+            if word_lower in self.TECHNOLOGIES and word_lower not in seen_names:
+                seen_names.add(word_lower)
+                entities.append(Entity(
+                    name=word,  # Preserve original case
+                    entity_type='technology'
+                ))
+        
+        return entities
+    
+    def extract_with_relationships(
+        self, text: str
+    ) -> tuple[list[Entity], list[Relationship]]:
+        """Extract both entities and relationships from text."""
+        entities = self.extract(text)
+        entity_names = {e.name.lower() for e in entities}
+        relationships = []
+        
+        for pattern, rel_type in self.RELATIONSHIP_PATTERNS:
+            for match in pattern.finditer(text):
+                source = match.group(1).strip('.,;:')
+                target = match.group(2).strip('.,;:')
+                
+                # Only create relationship if both entities were extracted
+                # or if they look like valid entity names
+                source_valid = (
+                    source.lower() in entity_names or 
+                    self._looks_like_entity(source)
+                )
+                target_valid = (
+                    target.lower() in entity_names or 
+                    self._looks_like_entity(target)
+                )
+                
+                if source_valid and target_valid:
+                    relationships.append(Relationship(
+                        source=source,
+                        target=target,
+                        relation_type=rel_type
+                    ))
+                    
+                    # Add entities if not already present
+                    if source.lower() not in entity_names:
+                        entity_names.add(source.lower())
+                        entities.append(Entity(
+                            name=source,
+                            entity_type=self._infer_type(source)
+                        ))
+                    if target.lower() not in entity_names:
+                        entity_names.add(target.lower())
+                        entities.append(Entity(
+                            name=target,
+                            entity_type=self._infer_type(target)
+                        ))
+        
+        return entities, relationships
+    
+    def _infer_service_type(self, name: str) -> str:
+        """Infer entity type from service-like name.
+        
+        Args:
+            name: Service name to analyze.
+            
+        Returns:
+            Entity type string (e.g., 'service', 'database', 'worker').
+        """
+        name_lower = name.lower()
+        if '-db' in name_lower or '-database' in name_lower:
+            return 'database'
+        if '-api' in name_lower or '-service' in name_lower:
+            return 'service'
+        if '-worker' in name_lower or '-job' in name_lower:
+            return 'worker'
+        if '-cache' in name_lower:
+            return 'cache'
+        if '-gateway' in name_lower or '-proxy' in name_lower:
+            return 'gateway'
+        if '-server' in name_lower:
+            return 'server'
+        if '-client' in name_lower:
+            return 'client'
+        return 'service'
+    
+    def _infer_type(self, name: str) -> str:
+        """Infer entity type from name.
+        
+        Args:
+            name: Entity name to analyze.
+            
+        Returns:
+            Entity type string.
+        """
+        if name.lower() in self.TECHNOLOGIES:
+            return 'technology'
+        if self.SERVICE_PATTERN.match(name):
+            return self._infer_service_type(name)
+        return 'concept'
+    
+    def _looks_like_entity(self, name: str) -> bool:
+        """Check if a string looks like a valid entity name.
+        
+        Args:
+            name: String to check.
+            
+        Returns:
+            True if the string looks like an entity name.
+        """
+        if not name or len(name) < MIN_ENTITY_NAME_LENGTH:
+            return False
+        if name.lower() in self.TECHNOLOGIES:
+            return True
+        if self.SERVICE_PATTERN.match(name):
+            return True
+        # Capitalized words (proper nouns)
+        if name[0].isupper() and name.isalnum():
+            return True
+        return False
+
+
+class GraphStore:
+    """SQLite-backed graph storage for entities and relationships.
+    
+    Schema:
+    - entities: (id, name, entity_type, metadata_json)
+    - entity_memories: (entity_id, memory_id) - many-to-many
+    - relationships: (id, source_entity_id, target_entity_id, relation_type, metadata_json)
+    - relationship_memories: (relationship_id, memory_id) - many-to-many
+    
+    Note on connection management:
+        Each operation creates a fresh connection. For high-throughput scenarios,
+        consider using connection pooling. SQLite's file locking handles concurrency.
+    """
+    
+    # Known technology names for type inference
+    KNOWN_TECHNOLOGIES = EntityExtractor.TECHNOLOGIES
+    
+    def __init__(self, db_path: str | Path):
+        """Initialize graph store with SQLite database.
+        
+        Args:
+            db_path: Path to the SQLite database file.
+        """
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_schema()
+    
+    def _get_connection(self) -> sqlite3.Connection:
+        """Get a database connection.
+        
+        Returns:
+            SQLite connection with Row factory.
+        """
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+    
+    def _infer_entity_type(self, name: str) -> str:
+        """Infer entity type from name when creating from relationships.
+        
+        Args:
+            name: Entity name to analyze.
+            
+        Returns:
+            Inferred entity type string.
+        """
+        if name.lower() in self.KNOWN_TECHNOLOGIES:
+            return 'technology'
+        # Check for service-like patterns
+        name_lower = name.lower()
+        if '-db' in name_lower or '-database' in name_lower:
+            return 'database'
+        if '-api' in name_lower or '-service' in name_lower:
+            return 'service'
+        if '-worker' in name_lower or '-job' in name_lower:
+            return 'worker'
+        if '-cache' in name_lower:
+            return 'cache'
+        if '-gateway' in name_lower or '-proxy' in name_lower:
+            return 'gateway'
+        if '-' in name:  # Generic kebab-case, probably a service
+            return 'service'
+        return 'concept'
+    
+    def _init_schema(self) -> None:
+        """Initialize database schema."""
+        with self._get_connection() as conn:
+            conn.executescript("""
+                CREATE TABLE IF NOT EXISTS entities (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL,
+                    entity_type TEXT NOT NULL,
+                    metadata_json TEXT DEFAULT '{}',
+                    UNIQUE(name)
+                );
+                
+                CREATE TABLE IF NOT EXISTS entity_memories (
+                    entity_id INTEGER NOT NULL,
+                    memory_id TEXT NOT NULL,
+                    FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+                    UNIQUE(entity_id, memory_id)
+                );
+                
+                CREATE TABLE IF NOT EXISTS relationships (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    source_entity_id INTEGER NOT NULL,
+                    target_entity_id INTEGER NOT NULL,
+                    relation_type TEXT NOT NULL,
+                    metadata_json TEXT DEFAULT '{}',
+                    FOREIGN KEY (source_entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+                    FOREIGN KEY (target_entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+                    UNIQUE(source_entity_id, target_entity_id, relation_type)
+                );
+                
+                CREATE TABLE IF NOT EXISTS relationship_memories (
+                    relationship_id INTEGER NOT NULL,
+                    memory_id TEXT NOT NULL,
+                    FOREIGN KEY (relationship_id) REFERENCES relationships(id) ON DELETE CASCADE,
+                    UNIQUE(relationship_id, memory_id)
+                );
+                
+                CREATE INDEX IF NOT EXISTS idx_entity_name ON entities(name);
+                CREATE INDEX IF NOT EXISTS idx_entity_memories_memory ON entity_memories(memory_id);
+                CREATE INDEX IF NOT EXISTS idx_rel_source ON relationships(source_entity_id);
+                CREATE INDEX IF NOT EXISTS idx_rel_target ON relationships(target_entity_id);
+            """)
+    
+    def add_entity(self, entity: Entity, memory_id: str) -> int:
+        """Add an entity and associate it with a memory.
+        
+        Returns the entity ID.
+        """
+        with self._get_connection() as conn:
+            # Upsert entity
+            cursor = conn.execute(
+                """
+                INSERT INTO entities (name, entity_type, metadata_json)
+                VALUES (?, ?, ?)
+                ON CONFLICT(name) DO UPDATE SET
+                    entity_type = COALESCE(excluded.entity_type, entities.entity_type)
+                RETURNING id
+                """,
+                (entity.name, entity.entity_type, '{}')
+            )
+            entity_id = cursor.fetchone()[0]
+            
+            # Associate with memory
+            conn.execute(
+                """
+                INSERT OR IGNORE INTO entity_memories (entity_id, memory_id)
+                VALUES (?, ?)
+                """,
+                (entity_id, memory_id)
+            )
+            
+            return entity_id
+    
+    def add_relationship(self, relationship: Relationship, memory_id: str) -> int:
+        """Add a relationship and associate it with a memory.
+        
+        Args:
+            relationship: The relationship to store.
+            memory_id: ID of the memory this relationship was extracted from.
+        
+        Returns:
+            The relationship ID.
+        """
+        with self._get_connection() as conn:
+            # Get or create source entity (infer type from name)
+            source_row = conn.execute(
+                "SELECT id FROM entities WHERE name = ?",
+                (relationship.source,)
+            ).fetchone()
+            if not source_row:
+                source_type = self._infer_entity_type(relationship.source)
+                cursor = conn.execute(
+                    "INSERT INTO entities (name, entity_type) VALUES (?, ?) RETURNING id",
+                    (relationship.source, source_type)
+                )
+                source_id = cursor.fetchone()[0]
+            else:
+                source_id = source_row[0]
+            
+            # Get or create target entity (infer type from name)
+            target_row = conn.execute(
+                "SELECT id FROM entities WHERE name = ?",
+                (relationship.target,)
+            ).fetchone()
+            if not target_row:
+                target_type = self._infer_entity_type(relationship.target)
+                cursor = conn.execute(
+                    "INSERT INTO entities (name, entity_type) VALUES (?, ?) RETURNING id",
+                    (relationship.target, target_type)
+                )
+                target_id = cursor.fetchone()[0]
+            else:
+                target_id = target_row[0]
+            
+            # Upsert relationship
+            cursor = conn.execute(
+                """
+                INSERT INTO relationships (source_entity_id, target_entity_id, relation_type)
+                VALUES (?, ?, ?)
+                ON CONFLICT(source_entity_id, target_entity_id, relation_type) DO NOTHING
+                RETURNING id
+                """,
+                (source_id, target_id, relationship.relation_type)
+            )
+            row = cursor.fetchone()
+            if row:
+                rel_id = row[0]
+            else:
+                # Relationship already exists, get its ID
+                rel_id = conn.execute(
+                    """
+                    SELECT id FROM relationships 
+                    WHERE source_entity_id = ? AND target_entity_id = ? AND relation_type = ?
+                    """,
+                    (source_id, target_id, relationship.relation_type)
+                ).fetchone()[0]
+            
+            # Associate with memory
+            conn.execute(
+                """
+                INSERT OR IGNORE INTO relationship_memories (relationship_id, memory_id)
+                VALUES (?, ?)
+                """,
+                (rel_id, memory_id)
+            )
+            
+            return rel_id
+    
+    def get_entities_for_memory(self, memory_id: str) -> list[Entity]:
+        """Get all entities associated with a memory."""
+        with self._get_connection() as conn:
+            rows = conn.execute(
+                """
+                SELECT e.name, e.entity_type, e.metadata_json
+                FROM entities e
+                JOIN entity_memories em ON e.id = em.entity_id
+                WHERE em.memory_id = ?
+                """,
+                (memory_id,)
+            ).fetchall()
+            
+            return [
+                Entity(name=row['name'], entity_type=row['entity_type'])
+                for row in rows
+            ]
+    
+    def get_relationships_for_entity(self, entity_name: str) -> list[Relationship]:
+        """Get all relationships where entity is the source."""
+        with self._get_connection() as conn:
+            rows = conn.execute(
+                """
+                SELECT e_source.name as source, e_target.name as target, r.relation_type
+                FROM relationships r
+                JOIN entities e_source ON r.source_entity_id = e_source.id
+                JOIN entities e_target ON r.target_entity_id = e_target.id
+                WHERE e_source.name = ?
+                """,
+                (entity_name,)
+            ).fetchall()
+            
+            return [
+                Relationship(
+                    source=row['source'],
+                    target=row['target'],
+                    relation_type=row['relation_type']
+                )
+                for row in rows
+            ]
+    
+    def get_memories_for_entity(self, entity_name: str) -> list[str]:
+        """Get all memory IDs associated with an entity."""
+        with self._get_connection() as conn:
+            rows = conn.execute(
+                """
+                SELECT DISTINCT em.memory_id
+                FROM entity_memories em
+                JOIN entities e ON em.entity_id = e.id
+                WHERE e.name = ?
+                """,
+                (entity_name,)
+            ).fetchall()
+            
+            return [row['memory_id'] for row in rows]
+    
+    def find_connected(
+        self, 
+        entity_name: str, 
+        hops: int = 1,
+        include_source: bool = False
+    ) -> list[Entity]:
+        """Find entities connected to the given entity within N hops.
+        
+        Args:
+            entity_name: Starting entity name.
+            hops: Maximum number of relationship hops (1 = direct connections).
+                  Capped at MAX_HOP_ITERATIONS for safety.
+            include_source: Whether to include the source entity in results.
+        
+        Returns:
+            List of connected entities.
+        """
+        # Safety: cap hops to prevent runaway traversal
+        safe_hops = min(hops, MAX_HOP_ITERATIONS)
+        
+        with self._get_connection() as conn:
+            # Start with source entity
+            source = conn.execute(
+                "SELECT id, name, entity_type FROM entities WHERE name = ?",
+                (entity_name,)
+            ).fetchone()
+            
+            if not source:
+                return []
+            
+            visited: set[int] = {source['id']}
+            current_frontier: set[int] = {source['id']}
+            result_ids: set[int] = set()
+            
+            for _ in range(safe_hops):
+                if not current_frontier:
+                    break
+                
+                # Find all entities connected to current frontier
+                # SECURITY NOTE: placeholders is safe because it's computed from
+                # len(current_frontier) (an integer), not user input. The actual
+                # values are passed as parameters, not interpolated.
+                placeholders = ','.join('?' * len(current_frontier))
+                rows = conn.execute(
+                    f"""
+                    SELECT DISTINCT e.id, e.name, e.entity_type
+                    FROM entities e
+                    JOIN relationships r ON (
+                        (r.source_entity_id IN ({placeholders}) AND r.target_entity_id = e.id)
+                        OR
+                        (r.target_entity_id IN ({placeholders}) AND r.source_entity_id = e.id)
+                    )
+                    """,
+                    list(current_frontier) + list(current_frontier)
+                ).fetchall()
+                
+                next_frontier: set[int] = set()
+                for row in rows:
+                    if row['id'] not in visited:
+                        visited.add(row['id'])
+                        next_frontier.add(row['id'])
+                        result_ids.add(row['id'])
+                
+                current_frontier = next_frontier
+            
+            # Fetch full entity info for results
+            if not result_ids:
+                return []
+            
+            placeholders = ','.join('?' * len(result_ids))
+            rows = conn.execute(
+                f"SELECT name, entity_type FROM entities WHERE id IN ({placeholders})",
+                list(result_ids)
+            ).fetchall()
+            
+            result = [
+                Entity(name=row['name'], entity_type=row['entity_type'])
+                for row in rows
+            ]
+            
+            if include_source:
+                result.insert(0, Entity(
+                    name=source['name'], 
+                    entity_type=source['entity_type']
+                ))
+            
+            return result
+    
+    def delete_memory(self, memory_id: str) -> None:
+        """Delete all entity and relationship associations for a memory.
+        
+        Note: Entities themselves are preserved (they may be referenced by other memories).
+        Only the associations are removed.
+        """
+        with self._get_connection() as conn:
+            # Delete relationship associations
+            conn.execute(
+                "DELETE FROM relationship_memories WHERE memory_id = ?",
+                (memory_id,)
+            )
+            
+            # Delete entity associations
+            conn.execute(
+                "DELETE FROM entity_memories WHERE memory_id = ?",
+                (memory_id,)
+            )
+            
+            # Clean up orphaned relationships (no memory references)
+            conn.execute("""
+                DELETE FROM relationships 
+                WHERE id NOT IN (SELECT relationship_id FROM relationship_memories)
+            """)
+            
+            # Optionally clean up orphaned entities (no memory or relationship references)
+            conn.execute("""
+                DELETE FROM entities 
+                WHERE id NOT IN (SELECT entity_id FROM entity_memories)
+                AND id NOT IN (SELECT source_entity_id FROM relationships)
+                AND id NOT IN (SELECT target_entity_id FROM relationships)
+            """)

tribalmemory/services/memory.py

@@ -1,5 +1,6 @@
 """Tribal Memory Service - Main API for agents."""
 
+import asyncio
 import logging
 import os
 from datetime import datetime
@@ -18,6 +19,7 @@ from ..interfaces import (
 )
 from .deduplication import SemanticDeduplicationService
 from .fts_store import FTSStore, hybrid_merge
+from .graph_store import GraphStore, EntityExtractor
 from .reranker import IReranker, NoopReranker, create_reranker
 
 logger = logging.getLogger(__name__)
@@ -37,6 +39,11 @@ class TribalMemoryService(IMemoryService):
         results = await service.recall("What language for Wally?")
     """
     
+    # Graph expansion scoring constants
+    GRAPH_1HOP_SCORE = 0.85  # Score for direct entity mentions
+    GRAPH_2HOP_SCORE = 0.70  # Score for connected entity mentions
+    GRAPH_EXPANSION_BUFFER = 2  # Multiplier for candidate pool before fetching
+    
     def __init__(
         self,
         instance_id: str,
@@ -52,6 +59,8 @@ class TribalMemoryService(IMemoryService):
         hybrid_candidate_multiplier: int = 4,
         reranker: Optional[IReranker] = None,
         rerank_pool_multiplier: int = 2,
+        graph_store: Optional[GraphStore] = None,
+        graph_enabled: bool = True,
     ):
         self.instance_id = instance_id
         self.embedding_service = embedding_service
@@ -64,6 +73,9 @@ class TribalMemoryService(IMemoryService):
         self.hybrid_candidate_multiplier = hybrid_candidate_multiplier
         self.reranker = reranker or NoopReranker()
         self.rerank_pool_multiplier = rerank_pool_multiplier
+        self.graph_store = graph_store
+        self.graph_enabled = graph_enabled and graph_store is not None
+        self.entity_extractor = EntityExtractor() if self.graph_enabled else None
         
         self.dedup_service = SemanticDeduplicationService(
             vector_store=vector_store,
@@ -118,6 +130,26 @@ class TribalMemoryService(IMemoryService):
             except Exception as e:
                 logger.warning("FTS indexing failed for %s: %s", entry.id, e)
         
+        # Extract and store entities for graph-enriched search
+        if result.success and self.graph_enabled and self.entity_extractor:
+            try:
+                entities, relationships = self.entity_extractor.extract_with_relationships(
+                    content
+                )
+                for entity in entities:
+                    self.graph_store.add_entity(entity, memory_id=entry.id)
+                for rel in relationships:
+                    self.graph_store.add_relationship(rel, memory_id=entry.id)
+                if entities:
+                    logger.debug(
+                        "Extracted entities: %s, relationships: %s from %s",
+                        [e.name for e in entities],
+                        [(r.source, r.relation_type, r.target) for r in relationships],
+                        entry.id
+                    )
+            except Exception as e:
+                logger.warning("Graph indexing failed for %s: %s", entry.id, e)
+        
         return result
     
     async def recall(
@@ -126,18 +158,29 @@ class TribalMemoryService(IMemoryService):
         limit: int = 5,
         min_relevance: float = 0.7,
         tags: Optional[list[str]] = None,
+        graph_expansion: bool = True,
     ) -> list[RecallResult]:
-        """Recall relevant memories using hybrid search.
+        """Recall relevant memories using hybrid search with optional graph expansion.
         
         When hybrid search is enabled (FTS store available), combines
         vector similarity with BM25 keyword matching for better results.
         Falls back to vector-only search when FTS is unavailable.
         
+        When graph expansion is enabled, entities are extracted from the query
+        and the candidate pool is expanded via entity graph traversal.
+        
         Args:
             query: Natural language query
             limit: Maximum results
             min_relevance: Minimum similarity score
             tags: Filter by tags (e.g., ["work", "preferences"])
+            graph_expansion: Expand candidates via entity graph (default True)
+        
+        Returns:
+            List of RecallResult objects with retrieval_method indicating source:
+            - "vector": Pure vector similarity search
+            - "hybrid": Vector + BM25 merge
+            - "graph": Entity graph traversal (1-hop or 2-hop)
         """
         try:
             query_embedding = await self.embedding_service.embed(query)
@@ -147,17 +190,33 @@ class TribalMemoryService(IMemoryService):
         filters = {"tags": tags} if tags else None
 
         if self.hybrid_search and self.fts_store:
-            return await self._hybrid_recall(
+            results = await self._hybrid_recall(
                 query, query_embedding, limit, min_relevance, filters
             )
+        else:
+            # Vector-only fallback
+            vector_results = await self.vector_store.recall(
+                query_embedding,
+                limit=limit,
+                min_similarity=min_relevance,
+                filters=filters,
+            )
+            # Mark as vector retrieval
+            results = [
+                RecallResult(
+                    memory=r.memory,
+                    similarity_score=r.similarity_score,
+                    retrieval_time_ms=r.retrieval_time_ms,
+                    retrieval_method="vector",
+                )
+                for r in vector_results
+            ]
         
-        # Vector-only fallback
-        results = await self.vector_store.recall(
-            query_embedding,
-            limit=limit,
-            min_similarity=min_relevance,
-            filters=filters,
-        )
+        # Graph expansion: find additional memories via entity connections
+        if graph_expansion and self.graph_enabled and self.entity_extractor:
+            results = await self._expand_via_graph(
+                query, results, limit, min_relevance
+            )
         
         return self._filter_superseded(results)
 
@@ -215,7 +274,6 @@ class TribalMemoryService(IMemoryService):
                 bm25_only_ids.append(m)
         
         # Batch-fetch BM25-only hits concurrently
-        import asyncio
         fetched_entries = await asyncio.gather(
             *(self.vector_store.get(m["id"]) for m in bm25_only_ids)
         ) if bm25_only_ids else []
@@ -223,12 +281,13 @@ class TribalMemoryService(IMemoryService):
         # Build candidate list
         candidates: list[RecallResult] = []
         
-        # Add cached vector hits
+        # Add cached vector hits (mark as hybrid since we used BM25 merge)
         for m, recall_result in cached_hits:
             candidates.append(RecallResult(
                 memory=recall_result.memory,
                 similarity_score=m["final_score"],
                 retrieval_time_ms=recall_result.retrieval_time_ms,
+                retrieval_method="hybrid",
             ))
         
         # Add fetched BM25-only hits
@@ -238,12 +297,116 @@ class TribalMemoryService(IMemoryService):
                     memory=entry,
                     similarity_score=m["final_score"],
                     retrieval_time_ms=0,
+                    retrieval_method="hybrid",
                 ))
 
         # 6. Rerank candidates
         reranked = self.reranker.rerank(query, candidates, top_k=limit)
 
         return self._filter_superseded(reranked)
+
+    async def _expand_via_graph(
+        self,
+        query: str,
+        existing_results: list[RecallResult],
+        limit: int,
+        min_relevance: float,
+    ) -> list[RecallResult]:
+        """Expand recall candidates via entity graph traversal.
+        
+        Extracts entities from the query, finds memories connected to those
+        entities via the graph, and merges them with existing results.
+        
+        Args:
+            query: The original query string.
+            existing_results: Results from vector/hybrid search.
+            limit: Maximum total results.
+            min_relevance: Minimum relevance threshold (filters graph results too).
+            
+        Returns:
+            Combined results with graph-expanded memories, sorted by score.
+        """
+        # Extract entities from query
+        query_entities = self.entity_extractor.extract(query)
+        if not query_entities:
+            return existing_results
+        
+        # Collect memory IDs from existing results to avoid duplicates
+        existing_ids = {r.memory.id for r in existing_results}
+        
+        # Find memories connected to query entities via graph
+        graph_memory_ids: set[str] = set()
+        entity_to_hops: dict[str, int] = {}  # Track hop distance for scoring
+        
+        for entity in query_entities:
+            # Direct mentions (1 hop)
+            direct_ids = self.graph_store.get_memories_for_entity(entity.name)
+            for mid in direct_ids:
+                if mid not in existing_ids:
+                    graph_memory_ids.add(mid)
+                    # Use setdefault to preserve shortest path (1-hop takes precedence)
+                    entity_to_hops.setdefault(mid, 1)
+            
+            # Connected entities (2 hops)
+            connected = self.graph_store.find_connected(entity.name, hops=1)
+            for connected_entity in connected:
+                connected_ids = self.graph_store.get_memories_for_entity(
+                    connected_entity.name
+                )
+                for mid in connected_ids:
+                    if mid not in existing_ids:
+                        graph_memory_ids.add(mid)
+                        # Use setdefault to preserve shortest path
+                        entity_to_hops.setdefault(mid, 2)
+        
+        if not graph_memory_ids:
+            return existing_results
+        
+        # Cap graph candidates to prevent memory leak (#2)
+        max_graph_candidates = limit * self.GRAPH_EXPANSION_BUFFER
+        if len(graph_memory_ids) > max_graph_candidates:
+            # Prioritize 1-hop over 2-hop when capping
+            one_hop_ids = [mid for mid in graph_memory_ids if entity_to_hops[mid] == 1]
+            two_hop_ids = [mid for mid in graph_memory_ids if entity_to_hops[mid] == 2]
+            
+            capped_ids: list[str] = []
+            capped_ids.extend(one_hop_ids[:max_graph_candidates])
+            remaining = max_graph_candidates - len(capped_ids)
+            if remaining > 0:
+                capped_ids.extend(two_hop_ids[:remaining])
+            
+            graph_memory_ids = set(capped_ids)
+        
+        # Batch-fetch graph-connected memories concurrently for performance
+        graph_memory_list = list(graph_memory_ids)
+        fetched_entries = await asyncio.gather(
+            *(self.vector_store.get(mid) for mid in graph_memory_list)
+        ) if graph_memory_list else []
+        
+        graph_results: list[RecallResult] = []
+        for memory_id, entry in zip(graph_memory_list, fetched_entries):
+            if entry:
+                # Score based on hop distance using class constants
+                hops = entity_to_hops[memory_id]  # Fail fast if logic is wrong
+                graph_score = (
+                    self.GRAPH_1HOP_SCORE if hops == 1 
+                    else self.GRAPH_2HOP_SCORE
+                )
+                
+                # Filter by min_relevance
+                if graph_score >= min_relevance:
+                    graph_results.append(RecallResult(
+                        memory=entry,
+                        similarity_score=graph_score,
+                        retrieval_time_ms=0,
+                        retrieval_method="graph",
+                    ))
+        
+        # Combine existing + graph results (#10: single sort, no redundant pre-sort)
+        combined = existing_results + graph_results
+        combined.sort(key=lambda r: r.similarity_score, reverse=True)
+        
+        return combined[:limit]
     
     async def correct(
         self,
@@ -286,6 +449,11 @@ class TribalMemoryService(IMemoryService):
                 self.fts_store.delete(memory_id)
             except Exception as e:
                 logger.warning("FTS cleanup failed for %s: %s", memory_id, e)
+        if result and self.graph_store:
+            try:
+                self.graph_store.delete_memory(memory_id)
+            except Exception as e:
+                logger.warning("Graph cleanup failed for %s: %s", memory_id, e)
         return result
     
     async def get(self, memory_id: str) -> Optional[MemoryEntry]:
@@ -311,6 +479,99 @@ class TribalMemoryService(IMemoryService):
             return results
         return [r for r in results if r.memory.id not in superseded_ids]
 
+    async def recall_entity(
+        self,
+        entity_name: str,
+        hops: int = 1,
+        limit: int = 10,
+    ) -> list[RecallResult]:
+        """Recall all memories associated with an entity and its connections.
+        
+        This enables entity-centric queries like:
+        - "Tell me everything about auth-service"
+        - "What do we know about PostgreSQL?"
+        
+        Args:
+            entity_name: Name of the entity to query
+            hops: Number of relationship hops to traverse (1 = direct only)
+            limit: Maximum results to return
+        
+        Returns:
+            List of recall results for memories mentioning the entity or connected entities
+        """
+        if not self.graph_enabled:
+            logger.warning("Graph search not enabled, returning empty results")
+            return []
+        
+        # Get memories directly mentioning the entity
+        direct_memories = set(self.graph_store.get_memories_for_entity(entity_name))
+        
+        # Get memories for connected entities (if hops > 0)
+        if hops > 0:
+            connected = self.graph_store.find_connected(entity_name, hops=hops)
+            for entity in connected:
+                direct_memories.update(
+                    self.graph_store.get_memories_for_entity(entity.name)
+                )
+        
+        if not direct_memories:
+            return []
+        
+        # Fetch full memory entries
+        results: list[RecallResult] = []
+        for memory_id in list(direct_memories)[:limit]:
+            entry = await self.vector_store.get(memory_id)
+            if entry:
+                results.append(RecallResult(
+                    memory=entry,
+                    similarity_score=1.0,  # Entity match confidence (exact)
+                    retrieval_time_ms=0,
+                    retrieval_method="entity",
+                ))
+        
+        return results
+
+    def get_entity_graph(
+        self,
+        entity_name: str,
+        hops: int = 2,
+    ) -> dict:
+        """Get the relationship graph around an entity.
+        
+        Returns a dict with:
+        - entities: list of connected entities with types
+        - relationships: list of relationships
+        
+        Useful for visualization and debugging.
+        """
+        if not self.graph_enabled:
+            return {"entities": [], "relationships": []}
+        
+        connected = self.graph_store.find_connected(
+            entity_name, hops=hops, include_source=True
+        )
+        
+        entities = [
+            {"name": e.name, "type": e.entity_type}
+            for e in connected
+        ]
+        
+        # Get relationships for all entities
+        relationships = []
+        seen_rels = set()
+        for entity in connected:
+            for rel in self.graph_store.get_relationships_for_entity(entity.name):
+                rel_key = (rel.source, rel.target, rel.relation_type)
+                if rel_key not in seen_rels:
+                    seen_rels.add(rel_key)
+                    relationships.append({
+                        "source": rel.source,
+                        "target": rel.target,
+                        "type": rel.relation_type,
+                    })
+        
+        return {"entities": entities, "relationships": relationships}
+
 
 def create_memory_service(
     instance_id: Optional[str] = None,
@@ -421,6 +682,17 @@ def create_memory_service(
     )
     reranker = create_reranker(search_config)
     
+    # Create graph store for entity-enriched search (co-located with LanceDB)
+    graph_store = None
+    if db_path:
+        try:
+            graph_db_path = str(Path(db_path) / "graph.db")
+            graph_store = GraphStore(graph_db_path)
+            logger.info("Graph store enabled (SQLite)")
+        except Exception as e:
+            logger.warning(f"Graph store init failed: {e}. Graph search disabled.")
+            graph_store = None
+    
     return TribalMemoryService(
         instance_id=instance_id,
         embedding_service=embedding_service,
@@ -432,4 +704,6 @@ def create_memory_service(
         hybrid_candidate_multiplier=hybrid_candidate_multiplier,
         reranker=reranker,
         rerank_pool_multiplier=rerank_pool_multiplier,
+        graph_store=graph_store,
+        graph_enabled=graph_store is not None,
     )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tribalmemory
-Version: 0.2.0
+Version: 0.3.0
 Summary: Shared memory infrastructure for multi-instance AI agents
 Author-email: Joe <joe@example.com>
 License: Apache-2.0

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

@@ -1,6 +1,6 @@
 tribalmemory/__init__.py,sha256=DNgC_ZT0lrhxsPdhXu4oeG_UdrLstYQHeKwR-U2toeY,104
 tribalmemory/cli.py,sha256=wbVsgMst4NEuWkwA2dily_qC8AP6jvAHKwHgE3B-TG8,15960
-tribalmemory/interfaces.py,sha256=d3uFTBG9mDtB69cVSMipE5Qi3JDGZGUAYmhhAagT3rM,11430
+tribalmemory/interfaces.py,sha256=hs32jxImd3AXa0EfysGhP-goDAMQ90fqVQV4PbTpgQQ,12287
 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=4YyY0Wl0RZRKFNkxc2kaFbkt4HWcVP6eryrABKfFKZQ,21029
+tribalmemory/mcp/server.py,sha256=URosl0xbxqn0m57bkO52y-pKIBzgkP-f8wTm_MRWzd8,24708
 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
@@ -35,8 +35,9 @@ tribalmemory/services/__init__.py,sha256=htv8HuG_r_lYJwP5Q1bwO-oir436U0NfJrOxk9m
 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/graph_store.py,sha256=zekWCdmqvZR9qH09FFqp6L7QKSI1z368CKLUDH1osys,24376
 tribalmemory/services/import_export.py,sha256=KfEl5EXAFcuyDmhOYJZfjiIRtJYY4qQlvxv2ePJQHaA,15095
-tribalmemory/services/memory.py,sha256=R7p3K73VXebNWLIMeJUQNH3SvyYisydslei4FCF_y2k,15943
+tribalmemory/services/memory.py,sha256=uWw-Eg8cJYmzwMsXBxmkGzPRM66Ew13OuRDKBAI2lng,27472
 tribalmemory/services/reranker.py,sha256=0RSvQFHB609aWcxBl92fiwxIbAYILTqNL9MaAp0lQ74,8720
 tribalmemory/services/session_store.py,sha256=wkVF9pNJOqkVXIYOkyvABSaRxaLoHDldT8KTZGThDU0,13818
 tribalmemory/services/vector_store.py,sha256=fL8YgnHiCLPqxqV64pQ_rMLIzdJc6ohN2c4wgGz0buw,15364
@@ -46,9 +47,9 @@ tribalmemory/testing/fixtures.py,sha256=_zDyUVm6CQqXK1Us8CN6A95tJcmo1D7LFDktIvjO
 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.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,,
+tribalmemory-0.3.0.dist-info/licenses/LICENSE,sha256=M8D9Xf3B6C6DFiCgAAhKcXeTscaC4cw1fhr3LHUrALU,10774
+tribalmemory-0.3.0.dist-info/METADATA,sha256=05lUAOlIf1Zei-I2USroVXkuq2gCijCrCn52B_IqR6Y,9239
+tribalmemory-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tribalmemory-0.3.0.dist-info/entry_points.txt,sha256=9Pep7JNCk9ifdFP4WbeCugDOjMrLVegGJ5iuvbcZ9e8,103
+tribalmemory-0.3.0.dist-info/top_level.txt,sha256=kX36ZpH4W7EWcInV4MrIudicusdz5hfkezKMZ3HCMQs,13
+tribalmemory-0.3.0.dist-info/RECORD,,