letta-nightly 0.8.13.dev20250714104447__py3-none-any.whl → 0.8.15.dev20250715080149__py3-none-any.whl

letta/__init__.py

@@ -5,7 +5,7 @@ try:
     __version__ = version("letta")
 except PackageNotFoundError:
     # Fallback for development installations
-    __version__ = "0.8.13"
+    __version__ = "0.8.15"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

letta/constants.py

@@ -372,3 +372,9 @@ PINECONE_METRIC = "cosine"
 PINECONE_CLOUD = "aws"
 PINECONE_REGION = "us-east-1"
 PINECONE_MAX_BATCH_SIZE = 96
+
+# retry configuration
+PINECONE_MAX_RETRY_ATTEMPTS = 3
+PINECONE_RETRY_BASE_DELAY = 1.0  # seconds
+PINECONE_RETRY_MAX_DELAY = 60.0  # seconds
+PINECONE_RETRY_BACKOFF_FACTOR = 2.0

letta/functions/function_sets/base.py

@@ -135,7 +135,7 @@ def core_memory_append(agent_state: "AgentState", label: str, content: str) -> O
     Append to the contents of core memory.
 
     Args:
-        label (str): Section of the memory to be edited (persona or human).
+        label (str): Section of the memory to be edited.
         content (str): Content to write to the memory. All unicode (including emojis) are supported.
 
     Returns:
@@ -152,7 +152,7 @@ def core_memory_replace(agent_state: "AgentState", label: str, old_content: str,
     Replace the contents of core memory. To delete memories, use an empty string for new_content.
 
     Args:
-        label (str): Section of the memory to be edited (persona or human).
+        label (str): Section of the memory to be edited.
         old_content (str): String to replace. Must be an exact match.
         new_content (str): Content to write to the memory. All unicode (including emojis) are supported.
 

letta/functions/function_sets/files.py

@@ -46,12 +46,12 @@ async def grep_files(
     context_lines: Optional[int] = 3,
 ) -> str:
     """
-    Grep tool to search files across data sources using a keyword or regex pattern.
+    Searches file contents for pattern matches with surrounding context.
 
-    Use this when you want to:
-    - Quickly find occurrences of a variable, function, or keyword
-    - Locate log messages, error codes, or TODOs across files
-    - Understand surrounding code by including `context_lines`
+    Ideal for:
+    - Finding specific code elements (variables, functions, keywords)
+    - Locating error messages or specific text across multiple files
+    - Examining code in context to understand usage patterns
 
     Args:
         pattern (str): Keyword or regex pattern to search within file contents.
@@ -67,15 +67,15 @@ async def grep_files(
 
 async def semantic_search_files(agent_state: "AgentState", query: str, limit: int = 5) -> List["FileMetadata"]:
     """
-    Get list of most relevant chunks from any file using vector/embedding search.
+    Searches file contents using semantic meaning rather than exact matches.
 
-    Use this when you want to:
-    - Find related content that without using exact keywords (e.g., conceptually similar sections)
-    - Look up high-level descriptions, documentation, or config patterns
-    - Perform fuzzy search when grep isn't sufficient
+    Ideal for:
+    - Finding conceptually related information across files
+    - Discovering relevant content without knowing exact keywords
+    - Locating files with similar topics or themes
 
     Args:
-        query (str): The search query.
+        query (str): The search query text to find semantically similar content.
         limit: Maximum number of results to return (default: 5)
 
     Returns:

letta/helpers/decorators.py

@@ -152,7 +152,7 @@ def async_redis_cache(
         def get_cache_key(*args, **kwargs):
             return f"{prefix}:{key_func(*args, **kwargs)}"
 
-        # async_wrapper.cache_invalidate = invalidate
+        async_wrapper.cache_invalidate = invalidate
         async_wrapper.cache_key_func = get_cache_key
         async_wrapper.cache_stats = stats
         return async_wrapper

letta/helpers/pinecone_utils.py

@@ -1,8 +1,20 @@
+import asyncio
+import random
+import time
+from functools import wraps
 from typing import Any, Dict, List
 
+from letta.otel.tracing import trace_method
+
 try:
     from pinecone import IndexEmbed, PineconeAsyncio
-    from pinecone.exceptions.exceptions import NotFoundException
+    from pinecone.exceptions.exceptions import (
+        ForbiddenException,
+        NotFoundException,
+        PineconeApiException,
+        ServiceException,
+        UnauthorizedException,
+    )
 
     PINECONE_AVAILABLE = True
 except ImportError:
@@ -12,8 +24,12 @@ from letta.constants import (
     PINECONE_CLOUD,
     PINECONE_EMBEDDING_MODEL,
     PINECONE_MAX_BATCH_SIZE,
+    PINECONE_MAX_RETRY_ATTEMPTS,
     PINECONE_METRIC,
     PINECONE_REGION,
+    PINECONE_RETRY_BACKOFF_FACTOR,
+    PINECONE_RETRY_BASE_DELAY,
+    PINECONE_RETRY_MAX_DELAY,
     PINECONE_TEXT_FIELD_NAME,
 )
 from letta.log import get_logger
@@ -23,6 +39,87 @@ from letta.settings import settings
 logger = get_logger(__name__)
 
 
+def pinecone_retry(
+    max_attempts: int = PINECONE_MAX_RETRY_ATTEMPTS,
+    base_delay: float = PINECONE_RETRY_BASE_DELAY,
+    max_delay: float = PINECONE_RETRY_MAX_DELAY,
+    backoff_factor: float = PINECONE_RETRY_BACKOFF_FACTOR,
+):
+    """
+    Decorator to retry Pinecone operations with exponential backoff.
+
+    Args:
+        max_attempts: Maximum number of retry attempts
+        base_delay: Base delay in seconds for the first retry
+        max_delay: Maximum delay in seconds between retries
+        backoff_factor: Factor to increase delay after each failed attempt
+    """
+
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            operation_name = func.__name__
+            start_time = time.time()
+
+            for attempt in range(max_attempts):
+                try:
+                    logger.debug(f"[Pinecone] Starting {operation_name} (attempt {attempt + 1}/{max_attempts})")
+                    result = await func(*args, **kwargs)
+
+                    execution_time = time.time() - start_time
+                    logger.info(f"[Pinecone] {operation_name} completed successfully in {execution_time:.2f}s")
+                    return result
+
+                except (ServiceException, PineconeApiException) as e:
+                    # retryable server errors
+                    if attempt == max_attempts - 1:
+                        execution_time = time.time() - start_time
+                        logger.error(f"[Pinecone] {operation_name} failed after {max_attempts} attempts in {execution_time:.2f}s: {str(e)}")
+                        raise
+
+                    # calculate delay with exponential backoff and jitter
+                    delay = min(base_delay * (backoff_factor**attempt), max_delay)
+                    jitter = random.uniform(0, delay * 0.1)  # add up to 10% jitter
+                    total_delay = delay + jitter
+
+                    logger.warning(
+                        f"[Pinecone] {operation_name} failed (attempt {attempt + 1}/{max_attempts}): {str(e)}. Retrying in {total_delay:.2f}s"
+                    )
+                    await asyncio.sleep(total_delay)
+
+                except (UnauthorizedException, ForbiddenException) as e:
+                    # non-retryable auth errors
+                    execution_time = time.time() - start_time
+                    logger.error(f"[Pinecone] {operation_name} failed with auth error in {execution_time:.2f}s: {str(e)}")
+                    raise
+
+                except NotFoundException as e:
+                    # non-retryable not found errors
+                    execution_time = time.time() - start_time
+                    logger.warning(f"[Pinecone] {operation_name} failed with not found error in {execution_time:.2f}s: {str(e)}")
+                    raise
+
+                except Exception as e:
+                    # other unexpected errors - retry once then fail
+                    if attempt == max_attempts - 1:
+                        execution_time = time.time() - start_time
+                        logger.error(f"[Pinecone] {operation_name} failed after {max_attempts} attempts in {execution_time:.2f}s: {str(e)}")
+                        raise
+
+                    delay = min(base_delay * (backoff_factor**attempt), max_delay)
+                    jitter = random.uniform(0, delay * 0.1)
+                    total_delay = delay + jitter
+
+                    logger.warning(
+                        f"[Pinecone] {operation_name} failed with unexpected error (attempt {attempt + 1}/{max_attempts}): {str(e)}. Retrying in {total_delay:.2f}s"
+                    )
+                    await asyncio.sleep(total_delay)
+
+        return wrapper
+
+    return decorator
+
+
 def should_use_pinecone(verbose: bool = False):
     if verbose:
         logger.info(
@@ -44,29 +141,42 @@ def should_use_pinecone(verbose: bool = False):
     )
 
 
+@pinecone_retry()
+@trace_method
 async def upsert_pinecone_indices():
     if not PINECONE_AVAILABLE:
         raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
 
-    for index_name in get_pinecone_indices():
+    indices = get_pinecone_indices()
+    logger.info(f"[Pinecone] Upserting {len(indices)} indices: {indices}")
+
+    for index_name in indices:
         async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
             if not await pc.has_index(index_name):
+                logger.info(f"[Pinecone] Creating index {index_name} with model {PINECONE_EMBEDDING_MODEL}")
                 await pc.create_index_for_model(
                     name=index_name,
                     cloud=PINECONE_CLOUD,
                     region=PINECONE_REGION,
                     embed=IndexEmbed(model=PINECONE_EMBEDDING_MODEL, field_map={"text": PINECONE_TEXT_FIELD_NAME}, metric=PINECONE_METRIC),
                 )
+                logger.info(f"[Pinecone] Successfully created index {index_name}")
+            else:
+                logger.debug(f"[Pinecone] Index {index_name} already exists")
 
 
 def get_pinecone_indices() -> List[str]:
     return [settings.pinecone_agent_index, settings.pinecone_source_index]
 
 
+@pinecone_retry()
+@trace_method
 async def upsert_file_records_to_pinecone_index(file_id: str, source_id: str, chunks: List[str], actor: User):
     if not PINECONE_AVAILABLE:
         raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
 
+    logger.info(f"[Pinecone] Preparing to upsert {len(chunks)} chunks for file {file_id} source {source_id}")
+
     records = []
     for i, chunk in enumerate(chunks):
         record = {
@@ -77,14 +187,19 @@ async def upsert_file_records_to_pinecone_index(file_id: str, source_id: str, ch
         }
         records.append(record)
 
+    logger.debug(f"[Pinecone] Created {len(records)} records for file {file_id}")
     return await upsert_records_to_pinecone_index(records, actor)
 
 
+@pinecone_retry()
+@trace_method
 async def delete_file_records_from_pinecone_index(file_id: str, actor: User):
     if not PINECONE_AVAILABLE:
         raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
 
     namespace = actor.organization_id
+    logger.info(f"[Pinecone] Deleting records for file {file_id} from index {settings.pinecone_source_index} namespace {namespace}")
+
     try:
         async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
             description = await pc.describe_index(name=settings.pinecone_source_index)
@@ -95,48 +210,72 @@ async def delete_file_records_from_pinecone_index(file_id: str, actor: User):
                     },
                     namespace=namespace,
                 )
+                logger.info(f"[Pinecone] Successfully deleted records for file {file_id}")
     except NotFoundException:
-        logger.warning(f"Pinecone namespace {namespace} not found for {file_id} and {actor.organization_id}")
+        logger.warning(f"[Pinecone] Namespace {namespace} not found for file {file_id} and org {actor.organization_id}")
 
 
+@pinecone_retry()
+@trace_method
 async def delete_source_records_from_pinecone_index(source_id: str, actor: User):
     if not PINECONE_AVAILABLE:
         raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
 
     namespace = actor.organization_id
+    logger.info(f"[Pinecone] Deleting records for source {source_id} from index {settings.pinecone_source_index} namespace {namespace}")
+
     try:
         async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
             description = await pc.describe_index(name=settings.pinecone_source_index)
             async with pc.IndexAsyncio(host=description.index.host) as dense_index:
                 await dense_index.delete(filter={"source_id": {"$eq": source_id}}, namespace=namespace)
+                logger.info(f"[Pinecone] Successfully deleted records for source {source_id}")
     except NotFoundException:
-        logger.warning(f"Pinecone namespace {namespace} not found for {source_id} and {actor.organization_id}")
+        logger.warning(f"[Pinecone] Namespace {namespace} not found for source {source_id} and org {actor.organization_id}")
 
 
+@pinecone_retry()
+@trace_method
 async def upsert_records_to_pinecone_index(records: List[dict], actor: User):
     if not PINECONE_AVAILABLE:
         raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
 
+    logger.info(f"[Pinecone] Upserting {len(records)} records to index {settings.pinecone_source_index} for org {actor.organization_id}")
+
     async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
         description = await pc.describe_index(name=settings.pinecone_source_index)
         async with pc.IndexAsyncio(host=description.index.host) as dense_index:
-            # Process records in batches to avoid exceeding Pinecone limits
+            # process records in batches to avoid exceeding pinecone limits
+            total_batches = (len(records) + PINECONE_MAX_BATCH_SIZE - 1) // PINECONE_MAX_BATCH_SIZE
+            logger.debug(f"[Pinecone] Processing {total_batches} batches of max {PINECONE_MAX_BATCH_SIZE} records each")
+
             for i in range(0, len(records), PINECONE_MAX_BATCH_SIZE):
                 batch = records[i : i + PINECONE_MAX_BATCH_SIZE]
+                batch_num = (i // PINECONE_MAX_BATCH_SIZE) + 1
+
+                logger.debug(f"[Pinecone] Upserting batch {batch_num}/{total_batches} with {len(batch)} records")
                 await dense_index.upsert_records(actor.organization_id, batch)
 
+            logger.info(f"[Pinecone] Successfully upserted all {len(records)} records in {total_batches} batches")
+
 
+@pinecone_retry()
+@trace_method
 async def search_pinecone_index(query: str, limit: int, filter: Dict[str, Any], actor: User) -> Dict[str, Any]:
     if not PINECONE_AVAILABLE:
         raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
 
+    namespace = actor.organization_id
+    logger.info(
+        f"[Pinecone] Searching index {settings.pinecone_source_index} namespace {namespace} with query length {len(query)} chars, limit {limit}"
+    )
+    logger.debug(f"[Pinecone] Search filter: {filter}")
+
     async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
         description = await pc.describe_index(name=settings.pinecone_source_index)
         async with pc.IndexAsyncio(host=description.index.host) as dense_index:
-            namespace = actor.organization_id
-
             try:
-                # Search the dense index with reranking
+                # search the dense index with reranking
                 search_results = await dense_index.search(
                     namespace=namespace,
                     query={
@@ -146,17 +285,26 @@ async def search_pinecone_index(query: str, limit: int, filter: Dict[str, Any],
                     },
                     rerank={"model": "bge-reranker-v2-m3", "top_n": limit, "rank_fields": [PINECONE_TEXT_FIELD_NAME]},
                 )
+
+                result_count = len(search_results.get("matches", []))
+                logger.info(f"[Pinecone] Search completed, found {result_count} matches")
                 return search_results
+
             except Exception as e:
-                logger.warning(f"Failed to search Pinecone namespace {actor.organization_id}: {str(e)}")
+                logger.warning(f"[Pinecone] Failed to search namespace {namespace}: {str(e)}")
                 raise e
 
 
+@pinecone_retry()
+@trace_method
 async def list_pinecone_index_for_files(file_id: str, actor: User, limit: int = None, pagination_token: str = None) -> List[str]:
     if not PINECONE_AVAILABLE:
         raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
 
     namespace = actor.organization_id
+    logger.info(f"[Pinecone] Listing records for file {file_id} from index {settings.pinecone_source_index} namespace {namespace}")
+    logger.debug(f"[Pinecone] List params - limit: {limit}, pagination_token: {pagination_token}")
+
     try:
         async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
             description = await pc.describe_index(name=settings.pinecone_source_index)
@@ -172,9 +320,14 @@ async def list_pinecone_index_for_files(file_id: str, actor: User, limit: int =
                     result = []
                     async for ids in dense_index.list(**kwargs):
                         result.extend(ids)
+
+                    logger.info(f"[Pinecone] Successfully listed {len(result)} records for file {file_id}")
                     return result
+
                 except Exception as e:
-                    logger.warning(f"Failed to list Pinecone namespace {actor.organization_id}: {str(e)}")
+                    logger.warning(f"[Pinecone] Failed to list records for file {file_id} in namespace {namespace}: {str(e)}")
                     raise e
+
     except NotFoundException:
-        logger.warning(f"Pinecone namespace {namespace} not found for {file_id} and {actor.organization_id}")
+        logger.warning(f"[Pinecone] Namespace {namespace} not found for file {file_id} and org {actor.organization_id}")
+        return []

letta/orm/agent.py

@@ -314,7 +314,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
         state["sources"] = [s.to_pydantic() for s in sources]
         state["memory"] = Memory(
             blocks=[m.to_pydantic() for m in memory],
-            file_blocks=[block for b in self.file_agents if (block := b.to_pydantic_block()) is not None],
+            file_blocks=[block for b in file_agents if (block := b.to_pydantic_block()) is not None],
             prompt_template=get_prompt_template_for_agent_type(self.agent_type),
         )
         state["identity_ids"] = [i.id for i in identities]

letta/orm/file.py

@@ -1,5 +1,5 @@
 import uuid
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Optional
 
 from sqlalchemy import ForeignKey, Index, Integer, String, Text, UniqueConstraint, desc
 from sqlalchemy.ext.asyncio import AsyncAttrs
@@ -11,10 +11,7 @@ from letta.schemas.enums import FileProcessingStatus
 from letta.schemas.file import FileMetadata as PydanticFileMetadata
 
 if TYPE_CHECKING:
-    from letta.orm.files_agents import FileAgent
-    from letta.orm.organization import Organization
-    from letta.orm.passage import SourcePassage
-    from letta.orm.source import Source
+    pass
 
 
 # TODO: Note that this is NOT organization scoped, this is potentially dangerous if we misuse this
@@ -64,18 +61,6 @@ class FileMetadata(SqlalchemyBase, OrganizationMixin, SourceMixin, AsyncAttrs):
     chunks_embedded: Mapped[Optional[int]] = mapped_column(Integer, nullable=True, doc="Number of chunks that have been embedded.")
 
     # relationships
-    organization: Mapped["Organization"] = relationship("Organization", back_populates="files", lazy="selectin")
-    source: Mapped["Source"] = relationship("Source", back_populates="files", lazy="selectin")
-    source_passages: Mapped[List["SourcePassage"]] = relationship(
-        "SourcePassage", back_populates="file", lazy="selectin", cascade="all, delete-orphan"
-    )
-    file_agents: Mapped[List["FileAgent"]] = relationship(
-        "FileAgent",
-        back_populates="file",
-        lazy="selectin",
-        cascade="all, delete-orphan",
-        passive_deletes=True,  # ← add this
-    )
     content: Mapped[Optional["FileContent"]] = relationship(
         "FileContent",
         uselist=False,

letta/orm/files_agents.py

@@ -12,7 +12,7 @@ from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.file import FileAgent as PydanticFileAgent
 
 if TYPE_CHECKING:
-    from letta.orm.file import FileMetadata
+    pass
 
 
 class FileAgent(SqlalchemyBase, OrganizationMixin):
@@ -55,6 +55,12 @@ class FileAgent(SqlalchemyBase, OrganizationMixin):
         nullable=False,
         doc="ID of the agent",
     )
+    source_id: Mapped[str] = mapped_column(
+        String,
+        ForeignKey("sources.id", ondelete="CASCADE"),
+        nullable=False,
+        doc="ID of the source (denormalized from files.source_id)",
+    )
 
     file_name: Mapped[str] = mapped_column(
         String,
@@ -78,13 +84,6 @@ class FileAgent(SqlalchemyBase, OrganizationMixin):
         back_populates="file_agents",
         lazy="selectin",
     )
-    file: Mapped["FileMetadata"] = relationship(
-        "FileMetadata",
-        foreign_keys=[file_id],
-        lazy="selectin",
-        back_populates="file_agents",
-        passive_deletes=True,  # ← add this
-    )
 
     # TODO: This is temporary as we figure out if we want FileBlock as a first class citizen
     def to_pydantic_block(self) -> PydanticBlock:
@@ -99,8 +98,8 @@ class FileAgent(SqlalchemyBase, OrganizationMixin):
         return PydanticBlock(
             organization_id=self.organization_id,
             value=visible_content,
-            label=self.file.file_name,
+            label=self.file_name,  # use denormalized file_name instead of self.file.file_name
             read_only=True,
-            metadata={"source_id": self.file.source_id},
+            metadata={"source_id": self.source_id},  # use denormalized source_id
             limit=CORE_MEMORY_SOURCE_CHAR_LIMIT,
         )

letta/orm/organization.py

@@ -9,7 +9,6 @@ if TYPE_CHECKING:
     from letta.orm.agent import Agent
     from letta.orm.agent_passage import AgentPassage
     from letta.orm.block import Block
-    from letta.orm.file import FileMetadata
     from letta.orm.group import Group
     from letta.orm.identity import Identity
     from letta.orm.llm_batch_item import LLMBatchItem
@@ -18,7 +17,6 @@ if TYPE_CHECKING:
     from letta.orm.provider import Provider
     from letta.orm.sandbox_config import AgentEnvironmentVariable, SandboxConfig
     from letta.orm.sandbox_environment_variable import SandboxEnvironmentVariable
-    from letta.orm.source import Source
     from letta.orm.source_passage import SourcePassage
     from letta.orm.tool import Tool
     from letta.orm.user import User
@@ -38,8 +36,6 @@ class Organization(SqlalchemyBase):
     tools: Mapped[List["Tool"]] = relationship("Tool", back_populates="organization", cascade="all, delete-orphan")
     # mcp_servers: Mapped[List["MCPServer"]] = relationship("MCPServer", back_populates="organization", cascade="all, delete-orphan")
     blocks: Mapped[List["Block"]] = relationship("Block", back_populates="organization", cascade="all, delete-orphan")
-    sources: Mapped[List["Source"]] = relationship("Source", back_populates="organization", cascade="all, delete-orphan")
-    files: Mapped[List["FileMetadata"]] = relationship("FileMetadata", back_populates="organization", cascade="all, delete-orphan")
     sandbox_configs: Mapped[List["SandboxConfig"]] = relationship(
         "SandboxConfig", back_populates="organization", cascade="all, delete-orphan"
     )

letta/orm/passage.py

@@ -49,11 +49,6 @@ class SourcePassage(BasePassage, FileMixin, SourceMixin):
 
     file_name: Mapped[str] = mapped_column(doc="The name of the file that this passage was derived from")
 
-    @declared_attr
-    def file(cls) -> Mapped["FileMetadata"]:
-        """Relationship to file"""
-        return relationship("FileMetadata", back_populates="source_passages", lazy="selectin")
-
     @declared_attr
     def organization(cls) -> Mapped["Organization"]:
         return relationship("Organization", back_populates="source_passages", lazy="selectin")
@@ -74,11 +69,6 @@ class SourcePassage(BasePassage, FileMixin, SourceMixin):
             {"extend_existing": True},
         )
 
-    @declared_attr
-    def source(cls) -> Mapped["Source"]:
-        """Relationship to source"""
-        return relationship("Source", back_populates="passages", lazy="selectin", passive_deletes=True)
-
 
 class AgentPassage(BasePassage, AgentMixin):
     """Passages created by agents as archival memories"""

letta/orm/source.py

@@ -1,9 +1,8 @@
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Optional
 
 from sqlalchemy import JSON, Index, UniqueConstraint
-from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.orm import Mapped, mapped_column
 
-from letta.orm import FileMetadata
 from letta.orm.custom_columns import EmbeddingConfigColumn
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
@@ -11,10 +10,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.source import Source as PydanticSource
 
 if TYPE_CHECKING:
-    from letta.orm.agent import Agent
-    from letta.orm.file import FileMetadata
-    from letta.orm.organization import Organization
-    from letta.orm.passage import SourcePassage
+    pass
 
 
 class Source(SqlalchemyBase, OrganizationMixin):
@@ -34,16 +30,3 @@ class Source(SqlalchemyBase, OrganizationMixin):
     instructions: Mapped[str] = mapped_column(nullable=True, doc="instructions for how to use the source")
     embedding_config: Mapped[EmbeddingConfig] = mapped_column(EmbeddingConfigColumn, doc="Configuration settings for embedding.")
     metadata_: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True, doc="metadata for the source.")
-
-    # relationships
-    organization: Mapped["Organization"] = relationship("Organization", back_populates="sources")
-    files: Mapped[List["FileMetadata"]] = relationship("FileMetadata", back_populates="source", cascade="all, delete-orphan")
-    passages: Mapped[List["SourcePassage"]] = relationship("SourcePassage", back_populates="source", cascade="all, delete-orphan")
-    agents: Mapped[List["Agent"]] = relationship(
-        "Agent",
-        secondary="sources_agents",
-        back_populates="sources",
-        lazy="selectin",
-        cascade="save-update",  # Only propagate save and update operations
-        passive_deletes=True,  # Let the database handle deletions
-    )