letta-nightly 0.5.0.dev20241022104124__py3-none-any.whl → 0.5.1.dev20241023193051__py3-none-any.whl

letta/__init__.py

@@ -1,7 +1,6 @@
-__version__ = "0.5.0"
+__version__ = "0.5.1"
 
 # import clients
-from letta.client.admin import Admin
 from letta.client.client import LocalClient, RESTClient, create_client
 
 # imports for easier access
@@ -13,7 +12,13 @@ from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.letta_message import LettaMessage
 from letta.schemas.llm_config import LLMConfig
-from letta.schemas.memory import ArchivalMemorySummary, Memory, RecallMemorySummary
+from letta.schemas.memory import (
+    ArchivalMemorySummary,
+    BasicBlockMemory,
+    ChatMemory,
+    Memory,
+    RecallMemorySummary,
+)
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.organization import Organization

letta/agent_store/db.py

@@ -25,10 +25,10 @@ from sqlalchemy_json import MutableJson
 from tqdm import tqdm
 
 from letta.agent_store.storage import StorageConnector, TableType
-from letta.base import Base
 from letta.config import LettaConfig
 from letta.constants import MAX_EMBEDDING_DIM
 from letta.metadata import EmbeddingConfigColumn, FileMetadataModel, ToolCallColumn
+from letta.orm.base import Base
 
 # from letta.schemas.message import Message, Passage, Record, RecordType, ToolCall
 from letta.schemas.message import Message
@@ -509,8 +509,10 @@ class SQLLiteStorageConnector(SQLStorageConnector):
 
         self.session_maker = db_context
 
+        # Need this in order to allow UUIDs to be stored successfully in the sqlite database
         # import sqlite3
-
+        # import uuid
+        #
         # sqlite3.register_adapter(uuid.UUID, lambda u: u.bytes_le)
         # sqlite3.register_converter("UUID", lambda b: uuid.UUID(bytes_le=b))
 

letta/cli/cli_config.py

@@ -105,7 +105,7 @@ def add_tool(
     """Add or update a tool from a Python file."""
     from letta.client.client import create_client
 
-    client = create_client(base_url=os.getenv("MEMGPT_BASE_URL"), token=os.getenv("MEMGPT_SERVER_PASS"))
+    client = create_client()
 
     # 1. Parse the Python file
     with open(filename, "r", encoding="utf-8") as file:
@@ -145,7 +145,7 @@ def list_tools():
     """List all available tools."""
     from letta.client.client import create_client
 
-    client = create_client(base_url=os.getenv("MEMGPT_BASE_URL"), token=os.getenv("MEMGPT_SERVER_PASS"))
+    client = create_client()
 
     tools = client.list_tools()
     for tool in tools:

letta/client/client.py

@@ -1777,6 +1777,19 @@ class LocalClient(AbstractClient):
         """
         self.server.delete_agent(user_id=self.user_id, agent_id=agent_id)
 
+    def get_agent_by_name(self, agent_name: str, user_id: str) -> AgentState:
+        """
+        Get an agent by its name
+
+        Args:
+            agent_name (str): Name of the agent
+
+        Returns:
+            agent_state (AgentState): State of the agent
+        """
+        self.interface.clear()
+        return self.server.get_agent(agent_name=agent_name, user_id=user_id, agent_id=None)
+
     def get_agent(self, agent_id: str) -> AgentState:
         """
         Get an agent's state by its ID.

letta/constants.py

@@ -4,10 +4,13 @@ from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
 LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
 
 # Defaults
-DEFAULT_USER_ID = "user-00000000"
-DEFAULT_ORG_ID = "org-00000000"
-DEFAULT_USER_NAME = "default"
-DEFAULT_ORG_NAME = "default"
+DEFAULT_USER_ID = "user-00000000-0000-4000-8000-000000000000"
+# This UUID follows the UUID4 rules:
+# The 13th character (4) indicates it's version 4.
+# The first character of the third segment (8) ensures the variant is correctly set.
+DEFAULT_ORG_ID = "organization-00000000-0000-4000-8000-000000000000"
+DEFAULT_USER_NAME = "default_user"
+DEFAULT_ORG_NAME = "default_org"
 
 
 # String in the error message for when the context window is too large

letta/embeddings.py

@@ -21,7 +21,6 @@ from letta.constants import (
     EMBEDDING_TO_TOKENIZER_MAP,
     MAX_EMBEDDING_DIM,
 )
-from letta.credentials import LettaCredentials
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.utils import is_valid_url, printd
 
@@ -138,6 +137,18 @@ class EmbeddingEndpoint:
         return self._call_api(text)
 
 
+class AzureOpenAIEmbedding:
+    def __init__(self, api_endpoint: str, api_key: str, api_version: str, model: str):
+        from openai import AzureOpenAI
+
+        self.client = AzureOpenAI(api_key=api_key, api_version=api_version, azure_endpoint=api_endpoint)
+        self.model = model
+
+    def get_text_embedding(self, text: str):
+        embeddings = self.client.embeddings.create(input=[text], model=self.model).data[0].embedding
+        return embeddings
+
+
 def default_embedding_model():
     # default to hugging face model running local
     # warning: this is a terrible model
@@ -161,8 +172,8 @@ def embedding_model(config: EmbeddingConfig, user_id: Optional[uuid.UUID] = None
 
     endpoint_type = config.embedding_endpoint_type
 
-    # TODO refactor to pass credentials through args
-    credentials = LettaCredentials.load()
+    # TODO: refactor to pass in settings from server
+    from letta.settings import model_settings
 
     if endpoint_type == "openai":
         from llama_index.embeddings.openai import OpenAIEmbedding
@@ -170,7 +181,7 @@ def embedding_model(config: EmbeddingConfig, user_id: Optional[uuid.UUID] = None
         additional_kwargs = {"user_id": user_id} if user_id else {}
         model = OpenAIEmbedding(
             api_base=config.embedding_endpoint,
-            api_key=credentials.openai_key,
+            api_key=model_settings.openai_api_key,
             additional_kwargs=additional_kwargs,
         )
         return model
@@ -178,22 +189,29 @@ def embedding_model(config: EmbeddingConfig, user_id: Optional[uuid.UUID] = None
     elif endpoint_type == "azure":
         assert all(
             [
-                credentials.azure_key is not None,
-                credentials.azure_embedding_endpoint is not None,
-                credentials.azure_version is not None,
+                model_settings.azure_api_key is not None,
+                model_settings.azure_base_url is not None,
+                model_settings.azure_api_version is not None,
             ]
         )
-        from llama_index.embeddings.azure_openai import AzureOpenAIEmbedding
+        # from llama_index.embeddings.azure_openai import AzureOpenAIEmbedding
+
+        ## https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#embeddings
+        # model = "text-embedding-ada-002"
+        # deployment = credentials.azure_embedding_deployment if credentials.azure_embedding_deployment is not None else model
+        # return AzureOpenAIEmbedding(
+        #    model=model,
+        #    deployment_name=deployment,
+        #    api_key=credentials.azure_key,
+        #    azure_endpoint=credentials.azure_endpoint,
+        #    api_version=credentials.azure_version,
+        # )
 
-        # https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#embeddings
-        model = "text-embedding-ada-002"
-        deployment = credentials.azure_embedding_deployment if credentials.azure_embedding_deployment is not None else model
         return AzureOpenAIEmbedding(
-            model=model,
-            deployment_name=deployment,
-            api_key=credentials.azure_key,
-            azure_endpoint=credentials.azure_endpoint,
-            api_version=credentials.azure_version,
+            api_endpoint=model_settings.azure_base_url,
+            api_key=model_settings.azure_api_key,
+            api_version=model_settings.azure_api_version,
+            model=config.embedding_model,
         )
 
     elif endpoint_type == "hugging-face":

letta/llm_api/azure_openai.py

@@ -1,3 +1,5 @@
+from collections import defaultdict
+
 import requests
 
 from letta.llm_api.helpers import make_post_request
@@ -20,7 +22,14 @@ def get_azure_model_list_endpoint(base_url: str, api_version: str):
     return f"{base_url}/openai/models?api-version={api_version}"
 
 
-def azure_openai_get_model_list(base_url: str, api_key: str, api_version: str) -> list:
+def get_azure_deployment_list_endpoint(base_url: str):
+    # Please note that it has to be 2023-03-15-preview
+    # That's the only api version that works with this deployments endpoint
+    # TODO: Use the Azure Client library here instead
+    return f"{base_url}/openai/deployments?api-version=2023-03-15-preview"
+
+
+def azure_openai_get_deployed_model_list(base_url: str, api_key: str, api_version: str) -> list:
     """https://learn.microsoft.com/en-us/rest/api/azureopenai/models/list?view=rest-azureopenai-2023-05-15&tabs=HTTP"""
 
     # https://xxx.openai.azure.com/openai/models?api-version=xxx
@@ -28,18 +37,48 @@ def azure_openai_get_model_list(base_url: str, api_key: str, api_version: str) -
     if api_key is not None:
         headers["api-key"] = f"{api_key}"
 
+    # 1. Get all available models
     url = get_azure_model_list_endpoint(base_url, api_version)
     try:
         response = requests.get(url, headers=headers)
         response.raise_for_status()
     except requests.RequestException as e:
         raise RuntimeError(f"Failed to retrieve model list: {e}")
+    all_available_models = response.json().get("data", [])
 
-    return response.json().get("data", [])
+    # 2. Get all the deployed models
+    url = get_azure_deployment_list_endpoint(base_url)
+    try:
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+    except requests.RequestException as e:
+        raise RuntimeError(f"Failed to retrieve model list: {e}")
+
+    deployed_models = response.json().get("data", [])
+    deployed_model_names = set([m["id"] for m in deployed_models])
+
+    # 3. Only return the models in available models if they have been deployed
+    deployed_models = [m for m in all_available_models if m["id"] in deployed_model_names]
+
+    # 4. Remove redundant deployments, only include the ones with the latest deployment
+    # Create a dictionary to store the latest model for each ID
+    latest_models = defaultdict()
+
+    # Iterate through the models and update the dictionary with the most recent model
+    for model in deployed_models:
+        model_id = model["id"]
+        updated_at = model["created_at"]
+
+        # If the model ID is new or the current model has a more recent created_at, update the dictionary
+        if model_id not in latest_models or updated_at > latest_models[model_id]["created_at"]:
+            latest_models[model_id] = model
+
+    # Extract the unique models
+    return list(latest_models.values())
 
 
 def azure_openai_get_chat_completion_model_list(base_url: str, api_key: str, api_version: str) -> list:
-    model_list = azure_openai_get_model_list(base_url, api_key, api_version)
+    model_list = azure_openai_get_deployed_model_list(base_url, api_key, api_version)
     # Extract models that support text generation
     model_options = [m for m in model_list if m.get("capabilities").get("chat_completion") == True]
     return model_options
@@ -53,10 +92,11 @@ def azure_openai_get_embeddings_model_list(base_url: str, api_key: str, api_vers
 
         return m.get("capabilities").get("embeddings") == True and valid_name
 
-    model_list = azure_openai_get_model_list(base_url, api_key, api_version)
+    model_list = azure_openai_get_deployed_model_list(base_url, api_key, api_version)
     # Extract models that support embeddings
 
     model_options = [m for m in model_list if valid_embedding_model(m)]
+
     return model_options
 
 

letta/llm_api/openai.py

@@ -314,11 +314,17 @@ def openai_chat_completions_process_stream(
                             for _ in range(len(tool_calls_delta))
                         ]
 
+                    # There may be many tool calls in a tool calls delta (e.g. parallel tool calls)
                     for tool_call_delta in tool_calls_delta:
                         if tool_call_delta.id is not None:
                             # TODO assert that we're not overwriting?
                             # TODO += instead of =?
-                            accum_message.tool_calls[tool_call_delta.index].id = tool_call_delta.id
+                            if tool_call_delta.index not in range(len(accum_message.tool_calls)):
+                                warnings.warn(
+                                    f"Tool call index out of range ({tool_call_delta.index})\ncurrent tool calls: {accum_message.tool_calls}\ncurrent delta: {tool_call_delta}"
+                                )
+                            else:
+                                accum_message.tool_calls[tool_call_delta.index].id = tool_call_delta.id
                         if tool_call_delta.function is not None:
                             if tool_call_delta.function.name is not None:
                                 # TODO assert that we're not overwriting?

letta/metadata.py

@@ -15,13 +15,12 @@ from sqlalchemy import (
     String,
     TypeDecorator,
     asc,
-    desc,
     or_,
 )
 from sqlalchemy.sql import func
 
-from letta.base import Base
 from letta.config import LettaConfig
+from letta.orm.base import Base
 from letta.schemas.agent import AgentState
 from letta.schemas.api_key import APIKey
 from letta.schemas.block import Block, Human, Persona
@@ -31,10 +30,7 @@ from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
-
-# from letta.schemas.message import Message, Passage, Record, RecordType, ToolCall
 from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
-from letta.schemas.organization import Organization
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
 from letta.schemas.user import User
@@ -155,40 +151,6 @@ class ToolCallColumn(TypeDecorator):
         return value
 
 
-class UserModel(Base):
-    __tablename__ = "users"
-    __table_args__ = {"extend_existing": True}
-
-    id = Column(String, primary_key=True)
-    org_id = Column(String)
-    name = Column(String, nullable=False)
-    created_at = Column(DateTime(timezone=True))
-
-    # TODO: what is this?
-    policies_accepted = Column(Boolean, nullable=False, default=False)
-
-    def __repr__(self) -> str:
-        return f"<User(id='{self.id}' name='{self.name}')>"
-
-    def to_record(self) -> User:
-        return User(id=self.id, name=self.name, created_at=self.created_at, org_id=self.org_id)
-
-
-class OrganizationModel(Base):
-    __tablename__ = "organizations"
-    __table_args__ = {"extend_existing": True}
-
-    id = Column(String, primary_key=True)
-    name = Column(String, nullable=False)
-    created_at = Column(DateTime(timezone=True))
-
-    def __repr__(self) -> str:
-        return f"<Organization(id='{self.id}' name='{self.name}')>"
-
-    def to_record(self) -> Organization:
-        return Organization(id=self.id, name=self.name, created_at=self.created_at)
-
-
 # TODO: eventually store providers?
 # class Provider(Base):
 #    __tablename__ = "providers"
@@ -513,15 +475,6 @@ class MetadataStore:
             tokens = [r.to_record() for r in results]
             return tokens
 
-    @enforce_types
-    def get_user_from_api_key(self, api_key: str) -> Optional[User]:
-        """Get the user associated with a given API key"""
-        token = self.get_api_key(api_key=api_key)
-        if token is None:
-            raise ValueError(f"Provided token does not exist")
-        else:
-            return self.get_user(user_id=token.user_id)
-
     @enforce_types
     def create_agent(self, agent: AgentState):
         # insert into agent table
@@ -543,22 +496,6 @@ class MetadataStore:
             session.add(SourceModel(**vars(source)))
             session.commit()
 
-    @enforce_types
-    def create_user(self, user: User):
-        with self.session_maker() as session:
-            if session.query(UserModel).filter(UserModel.id == user.id).count() > 0:
-                raise ValueError(f"User with id {user.id} already exists")
-            session.add(UserModel(**vars(user)))
-            session.commit()
-
-    @enforce_types
-    def create_organization(self, organization: Organization):
-        with self.session_maker() as session:
-            if session.query(OrganizationModel).filter(OrganizationModel.id == organization.id).count() > 0:
-                raise ValueError(f"Organization with id {organization.id} already exists")
-            session.add(OrganizationModel(**vars(organization)))
-            session.commit()
-
     @enforce_types
     def create_block(self, block: Block):
         with self.session_maker() as session:
@@ -597,12 +534,6 @@ class MetadataStore:
             session.query(AgentModel).filter(AgentModel.id == agent.id).update(fields)
             session.commit()
 
-    @enforce_types
-    def update_user(self, user: User):
-        with self.session_maker() as session:
-            session.query(UserModel).filter(UserModel.id == user.id).update(vars(user))
-            session.commit()
-
     @enforce_types
     def update_source(self, source: Source):
         with self.session_maker() as session:
@@ -681,33 +612,6 @@ class MetadataStore:
 
             session.commit()
 
-    @enforce_types
-    def delete_user(self, user_id: str):
-        with self.session_maker() as session:
-            # delete from users table
-            session.query(UserModel).filter(UserModel.id == user_id).delete()
-
-            # delete associated agents
-            session.query(AgentModel).filter(AgentModel.user_id == user_id).delete()
-
-            # delete associated sources
-            session.query(SourceModel).filter(SourceModel.user_id == user_id).delete()
-
-            # delete associated mappings
-            session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.user_id == user_id).delete()
-
-            session.commit()
-
-    @enforce_types
-    def delete_organization(self, org_id: str):
-        with self.session_maker() as session:
-            # delete from organizations table
-            session.query(OrganizationModel).filter(OrganizationModel.id == org_id).delete()
-
-            # TODO: delete associated data
-
-            session.commit()
-
     @enforce_types
     def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50, user_id: Optional[str] = None) -> List[ToolModel]:
         with self.session_maker() as session:
@@ -753,54 +657,6 @@ class MetadataStore:
             assert len(results) == 1, f"Expected 1 result, got {len(results)}"  # should only be one result
             return results[0].to_record()
 
-    @enforce_types
-    def get_user(self, user_id: str) -> Optional[User]:
-        with self.session_maker() as session:
-            results = session.query(UserModel).filter(UserModel.id == user_id).all()
-            if len(results) == 0:
-                return None
-            assert len(results) == 1, f"Expected 1 result, got {len(results)}"
-            return results[0].to_record()
-
-    @enforce_types
-    def get_organization(self, org_id: str) -> Optional[Organization]:
-        with self.session_maker() as session:
-            results = session.query(OrganizationModel).filter(OrganizationModel.id == org_id).all()
-            if len(results) == 0:
-                return None
-            assert len(results) == 1, f"Expected 1 result, got {len(results)}"
-            return results[0].to_record()
-
-    @enforce_types
-    def list_organizations(self, cursor: Optional[str] = None, limit: Optional[int] = 50):
-        with self.session_maker() as session:
-            query = session.query(OrganizationModel).order_by(desc(OrganizationModel.id))
-            if cursor:
-                query = query.filter(OrganizationModel.id < cursor)
-            results = query.limit(limit).all()
-            if not results:
-                return None, []
-            organization_records = [r.to_record() for r in results]
-            next_cursor = organization_records[-1].id
-            assert isinstance(next_cursor, str)
-
-            return next_cursor, organization_records
-
-    @enforce_types
-    def get_all_users(self, cursor: Optional[str] = None, limit: Optional[int] = 50):
-        with self.session_maker() as session:
-            query = session.query(UserModel).order_by(desc(UserModel.id))
-            if cursor:
-                query = query.filter(UserModel.id < cursor)
-            results = query.limit(limit).all()
-            if not results:
-                return None, []
-            user_records = [r.to_record() for r in results]
-            next_cursor = user_records[-1].id
-            assert isinstance(next_cursor, str)
-
-            return next_cursor, user_records
-
     @enforce_types
     def get_source(
         self, source_id: Optional[str] = None, user_id: Optional[str] = None, source_name: Optional[str] = None

letta/orm/base.py

@@ -0,0 +1,75 @@
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+from sqlalchemy import UUID as SQLUUID
+from sqlalchemy import Boolean, DateTime, func, text
+from sqlalchemy.orm import (
+    DeclarativeBase,
+    Mapped,
+    declarative_mixin,
+    declared_attr,
+    mapped_column,
+)
+
+
+class Base(DeclarativeBase):
+    """absolute base for sqlalchemy classes"""
+
+
+@declarative_mixin
+class CommonSqlalchemyMetaMixins(Base):
+    __abstract__ = True
+
+    created_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), server_default=func.now(), server_onupdate=func.now())
+    is_deleted: Mapped[bool] = mapped_column(Boolean, server_default=text("FALSE"))
+
+    @declared_attr
+    def _created_by_id(cls):
+        return cls._user_by_id()
+
+    @declared_attr
+    def _last_updated_by_id(cls):
+        return cls._user_by_id()
+
+    @classmethod
+    def _user_by_id(cls):
+        """a flexible non-constrained record of a user.
+        This way users can get added, deleted etc without history freaking out
+        """
+        return mapped_column(SQLUUID(), nullable=True)
+
+    @property
+    def last_updated_by_id(self) -> Optional[str]:
+        return self._user_id_getter("last_updated")
+
+    @last_updated_by_id.setter
+    def last_updated_by_id(self, value: str) -> None:
+        self._user_id_setter("last_updated", value)
+
+    @property
+    def created_by_id(self) -> Optional[str]:
+        return self._user_id_getter("created")
+
+    @created_by_id.setter
+    def created_by_id(self, value: str) -> None:
+        self._user_id_setter("created", value)
+
+    def _user_id_getter(self, prop: str) -> Optional[str]:
+        """returns the user id for the specified property"""
+        full_prop = f"_{prop}_by_id"
+        prop_value = getattr(self, full_prop, None)
+        if not prop_value:
+            return
+        return f"user-{prop_value}"
+
+    def _user_id_setter(self, prop: str, value: str) -> None:
+        """returns the user id for the specified property"""
+        full_prop = f"_{prop}_by_id"
+        if not value:
+            setattr(self, full_prop, None)
+            return
+        prefix, id_ = value.split("-", 1)
+        assert prefix == "user", f"{prefix} is not a valid id prefix for a user id"
+        setattr(self, full_prop, UUID(id_))

letta/orm/enums.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ToolSourceType(str, Enum):
+    """Defines what a tool was derived from"""
+
+    python = "python"
+    json = "json"

letta/orm/errors.py

@@ -0,0 +1,6 @@
+class NoResultFound(Exception):
+    """A record or records cannot be found given the provided search params"""
+
+
+class MalformedIdError(Exception):
+    """An id not in the right format, most likely violating uuid4 format."""

letta/orm/mixins.py

@@ -0,0 +1,67 @@
+from typing import Optional
+from uuid import UUID
+
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from letta.orm.base import Base
+from letta.orm.errors import MalformedIdError
+
+
+def is_valid_uuid4(uuid_string: str) -> bool:
+    """Check if a string is a valid UUID4."""
+    try:
+        uuid_obj = UUID(uuid_string)
+        return uuid_obj.version == 4
+    except ValueError:
+        return False
+
+
+def _relation_getter(instance: "Base", prop: str) -> Optional[str]:
+    """Get relation and return id with prefix as a string."""
+    prefix = prop.replace("_", "")
+    formatted_prop = f"_{prop}_id"
+    try:
+        id_ = getattr(instance, formatted_prop)  # Get the string id directly
+        return f"{prefix}-{id_}"
+    except AttributeError:
+        return None
+
+
+def _relation_setter(instance: "Base", prop: str, value: str) -> None:
+    """Set relation using the id with prefix, ensuring the id is a valid UUIDv4."""
+    formatted_prop = f"_{prop}_id"
+    prefix = prop.replace("_", "")
+    if not value:
+        setattr(instance, formatted_prop, None)
+        return
+    try:
+        found_prefix, id_ = value.split("-", 1)
+    except ValueError as e:
+        raise MalformedIdError(f"{value} is not a valid ID.") from e
+
+    # Ensure prefix matches
+    assert found_prefix == prefix, f"{found_prefix} is not a valid id prefix, expecting {prefix}"
+
+    # Validate that the id is a valid UUID4 string
+    if not is_valid_uuid4(id_):
+        raise MalformedIdError(f"Hash segment of {value} is not a valid UUID4")
+
+    setattr(instance, formatted_prop, id_)  # Store id as a string
+
+
+class OrganizationMixin(Base):
+    """Mixin for models that belong to an organization."""
+
+    __abstract__ = True
+
+    # Changed _organization_id to store string (still a valid UUID4 string)
+    _organization_id: Mapped[str] = mapped_column(String, ForeignKey("organization._id"))
+
+    @property
+    def organization_id(self) -> str:
+        return _relation_getter(self, "organization")
+
+    @organization_id.setter
+    def organization_id(self, value: str) -> None:
+        _relation_setter(self, "organization", value)