letta-nightly 0.6.4.dev20241213193437__py3-none-any.whl → 0.6.4.dev20241215104129__py3-none-any.whl

letta/config.py

@@ -1,12 +1,9 @@
 import configparser
-import inspect
-import json
 import os
 from dataclasses import dataclass
 from typing import Optional
 
 import letta
-import letta.utils as utils
 from letta.constants import (
     CORE_MEMORY_HUMAN_CHAR_LIMIT,
     CORE_MEMORY_PERSONA_CHAR_LIMIT,
@@ -16,7 +13,6 @@ from letta.constants import (
     LETTA_DIR,
 )
 from letta.log import get_logger
-from letta.schemas.agent import PersistedAgentState
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.llm_config import LLMConfig
 
@@ -312,160 +308,3 @@ class LettaConfig:
         for folder in folders:
             if not os.path.exists(os.path.join(LETTA_DIR, folder)):
                 os.makedirs(os.path.join(LETTA_DIR, folder))
-
-
-@dataclass
-class AgentConfig:
-    """
-
-    NOTE: this is a deprecated class, use AgentState instead. This class is only used for backcompatibility.
-    Configuration for a specific instance of an agent
-    """
-
-    def __init__(
-        self,
-        persona,
-        human,
-        # model info
-        model=None,
-        model_endpoint_type=None,
-        model_endpoint=None,
-        model_wrapper=None,
-        context_window=None,
-        # embedding info
-        embedding_endpoint_type=None,
-        embedding_endpoint=None,
-        embedding_model=None,
-        embedding_dim=None,
-        embedding_chunk_size=None,
-        # other
-        preset=None,
-        data_sources=None,
-        # agent info
-        agent_config_path=None,
-        name=None,
-        create_time=None,
-        letta_version=None,
-        # functions
-        functions=None,  # schema definitions ONLY (linked at runtime)
-    ):
-
-        assert name, f"Agent name must be provided"
-        self.name = name
-
-        config = LettaConfig.load()  # get default values
-        self.persona = config.persona if persona is None else persona
-        self.human = config.human if human is None else human
-        self.preset = config.preset if preset is None else preset
-        self.context_window = config.default_llm_config.context_window if context_window is None else context_window
-        self.model = config.default_llm_config.model if model is None else model
-        self.model_endpoint_type = config.default_llm_config.model_endpoint_type if model_endpoint_type is None else model_endpoint_type
-        self.model_endpoint = config.default_llm_config.model_endpoint if model_endpoint is None else model_endpoint
-        self.model_wrapper = config.default_llm_config.model_wrapper if model_wrapper is None else model_wrapper
-        self.llm_config = LLMConfig(
-            model=self.model,
-            model_endpoint_type=self.model_endpoint_type,
-            model_endpoint=self.model_endpoint,
-            model_wrapper=self.model_wrapper,
-            context_window=self.context_window,
-        )
-        self.embedding_endpoint_type = (
-            config.default_embedding_config.embedding_endpoint_type if embedding_endpoint_type is None else embedding_endpoint_type
-        )
-        self.embedding_endpoint = config.default_embedding_config.embedding_endpoint if embedding_endpoint is None else embedding_endpoint
-        self.embedding_model = config.default_embedding_config.embedding_model if embedding_model is None else embedding_model
-        self.embedding_dim = config.default_embedding_config.embedding_dim if embedding_dim is None else embedding_dim
-        self.embedding_chunk_size = (
-            config.default_embedding_config.embedding_chunk_size if embedding_chunk_size is None else embedding_chunk_size
-        )
-        self.embedding_config = EmbeddingConfig(
-            embedding_endpoint_type=self.embedding_endpoint_type,
-            embedding_endpoint=self.embedding_endpoint,
-            embedding_model=self.embedding_model,
-            embedding_dim=self.embedding_dim,
-            embedding_chunk_size=self.embedding_chunk_size,
-        )
-
-        # agent metadata
-        self.data_sources = data_sources if data_sources is not None else []
-        self.create_time = create_time if create_time is not None else utils.get_local_time()
-        if letta_version is None:
-            import letta
-
-            self.letta_version = letta.__version__
-        else:
-            self.letta_version = letta_version
-
-        # functions
-        self.functions = functions
-
-        # save agent config
-        self.agent_config_path = (
-            os.path.join(LETTA_DIR, "agents", self.name, "config.json") if agent_config_path is None else agent_config_path
-        )
-
-    def attach_data_source(self, data_source: str):
-        # TODO: add warning that only once source can be attached
-        # i.e. previous source will be overriden
-        self.data_sources.append(data_source)
-        self.save()
-
-    def save_dir(self):
-        return os.path.join(LETTA_DIR, "agents", self.name)
-
-    def save_state_dir(self):
-        # directory to save agent state
-        return os.path.join(LETTA_DIR, "agents", self.name, "agent_state")
-
-    def save_persistence_manager_dir(self):
-        # directory to save persistent manager state
-        return os.path.join(LETTA_DIR, "agents", self.name, "persistence_manager")
-
-    def save_agent_index_dir(self):
-        # save llama index inside of persistent manager directory
-        return os.path.join(self.save_persistence_manager_dir(), "index")
-
-    def save(self):
-        # save state of persistence manager
-        os.makedirs(os.path.join(LETTA_DIR, "agents", self.name), exist_ok=True)
-        # save version
-        self.letta_version = letta.__version__
-        with open(self.agent_config_path, "w", encoding="utf-8") as f:
-            json.dump(vars(self), f, indent=4)
-
-    def to_agent_state(self):
-        return PersistedAgentState(
-            name=self.name,
-            preset=self.preset,
-            persona=self.persona,
-            human=self.human,
-            llm_config=self.llm_config,
-            embedding_config=self.embedding_config,
-            create_time=self.create_time,
-        )
-
-    @staticmethod
-    def exists(name: str):
-        """Check if agent config exists"""
-        agent_config_path = os.path.join(LETTA_DIR, "agents", name)
-        return os.path.exists(agent_config_path)
-
-    @classmethod
-    def load(cls, name: str):
-        """Load agent config from JSON file"""
-        agent_config_path = os.path.join(LETTA_DIR, "agents", name, "config.json")
-        assert os.path.exists(agent_config_path), f"Agent config file does not exist at {agent_config_path}"
-        with open(agent_config_path, "r", encoding="utf-8") as f:
-            agent_config = json.load(f)
-        # allow compatibility accross versions
-        try:
-            class_args = inspect.getargspec(cls.__init__).args
-        except AttributeError:
-            # https://github.com/pytorch/pytorch/issues/15344
-            class_args = inspect.getfullargspec(cls.__init__).args
-        agent_fields = list(agent_config.keys())
-        for key in agent_fields:
-            if key not in class_args:
-                utils.printd(f"Removing missing argument {key} from agent config")
-                del agent_config[key]
-        return cls(**agent_config)

letta/main.py

@@ -19,7 +19,6 @@ from letta.cli.cli_config import add, add_tool, configure, delete, list, list_to
 from letta.cli.cli_load import app as load_app
 from letta.config import LettaConfig
 from letta.constants import FUNC_FAILED_HEARTBEAT_MESSAGE, REQ_HEARTBEAT_MESSAGE
-from letta.metadata import MetadataStore
 
 # from letta.interface import CLIInterface as interface  # for printing to terminal
 from letta.streaming_interface import AgentRefreshStreamingInterface
@@ -62,7 +61,6 @@ def run_agent_loop(
     letta_agent: agent.Agent,
     config: LettaConfig,
     first: bool,
-    ms: MetadataStore,
     no_verify: bool = False,
     strip_ui: bool = False,
     stream: bool = False,
@@ -92,7 +90,6 @@ def run_agent_loop(
 
     # create client
     client = create_client()
-    ms = MetadataStore(config)  # TODO: remove
 
     # run loops
     while True:
@@ -130,11 +127,11 @@ def run_agent_loop(
                 # updated agent save functions
                 if user_input.lower() == "/exit":
                     # letta_agent.save()
-                    agent.save_agent(letta_agent, ms)
+                    agent.save_agent(letta_agent)
                     break
                 elif user_input.lower() == "/save" or user_input.lower() == "/savechat":
                     # letta_agent.save()
-                    agent.save_agent(letta_agent, ms)
+                    agent.save_agent(letta_agent)
                     continue
                 elif user_input.lower() == "/attach":
                     # TODO: check if agent already has it
@@ -378,7 +375,6 @@ def run_agent_loop(
                     first_message=False,
                     skip_verify=no_verify,
                     stream=stream,
-                    ms=ms,
                 )
             else:
                 step_response = letta_agent.step_user_message(
@@ -386,7 +382,6 @@ def run_agent_loop(
                     first_message=False,
                     skip_verify=no_verify,
                     stream=stream,
-                    ms=ms,
                 )
             new_messages = step_response.messages
             heartbeat_request = step_response.heartbeat_request
@@ -394,7 +389,7 @@ def run_agent_loop(
             token_warning = step_response.in_context_memory_warning
             step_response.usage
 
-            agent.save_agent(letta_agent, ms)
+            agent.save_agent(letta_agent)
             skip_next_user_input = False
             if token_warning:
                 user_message = system.get_token_limit_warning()

letta/memory.py

@@ -1,23 +1,13 @@
-import datetime
-from abc import ABC, abstractmethod
-from typing import Callable, Dict, List, Tuple, Union
+from typing import Callable, Dict, List
 
 from letta.constants import MESSAGE_SUMMARY_REQUEST_ACK, MESSAGE_SUMMARY_WARNING_FRAC
-from letta.embeddings import embedding_model, parse_and_chunk_text, query_embedding
 from letta.llm_api.llm_api_tools import create
 from letta.prompts.gpt_summarize import SYSTEM as SUMMARY_PROMPT_SYSTEM
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole
 from letta.schemas.memory import Memory
 from letta.schemas.message import Message
-from letta.schemas.passage import Passage
-from letta.utils import (
-    count_tokens,
-    extract_date_from_timestamp,
-    get_local_time,
-    printd,
-    validate_date_format,
-)
+from letta.utils import count_tokens, printd
 
 
 def get_memory_functions(cls: Memory) -> Dict[str, Callable]:
@@ -67,7 +57,6 @@ def summarize_messages(
             + message_sequence_to_summarize[cutoff:]
         )
 
-    agent_state.user_id
     dummy_agent_id = agent_state.id
     message_sequence = []
     message_sequence.append(Message(agent_id=dummy_agent_id, role=MessageRole.system, text=summary_prompt))
@@ -79,7 +68,7 @@ def summarize_messages(
     llm_config_no_inner_thoughts.put_inner_thoughts_in_kwargs = False
     response = create(
         llm_config=llm_config_no_inner_thoughts,
-        user_id=agent_state.user_id,
+        user_id=agent_state.created_by_id,
         messages=message_sequence,
         stream=False,
     )

letta/o1_agent.py

@@ -2,7 +2,6 @@ from typing import List, Optional, Union
 
 from letta.agent import Agent, save_agent
 from letta.interface import AgentInterface
-from letta.metadata import MetadataStore
 from letta.schemas.agent import AgentState
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import UsageStatistics
@@ -56,7 +55,6 @@ class O1Agent(Agent):
         messages: Union[Message, List[Message]],
         chaining: bool = True,
         max_chaining_steps: Optional[int] = None,
-        ms: Optional[MetadataStore] = None,
         **kwargs,
     ) -> LettaUsageStatistics:
         """Run Agent.inner_step in a loop, terminate when final thinking message is sent or max_thinking_steps is reached"""
@@ -70,7 +68,6 @@ class O1Agent(Agent):
             if counter > 0:
                 next_input_message = []
 
-            kwargs["ms"] = ms
             kwargs["first_message"] = False
             step_response = self.inner_step(
                 messages=next_input_message,
@@ -84,7 +81,6 @@ class O1Agent(Agent):
             # check if it is final thinking message
             if step_response.messages[-1].name == "send_final_message":
                 break
-            if ms:
-                save_agent(self, ms)
+            save_agent(self)
 
         return LettaUsageStatistics(**total_usage.model_dump(), step_count=step_count)

letta/offline_memory_agent.py

@@ -2,7 +2,6 @@ from typing import List, Optional, Union
 
 from letta.agent import Agent, AgentState, save_agent
 from letta.interface import AgentInterface
-from letta.metadata import MetadataStore
 from letta.orm import User
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import UsageStatistics
@@ -130,7 +129,7 @@ class OfflineMemoryAgent(Agent):
         # extras
         first_message_verify_mono: bool = False,
         max_memory_rethinks: int = 10,
-        initial_message_sequence: Optional[List[Message]] = None,  
+        initial_message_sequence: Optional[List[Message]] = None,
     ):
         super().__init__(interface, agent_state, user, initial_message_sequence=initial_message_sequence)
         self.first_message_verify_mono = first_message_verify_mono
@@ -141,7 +140,6 @@ class OfflineMemoryAgent(Agent):
         messages: Union[Message, List[Message]],
         chaining: bool = True,
         max_chaining_steps: Optional[int] = None,
-        ms: Optional[MetadataStore] = None,
         **kwargs,
     ) -> LettaUsageStatistics:
         """Go through what is currently in memory core memory and integrate information."""
@@ -153,7 +151,6 @@ class OfflineMemoryAgent(Agent):
         while counter < self.max_memory_rethinks:
             if counter > 0:
                 next_input_message = []
-            kwargs["ms"] = ms
             kwargs["first_message"] = False
             step_response = self.inner_step(
                 messages=next_input_message,
@@ -172,7 +169,6 @@ class OfflineMemoryAgent(Agent):
             counter += 1
             self.interface.step_complete()
 
-            if ms:
-                save_agent(self, ms)
+            save_agent(self)
 
         return LettaUsageStatistics(**total_usage.model_dump(), step_count=step_count)

letta/orm/__init__.py

@@ -1,3 +1,4 @@
+from letta.orm.agent import Agent
 from letta.orm.agents_tags import AgentsTags
 from letta.orm.base import Base
 from letta.orm.block import Block
@@ -9,6 +10,7 @@ from letta.orm.organization import Organization
 from letta.orm.passage import Passage
 from letta.orm.sandbox_config import SandboxConfig, SandboxEnvironmentVariable
 from letta.orm.source import Source
+from letta.orm.sources_agents import SourcesAgents
 from letta.orm.tool import Tool
 from letta.orm.tools_agents import ToolsAgents
 from letta.orm.user import User

letta/orm/agent.py

@@ -0,0 +1,109 @@
+import uuid
+from typing import TYPE_CHECKING, List, Optional
+
+from sqlalchemy import JSON, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.block import Block
+from letta.orm.custom_columns import (
+    EmbeddingConfigColumn,
+    LLMConfigColumn,
+    ToolRulesColumn,
+)
+from letta.orm.message import Message
+from letta.orm.mixins import OrganizationMixin
+from letta.orm.organization import Organization
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.agent import AgentState as PydanticAgentState
+from letta.schemas.agent import AgentType
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.memory import Memory
+from letta.schemas.tool_rule import ToolRule
+
+if TYPE_CHECKING:
+    from letta.orm.agents_tags import AgentsTags
+    from letta.orm.organization import Organization
+    from letta.orm.source import Source
+    from letta.orm.tool import Tool
+
+
+class Agent(SqlalchemyBase, OrganizationMixin):
+    __tablename__ = "agents"
+    __pydantic_model__ = PydanticAgentState
+    __table_args__ = (UniqueConstraint("organization_id", "name", name="unique_org_agent_name"),)
+
+    # agent generates its own id
+    # TODO: We want to migrate all the ORM models to do this, so we will need to move this to the SqlalchemyBase
+    # TODO: Move this in this PR? at the very end?
+    id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"agent-{uuid.uuid4()}")
+
+    # Descriptor fields
+    agent_type: Mapped[Optional[AgentType]] = mapped_column(String, nullable=True, doc="The type of Agent")
+    name: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="a human-readable identifier for an agent, non-unique.")
+    description: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The description of the agent.")
+
+    # System prompt
+    system: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The system prompt used by the agent.")
+
+    # In context memory
+    # TODO: This should be a separate mapping table
+    # This is dangerously flexible with the JSON type
+    message_ids: Mapped[Optional[List[str]]] = mapped_column(JSON, nullable=True, doc="List of message IDs in in-context memory.")
+
+    # Metadata and configs
+    metadata_: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True, doc="metadata for the agent.")
+    llm_config: Mapped[Optional[LLMConfig]] = mapped_column(
+        LLMConfigColumn, nullable=True, doc="the LLM backend configuration object for this agent."
+    )
+    embedding_config: Mapped[Optional[EmbeddingConfig]] = mapped_column(
+        EmbeddingConfigColumn, doc="the embedding configuration object for this agent."
+    )
+
+    # Tool rules
+    tool_rules: Mapped[Optional[List[ToolRule]]] = mapped_column(ToolRulesColumn, doc="the tool rules for this agent.")
+
+    # relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="agents")
+    tools: Mapped[List["Tool"]] = relationship("Tool", secondary="tools_agents", lazy="selectin", passive_deletes=True)
+    sources: Mapped[List["Source"]] = relationship("Source", secondary="sources_agents", lazy="selectin")
+    core_memory: Mapped[List["Block"]] = relationship("Block", secondary="blocks_agents", lazy="selectin")
+    messages: Mapped[List["Message"]] = relationship(
+        "Message",
+        back_populates="agent",
+        lazy="selectin",
+        cascade="all, delete-orphan",  # Ensure messages are deleted when the agent is deleted
+        passive_deletes=True,
+    )
+    tags: Mapped[List["AgentsTags"]] = relationship(
+        "AgentsTags",
+        back_populates="agent",
+        cascade="all, delete-orphan",
+        lazy="selectin",
+        doc="Tags associated with the agent.",
+    )
+    # passages: Mapped[List["Passage"]] = relationship("Passage", back_populates="agent", lazy="selectin")
+
+    def to_pydantic(self) -> PydanticAgentState:
+        """converts to the basic pydantic model counterpart"""
+        state = {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "message_ids": self.message_ids,
+            "tools": self.tools,
+            "sources": self.sources,
+            "tags": [t.tag for t in self.tags],
+            "tool_rules": self.tool_rules,
+            "system": self.system,
+            "agent_type": self.agent_type,
+            "llm_config": self.llm_config,
+            "embedding_config": self.embedding_config,
+            "metadata_": self.metadata_,
+            "memory": Memory(blocks=[b.to_pydantic() for b in self.core_memory]),
+            "created_by_id": self.created_by_id,
+            "last_updated_by_id": self.last_updated_by_id,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+        }
+        return self.__pydantic_model__(**state)

letta/orm/agents_tags.py

@@ -1,28 +1,20 @@
-from typing import TYPE_CHECKING
-
 from sqlalchemy import ForeignKey, String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from letta.orm.mixins import OrganizationMixin
-from letta.orm.sqlalchemy_base import SqlalchemyBase
-from letta.schemas.agents_tags import AgentsTags as PydanticAgentsTags
-
-if TYPE_CHECKING:
-    from letta.orm.organization import Organization
-
+from letta.orm.base import Base
 
-class AgentsTags(SqlalchemyBase, OrganizationMixin):
-    """Associates tags with agents, allowing agents to have multiple tags and supporting tag-based filtering."""
 
+class AgentsTags(Base):
     __tablename__ = "agents_tags"
-    __pydantic_model__ = PydanticAgentsTags
     __table_args__ = (UniqueConstraint("agent_id", "tag", name="unique_agent_tag"),)
 
-    # The agent associated with this tag
-    agent_id = mapped_column(String, ForeignKey("agents.id"), primary_key=True)
+    # # agent generates its own id
+    # # TODO: We want to migrate all the ORM models to do this, so we will need to move this to the SqlalchemyBase
+    # # TODO: Move this in this PR? at the very end?
+    # id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"agents_tags-{uuid.uuid4()}")
 
-    # The name of the tag
-    tag: Mapped[str] = mapped_column(String, nullable=False, doc="The name of the tag associated with the agent.")
+    agent_id: Mapped[String] = mapped_column(String, ForeignKey("agents.id"), primary_key=True)
+    tag: Mapped[str] = mapped_column(String, doc="The name of the tag associated with the agent.", primary_key=True)
 
-    # relationships
-    organization: Mapped["Organization"] = relationship("Organization", back_populates="agents_tags")
+    # Relationships
+    agent: Mapped["Agent"] = relationship("Agent", back_populates="tags")

letta/orm/block.py

@@ -1,16 +1,17 @@
 from typing import TYPE_CHECKING, Optional, Type
 
-from sqlalchemy import JSON, BigInteger, Integer, UniqueConstraint
-from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy import JSON, BigInteger, Integer, UniqueConstraint, event
+from sqlalchemy.orm import Mapped, attributes, mapped_column, relationship
 
 from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
+from letta.orm.blocks_agents import BlocksAgents
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.block import Human, Persona
 
 if TYPE_CHECKING:
-    from letta.orm import BlocksAgents, Organization
+    from letta.orm import Organization
 
 
 class Block(OrganizationMixin, SqlalchemyBase):
@@ -35,7 +36,6 @@ class Block(OrganizationMixin, SqlalchemyBase):
 
     # relationships
     organization: Mapped[Optional["Organization"]] = relationship("Organization")
-    blocks_agents: Mapped[list["BlocksAgents"]] = relationship("BlocksAgents", back_populates="block", cascade="all, delete")
 
     def to_pydantic(self) -> Type:
         match self.label:
@@ -46,3 +46,28 @@ class Block(OrganizationMixin, SqlalchemyBase):
             case _:
                 Schema = PydanticBlock
         return Schema.model_validate(self)
+
+
+@event.listens_for(Block, "after_update")  # Changed from 'before_update'
+def block_before_update(mapper, connection, target):
+    """Handle updating BlocksAgents when a block's label changes."""
+    label_history = attributes.get_history(target, "label")
+    if not label_history.has_changes():
+        return
+
+    blocks_agents = BlocksAgents.__table__
+    connection.execute(
+        blocks_agents.update()
+        .where(blocks_agents.c.block_id == target.id, blocks_agents.c.block_label == label_history.deleted[0])
+        .values(block_label=label_history.added[0])
+    )
+
+
+@event.listens_for(Block, "before_insert")
+@event.listens_for(Block, "before_update")
+def validate_value_length(mapper, connection, target):
+    """Ensure the value length does not exceed the limit."""
+    if target.value and len(target.value) > target.limit:
+        raise ValueError(
+            f"Value length ({len(target.value)}) exceeds the limit ({target.limit}) for block with label '{target.label}' and id '{target.id}'."
+        )

letta/orm/blocks_agents.py

@@ -1,15 +1,13 @@
 from sqlalchemy import ForeignKey, ForeignKeyConstraint, String, UniqueConstraint
-from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.orm import Mapped, mapped_column
 
-from letta.orm.sqlalchemy_base import SqlalchemyBase
-from letta.schemas.blocks_agents import BlocksAgents as PydanticBlocksAgents
+from letta.orm.base import Base
 
 
-class BlocksAgents(SqlalchemyBase):
+class BlocksAgents(Base):
     """Agents must have one or many blocks to make up their core memory."""
 
     __tablename__ = "blocks_agents"
-    __pydantic_model__ = PydanticBlocksAgents
     __table_args__ = (
         UniqueConstraint(
             "agent_id",
@@ -17,16 +15,12 @@ class BlocksAgents(SqlalchemyBase):
             name="unique_label_per_agent",
         ),
         ForeignKeyConstraint(
-            ["block_id", "block_label"],
-            ["block.id", "block.label"],
-            name="fk_block_id_label",
+            ["block_id", "block_label"], ["block.id", "block.label"], name="fk_block_id_label", deferrable=True, initially="DEFERRED"
         ),
+        UniqueConstraint("agent_id", "block_id", name="unique_agent_block"),
     )
 
     # unique agent + block label
     agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id"), primary_key=True)
     block_id: Mapped[str] = mapped_column(String, primary_key=True)
     block_label: Mapped[str] = mapped_column(String, primary_key=True)
-
-    # relationships
-    block: Mapped["Block"] = relationship("Block", back_populates="blocks_agents")