memoryfn 0.0.1__tar.gz

memoryfn-0.0.1/.gitignore

@@ -0,0 +1,48 @@
+# Dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# Build outputs
+dist/
+build/
+*.tsbuildinfo
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Environment variables
+.env
+.env.*
+!.env.example
+
+# Testing
+coverage/
+.nyc_output
+
+# Editors
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Turbo
+.turbo/
+
+# Misc
+*.tgz
+.cache/
+
+
+_conduct/.meta
+
+.agent
+.venv

memoryfn-0.0.1/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: memoryfn
+Version: 0.0.1
+Summary: Self-hostable AI memory system for agents and applications
+Author: 21n
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pgvector>=0.2.0
+Requires-Dist: psycopg[binary]>=3.1
+Requires-Dist: pydantic>=2.6
+Requires-Dist: tenacity>=8.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.3.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# MemoryFn Python SDK
+
+> Self-hostable AI memory system for agents and applications
+
+## Installation
+
+```bash
+pip install memoryfn
+```
+
+## Usage
+
+```python
+import asyncio
+from memoryfn import MemoryFn, Config
+
+async def main():
+    memory = MemoryFn(Config(
+        storage_url="postgresql://user:pass@localhost:5432/memoryfn",
+        openai_api_key="sk-..."
+    ))
+
+    # Add memory
+    await memory.add(
+        content="User prefers dark mode",
+        container_tags=["user:alice"],
+        type="profile_static"
+    )
+
+    # Search
+    results = await memory.search(
+        q="preferences",
+        container_tags=["user:alice"]
+    )
+    
+    print(results)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

memoryfn-0.0.1/README.md

@@ -0,0 +1,40 @@
+# MemoryFn Python SDK
+
+> Self-hostable AI memory system for agents and applications
+
+## Installation
+
+```bash
+pip install memoryfn
+```
+
+## Usage
+
+```python
+import asyncio
+from memoryfn import MemoryFn, Config
+
+async def main():
+    memory = MemoryFn(Config(
+        storage_url="postgresql://user:pass@localhost:5432/memoryfn",
+        openai_api_key="sk-..."
+    ))
+
+    # Add memory
+    await memory.add(
+        content="User prefers dark mode",
+        container_tags=["user:alice"],
+        type="profile_static"
+    )
+
+    # Search
+    results = await memory.search(
+        q="preferences",
+        container_tags=["user:alice"]
+    )
+    
+    print(results)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

memoryfn-0.0.1/memoryfn/__init__.py

@@ -0,0 +1,5 @@
+from .core.pipeline import MemoryFn
+from .core.config import Config
+from .core.types import AddMemoryInput, SearchMemoryInput
+
+__all__ = ["MemoryFn", "Config", "AddMemoryInput", "SearchMemoryInput"]

memoryfn-0.0.1/memoryfn/core/config.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+from typing import Optional, Literal, Dict
+
+class Config(BaseModel):
+    storage_url: str = Field(alias="storageUrl")
+    openai_api_key: Optional[str] = Field(default=None, alias="openaiApiKey")
+    openai_model: str = Field(default="gpt-4o-mini", alias="openaiModel")
+    embedding_model: str = Field(default="text-embedding-3-small", alias="embeddingModel")
+    embedding_dims: int = Field(default=1536, alias="embeddingDims")

memoryfn-0.0.1/memoryfn/core/pipeline.py

@@ -0,0 +1,90 @@
+from memoryfn.core.config import Config
+from memoryfn.core.types import AddMemoryInput, SearchMemoryInput, SearchMemoryResult, Memory
+from memoryfn.storage.postgres import PostgresAdapter
+from memoryfn.providers.openai import OpenAIProvider
+from memoryfn.extraction.facts import FactExtractor
+import time
+
+class MemoryFn:
+    def __init__(self, config: Config):
+        self.config = config
+        self.storage = PostgresAdapter(config.storage_url)
+        self.provider = None
+        self.extractor = None
+        
+        if config.openai_api_key:
+            self.provider = OpenAIProvider(
+                api_key=config.openai_api_key,
+                embedding_model=config.embedding_model,
+                llm_model=config.openai_model
+            )
+            self.extractor = FactExtractor(self.provider)
+
+    async def add(self, input: AddMemoryInput) -> List[Memory]:
+        # 1. Normalize
+        content = input.content
+        memories_to_persist = []
+
+        # 2. Extract
+        if self.extractor:
+            facts = await self.extractor.extract(content)
+            if facts:
+                for fact in facts:
+                    memories_to_persist.append(Memory(
+                        tenantId=input.tenant_id,
+                        containerTags=input.container_tags + fact.get("tags", []),
+                        type=fact.get("type", "conversational"),
+                        content=fact.get("content"),
+                        metadata={**input.metadata, "confidence": fact.get("confidence", 1.0)}
+                    ))
+            else:
+                # Fallback
+                memories_to_persist.append(Memory(
+                    tenantId=input.tenant_id,
+                    containerTags=input.container_tags,
+                    type=input.type,
+                    content=content,
+                    metadata=input.metadata
+                ))
+        else:
+            memories_to_persist.append(Memory(
+                tenantId=input.tenant_id,
+                containerTags=input.container_tags,
+                type=input.type,
+                content=content,
+                metadata=input.metadata
+            ))
+
+        # 3. Embed
+        if self.provider:
+            texts = [m.content for m in memories_to_persist]
+            embeddings = await self.provider.embed_batch(texts)
+            for i, mem in enumerate(memories_to_persist):
+                mem.embedding = embeddings[i]
+
+        # 4. Persist
+        saved = await self.storage.insert_memories(memories_to_persist)
+        return saved
+
+    async def search(self, input: SearchMemoryInput) -> SearchMemoryResult:
+        embedding = []
+        if self.provider:
+            embedding = await self.provider.embed(input.q)
+        else:
+            # Mock or error
+            embedding = [0.0] * self.config.embedding_dims
+
+        results = await self.storage.search_vectors(
+            embedding=embedding,
+            container_tags=input.container_tags,
+            top_k=input.limit,
+            threshold=input.threshold
+        )
+
+        return SearchMemoryResult(
+            results=results,
+            totalFound=len(results)
+        )
+        
+    async def close(self):
+        await self.storage.close()

memoryfn-0.0.1/memoryfn/core/types.py

@@ -0,0 +1,60 @@
+from typing import List, Optional, Dict, Any, Literal
+from pydantic import BaseModel, Field
+from datetime import datetime
+import time
+
+MemoryType = Literal[
+    "profile_static",
+    "profile_dynamic",
+    "conversational",
+    "procedural",
+    "document",
+    "derived"
+]
+
+RelationType = Literal["updates", "extends", "contradicts", "derives", "related"]
+
+class Memory(BaseModel):
+    id: Optional[str] = None
+    tenant_id: str = Field(default="default", alias="tenantId")
+    container_tags: List[str] = Field(default_factory=list, alias="containerTags")
+    type: MemoryType = "conversational"
+    content: str
+    embedding: Optional[List[float]] = None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+    is_latest: bool = Field(default=True, alias="isLatest")
+    created_at: float = Field(default_factory=lambda: time.time() * 1000, alias="createdAt")
+    updated_at: float = Field(default_factory=lambda: time.time() * 1000, alias="updatedAt")
+
+    class Config:
+        populate_by_name = True
+
+class MemoryRelationship(BaseModel):
+    id: Optional[str] = None
+    from_id: str = Field(alias="fromId")
+    to_id: str = Field(alias="toId")
+    type: RelationType
+    confidence: float = 1.0
+    reasoning: Optional[str] = None
+    created_at: float = Field(default_factory=lambda: time.time() * 1000, alias="createdAt")
+
+    class Config:
+        populate_by_name = True
+
+class AddMemoryInput(BaseModel):
+    content: str
+    container_tags: List[str] = Field(default_factory=list, alias="containerTags")
+    type: MemoryType = "conversational"
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+    tenant_id: str = Field(default="default", alias="tenantId")
+
+class SearchMemoryInput(BaseModel):
+    q: str
+    container_tags: List[str] = Field(default_factory=list, alias="containerTags")
+    filters: Optional[Dict[str, Any]] = None
+    limit: int = 10
+    threshold: float = 0.7
+
+class SearchMemoryResult(BaseModel):
+    results: List[Memory]
+    total_found: int = Field(alias="totalFound")

memoryfn-0.0.1/memoryfn/extraction/facts.py

@@ -0,0 +1,25 @@
+from memoryfn.providers.openai import OpenAIProvider
+from typing import List, Dict
+
+class FactExtractor:
+    def __init__(self, provider: OpenAIProvider):
+        self.provider = provider
+
+    async def extract(self, text: str) -> List[Dict]:
+        prompt = f"""
+        Analyze the following text and extract discrete, atomic facts. 
+        Return a JSON object with a key "facts" containing an array of objects.
+        Each object should have:
+        - "content": The fact as a standalone sentence.
+        - "type": One of "profile_static", "profile_dynamic", "conversational".
+        - "confidence": A number between 0 and 1.
+        - "tags": Array of relevant keywords.
+
+        Text: "{text}"
+        """
+        try:
+            result = await self.provider.generate_json(prompt)
+            return result.get("facts", [])
+        except Exception as e:
+            print(f"Extraction failed: {e}")
+            return []

memoryfn-0.0.1/memoryfn/providers/openai.py

@@ -0,0 +1,34 @@
+from typing import List
+from openai import AsyncOpenAI
+
+class OpenAIProvider:
+    def __init__(self, api_key: str, embedding_model: str, llm_model: str):
+        self.client = AsyncOpenAI(api_key=api_key)
+        self.embedding_model = embedding_model
+        self.llm_model = llm_model
+
+    async def embed(self, text: str) -> List[float]:
+        resp = await self.client.embeddings.create(
+            model=self.embedding_model,
+            input=text
+        )
+        return resp.data[0].embedding
+
+    async def embed_batch(self, texts: List[str]) -> List[List[float]]:
+        resp = await self.client.embeddings.create(
+            model=self.embedding_model,
+            input=texts
+        )
+        return [d.embedding for d in resp.data]
+
+    async def generate_json(self, prompt: str) -> dict:
+        resp = await self.client.chat.completions.create(
+            model=self.llm_model,
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant that outputs JSON."},
+                {"role": "user", "content": prompt}
+            ],
+            response_format={"type": "json_object"}
+        )
+        import json
+        return json.loads(resp.choices[0].message.content)

memoryfn-0.0.1/memoryfn/storage/postgres.py

@@ -0,0 +1,138 @@
+from typing import List, Optional
+import psycopg
+from pgvector.psycopg import register_vector
+from memoryfn.core.types import Memory, MemoryRelationship
+import json
+from datetime import datetime
+
+class PostgresAdapter:
+    def __init__(self, dsn: str):
+        self.dsn = dsn
+        self._conn = None
+
+    async def connect(self):
+        if not self._conn:
+            # Note: In a real async app we'd use psycopg_pool or AsyncConnection
+            # Here we use standard sync connection for simplicity or psycopg.AsyncConnection
+            self._conn = await psycopg.AsyncConnection.connect(self.dsn, autocommit=True)
+            # Enable vector extension support
+            await register_vector(self._conn)
+
+    async def insert_memories(self, memories: List[Memory]) -> List[Memory]:
+        await self.connect()
+        async with self._conn.cursor() as cur:
+            results = []
+            for mem in memories:
+                # Using timestamp in ms for domain, but DB uses timestamptz
+                created_at = datetime.fromtimestamp(mem.created_at / 1000.0)
+                updated_at = datetime.fromtimestamp(mem.updated_at / 1000.0)
+                
+                await cur.execute(
+                    """
+                    INSERT INTO memories (
+                        tenant_id, container_tags, type, content, embedding, 
+                        metadata, is_latest, created_at, updated_at
+                    ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
+                    RETURNING id
+                    """,
+                    (
+                        mem.tenant_id,
+                        mem.container_tags,
+                        mem.type,
+                        mem.content,
+                        mem.embedding,
+                        json.dumps(mem.metadata),
+                        mem.is_latest,
+                        created_at,
+                        updated_at
+                    )
+                )
+                row = await cur.fetchone()
+                mem.id = str(row[0])
+                results.append(mem)
+            return results
+
+    async def insert_relationships(self, relationships: List[MemoryRelationship]) -> List[MemoryRelationship]:
+        await self.connect()
+        async with self._conn.cursor() as cur:
+            results = []
+            for rel in relationships:
+                created_at = datetime.fromtimestamp(rel.created_at / 1000.0)
+                await cur.execute(
+                    """
+                    INSERT INTO memory_relationships (
+                        from_id, to_id, type, confidence, reasoning, created_at
+                    ) VALUES (%s, %s, %s, %s, %s, %s)
+                    RETURNING id
+                    """,
+                    (
+                        rel.from_id,
+                        rel.to_id,
+                        rel.type,
+                        rel.confidence,
+                        rel.reasoning,
+                        created_at
+                    )
+                )
+                row = await cur.fetchone()
+                rel.id = str(row[0])
+                results.append(rel)
+            return results
+
+    async def search_vectors(
+        self, 
+        embedding: List[float], 
+        container_tags: List[str], 
+        top_k: int = 10,
+        threshold: float = 0.7
+    ) -> List[Memory]:
+        await self.connect()
+        
+        # Build query
+        # Using <=> for cosine distance. Distance = 1 - similarity.
+        # Similarity >= threshold  =>  Distance <= 1 - threshold
+        max_dist = 1.0 - threshold
+        
+        query = """
+            SELECT id, tenant_id, container_tags, type, content, embedding, 
+                   metadata, is_latest, created_at, updated_at,
+                   1 - (embedding <=> %s::vector) as similarity
+            FROM memories
+            WHERE 1=1
+        """
+        params = [embedding]
+        
+        if container_tags:
+            query += " AND container_tags && %s"
+            params.append(container_tags)
+            
+        if threshold:
+            query += f" AND (embedding <=> %s::vector) <= {max_dist}"
+            params.append(embedding)
+            
+        query += " ORDER BY embedding <=> %s::vector LIMIT %s"
+        params.extend([embedding, top_k])
+        
+        async with self._conn.cursor() as cur:
+            await cur.execute(query, params)
+            rows = await cur.fetchall()
+            
+            results = []
+            for row in rows:
+                results.append(Memory(
+                    id=str(row[0]),
+                    tenantId=row[1],
+                    containerTags=row[2],
+                    type=row[3],
+                    content=row[4],
+                    embedding=row[5].tolist() if hasattr(row[5], 'tolist') else row[5],
+                    metadata=row[6],
+                    isLatest=row[7],
+                    createdAt=row[8].timestamp() * 1000,
+                    updatedAt=row[9].timestamp() * 1000
+                ))
+            return results
+    
+    async def close(self):
+        if self._conn:
+            await self._conn.close()

memoryfn-0.0.1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "memoryfn"
+version = "0.0.1"
+description = "Self-hostable AI memory system for agents and applications"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+    { name = "21n" },
+]
+dependencies = [
+    "pydantic>=2.6",
+    "httpx>=0.27",
+    "pgvector>=0.2.0",
+    "psycopg[binary]>=3.1",
+    "openai>=1.0.0",
+    "tenacity>=8.0.0"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "ruff>=0.3.0"
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["memoryfn"]

memoryfn-0.0.1/tests/test_pipeline.py

@@ -0,0 +1,58 @@
+import pytest
+from unittest.mock import AsyncMock, MagicMock
+from memoryfn.core.pipeline import MemoryFn
+from memoryfn.core.config import Config
+from memoryfn.core.types import AddMemoryInput, SearchMemoryInput, Memory
+
+@pytest.mark.asyncio
+async def test_memoryfn_pipeline():
+    # Mock Config
+    config = Config(
+        storageUrl="postgresql://mock:mock@localhost:5432/mock",
+        openaiApiKey="mock-key"
+    )
+
+    # Mock Storage
+    mock_storage = AsyncMock()
+    mock_storage.insert_memories.return_value = [
+        Memory(id="1", content="Test content", type="conversational")
+    ]
+    mock_storage.search_vectors.return_value = [
+        Memory(id="1", content="Test content", type="conversational")
+    ]
+
+    # Mock Provider
+    mock_provider = AsyncMock()
+    mock_provider.embed.return_value = [0.1] * 1536
+    mock_provider.embed_batch.return_value = [[0.1] * 1536]
+    mock_provider.generate_json.return_value = {"facts": [{"content": "Test content", "type": "conversational", "confidence": 0.9}]}
+
+    # Initialize MemoryFn and inject mocks
+    memory = MemoryFn(config)
+    memory.storage = mock_storage
+    memory.provider = mock_provider
+    memory.extractor.provider = mock_provider # type: ignore
+
+    # Test Add
+    input_data = AddMemoryInput(
+        content="Test content",
+        containerTags=["user:test"],
+        tenantId="test-tenant"
+    )
+    result = await memory.add(input_data)
+    
+    assert len(result) == 1
+    assert result[0].content == "Test content"
+    mock_storage.insert_memories.assert_called_once()
+    mock_provider.embed_batch.assert_called_once()
+
+    # Test Search
+    search_input = SearchMemoryInput(
+        q="query",
+        containerTags=["user:test"]
+    )
+    search_result = await memory.search(search_input)
+    
+    assert len(search_result.results) == 1
+    assert search_result.total_found == 1
+    mock_storage.search_vectors.assert_called_once()