Store schema

Classes:

Name	Description
DistanceMetric	Supported distance metrics for vector similarity.
MemoryRecord	Comprehensive memory record for storage (Pydantic model).
MemorySearchResult	Result from a memory search operation (Pydantic model).
MemoryType	Types of memories that can be stored.
RetrievalStrategy	Memory retrieval strategies.

Classes

DistanceMetric

Bases: Enum

Supported distance metrics for vector similarity.

Attributes:

Name	Type	Description
COSINE
DOT_PRODUCT
EUCLIDEAN
MANHATTAN

Source code in pyagenity/store/store_schema.py

class DistanceMetric(Enum):
    """Supported distance metrics for vector similarity."""

    COSINE = "cosine"
    EUCLIDEAN = "euclidean"
    DOT_PRODUCT = "dot_product"
    MANHATTAN = "manhattan"

Attributes

COSINE class-attribute instance-attribute

COSINE = 'cosine'

DOT_PRODUCT class-attribute instance-attribute

DOT_PRODUCT = 'dot_product'

EUCLIDEAN class-attribute instance-attribute

EUCLIDEAN = 'euclidean'

MANHATTAN class-attribute instance-attribute

MANHATTAN = 'manhattan'

MemoryRecord

Bases: BaseModel

Comprehensive memory record for storage (Pydantic model).

Methods:

Name	Description
from_message
validate_vector

Attributes:

Name	Type	Description
category	str
content	str
id	str
memory_type	MemoryType
metadata	dict[str, Any]
thread_id	str | None
timestamp	datetime | None
user_id	str | None
vector	list[float] | None

Source code in pyagenity/store/store_schema.py

class MemoryRecord(BaseModel):
    """Comprehensive memory record for storage (Pydantic model)."""

    id: str = Field(default_factory=lambda: str(uuid4()))
    content: str
    user_id: str | None = None
    thread_id: str | None = None
    memory_type: MemoryType = Field(default=MemoryType.EPISODIC)
    metadata: dict[str, Any] = Field(default_factory=dict)
    category: str = Field(default="general")
    vector: list[float] | None = None
    timestamp: datetime | None = Field(default_factory=datetime.now)

    @field_validator("vector")
    @classmethod
    def validate_vector(cls, v):
        if v is not None and (
            not isinstance(v, list) or any(not isinstance(x, (int | float)) for x in v)
        ):
            raise ValueError("vector must be list[float] or None")
        return v

    @classmethod
    def from_message(
        cls,
        message: Message,
        user_id: str | None = None,
        thread_id: str | None = None,
        vector: list[float] | None = None,
        additional_metadata: dict[str, Any] | None = None,
    ) -> "MemoryRecord":
        content = message.text()
        metadata = {
            "role": message.role,
            "message_id": str(message.message_id),
            "timestamp": message.timestamp.isoformat() if message.timestamp else None,
            "has_tool_calls": bool(message.tools_calls),
            "has_reasoning": bool(message.reasoning),
            "token_usage": message.usages.model_dump() if message.usages else None,
            **(additional_metadata or {}),
        }
        return cls(
            content=content,
            user_id=user_id,
            thread_id=thread_id,
            memory_type=MemoryType.EPISODIC,
            metadata=metadata,
            vector=vector,
        )

Attributes

category class-attribute instance-attribute

category = Field(default='general')

content instance-attribute

content

id class-attribute instance-attribute

id = Field(default_factory=lambda: str(uuid4()))

memory_type class-attribute instance-attribute

memory_type = Field(default=EPISODIC)

metadata class-attribute instance-attribute

metadata = Field(default_factory=dict)

thread_id class-attribute instance-attribute

thread_id = None

timestamp class-attribute instance-attribute

timestamp = Field(default_factory=now)

user_id class-attribute instance-attribute

user_id = None

vector class-attribute instance-attribute

vector = None

Functions

from_message classmethod

from_message(message, user_id=None, thread_id=None, vector=None, additional_metadata=None)

Source code in pyagenity/store/store_schema.py

@classmethod
def from_message(
    cls,
    message: Message,
    user_id: str | None = None,
    thread_id: str | None = None,
    vector: list[float] | None = None,
    additional_metadata: dict[str, Any] | None = None,
) -> "MemoryRecord":
    content = message.text()
    metadata = {
        "role": message.role,
        "message_id": str(message.message_id),
        "timestamp": message.timestamp.isoformat() if message.timestamp else None,
        "has_tool_calls": bool(message.tools_calls),
        "has_reasoning": bool(message.reasoning),
        "token_usage": message.usages.model_dump() if message.usages else None,
        **(additional_metadata or {}),
    }
    return cls(
        content=content,
        user_id=user_id,
        thread_id=thread_id,
        memory_type=MemoryType.EPISODIC,
        metadata=metadata,
        vector=vector,
    )

validate_vector classmethod

validate_vector(v)

Source code in pyagenity/store/store_schema.py

@field_validator("vector")
@classmethod
def validate_vector(cls, v):
    if v is not None and (
        not isinstance(v, list) or any(not isinstance(x, (int | float)) for x in v)
    ):
        raise ValueError("vector must be list[float] or None")
    return v

MemorySearchResult

Bases: BaseModel

Result from a memory search operation (Pydantic model).

Methods:

Name	Description
validate_vector

Attributes:

Name	Type	Description
content	str
id	str
memory_type	MemoryType
metadata	dict[str, Any]
score	float
thread_id	str | None
timestamp	datetime | None
user_id	str | None
vector	list[float] | None

Source code in pyagenity/store/store_schema.py

class MemorySearchResult(BaseModel):
    """Result from a memory search operation (Pydantic model)."""

    id: str = Field(default_factory=lambda: str(uuid4()))
    content: str = Field(default="", description="Primary textual content of the memory")
    score: float = Field(default=0.0, ge=0.0, description="Similarity / relevance score")
    memory_type: MemoryType = Field(default=MemoryType.EPISODIC)
    metadata: dict[str, Any] = Field(default_factory=dict)
    vector: list[float] | None = Field(default=None)
    user_id: str | None = None
    thread_id: str | None = None
    timestamp: datetime | None = Field(default_factory=datetime.now)

    @field_validator("vector")
    @classmethod
    def validate_vector(cls, v):
        if v is not None and (
            not isinstance(v, list) or any(not isinstance(x, (int | float)) for x in v)
        ):
            raise ValueError("vector must be list[float] or None")
        return v

Attributes

content class-attribute instance-attribute

content = Field(default='', description='Primary textual content of the memory')

id class-attribute instance-attribute

id = Field(default_factory=lambda: str(uuid4()))

memory_type class-attribute instance-attribute

memory_type = Field(default=EPISODIC)

metadata class-attribute instance-attribute

metadata = Field(default_factory=dict)

score class-attribute instance-attribute

score = Field(default=0.0, ge=0.0, description='Similarity / relevance score')

thread_id class-attribute instance-attribute

thread_id = None

timestamp class-attribute instance-attribute

timestamp = Field(default_factory=now)

user_id class-attribute instance-attribute

user_id = None

vector class-attribute instance-attribute

vector = Field(default=None)

Functions

validate_vector classmethod

validate_vector(v)

Source code in pyagenity/store/store_schema.py

@field_validator("vector")
@classmethod
def validate_vector(cls, v):
    if v is not None and (
        not isinstance(v, list) or any(not isinstance(x, (int | float)) for x in v)
    ):
        raise ValueError("vector must be list[float] or None")
    return v

MemoryType

Bases: Enum

Types of memories that can be stored.

Attributes:

Name	Type	Description
CUSTOM
DECLARATIVE
ENTITY
EPISODIC
PROCEDURAL
RELATIONSHIP
SEMANTIC

Source code in pyagenity/store/store_schema.py

class MemoryType(Enum):
    """Types of memories that can be stored."""

    EPISODIC = "episodic"  # Conversation memories
    SEMANTIC = "semantic"  # Facts and knowledge
    PROCEDURAL = "procedural"  # How-to knowledge
    ENTITY = "entity"  # Entity-based memories
    RELATIONSHIP = "relationship"  # Entity relationships
    CUSTOM = "custom"  # Custom memory types
    DECLARATIVE = "declarative"  # Explicit facts and events

Attributes

CUSTOM class-attribute instance-attribute

CUSTOM = 'custom'

DECLARATIVE class-attribute instance-attribute

DECLARATIVE = 'declarative'

ENTITY class-attribute instance-attribute

ENTITY = 'entity'

EPISODIC class-attribute instance-attribute

EPISODIC = 'episodic'

PROCEDURAL class-attribute instance-attribute

PROCEDURAL = 'procedural'

RELATIONSHIP class-attribute instance-attribute

RELATIONSHIP = 'relationship'

SEMANTIC class-attribute instance-attribute

SEMANTIC = 'semantic'

RetrievalStrategy

Bases: Enum

Memory retrieval strategies.

Attributes:

Name	Type	Description
GRAPH_TRAVERSAL
HYBRID
RELEVANCE
SIMILARITY
TEMPORAL

Source code in pyagenity/store/store_schema.py

class RetrievalStrategy(Enum):
    """Memory retrieval strategies."""

    SIMILARITY = "similarity"  # Vector similarity search
    TEMPORAL = "temporal"  # Time-based retrieval
    RELEVANCE = "relevance"  # Relevance scoring
    HYBRID = "hybrid"  # Combined approaches
    GRAPH_TRAVERSAL = "graph_traversal"  # Knowledge graph navigation

Attributes

GRAPH_TRAVERSAL class-attribute instance-attribute

GRAPH_TRAVERSAL = 'graph_traversal'

HYBRID class-attribute instance-attribute

HYBRID = 'hybrid'

RELEVANCE class-attribute instance-attribute

RELEVANCE = 'relevance'

SIMILARITY class-attribute instance-attribute

SIMILARITY = 'similarity'

TEMPORAL class-attribute instance-attribute

TEMPORAL = 'temporal'