Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
feat: Add project_id to message filtering/inserting to Turbopuffer [LET-4252] (#4466)
Matthew Zhou531eb6afeba2
diff --git a/letta/agents/letta_agent.py b/letta/agents/letta_agent.pyindex 44e58ebc2..e5639be0f 100644--- a/letta/agents/letta_agent.py+++ b/letta/agents/letta_agent.py@@ -498,6 +498,7 @@ class LettaAgent(BaseAgent):initial_messages,actor=self.actor,project_id=agent_state.project_id,+ template_id=agent_state.template_id,)elif step_progression <= StepProgression.LOGGED_TRACE:if stop_reason is None:@@ -828,6 +829,7 @@ class LettaAgent(BaseAgent):initial_messages,actor=self.actor,project_id=agent_state.project_id,+ template_id=agent_state.template_id,)elif step_progression <= StepProgression.LOGGED_TRACE:if stop_reason is None:@@ -1269,6 +1271,7 @@ class LettaAgent(BaseAgent):initial_messages,actor=self.actor,project_id=agent_state.project_id,+ template_id=agent_state.template_id,)elif step_progression <= StepProgression.LOGGED_TRACE:if stop_reason is None:@@ -1676,7 +1679,7 @@ class LettaAgent(BaseAgent):)messages_to_persist = (initial_messages or []) + tool_call_messagespersisted_messages = await self.message_manager.create_many_messages_async(- messages_to_persist, actor=self.actor, project_id=agent_state.project_id+ messages_to_persist, actor=self.actor, project_id=agent_state.project_id, template_id=agent_state.template_id)return persisted_messages, continue_stepping, stop_reason@@ -1787,7 +1790,7 @@ class LettaAgent(BaseAgent):messages_to_persist = (initial_messages or []) + tool_call_messagespersisted_messages = await self.message_manager.create_many_messages_async(- messages_to_persist, actor=self.actor, project_id=agent_state.project_id+ messages_to_persist, actor=self.actor, project_id=agent_state.project_id, template_id=agent_state.template_id)if run_id:diff --git a/letta/helpers/tpuf_client.py b/letta/helpers/tpuf_client.pyindex 3a6211d64..afdebec54 100644--- a/letta/helpers/tpuf_client.py+++ b/letta/helpers/tpuf_client.py@@ -220,6 +220,7 @@ class TurbopufferClient:roles: List[MessageRole],created_ats: List[datetime],project_id: Optional[str] = None,+ template_id: Optional[str] = None,) -> bool:"""Insert messages into Turbopuffer.@@ -232,6 +233,7 @@ class TurbopufferClient:roles: List of message roles corresponding to each messagecreated_ats: List of creation timestamps for each messageproject_id: Optional project ID for all messages+ template_id: Optional template ID for all messagesReturns:True if successful@@ -262,6 +264,7 @@ class TurbopufferClient:message_roles = []created_at_timestamps = []project_ids = []+ template_ids = []for idx, (text, embedding, role, created_at) in enumerate(zip(message_texts, embeddings, roles, created_ats)):message_id = message_ids[idx]@@ -283,6 +286,7 @@ class TurbopufferClient:message_roles.append(role.value)created_at_timestamps.append(timestamp)project_ids.append(project_id)+ template_ids.append(template_id)# build column-based upsert dataupsert_columns = {@@ -299,6 +303,10 @@ class TurbopufferClient:if project_id is not None:upsert_columns["project_id"] = project_ids+ # only include template_id if it's provided+ if template_id is not None:+ upsert_columns["template_id"] = template_ids+try:# Use AsyncTurbopuffer as a context manager for proper resource cleanupasync with AsyncTurbopuffer(api_key=self.api_key, region=self.region) as client:@@ -573,6 +581,7 @@ class TurbopufferClient:top_k: int = 10,roles: Optional[List[MessageRole]] = None,project_id: Optional[str] = None,+ template_id: Optional[str] = None,vector_weight: float = 0.5,fts_weight: float = 0.5,start_date: Optional[datetime] = None,@@ -589,6 +598,7 @@ class TurbopufferClient:top_k: Number of results to returnroles: Optional list of message roles to filter byproject_id: Optional project ID to filter messages by+ template_id: Optional template ID to filter messages byvector_weight: Weight for vector search results in hybrid mode (default: 0.5)fts_weight: Weight for FTS results in hybrid mode (default: 0.5)start_date: Optional datetime to filter messages created after this date@@ -644,12 +654,19 @@ class TurbopufferClient:if project_id:project_filter = ("project_id", "Eq", project_id)+ # build template_id filter if provided+ template_filter = None+ if template_id:+ template_filter = ("template_id", "Eq", template_id)+# combine all filtersall_filters = [agent_filter] # always include agent_id filterif role_filter:all_filters.append(role_filter)if project_filter:all_filters.append(project_filter)+ if template_filter:+ all_filters.append(template_filter)if date_filters:all_filters.extend(date_filters)@@ -717,6 +734,7 @@ class TurbopufferClient:top_k: int = 10,roles: Optional[List[MessageRole]] = None,project_id: Optional[str] = None,+ template_id: Optional[str] = None,vector_weight: float = 0.5,fts_weight: float = 0.5,start_date: Optional[datetime] = None,@@ -732,6 +750,7 @@ class TurbopufferClient:top_k: Number of results to returnroles: Optional list of message roles to filter byproject_id: Optional project ID to filter messages by+ template_id: Optional template ID to filter messages byvector_weight: Weight for vector search results in hybrid mode (default: 0.5)fts_weight: Weight for FTS results in hybrid mode (default: 0.5)start_date: Optional datetime to filter messages created after this date@@ -766,6 +785,10 @@ class TurbopufferClient:if project_id:all_filters.append(("project_id", "Eq", project_id))+ # template filter+ if template_id:+ all_filters.append(("template_id", "Eq", template_id))+# date filtersif start_date:all_filters.append(("created_at", "Gte", start_date))diff --git a/letta/schemas/message.py b/letta/schemas/message.pyindex 1e1a2200c..eadcbf41d 100644--- a/letta/schemas/message.py+++ b/letta/schemas/message.py@@ -1196,6 +1196,7 @@ class MessageSearchRequest(BaseModel):search_mode: Literal["vector", "fts", "hybrid"] = Field("hybrid", description="Search mode to use")roles: Optional[List[MessageRole]] = Field(None, description="Filter messages by role")project_id: Optional[str] = Field(None, description="Filter messages by project ID")+ template_id: Optional[str] = Field(None, description="Filter messages by template ID")limit: int = Field(50, description="Maximum number of results to return", ge=1, le=100)start_date: Optional[datetime] = Field(None, description="Filter messages created after this date")end_date: Optional[datetime] = Field(None, description="Filter messages created on or before this date")diff --git a/letta/server/rest_api/routers/v1/agents.py b/letta/server/rest_api/routers/v1/agents.pyindex 6af060374..320075c07 100644--- a/letta/server/rest_api/routers/v1/agents.py+++ b/letta/server/rest_api/routers/v1/agents.py@@ -1524,7 +1524,7 @@ async def search_messages(actor_id: str | None = Header(None, alias="user_id"),):"""- Search messages across the entire organization with optional project filtering. Returns messages with FTS/vector ranks and total RRF score.+ Search messages across the entire organization with optional project and template filtering. Returns messages with FTS/vector ranks and total RRF score.This is a cloud-only feature."""@@ -1543,6 +1543,7 @@ async def search_messages(search_mode=request.search_mode,roles=request.roles,project_id=request.project_id,+ template_id=request.template_id,limit=request.limit,start_date=request.start_date,end_date=request.end_date,diff --git a/letta/services/agent_manager.py b/letta/services/agent_manager.pyindex 022e2f3ba..417a010c3 100644--- a/letta/services/agent_manager.py+++ b/letta/services/agent_manager.py@@ -719,7 +719,9 @@ class AgentManager:# Only create messages if we initialized with messagesif not _init_with_no_messages:- await self.message_manager.create_many_messages_async(pydantic_msgs=init_messages, actor=actor, project_id=result.project_id)+ await self.message_manager.create_many_messages_async(+ pydantic_msgs=init_messages, actor=actor, project_id=result.project_id, template_id=result.template_id+ )return result@enforce_types@@ -1886,7 +1888,9 @@ class AgentManager:self, messages: List[PydanticMessage], agent_id: str, actor: PydanticUser) -> PydanticAgentState:agent = await self.get_agent_by_id_async(agent_id=agent_id, actor=actor)- messages = await self.message_manager.create_many_messages_async(messages, actor=actor, project_id=agent.project_id)+ messages = await self.message_manager.create_many_messages_async(+ messages, actor=actor, project_id=agent.project_id, template_id=agent.template_id+ )message_ids = agent.message_ids or []message_ids += [m.id for m in messages]return await self.set_in_context_messages_async(agent_id=agent_id, message_ids=message_ids, actor=actor)diff --git a/letta/services/agent_serialization_manager.py b/letta/services/agent_serialization_manager.pyindex 992c50eac..bc0e07c3e 100644--- a/letta/services/agent_serialization_manager.py+++ b/letta/services/agent_serialization_manager.py@@ -679,6 +679,7 @@ class AgentSerializationManager:pydantic_msgs=messages,actor=actor,project_id=created_agent.project_id,+ template_id=created_agent.template_id,)imported_count += len(created_messages)diff --git a/letta/services/message_manager.py b/letta/services/message_manager.pyindex 51b07e1fe..f5b7f7be9 100644--- a/letta/services/message_manager.py+++ b/letta/services/message_manager.py@@ -315,6 +315,7 @@ class MessageManager:actor: PydanticUser,strict_mode: bool = False,project_id: Optional[str] = None,+ template_id: Optional[str] = None,) -> List[PydanticMessage]:"""Create multiple messages in a single database transaction asynchronously.@@ -324,6 +325,7 @@ class MessageManager:actor: User performing the actionstrict_mode: If True, wait for embedding to complete; if False, run in backgroundproject_id: Optional project ID for the messages (for Turbopuffer indexing)+ template_id: Optional template ID for the messages (for Turbopuffer indexing)Returns:List of created Pydantic message models@@ -371,11 +373,11 @@ class MessageManager:if agent_id:if strict_mode:# wait for embedding to complete- await self._embed_messages_background(result, actor, agent_id, project_id)+ await self._embed_messages_background(result, actor, agent_id, project_id, template_id)else:# fire and forget - run embedding in backgroundfire_and_forget(- self._embed_messages_background(result, actor, agent_id, project_id),+ self._embed_messages_background(result, actor, agent_id, project_id, template_id),task_name=f"embed_messages_for_agent_{agent_id}",)@@ -387,6 +389,7 @@ class MessageManager:actor: PydanticUser,agent_id: str,project_id: Optional[str] = None,+ template_id: Optional[str] = None,) -> None:"""Background task to embed and store messages in Turbopuffer.@@ -395,6 +398,7 @@ class MessageManager:actor: User performing the actionagent_id: Agent ID for the messagesproject_id: Optional project ID for the messages+ template_id: Optional template ID for the messages"""try:from letta.helpers.tpuf_client import TurbopufferClient@@ -428,6 +432,7 @@ class MessageManager:roles=roles,created_ats=created_ats,project_id=project_id,+ template_id=template_id,)logger.info(f"Successfully embedded {len(message_texts)} messages for agent {agent_id}")except Exception as e:@@ -539,6 +544,7 @@ class MessageManager:actor: PydanticUser,strict_mode: bool = False,project_id: Optional[str] = None,+ template_id: Optional[str] = None,) -> PydanticMessage:"""Updates an existing record in the database with values from the provided record object.@@ -550,6 +556,7 @@ class MessageManager:actor: User performing the actionstrict_mode: If True, wait for embedding update to complete; if False, run in backgroundproject_id: Optional project ID for the message (for Turbopuffer indexing)+ template_id: Optional template ID for the message (for Turbopuffer indexing)"""async with db_registry.async_session() as session:# Fetch existing message from database@@ -575,18 +582,18 @@ class MessageManager:if text:if strict_mode:# wait for embedding update to complete- await self._update_message_embedding_background(pydantic_message, text, actor, project_id)+ await self._update_message_embedding_background(pydantic_message, text, actor, project_id, template_id)else:# fire and forget - run embedding update in backgroundfire_and_forget(- self._update_message_embedding_background(pydantic_message, text, actor, project_id),+ self._update_message_embedding_background(pydantic_message, text, actor, project_id, template_id),task_name=f"update_message_embedding_{message_id}",)return pydantic_messageasync def _update_message_embedding_background(- self, message: PydanticMessage, text: str, actor: PydanticUser, project_id: Optional[str] = None+ self, message: PydanticMessage, text: str, actor: PydanticUser, project_id: Optional[str] = None, template_id: Optional[str] = None) -> None:"""Background task to update a message's embedding in Turbopuffer.@@ -595,6 +602,7 @@ class MessageManager:text: Extracted text content from the messageactor: User performing the actionproject_id: Optional project ID for the message+ template_id: Optional template ID for the message"""try:from letta.helpers.tpuf_client import TurbopufferClient@@ -614,6 +622,7 @@ class MessageManager:roles=[message.role],created_ats=[message.created_at],project_id=project_id,+ template_id=template_id,)logger.info(f"Successfully updated message {message.id} in Turbopuffer")except Exception as e:@@ -1097,6 +1106,8 @@ class MessageManager:query_text: Optional[str] = None,search_mode: str = "hybrid",roles: Optional[List[MessageRole]] = None,+ project_id: Optional[str] = None,+ template_id: Optional[str] = None,limit: int = 50,start_date: Optional[datetime] = None,end_date: Optional[datetime] = None,@@ -1110,6 +1121,8 @@ class MessageManager:query_text: Text query (used for embedding in vector/hybrid modes, and FTS in fts/hybrid modes)search_mode: "vector", "fts", "hybrid", or "timestamp" (default: "hybrid")roles: Optional list of message roles to filter by+ project_id: Optional project ID to filter messages by+ template_id: Optional template ID to filter messages bylimit: Maximum number of results to returnstart_date: Optional filter for messages created after this dateend_date: Optional filter for messages created on or before this date (inclusive)@@ -1132,6 +1145,8 @@ class MessageManager:search_mode=search_mode,top_k=limit,roles=roles,+ project_id=project_id,+ template_id=template_id,start_date=start_date,end_date=end_date,)@@ -1211,6 +1226,7 @@ class MessageManager:search_mode: str = "hybrid",roles: Optional[List[MessageRole]] = None,project_id: Optional[str] = None,+ template_id: Optional[str] = None,limit: int = 50,start_date: Optional[datetime] = None,end_date: Optional[datetime] = None,@@ -1224,6 +1240,7 @@ class MessageManager:search_mode: "vector", "fts", or "hybrid" (default: "hybrid")roles: Optional list of message roles to filter byproject_id: Optional project ID to filter messages by+ template_id: Optional template ID to filter messages bylimit: Maximum number of results to returnstart_date: Optional filter for messages created after this dateend_date: Optional filter for messages created on or before this date (inclusive)@@ -1251,6 +1268,7 @@ class MessageManager:top_k=limit,roles=roles,project_id=project_id,+ template_id=template_id,start_date=start_date,end_date=end_date,)diff --git a/letta/services/summarizer/summarizer.py b/letta/services/summarizer/summarizer.pyindex d6e0fe010..6dc99ea18 100644--- a/letta/services/summarizer/summarizer.py+++ b/letta/services/summarizer/summarizer.py@@ -196,6 +196,7 @@ class Summarizer:pydantic_msgs=[summary_message_obj],actor=self.actor,project_id=agent_state.project_id,+ template_id=agent_state.template_id,)updated_in_context_messages = all_in_context_messages[assistant_message_index:]diff --git a/tests/integration_test_turbopuffer.py b/tests/integration_test_turbopuffer.pyindex e1c4bf927..87105bbc3 100644--- a/tests/integration_test_turbopuffer.py+++ b/tests/integration_test_turbopuffer.py@@ -114,1968 +114,1972 @@ def sample_embedding_config():return EmbeddingConfig.default_config(model_name="letta")-class TestTurbopufferIntegration:- """Test Turbopuffer integration functionality with real connections"""+async def wait_for_embedding(+ agent_id: str, message_id: str, organization_id: str, actor, max_wait: float = 10.0, poll_interval: float = 0.5+) -> bool:+ """Poll Turbopuffer directly to check if a message has been embedded.- def test_should_use_tpuf_with_settings(self):- """Test that should_use_tpuf correctly reads settings"""- # Save original values- original_use_tpuf = settings.use_tpuf- original_api_key = settings.tpuf_api_key+ Args:+ agent_id: Agent ID for the message+ message_id: ID of the message to find+ organization_id: Organization ID+ max_wait: Maximum time to wait in seconds+ poll_interval: Time between polls in seconds- try:- # Test when both are set- settings.use_tpuf = True- settings.tpuf_api_key = "test-key"- assert should_use_tpuf() is True-- # Test when use_tpuf is False- settings.use_tpuf = False- assert should_use_tpuf() is False-- # Test when API key is missing- settings.use_tpuf = True- settings.tpuf_api_key = None- assert should_use_tpuf() is False- finally:- # Restore original values- settings.use_tpuf = original_use_tpuf- settings.tpuf_api_key = original_api_key-- @pytest.mark.asyncio- async def test_archive_creation_with_tpuf_enabled(self, server, default_user, enable_turbopuffer):- """Test that archives are created with correct vector_db_provider when TPUF is enabled"""- archive = await server.archive_manager.create_archive_async(name="Test Archive with TPUF", actor=default_user)- assert archive.vector_db_provider == VectorDBProvider.TPUF- # TODO: Add cleanup when delete_archive method is available-- @pytest.mark.asyncio- async def test_archive_creation_with_tpuf_disabled(self, server, default_user, disable_turbopuffer):- """Test that archives default to NATIVE when TPUF is disabled"""- archive = await server.archive_manager.create_archive_async(name="Test Archive without TPUF", actor=default_user)- assert archive.vector_db_provider == VectorDBProvider.NATIVE- # TODO: Add cleanup when delete_archive method is available-- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured for testing")- async def test_dual_write_and_query_with_real_tpuf(self, server, default_user, sarah_agent, enable_turbopuffer):- """Test that passages are written to both SQL and Turbopuffer with real connection and can be queried"""-- # Create a TPUF-enabled archive- archive = await server.archive_manager.create_archive_async(name="Test TPUF Archive for Real Dual Write", actor=default_user)- assert archive.vector_db_provider == VectorDBProvider.TPUF-- # Attach the agent to the archive- await server.archive_manager.attach_agent_to_archive_async(- agent_id=sarah_agent.id, archive_id=archive.id, is_owner=True, actor=default_user- )-- try:- # Insert passages - this should trigger dual write- test_passages = [- "Turbopuffer is a vector database optimized for performance.",- "This integration test verifies dual-write functionality.",- "Metadata attributes should be properly stored in Turbopuffer.",- ]-- for text in test_passages:- passages = await server.passage_manager.insert_passage(- agent_state=sarah_agent, text=text, actor=default_user, strict_mode=True- )- assert passages is not None- assert len(passages) > 0+ Returns:+ True if message was found in Turbopuffer within timeout, False otherwise+ """+ import asyncio- # Verify passages are in SQL - use agent_manager to list passages- sql_passages = await server.agent_manager.query_agent_passages_async(actor=default_user, agent_id=sarah_agent.id, limit=10)- assert len(sql_passages) >= len(test_passages)- for text in test_passages:- assert any(p.text == text for p, _, _ in sql_passages)+ from letta.helpers.tpuf_client import TurbopufferClient- # Test vector search which should use Turbopuffer- embedding_config = sarah_agent.embedding_config or EmbeddingConfig.default_config(provider="openai")+ client = TurbopufferClient()+ start_time = asyncio.get_event_loop().time()- # Perform vector search- vector_results = await server.agent_manager.query_agent_passages_async(- actor=default_user,- agent_id=sarah_agent.id,- query_text="turbopuffer vector database",- embedding_config=embedding_config,- embed_query=True,- limit=5,+ while asyncio.get_event_loop().time() - start_time < max_wait:+ try:+ # Query Turbopuffer directly using timestamp mode to get all messages+ results = await client.query_messages_by_agent_id(+ agent_id=agent_id,+ organization_id=organization_id,+ actor=actor,+ search_mode="timestamp",+ top_k=100, # Get more messages to ensure we find it)- # Should find relevant passages via Turbopuffer vector search- assert len(vector_results) > 0- # The most relevant result should be about Turbopuffer- assert any("Turbopuffer" in p.text or "vector" in p.text for p, _, _ in vector_results)+ # Check if our message ID is in the results+ if any(msg["id"] == message_id for msg, _, _ in results):+ return True- # Test deletion - should delete from both- passage_to_delete = sql_passages[0][0] # Extract passage from tuple- await server.passage_manager.delete_agent_passages_async([passage_to_delete], default_user, strict_mode=True)+ except Exception as e:+ # Log but don't fail - Turbopuffer might still be processing+ pass- # Verify deleted from SQL- remaining = await server.agent_manager.query_agent_passages_async(actor=default_user, agent_id=sarah_agent.id, limit=10)- assert not any(p.id == passage_to_delete.id for p, _, _ in remaining)+ await asyncio.sleep(poll_interval)- # Verify vector search no longer returns deleted passage- vector_results_after_delete = await server.agent_manager.query_agent_passages_async(- actor=default_user,- agent_id=sarah_agent.id,- query_text=passage_to_delete.text,- embedding_config=embedding_config,- embed_query=True,- limit=10,- )- assert not any(p.id == passage_to_delete.id for p, _, _ in vector_results_after_delete)+ return False- finally:- # TODO: Clean up archive when delete_archive method is available- pass- @pytest.mark.asyncio- async def test_turbopuffer_metadata_attributes(self, default_user, enable_turbopuffer):- """Test that Turbopuffer properly stores and retrieves metadata attributes"""+def test_should_use_tpuf_with_settings():+ """Test that should_use_tpuf correctly reads settings"""+ # Save original values+ original_use_tpuf = settings.use_tpuf+ original_api_key = settings.tpuf_api_key- # Only run if we have a real API key- if not settings.tpuf_api_key:- pytest.skip("No Turbopuffer API key available")+ try:+ # Test when both are set+ settings.use_tpuf = True+ settings.tpuf_api_key = "test-key"+ assert should_use_tpuf() is True++ # Test when use_tpuf is False+ settings.use_tpuf = False+ assert should_use_tpuf() is False++ # Test when API key is missing+ settings.use_tpuf = True+ settings.tpuf_api_key = None+ assert should_use_tpuf() is False+ finally:+ # Restore original values+ settings.use_tpuf = original_use_tpuf+ settings.tpuf_api_key = original_api_key- client = TurbopufferClient()- archive_id = f"test-archive-{datetime.now().timestamp()}"- try:- # Insert passages with various metadata- test_data = [- {- "id": f"passage-{uuid.uuid4()}",- "text": "First test passage",- "vector": [0.1] * 1536,- "organization_id": "org-123",- "created_at": datetime.now(timezone.utc),- },- {- "id": f"passage-{uuid.uuid4()}",- "text": "Second test passage",- "vector": [0.2] * 1536,- "organization_id": "org-123",- "created_at": datetime.now(timezone.utc),- },- {- "id": f"passage-{uuid.uuid4()}",- "text": "Third test passage from different org",- "vector": [0.3] * 1536,- "organization_id": "org-456",- "created_at": datetime.now(timezone.utc),- },- ]-- # Insert all passages- result = await client.insert_archival_memories(- archive_id=archive_id,- text_chunks=[d["text"] for d in test_data],- passage_ids=[d["id"] for d in test_data],- organization_id="org-123", # Default org- actor=default_user,- created_at=datetime.now(timezone.utc),- )+async def test_archive_creation_with_tpuf_enabled(server, default_user, enable_turbopuffer):+ """Test that archives are created with correct vector_db_provider when TPUF is enabled"""+ archive = await server.archive_manager.create_archive_async(name="Test Archive with TPUF", actor=default_user)+ assert archive.vector_db_provider == VectorDBProvider.TPUF+ # TODO: Add cleanup when delete_archive method is available- assert len(result) == 3- # Query all passages (no tag filtering)- results = await client.query_passages(archive_id=archive_id, actor=default_user, top_k=10)+async def test_archive_creation_with_tpuf_disabled(server, default_user, disable_turbopuffer):+ """Test that archives default to NATIVE when TPUF is disabled"""+ archive = await server.archive_manager.create_archive_async(name="Test Archive without TPUF", actor=default_user)+ assert archive.vector_db_provider == VectorDBProvider.NATIVE+ # TODO: Add cleanup when delete_archive method is available- # Should get all passages- assert len(results) == 3 # All three passages- for passage, score, metadata in results:- assert passage.organization_id is not None- # Clean up- await client.delete_passages(archive_id=archive_id, passage_ids=[d["id"] for d in test_data])[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured for testing")+async def test_dual_write_and_query_with_real_tpuf(server, default_user, sarah_agent, enable_turbopuffer):+ """Test that passages are written to both SQL and Turbopuffer with real connection and can be queried"""- except Exception as e:- # Clean up on error- try:- await client.delete_all_passages(archive_id)- except:- pass- raise e-- @pytest.mark.asyncio- async def test_native_only_operations(self, server, default_user, sarah_agent, disable_turbopuffer):- """Test that operations work correctly when using only native PostgreSQL"""-- # Create archive (should be NATIVE since turbopuffer is disabled)- archive = await server.archive_manager.get_or_create_default_archive_for_agent_async(- agent_id=sarah_agent.id, agent_name=sarah_agent.name, actor=default_user- )- assert archive.vector_db_provider == VectorDBProvider.NATIVE+ # Create a TPUF-enabled archive+ archive = await server.archive_manager.create_archive_async(name="Test TPUF Archive for Real Dual Write", actor=default_user)+ assert archive.vector_db_provider == VectorDBProvider.TPUF- # Insert passages - should only write to SQL- text_content = "This is a test passage for native PostgreSQL only."- passages = await server.passage_manager.insert_passage(- agent_state=sarah_agent, text=text_content, actor=default_user, strict_mode=True- )+ # Attach the agent to the archive+ await server.archive_manager.attach_agent_to_archive_async(+ agent_id=sarah_agent.id, archive_id=archive.id, is_owner=True, actor=default_user+ )++ try:+ # Insert passages - this should trigger dual write+ test_passages = [+ "Turbopuffer is a vector database optimized for performance.",+ "This integration test verifies dual-write functionality.",+ "Metadata attributes should be properly stored in Turbopuffer.",+ ]- assert passages is not None- assert len(passages) > 0+ for text in test_passages:+ passages = await server.passage_manager.insert_passage(agent_state=sarah_agent, text=text, actor=default_user, strict_mode=True)+ assert passages is not None+ assert len(passages) > 0- # List passages - should work from SQL+ # Verify passages are in SQL - use agent_manager to list passagessql_passages = await server.agent_manager.query_agent_passages_async(actor=default_user, agent_id=sarah_agent.id, limit=10)- assert any(p.text == text_content for p, _, _ in sql_passages)+ assert len(sql_passages) >= len(test_passages)+ for text in test_passages:+ assert any(p.text == text for p, _, _ in sql_passages)- # Vector search should use PostgreSQL pgvector+ # Test vector search which should use Turbopufferembedding_config = sarah_agent.embedding_config or EmbeddingConfig.default_config(provider="openai")++ # Perform vector searchvector_results = await server.agent_manager.query_agent_passages_async(actor=default_user,agent_id=sarah_agent.id,- query_text="native postgresql",+ query_text="turbopuffer vector database",embedding_config=embedding_config,embed_query=True,+ limit=5,)- # Should still work with native PostgreSQL- assert isinstance(vector_results, list)+ # Should find relevant passages via Turbopuffer vector search+ assert len(vector_results) > 0+ # The most relevant result should be about Turbopuffer+ assert any("Turbopuffer" in p.text or "vector" in p.text for p, _, _ in vector_results)- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured for testing")- async def test_hybrid_search_with_real_tpuf(self, default_user, enable_turbopuffer):- """Test hybrid search functionality combining vector and full-text search"""+ # Test deletion - should delete from both+ passage_to_delete = sql_passages[0][0] # Extract passage from tuple+ await server.passage_manager.delete_agent_passages_async([passage_to_delete], default_user, strict_mode=True)- import uuid+ # Verify deleted from SQL+ remaining = await server.agent_manager.query_agent_passages_async(actor=default_user, agent_id=sarah_agent.id, limit=10)+ assert not any(p.id == passage_to_delete.id for p, _, _ in remaining)- from letta.helpers.tpuf_client import TurbopufferClient+ # Verify vector search no longer returns deleted passage+ vector_results_after_delete = await server.agent_manager.query_agent_passages_async(+ actor=default_user,+ agent_id=sarah_agent.id,+ query_text=passage_to_delete.text,+ embedding_config=embedding_config,+ embed_query=True,+ limit=10,+ )+ assert not any(p.id == passage_to_delete.id for p, _, _ in vector_results_after_delete)- client = TurbopufferClient()- archive_id = f"test-hybrid-{datetime.now().timestamp()}"- org_id = str(uuid.uuid4())+ finally:+ # TODO: Clean up archive when delete_archive method is available+ pass- try:- # Insert test passages with different characteristics- texts = [- "Turbopuffer is a vector database optimized for high-performance similarity search",- "The quick brown fox jumps over the lazy dog",- "Machine learning models require vector embeddings for semantic search",- "Database optimization techniques improve query performance",- "Turbopuffer supports both vector and full-text search capabilities",- ]-- # Create simple embeddings for testing (normally you'd use a real embedding model)- embeddings = [[float(i), float(i + 5), float(i + 10)] for i in range(len(texts))]- passage_ids = [f"passage-{str(uuid.uuid4())}" for _ in texts]-- # Insert passages- await client.insert_archival_memories(- archive_id=archive_id, text_chunks=texts, passage_ids=passage_ids, organization_id=org_id, actor=default_user- )- # Test vector-only search- vector_results = await client.query_passages(- archive_id=archive_id,- actor=default_user,- query_text="python programming tutorial",- search_mode="vector",- top_k=3,- )- assert 0 < len(vector_results) <= 3- # all results should have scores- assert all(isinstance(score, float) for _, score, _ in vector_results)+async def test_turbopuffer_metadata_attributes(default_user, enable_turbopuffer):+ """Test that Turbopuffer properly stores and retrieves metadata attributes"""- # Test FTS-only search- fts_results = await client.query_passages(- archive_id=archive_id, actor=default_user, query_text="Turbopuffer vector database", search_mode="fts", top_k=3- )- assert 0 < len(fts_results) <= 3- # should find passages mentioning Turbopuffer- assert any("Turbopuffer" in passage.text for passage, _, _ in fts_results)- # all results should have scores- assert all(isinstance(score, float) for _, score, _ in fts_results)-- # Test hybrid search- hybrid_results = await client.query_passages(- archive_id=archive_id,- actor=default_user,- query_text="vector search Turbopuffer",- search_mode="hybrid",- top_k=3,- vector_weight=0.5,- fts_weight=0.5,- )- assert 0 < len(hybrid_results) <= 3- # hybrid should combine both vector and text relevance- assert any("Turbopuffer" in passage.text or "vector" in passage.text for passage, _, _ in hybrid_results)- # all results should have scores- assert all(isinstance(score, float) for _, score, _ in hybrid_results)- # results should be sorted by score (highest first)- scores = [score for _, score, _ in hybrid_results]- assert scores == sorted(scores, reverse=True)-- # Test with different weights- vector_heavy_results = await client.query_passages(- archive_id=archive_id,- actor=default_user,- query_text="quick brown fox", # matches second passage- search_mode="hybrid",- top_k=3,- vector_weight=0.8, # emphasize vector search- fts_weight=0.2,- )- assert 0 < len(vector_heavy_results) <= 3- # all results should have scores- assert all(isinstance(score, float) for _, score, _ in vector_heavy_results)+ # Only run if we have a real API key+ if not settings.tpuf_api_key:+ pytest.skip("No Turbopuffer API key available")- # Test with different search modes- await client.query_passages(archive_id=archive_id, actor=default_user, query_text="test", search_mode="vector", top_k=3)- await client.query_passages(archive_id=archive_id, actor=default_user, query_text="test", search_mode="fts", top_k=3)- await client.query_passages(archive_id=archive_id, actor=default_user, query_text="test", search_mode="hybrid", top_k=3)+ client = TurbopufferClient()+ archive_id = f"test-archive-{datetime.now().timestamp()}"- # Test explicit timestamp mode- timestamp_results = await client.query_passages(archive_id=archive_id, actor=default_user, search_mode="timestamp", top_k=3)- assert len(timestamp_results) <= 3- # Should return passages ordered by timestamp (most recent first)- assert all(isinstance(passage, Passage) for passage, _, _ in timestamp_results)+ try:+ # Insert passages with various metadata+ test_data = [+ {+ "id": f"passage-{uuid.uuid4()}",+ "text": "First test passage",+ "vector": [0.1] * 1536,+ "organization_id": "org-123",+ "created_at": datetime.now(timezone.utc),+ },+ {+ "id": f"passage-{uuid.uuid4()}",+ "text": "Second test passage",+ "vector": [0.2] * 1536,+ "organization_id": "org-123",+ "created_at": datetime.now(timezone.utc),+ },+ {+ "id": f"passage-{uuid.uuid4()}",+ "text": "Third test passage from different org",+ "vector": [0.3] * 1536,+ "organization_id": "org-456",+ "created_at": datetime.now(timezone.utc),+ },+ ]- finally:- # Clean up- try:- await client.delete_all_passages(archive_id)- except:- pass+ # Insert all passages+ result = await client.insert_archival_memories(+ archive_id=archive_id,+ text_chunks=[d["text"] for d in test_data],+ passage_ids=[d["id"] for d in test_data],+ organization_id="org-123", # Default org+ actor=default_user,+ created_at=datetime.now(timezone.utc),+ )- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured for testing")- async def test_tag_filtering_with_real_tpuf(self, default_user, enable_turbopuffer):- """Test tag filtering functionality with AND and OR logic"""+ assert len(result) == 3- import uuid+ # Query all passages (no tag filtering)+ results = await client.query_passages(archive_id=archive_id, actor=default_user, top_k=10)- from letta.helpers.tpuf_client import TurbopufferClient+ # Should get all passages+ assert len(results) == 3 # All three passages+ for passage, score, metadata in results:+ assert passage.organization_id is not None- client = TurbopufferClient()- archive_id = f"test-tags-{datetime.now().timestamp()}"- org_id = str(uuid.uuid4())+ # Clean up+ await client.delete_passages(archive_id=archive_id, passage_ids=[d["id"] for d in test_data])+ except Exception as e:+ # Clean up on errortry:- # Insert passages with different tag combinations- texts = [- "Python programming tutorial",- "Machine learning with Python",- "JavaScript web development",- "Python data science tutorial",- "React JavaScript framework",- ]-- tag_sets = [- ["python", "tutorial"],- ["python", "ml"],- ["javascript", "web"],- ["python", "tutorial", "data"],- ["javascript", "react"],- ]-- embeddings = [[float(i), float(i + 5), float(i + 10)] for i in range(len(texts))]- passage_ids = [f"passage-{str(uuid.uuid4())}" for _ in texts]-- # Insert passages with tags- for i, (text, tags, passage_id) in enumerate(zip(texts, tag_sets, passage_ids)):- await client.insert_archival_memories(- archive_id=archive_id,- text_chunks=[text],- passage_ids=[passage_id],- organization_id=org_id,- actor=default_user,- tags=tags,- created_at=datetime.now(timezone.utc),- )+ await client.delete_all_passages(archive_id)+ except:+ pass+ raise e- # Test tag filtering with "any" mode (should find passages with any of the specified tags)- python_any_results = await client.query_passages(- archive_id=archive_id,- actor=default_user,- query_text="python programming",- search_mode="vector",- top_k=10,- tags=["python"],- tag_match_mode=TagMatchMode.ANY,- )- # Should find 3 passages with python tag- python_passages = [passage for passage, _, _ in python_any_results]- python_texts = [p.text for p in python_passages]- assert len(python_passages) == 3- assert "Python programming tutorial" in python_texts- assert "Machine learning with Python" in python_texts- assert "Python data science tutorial" in python_texts+async def test_native_only_operations(server, default_user, sarah_agent, disable_turbopuffer):+ """Test that operations work correctly when using only native PostgreSQL"""- # Test tag filtering with "all" mode- python_tutorial_all_results = await client.query_passages(- archive_id=archive_id,- actor=default_user,- query_text="python tutorial",- search_mode="vector",- top_k=10,- tags=["python", "tutorial"],- tag_match_mode=TagMatchMode.ALL,- )+ # Create archive (should be NATIVE since turbopuffer is disabled)+ archive = await server.archive_manager.get_or_create_default_archive_for_agent_async(+ agent_id=sarah_agent.id, agent_name=sarah_agent.name, actor=default_user+ )+ assert archive.vector_db_provider == VectorDBProvider.NATIVE- # Should find 2 passages that have both python AND tutorial tags- tutorial_passages = [passage for passage, _, _ in python_tutorial_all_results]- tutorial_texts = [p.text for p in tutorial_passages]- assert len(tutorial_passages) == 2- assert "Python programming tutorial" in tutorial_texts- assert "Python data science tutorial" in tutorial_texts+ # Insert passages - should only write to SQL+ text_content = "This is a test passage for native PostgreSQL only."+ passages = await server.passage_manager.insert_passage(agent_state=sarah_agent, text=text_content, actor=default_user, strict_mode=True)- # Test tag filtering with FTS mode- js_fts_results = await client.query_passages(- archive_id=archive_id,- actor=default_user,- query_text="javascript",- search_mode="fts",- top_k=10,- tags=["javascript"],- tag_match_mode=TagMatchMode.ANY,- )+ assert passages is not None+ assert len(passages) > 0- # Should find 2 passages with javascript tag- js_passages = [passage for passage, _, _ in js_fts_results]- js_texts = [p.text for p in js_passages]- assert len(js_passages) == 2- assert "JavaScript web development" in js_texts- assert "React JavaScript framework" in js_texts+ # List passages - should work from SQL+ sql_passages = await server.agent_manager.query_agent_passages_async(actor=default_user, agent_id=sarah_agent.id, limit=10)+ assert any(p.text == text_content for p, _, _ in sql_passages)- # Test hybrid search with tags- python_hybrid_results = await client.query_passages(- archive_id=archive_id,- actor=default_user,- query_text="python programming",- search_mode="hybrid",- top_k=10,- tags=["python"],- tag_match_mode=TagMatchMode.ANY,- vector_weight=0.6,- fts_weight=0.4,- )+ # Vector search should use PostgreSQL pgvector+ embedding_config = sarah_agent.embedding_config or EmbeddingConfig.default_config(provider="openai")+ vector_results = await server.agent_manager.query_agent_passages_async(+ actor=default_user,+ agent_id=sarah_agent.id,+ query_text="native postgresql",+ embedding_config=embedding_config,+ embed_query=True,+ )++ # Should still work with native PostgreSQL+ assert isinstance(vector_results, list)- # Should find python-tagged passages- hybrid_passages = [passage for passage, _, _ in python_hybrid_results]- hybrid_texts = [p.text for p in hybrid_passages]- assert len(hybrid_passages) == 3- assert all("Python" in text for text in hybrid_texts)- finally:- # Clean up- try:- await client.delete_all_passages(archive_id)- except:- pass[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured for testing")+async def test_hybrid_search_with_real_tpuf(default_user, enable_turbopuffer):+ """Test hybrid search functionality combining vector and full-text search"""- @pytest.mark.asyncio- async def test_temporal_filtering_with_real_tpuf(self, default_user, enable_turbopuffer):- """Test temporal filtering with date ranges"""- from datetime import datetime, timedelta, timezone+ import uuid- # Skip if Turbopuffer is not properly configured- if not should_use_tpuf():- pytest.skip("Turbopuffer not configured - skipping TPUF temporal filtering test")+ from letta.helpers.tpuf_client import TurbopufferClient- # Create client- client = TurbopufferClient()+ client = TurbopufferClient()+ archive_id = f"test-hybrid-{datetime.now().timestamp()}"+ org_id = str(uuid.uuid4())- # Create a unique archive ID for this test- archive_id = f"test-temporal-{uuid.uuid4()}"+ try:+ # Insert test passages with different characteristics+ texts = [+ "Turbopuffer is a vector database optimized for high-performance similarity search",+ "The quick brown fox jumps over the lazy dog",+ "Machine learning models require vector embeddings for semantic search",+ "Database optimization techniques improve query performance",+ "Turbopuffer supports both vector and full-text search capabilities",+ ]++ # Create simple embeddings for testing (normally you'd use a real embedding model)+ embeddings = [[float(i), float(i + 5), float(i + 10)] for i in range(len(texts))]+ passage_ids = [f"passage-{str(uuid.uuid4())}" for _ in texts]++ # Insert passages+ await client.insert_archival_memories(+ archive_id=archive_id, text_chunks=texts, passage_ids=passage_ids, organization_id=org_id, actor=default_user+ )++ # Test vector-only search+ vector_results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="python programming tutorial",+ search_mode="vector",+ top_k=3,+ )+ assert 0 < len(vector_results) <= 3+ # all results should have scores+ assert all(isinstance(score, float) for _, score, _ in vector_results)+ # Test FTS-only search+ fts_results = await client.query_passages(+ archive_id=archive_id, actor=default_user, query_text="Turbopuffer vector database", search_mode="fts", top_k=3+ )+ assert 0 < len(fts_results) <= 3+ # should find passages mentioning Turbopuffer+ assert any("Turbopuffer" in passage.text for passage, _, _ in fts_results)+ # all results should have scores+ assert all(isinstance(score, float) for _, score, _ in fts_results)++ # Test hybrid search+ hybrid_results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="vector search Turbopuffer",+ search_mode="hybrid",+ top_k=3,+ vector_weight=0.5,+ fts_weight=0.5,+ )+ assert 0 < len(hybrid_results) <= 3+ # hybrid should combine both vector and text relevance+ assert any("Turbopuffer" in passage.text or "vector" in passage.text for passage, _, _ in hybrid_results)+ # all results should have scores+ assert all(isinstance(score, float) for _, score, _ in hybrid_results)+ # results should be sorted by score (highest first)+ scores = [score for _, score, _ in hybrid_results]+ assert scores == sorted(scores, reverse=True)++ # Test with different weights+ vector_heavy_results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="quick brown fox", # matches second passage+ search_mode="hybrid",+ top_k=3,+ vector_weight=0.8, # emphasize vector search+ fts_weight=0.2,+ )+ assert 0 < len(vector_heavy_results) <= 3+ # all results should have scores+ assert all(isinstance(score, float) for _, score, _ in vector_heavy_results)++ # Test with different search modes+ await client.query_passages(archive_id=archive_id, actor=default_user, query_text="test", search_mode="vector", top_k=3)+ await client.query_passages(archive_id=archive_id, actor=default_user, query_text="test", search_mode="fts", top_k=3)+ await client.query_passages(archive_id=archive_id, actor=default_user, query_text="test", search_mode="hybrid", top_k=3)++ # Test explicit timestamp mode+ timestamp_results = await client.query_passages(archive_id=archive_id, actor=default_user, search_mode="timestamp", top_k=3)+ assert len(timestamp_results) <= 3+ # Should return passages ordered by timestamp (most recent first)+ assert all(isinstance(passage, Passage) for passage, _, _ in timestamp_results)++ finally:+ # Clean uptry:- # Create passages with different timestamps- now = datetime.now(timezone.utc)- yesterday = now - timedelta(days=1)- last_week = now - timedelta(days=7)- last_month = now - timedelta(days=30)-- # Insert passages with specific timestamps- test_passages = [- ("Today's meeting notes about project Alpha", now),- ("Yesterday's standup summary", yesterday),- ("Last week's sprint review", last_week),- ("Last month's quarterly planning", last_month),- ]-- # We need to generate embeddings for the passages- # For testing, we'll use simple dummy embeddings- for text, timestamp in test_passages:- passage_id = f"passage-{uuid.uuid4()}"-- await client.insert_archival_memories(- archive_id=archive_id,- text_chunks=[text],- passage_ids=[passage_id],- organization_id="test-org",- actor=default_user,- created_at=timestamp,- )+ await client.delete_all_passages(archive_id)+ except:+ pass- # Test 1: Query with date range (last 3 days)- three_days_ago = now - timedelta(days=3)- results = await client.query_passages(- archive_id=archive_id,- actor=default_user,- query_text="meeting notes",- search_mode="vector",- top_k=10,- start_date=three_days_ago,- end_date=now,- )- # Should only get today's and yesterday's passages- passages = [p for p, _, _ in results]- texts = [p.text for p in passages]- assert len(passages) == 2- assert "Today's meeting notes" in texts[0] or "Today's meeting notes" in texts[1]- assert "Yesterday's standup" in texts[0] or "Yesterday's standup" in texts[1]- assert "Last week's sprint" not in str(texts)- assert "Last month's quarterly" not in str(texts)-- # Test 2: Query with only start_date (everything after 2 weeks ago)- two_weeks_ago = now - timedelta(days=14)- results = await client.query_passages(- archive_id=archive_id,- actor=default_user,- query_text="meeting notes",- search_mode="vector",- top_k=10,- start_date=two_weeks_ago,- )[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured for testing")+async def test_tag_filtering_with_real_tpuf(default_user, enable_turbopuffer):+ """Test tag filtering functionality with AND and OR logic"""- # Should get all except last month's passage- passages = [p for p, _, _ in results]- assert len(passages) == 3- texts = [p.text for p in passages]- assert "Last month's quarterly" not in str(texts)+ import uuid- # Test 3: Query with only end_date (everything before yesterday)- results = await client.query_passages(- archive_id=archive_id,- actor=default_user,- query_text="meeting notes",- search_mode="vector",- top_k=10,- end_date=yesterday + timedelta(hours=12), # Middle of yesterday- )+ from letta.helpers.tpuf_client import TurbopufferClient- # Should get yesterday and older passages- passages = [p for p, _, _ in results]- assert len(passages) >= 3 # yesterday, last week, last month- texts = [p.text for p in passages]- assert "Today's meeting notes" not in str(texts)+ client = TurbopufferClient()+ archive_id = f"test-tags-{datetime.now().timestamp()}"+ org_id = str(uuid.uuid4())- # Test 4: Test with FTS mode and date filtering- results = await client.query_passages(- archive_id=archive_id,- actor=default_user,- query_text="meeting notes project",- search_mode="fts",- top_k=10,- start_date=yesterday,- )+ try:+ # Insert passages with different tag combinations+ texts = [+ "Python programming tutorial",+ "Machine learning with Python",+ "JavaScript web development",+ "Python data science tutorial",+ "React JavaScript framework",+ ]++ tag_sets = [+ ["python", "tutorial"],+ ["python", "ml"],+ ["javascript", "web"],+ ["python", "tutorial", "data"],+ ["javascript", "react"],+ ]- # Should only find today's meeting notes- passages = [p for p, _, _ in results]- if len(passages) > 0: # FTS might not match if text search doesn't find keywords- texts = [p.text for p in passages]- assert "Today's meeting notes" in texts[0]+ embeddings = [[float(i), float(i + 5), float(i + 10)] for i in range(len(texts))]+ passage_ids = [f"passage-{str(uuid.uuid4())}" for _ in texts]- # Test 5: Test with hybrid mode and date filtering- results = await client.query_passages(+ # Insert passages with tags+ for i, (text, tags, passage_id) in enumerate(zip(texts, tag_sets, passage_ids)):+ await client.insert_archival_memories(archive_id=archive_id,+ text_chunks=[text],+ passage_ids=[passage_id],+ organization_id=org_id,actor=default_user,- query_text="sprint review",- search_mode="hybrid",- top_k=10,- start_date=last_week - timedelta(days=1),- end_date=last_week + timedelta(days=1),+ tags=tags,+ created_at=datetime.now(timezone.utc),)- # Should find last week's sprint review- passages = [p for p, _, _ in results]- if len(passages) > 0:- texts = [p.text for p in passages]- assert "Last week's sprint review" in texts[0]+ # Test tag filtering with "any" mode (should find passages with any of the specified tags)+ python_any_results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="python programming",+ search_mode="vector",+ top_k=10,+ tags=["python"],+ tag_match_mode=TagMatchMode.ANY,+ )- finally:- # Clean up- try:- await client.delete_all_passages(archive_id)- except:- pass+ # Should find 3 passages with python tag+ python_passages = [passage for passage, _, _ in python_any_results]+ python_texts = [p.text for p in python_passages]+ assert len(python_passages) == 3+ assert "Python programming tutorial" in python_texts+ assert "Machine learning with Python" in python_texts+ assert "Python data science tutorial" in python_texts++ # Test tag filtering with "all" mode+ python_tutorial_all_results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="python tutorial",+ search_mode="vector",+ top_k=10,+ tags=["python", "tutorial"],+ tag_match_mode=TagMatchMode.ALL,+ )+ # Should find 2 passages that have both python AND tutorial tags+ tutorial_passages = [passage for passage, _, _ in python_tutorial_all_results]+ tutorial_texts = [p.text for p in tutorial_passages]+ assert len(tutorial_passages) == 2+ assert "Python programming tutorial" in tutorial_texts+ assert "Python data science tutorial" in tutorial_texts[email protected]("turbopuffer_mode", [True, False], indirect=True)-class TestTurbopufferParametrized:- """Test that functionality works with and without Turbopuffer enabled"""+ # Test tag filtering with FTS mode+ js_fts_results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="javascript",+ search_mode="fts",+ top_k=10,+ tags=["javascript"],+ tag_match_mode=TagMatchMode.ANY,+ )- @pytest.mark.asyncio- async def test_passage_operations_with_mode(self, turbopuffer_mode, server, default_user, sarah_agent):- """Test that passage operations work in both modes"""+ # Should find 2 passages with javascript tag+ js_passages = [passage for passage, _, _ in js_fts_results]+ js_texts = [p.text for p in js_passages]+ assert len(js_passages) == 2+ assert "JavaScript web development" in js_texts+ assert "React JavaScript framework" in js_texts- # Get or create archive- archive = await server.archive_manager.get_or_create_default_archive_for_agent_async(- agent_id=sarah_agent.id, agent_name=sarah_agent.name, actor=default_user+ # Test hybrid search with tags+ python_hybrid_results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="python programming",+ search_mode="hybrid",+ top_k=10,+ tags=["python"],+ tag_match_mode=TagMatchMode.ANY,+ vector_weight=0.6,+ fts_weight=0.4,)- # Check that vector_db_provider matches the mode- if settings.use_tpuf and settings.tpuf_api_key:- expected_provider = VectorDBProvider.TPUF- else:- expected_provider = VectorDBProvider.NATIVE- assert archive.vector_db_provider == expected_provider+ # Should find python-tagged passages+ hybrid_passages = [passage for passage, _, _ in python_hybrid_results]+ hybrid_texts = [p.text for p in hybrid_passages]+ assert len(hybrid_passages) == 3+ assert all("Python" in text for text in hybrid_texts)- # Test inserting a passage (should work in both modes)- test_text = f"Test passage for {expected_provider} mode"- passages = await server.passage_manager.insert_passage(- agent_state=sarah_agent, text=test_text, actor=default_user, strict_mode=True- )+ finally:+ # Clean up+ try:+ await client.delete_all_passages(archive_id)+ except:+ pass- assert passages is not None- assert len(passages) > 0- assert passages[0].text == test_text- # List passages should work in both modes- listed = await server.agent_manager.query_agent_passages_async(actor=default_user, agent_id=sarah_agent.id, limit=10)- assert any(p.text == test_text for p, _, _ in listed)+async def test_temporal_filtering_with_real_tpuf(default_user, enable_turbopuffer):+ """Test temporal filtering with date ranges"""+ from datetime import datetime, timedelta, timezone- # Delete should work in both modes- await server.passage_manager.delete_agent_passages_async(passages, default_user, strict_mode=True)+ # Skip if Turbopuffer is not properly configured+ if not should_use_tpuf():+ pytest.skip("Turbopuffer not configured - skipping TPUF temporal filtering test")- # Verify deletion- remaining = await server.agent_manager.query_agent_passages_async(actor=default_user, agent_id=sarah_agent.id, limit=10)- assert not any(p.id == passages[0].id for p, _, _ in remaining)+ # Create client+ client = TurbopufferClient()- @pytest.mark.asyncio- async def test_temporal_filtering_in_both_modes(self, turbopuffer_mode, server, default_user, sarah_agent):- """Test that temporal filtering works in both NATIVE and TPUF modes"""- from datetime import datetime, timedelta, timezone+ # Create a unique archive ID for this test+ archive_id = f"test-temporal-{uuid.uuid4()}"- # Insert passages with different timestamps+ try:+ # Create passages with different timestampsnow = datetime.now(timezone.utc)yesterday = now - timedelta(days=1)last_week = now - timedelta(days=7)+ last_month = now - timedelta(days=30)# Insert passages with specific timestamps- recent_passage = await server.passage_manager.insert_passage(- agent_state=sarah_agent, text="Recent update from today", actor=default_user, created_at=now, strict_mode=True+ test_passages = [+ ("Today's meeting notes about project Alpha", now),+ ("Yesterday's standup summary", yesterday),+ ("Last week's sprint review", last_week),+ ("Last month's quarterly planning", last_month),+ ]++ # We need to generate embeddings for the passages+ # For testing, we'll use simple dummy embeddings+ for text, timestamp in test_passages:+ passage_id = f"passage-{uuid.uuid4()}"++ await client.insert_archival_memories(+ archive_id=archive_id,+ text_chunks=[text],+ passage_ids=[passage_id],+ organization_id="test-org",+ actor=default_user,+ created_at=timestamp,+ )++ # Test 1: Query with date range (last 3 days)+ three_days_ago = now - timedelta(days=3)+ results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="meeting notes",+ search_mode="vector",+ top_k=10,+ start_date=three_days_ago,+ end_date=now,)- old_passage = await server.passage_manager.insert_passage(- agent_state=sarah_agent, text="Old update from last week", actor=default_user, created_at=last_week, strict_mode=True+ # Should only get today's and yesterday's passages+ passages = [p for p, _, _ in results]+ texts = [p.text for p in passages]+ assert len(passages) == 2+ assert "Today's meeting notes" in texts[0] or "Today's meeting notes" in texts[1]+ assert "Yesterday's standup" in texts[0] or "Yesterday's standup" in texts[1]+ assert "Last week's sprint" not in str(texts)+ assert "Last month's quarterly" not in str(texts)++ # Test 2: Query with only start_date (everything after 2 weeks ago)+ two_weeks_ago = now - timedelta(days=14)+ results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="meeting notes",+ search_mode="vector",+ top_k=10,+ start_date=two_weeks_ago,)- # Query with date range that includes only recent passage- start_date = yesterday- end_date = now + timedelta(hours=1) # Slightly in the future to ensure we catch it+ # Should get all except last month's passage+ passages = [p for p, _, _ in results]+ assert len(passages) == 3+ texts = [p.text for p in passages]+ assert "Last month's quarterly" not in str(texts)- # Query with date filtering- results = await server.agent_manager.query_agent_passages_async(- actor=default_user, agent_id=sarah_agent.id, start_date=start_date, end_date=end_date, limit=10+ # Test 3: Query with only end_date (everything before yesterday)+ results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="meeting notes",+ search_mode="vector",+ top_k=10,+ end_date=yesterday + timedelta(hours=12), # Middle of yesterday)- # Should find only the recent passage, not the old one- assert len(results) >= 1- assert any("Recent update from today" in p.text for p, _, _ in results)- assert not any("Old update from last week" in p.text for p, _, _ in results)+ # Should get yesterday and older passages+ passages = [p for p, _, _ in results]+ assert len(passages) >= 3 # yesterday, last week, last month+ texts = [p.text for p in passages]+ assert "Today's meeting notes" not in str(texts)++ # Test 4: Test with FTS mode and date filtering+ results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="meeting notes project",+ search_mode="fts",+ top_k=10,+ start_date=yesterday,+ )- # Query with date range that includes only the old passage- old_start = last_week - timedelta(days=1)- old_end = last_week + timedelta(days=1)+ # Should only find today's meeting notes+ passages = [p for p, _, _ in results]+ if len(passages) > 0: # FTS might not match if text search doesn't find keywords+ texts = [p.text for p in passages]+ assert "Today's meeting notes" in texts[0]- old_results = await server.agent_manager.query_agent_passages_async(- actor=default_user, agent_id=sarah_agent.id, start_date=old_start, end_date=old_end, limit=10+ # Test 5: Test with hybrid mode and date filtering+ results = await client.query_passages(+ archive_id=archive_id,+ actor=default_user,+ query_text="sprint review",+ search_mode="hybrid",+ top_k=10,+ start_date=last_week - timedelta(days=1),+ end_date=last_week + timedelta(days=1),)- # Should find only the old passage- assert len(old_results) >= 1- assert any("Old update from last week" in p.text for p, _, _ in old_results)- assert not any("Recent update from today" in p.text for p, _, _ in old_results)+ # Should find last week's sprint review+ passages = [p for p, _, _ in results]+ if len(passages) > 0:+ texts = [p.text for p in passages]+ assert "Last week's sprint review" in texts[0]+ finally:# Clean up- await server.passage_manager.delete_agent_passages_async(recent_passage, default_user, strict_mode=True)- await server.passage_manager.delete_agent_passages_async(old_passage, default_user, strict_mode=True)+ try:+ await client.delete_all_passages(archive_id)+ except:+ pass-class TestTurbopufferMessagesIntegration:- """Test Turbopuffer message embedding functionality"""+def test_should_use_tpuf_for_messages_settings():+ """Test that should_use_tpuf_for_messages correctly checks both use_tpuf AND embed_all_messages"""+ # Save original values+ original_use_tpuf = settings.use_tpuf+ original_api_key = settings.tpuf_api_key+ original_embed_messages = settings.embed_all_messages- def test_should_use_tpuf_for_messages_settings(self):- """Test that should_use_tpuf_for_messages correctly checks both use_tpuf AND embed_all_messages"""- # Save original values- original_use_tpuf = settings.use_tpuf- original_api_key = settings.tpuf_api_key- original_embed_messages = settings.embed_all_messages+ try:+ # Test when both are true+ settings.use_tpuf = True+ settings.tpuf_api_key = "test-key"+ settings.embed_all_messages = True+ assert should_use_tpuf_for_messages() is True++ # Test when use_tpuf is False+ settings.use_tpuf = False+ settings.embed_all_messages = True+ assert should_use_tpuf_for_messages() is False++ # Test when embed_all_messages is False+ settings.use_tpuf = True+ settings.tpuf_api_key = "test-key"+ settings.embed_all_messages = False+ assert should_use_tpuf_for_messages() is False++ # Test when both are false+ settings.use_tpuf = False+ settings.embed_all_messages = False+ assert should_use_tpuf_for_messages() is False++ # Test when API key is missing+ settings.use_tpuf = True+ settings.tpuf_api_key = None+ settings.embed_all_messages = True+ assert should_use_tpuf_for_messages() is False+ finally:+ # Restore original values+ settings.use_tpuf = original_use_tpuf+ settings.tpuf_api_key = original_api_key+ settings.embed_all_messages = original_embed_messages- try:- # Test when both are true- settings.use_tpuf = True- settings.tpuf_api_key = "test-key"- settings.embed_all_messages = True- assert should_use_tpuf_for_messages() is True-- # Test when use_tpuf is False- settings.use_tpuf = False- settings.embed_all_messages = True- assert should_use_tpuf_for_messages() is False-- # Test when embed_all_messages is False- settings.use_tpuf = True- settings.tpuf_api_key = "test-key"- settings.embed_all_messages = False- assert should_use_tpuf_for_messages() is False-- # Test when both are false- settings.use_tpuf = False- settings.embed_all_messages = False- assert should_use_tpuf_for_messages() is False-- # Test when API key is missing- settings.use_tpuf = True- settings.tpuf_api_key = None- settings.embed_all_messages = True- assert should_use_tpuf_for_messages() is False- finally:- # Restore original values- settings.use_tpuf = original_use_tpuf- settings.tpuf_api_key = original_api_key- settings.embed_all_messages = original_embed_messages-- def test_message_text_extraction(self, server, default_user):- """Test extraction of text from various message content structures"""- manager = server.message_manager-- # Test 1: List with single string-like TextContent- msg1 = PydanticMessage(- role=MessageRole.user,- content=[TextContent(text="Simple text content")],- agent_id="test-agent",- )- text1 = manager._extract_message_text(msg1)- assert text1 == '{"content": "Simple text content"}'- # Test 2: List with single TextContent- msg2 = PydanticMessage(- role=MessageRole.user,- content=[TextContent(text="Single text content")],- agent_id="test-agent",- )- text2 = manager._extract_message_text(msg2)- assert text2 == '{"content": "Single text content"}'+def test_message_text_extraction(server, default_user):+ """Test extraction of text from various message content structures"""+ manager = server.message_manager- # Test 3: List with multiple TextContent items- msg3 = PydanticMessage(- role=MessageRole.user,- content=[- TextContent(text="First part"),- TextContent(text="Second part"),- TextContent(text="Third part"),- ],- agent_id="test-agent",- )- text3 = manager._extract_message_text(msg3)- assert text3 == '{"content": "First part Second part Third part"}'-- # Test 4: Empty content- msg4 = PydanticMessage(- role=MessageRole.system,- content=None,- agent_id="test-agent",- )- text4 = manager._extract_message_text(msg4)- assert text4 == ""+ # Test 1: List with single string-like TextContent+ msg1 = PydanticMessage(+ role=MessageRole.user,+ content=[TextContent(text="Simple text content")],+ agent_id="test-agent",+ )+ text1 = manager._extract_message_text(msg1)+ assert text1 == '{"content": "Simple text content"}'++ # Test 2: List with single TextContent+ msg2 = PydanticMessage(+ role=MessageRole.user,+ content=[TextContent(text="Single text content")],+ agent_id="test-agent",+ )+ text2 = manager._extract_message_text(msg2)+ assert text2 == '{"content": "Single text content"}'++ # Test 3: List with multiple TextContent items+ msg3 = PydanticMessage(+ role=MessageRole.user,+ content=[+ TextContent(text="First part"),+ TextContent(text="Second part"),+ TextContent(text="Third part"),+ ],+ agent_id="test-agent",+ )+ text3 = manager._extract_message_text(msg3)+ assert text3 == '{"content": "First part Second part Third part"}'++ # Test 4: Empty content+ msg4 = PydanticMessage(+ role=MessageRole.system,+ content=None,+ agent_id="test-agent",+ )+ text4 = manager._extract_message_text(msg4)+ assert text4 == ""++ # Test 5: Empty list+ msg5 = PydanticMessage(+ role=MessageRole.assistant,+ content=[],+ agent_id="test-agent",+ )+ text5 = manager._extract_message_text(msg5)+ assert text5 == ""++ # Test 6: Mixed content types with to_text() methods+ msg6 = PydanticMessage(+ role=MessageRole.assistant,+ content=[+ TextContent(text="User said:"),+ ToolCallContent(id="call-123", name="search", input={"query": "test"}),+ ToolReturnContent(tool_call_id="call-123", content="Found 5 results", is_error=False),+ ReasoningContent(is_native=True, reasoning="I should help the user", signature="step-1"),+ ],+ agent_id="test-agent",+ )+ text6 = manager._extract_message_text(msg6)+ expected_parts = [+ "User said:",+ 'Tool call: search({\n "query": "test"\n})',+ "Tool result: Found 5 results",+ "I should help the user",+ ]+ assert (+ text6+ == '{"content": "User said: Tool call: search({\\n \\"query\\": \\"test\\"\\n}) Tool result: Found 5 results I should help the user"}'+ )- # Test 5: Empty list- msg5 = PydanticMessage(- role=MessageRole.assistant,- content=[],- agent_id="test-agent",- )- text5 = manager._extract_message_text(msg5)- assert text5 == ""- # Test 6: Mixed content types with to_text() methods- msg6 = PydanticMessage([email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_embedding_without_config(server, default_user, sarah_agent, enable_message_embedding):+ """Test that messages are NOT embedded without embedding_config even when tpuf is enabled"""+ # Create messages WITHOUT embedding_config+ messages = [+ PydanticMessage(+ role=MessageRole.user,+ content=[TextContent(text="Test message without embedding config")],+ agent_id=sarah_agent.id,+ ),+ PydanticMessage(role=MessageRole.assistant,- content=[- TextContent(text="User said:"),- ToolCallContent(id="call-123", name="search", input={"query": "test"}),- ToolReturnContent(tool_call_id="call-123", content="Found 5 results", is_error=False),- ReasoningContent(is_native=True, reasoning="I should help the user", signature="step-1"),- ],- agent_id="test-agent",- )- text6 = manager._extract_message_text(msg6)- expected_parts = [- "User said:",- 'Tool call: search({\n "query": "test"\n})',- "Tool result: Found 5 results",- "I should help the user",- ]- assert (- text6- == '{"content": "User said: Tool call: search({\\n \\"query\\": \\"test\\"\\n}) Tool result: Found 5 results I should help the user"}'- )+ content=[TextContent(text="Response without embedding config")],+ agent_id=sarah_agent.id,+ ),+ ]- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_message_embedding_without_config(self, server, default_user, sarah_agent, enable_message_embedding):- """Test that messages are NOT embedded without embedding_config even when tpuf is enabled"""- # Create messages WITHOUT embedding_config- messages = [- PydanticMessage(- role=MessageRole.user,- content=[TextContent(text="Test message without embedding config")],- agent_id=sarah_agent.id,- ),- PydanticMessage(- role=MessageRole.assistant,- content=[TextContent(text="Response without embedding config")],- agent_id=sarah_agent.id,- ),- ]+ created = await server.message_manager.create_many_messages_async(+ pydantic_msgs=messages,+ actor=default_user,+ )- created = await server.message_manager.create_many_messages_async(- pydantic_msgs=messages,- actor=default_user,- )+ assert len(created) == 2+ assert all(msg.agent_id == sarah_agent.id for msg in created)- assert len(created) == 2- assert all(msg.agent_id == sarah_agent.id for msg in created)+ # Messages should be in SQL+ sql_messages = await server.message_manager.list_messages_for_agent_async(+ agent_id=sarah_agent.id,+ actor=default_user,+ limit=10,+ )+ assert len(sql_messages) >= 2++ # Clean up+ message_ids = [msg.id for msg in created]+ await server.message_manager.delete_messages_by_ids_async(message_ids, default_user)+++async def test_generic_reciprocal_rank_fusion():+ """Test the generic RRF function with different object types"""+ from letta.helpers.tpuf_client import TurbopufferClient++ client = TurbopufferClient()++ # Test with passage objects (backward compatibility)+ p1_id = "passage-78d49031-8502-49c1-a970-45663e9f6e07"+ p2_id = "passage-90df8386-4caf-49cc-acbc-d71526de6f77"+ passage1 = Passage(+ id=p1_id,+ text="First passage",+ organization_id="org1",+ archive_id="archive1",+ created_at=datetime.now(timezone.utc),+ metadata_={},+ tags=[],+ embedding=[],+ embedding_config=None,+ )+ passage2 = Passage(+ id=p2_id,+ text="Second passage",+ organization_id="org1",+ archive_id="archive1",+ created_at=datetime.now(timezone.utc),+ metadata_={},+ tags=[],+ embedding=[],+ embedding_config=None,+ )- # Messages should be in SQL- sql_messages = await server.message_manager.list_messages_for_agent_async(- agent_id=sarah_agent.id,- actor=default_user,- limit=10,- )- assert len(sql_messages) >= 2+ vector_results = [(passage1, 0.9), (passage2, 0.7)]+ fts_results = [(passage2, 0.8), (passage1, 0.6)]++ # Test with passages using the RRF function+ combined = client._reciprocal_rank_fusion(+ vector_results=[passage for passage, _ in vector_results],+ fts_results=[passage for passage, _ in fts_results],+ get_id_func=lambda p: p.id,+ vector_weight=0.5,+ fts_weight=0.5,+ top_k=2,+ )- # Clean up- message_ids = [msg.id for msg in created]- await server.message_manager.delete_messages_by_ids_async(message_ids, default_user)-- @pytest.mark.asyncio- async def test_generic_reciprocal_rank_fusion(self):- """Test the generic RRF function with different object types"""- from letta.helpers.tpuf_client import TurbopufferClient-- client = TurbopufferClient()-- # Test with passage objects (backward compatibility)- p1_id = "passage-78d49031-8502-49c1-a970-45663e9f6e07"- p2_id = "passage-90df8386-4caf-49cc-acbc-d71526de6f77"- passage1 = Passage(- id=p1_id,- text="First passage",- organization_id="org1",- archive_id="archive1",- created_at=datetime.now(timezone.utc),- metadata_={},- tags=[],- embedding=[],- embedding_config=None,- )- passage2 = Passage(- id=p2_id,- text="Second passage",- organization_id="org1",- archive_id="archive1",- created_at=datetime.now(timezone.utc),- metadata_={},- tags=[],- embedding=[],- embedding_config=None,- )+ assert len(combined) == 2+ # Both passages should be in results - now returns (passage, score, metadata)+ result_ids = [p.id for p, _, _ in combined]+ assert p1_id in result_ids+ assert p2_id in result_ids++ # Test with message dicts using generic function+ msg1 = {"id": "m1", "text": "First message"}+ msg2 = {"id": "m2", "text": "Second message"}+ msg3 = {"id": "m3", "text": "Third message"}++ vector_msg_results = [(msg1, 0.95), (msg2, 0.85), (msg3, 0.75)]+ fts_msg_results = [(msg2, 0.90), (msg3, 0.80), (msg1, 0.70)]++ combined_msgs = client._reciprocal_rank_fusion(+ vector_results=[msg for msg, _ in vector_msg_results],+ fts_results=[msg for msg, _ in fts_msg_results],+ get_id_func=lambda m: m["id"],+ vector_weight=0.6,+ fts_weight=0.4,+ top_k=3,+ )- vector_results = [(passage1, 0.9), (passage2, 0.7)]- fts_results = [(passage2, 0.8), (passage1, 0.6)]+ assert len(combined_msgs) == 3+ msg_ids = [m["id"] for m, _, _ in combined_msgs]+ assert "m1" in msg_ids+ assert "m2" in msg_ids+ assert "m3" in msg_ids++ # Test edge cases+ # Empty results+ empty_combined = client._reciprocal_rank_fusion(+ vector_results=[],+ fts_results=[],+ get_id_func=lambda x: x["id"],+ vector_weight=0.5,+ fts_weight=0.5,+ top_k=10,+ )+ assert len(empty_combined) == 0++ # Single result list+ single_combined = client._reciprocal_rank_fusion(+ vector_results=[msg1],+ fts_results=[],+ get_id_func=lambda m: m["id"],+ vector_weight=0.5,+ fts_weight=0.5,+ top_k=10,+ )+ assert len(single_combined) == 1+ assert single_combined[0][0]["id"] == "m1"- # Test with passages using the RRF function- combined = client._reciprocal_rank_fusion(- vector_results=[passage for passage, _ in vector_results],- fts_results=[passage for passage, _ in fts_results],- get_id_func=lambda p: p.id,- vector_weight=0.5,- fts_weight=0.5,- top_k=2,- )- assert len(combined) == 2- # Both passages should be in results - now returns (passage, score, metadata)- result_ids = [p.id for p, _, _ in combined]- assert p1_id in result_ids- assert p2_id in result_ids[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_dual_write_with_real_tpuf(enable_message_embedding, default_user):+ """Test actual message embedding and storage in Turbopuffer"""+ import uuid+ from datetime import datetime, timezone- # Test with message dicts using generic function- msg1 = {"id": "m1", "text": "First message"}- msg2 = {"id": "m2", "text": "Second message"}- msg3 = {"id": "m3", "text": "Third message"}+ from letta.helpers.tpuf_client import TurbopufferClient+ from letta.schemas.enums import MessageRole- vector_msg_results = [(msg1, 0.95), (msg2, 0.85), (msg3, 0.75)]- fts_msg_results = [(msg2, 0.90), (msg3, 0.80), (msg1, 0.70)]+ client = TurbopufferClient()+ agent_id = f"test-agent-{uuid.uuid4()}"+ org_id = str(uuid.uuid4())- combined_msgs = client._reciprocal_rank_fusion(- vector_results=[msg for msg, _ in vector_msg_results],- fts_results=[msg for msg, _ in fts_msg_results],- get_id_func=lambda m: m["id"],- vector_weight=0.6,- fts_weight=0.4,- top_k=3,+ try:+ # Prepare test messages+ message_texts = [+ "Hello, how can I help you today?",+ "I need help with Python programming.",+ "Sure, what specific Python topic?",+ ]+ message_ids = [str(uuid.uuid4()) for _ in message_texts]+ roles = [MessageRole.assistant, MessageRole.user, MessageRole.assistant]+ created_ats = [datetime.now(timezone.utc) for _ in message_texts]++ # Generate embeddings (dummy for test)+ embeddings = [[float(i), float(i + 1), float(i + 2)] for i in range(len(message_texts))]++ # Insert messages into Turbopuffer+ success = await client.insert_messages(+ agent_id=agent_id,+ message_texts=message_texts,+ message_ids=message_ids,+ organization_id=org_id,+ actor=default_user,+ roles=roles,+ created_ats=created_ats,)- assert len(combined_msgs) == 3- msg_ids = [m["id"] for m, _, _ in combined_msgs]- assert "m1" in msg_ids- assert "m2" in msg_ids- assert "m3" in msg_ids-- # Test edge cases- # Empty results- empty_combined = client._reciprocal_rank_fusion(- vector_results=[],- fts_results=[],- get_id_func=lambda x: x["id"],- vector_weight=0.5,- fts_weight=0.5,- top_k=10,- )- assert len(empty_combined) == 0+ assert success == True- # Single result list- single_combined = client._reciprocal_rank_fusion(- vector_results=[msg1],- fts_results=[],- get_id_func=lambda m: m["id"],- vector_weight=0.5,- fts_weight=0.5,- top_k=10,+ # Verify we can query the messages+ results = await client.query_messages_by_agent_id(+ agent_id=agent_id, organization_id=org_id, search_mode="timestamp", top_k=10, actor=default_user)- assert len(single_combined) == 1- assert single_combined[0][0]["id"] == "m1"-- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_message_dual_write_with_real_tpuf(self, enable_message_embedding, default_user):- """Test actual message embedding and storage in Turbopuffer"""- import uuid- from datetime import datetime, timezone- from letta.helpers.tpuf_client import TurbopufferClient- from letta.schemas.enums import MessageRole-- client = TurbopufferClient()- agent_id = f"test-agent-{uuid.uuid4()}"- org_id = str(uuid.uuid4())+ assert len(results) == 3+ # Results should be ordered by timestamp (most recent first)+ for msg_dict, score, metadata in results:+ assert msg_dict["agent_id"] == agent_id+ assert msg_dict["organization_id"] == org_id+ assert msg_dict["text"] in message_texts+ assert msg_dict["role"] in ["assistant", "user"]+ finally:+ # Clean up namespacetry:- # Prepare test messages- message_texts = [- "Hello, how can I help you today?",- "I need help with Python programming.",- "Sure, what specific Python topic?",- ]- message_ids = [str(uuid.uuid4()) for _ in message_texts]- roles = [MessageRole.assistant, MessageRole.user, MessageRole.assistant]- created_ats = [datetime.now(timezone.utc) for _ in message_texts]-- # Generate embeddings (dummy for test)- embeddings = [[float(i), float(i + 1), float(i + 2)] for i in range(len(message_texts))]-- # Insert messages into Turbopuffer- success = await client.insert_messages(- agent_id=agent_id,- message_texts=message_texts,- message_ids=message_ids,- organization_id=org_id,- actor=default_user,- roles=roles,- created_ats=created_ats,- )+ await client.delete_all_messages(agent_id)+ except:+ pass- assert success == True- # Verify we can query the messages- results = await client.query_messages_by_agent_id(- agent_id=agent_id, organization_id=org_id, search_mode="timestamp", top_k=10, actor=default_user- )[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_vector_search_with_real_tpuf(enable_message_embedding, default_user):+ """Test vector search on messages in Turbopuffer"""+ import uuid+ from datetime import datetime, timezone- assert len(results) == 3- # Results should be ordered by timestamp (most recent first)- for msg_dict, score, metadata in results:- assert msg_dict["agent_id"] == agent_id- assert msg_dict["organization_id"] == org_id- assert msg_dict["text"] in message_texts- assert msg_dict["role"] in ["assistant", "user"]-- finally:- # Clean up namespace- try:- await client.delete_all_messages(agent_id)- except:- pass-- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_message_vector_search_with_real_tpuf(self, enable_message_embedding, default_user):- """Test vector search on messages in Turbopuffer"""- import uuid- from datetime import datetime, timezone-- from letta.helpers.tpuf_client import TurbopufferClient- from letta.schemas.enums import MessageRole-- client = TurbopufferClient()- agent_id = f"test-agent-{uuid.uuid4()}"- org_id = str(uuid.uuid4())+ from letta.helpers.tpuf_client import TurbopufferClient+ from letta.schemas.enums import MessageRole- try:- # Insert messages with different embeddings- message_texts = [- "Python is a great programming language",- "JavaScript is used for web development",- "Machine learning with Python is powerful",- ]- message_ids = [str(uuid.uuid4()) for _ in message_texts]- roles = [MessageRole.assistant] * len(message_texts)- created_ats = [datetime.now(timezone.utc) for _ in message_texts]-- # Create embeddings that reflect content similarity- # Insert messages- await client.insert_messages(- agent_id=agent_id,- message_texts=message_texts,- message_ids=message_ids,- organization_id=org_id,- actor=default_user,- roles=roles,- created_ats=created_ats,- )+ client = TurbopufferClient()+ agent_id = f"test-agent-{uuid.uuid4()}"+ org_id = str(uuid.uuid4())- # Search for Python-related messages using vector search- results = await client.query_messages_by_agent_id(- agent_id=agent_id,- organization_id=org_id,- actor=default_user,- query_text="Python programming",- search_mode="vector",- top_k=2,- )+ try:+ # Insert messages with different embeddings+ message_texts = [+ "Python is a great programming language",+ "JavaScript is used for web development",+ "Machine learning with Python is powerful",+ ]+ message_ids = [str(uuid.uuid4()) for _ in message_texts]+ roles = [MessageRole.assistant] * len(message_texts)+ created_ats = [datetime.now(timezone.utc) for _ in message_texts]++ # Create embeddings that reflect content similarity+ # Insert messages+ await client.insert_messages(+ agent_id=agent_id,+ message_texts=message_texts,+ message_ids=message_ids,+ organization_id=org_id,+ actor=default_user,+ roles=roles,+ created_ats=created_ats,+ )++ # Search for Python-related messages using vector search+ results = await client.query_messages_by_agent_id(+ agent_id=agent_id,+ organization_id=org_id,+ actor=default_user,+ query_text="Python programming",+ search_mode="vector",+ top_k=2,+ )- assert len(results) == 2- # Should return Python-related messages first- result_texts = [msg["text"] for msg, _, _ in results]- assert "Python is a great programming language" in result_texts- assert "Machine learning with Python is powerful" in result_texts-- finally:- # Clean up namespace- try:- await client.delete_all_messages(agent_id)- except:- pass-- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_message_hybrid_search_with_real_tpuf(self, enable_message_embedding, default_user):- """Test hybrid search combining vector and FTS for messages"""- import uuid- from datetime import datetime, timezone-- from letta.helpers.tpuf_client import TurbopufferClient- from letta.schemas.enums import MessageRole-- client = TurbopufferClient()- agent_id = f"test-agent-{uuid.uuid4()}"- org_id = str(uuid.uuid4())+ assert len(results) == 2+ # Should return Python-related messages first+ result_texts = [msg["text"] for msg, _, _ in results]+ assert "Python is a great programming language" in result_texts+ assert "Machine learning with Python is powerful" in result_texts+ finally:+ # Clean up namespacetry:- # Insert diverse messages- message_texts = [- "The quick brown fox jumps over the lazy dog",- "Machine learning algorithms are fascinating",- "Quick tutorial on Python programming",- "Deep learning with neural networks",- ]- message_ids = [str(uuid.uuid4()) for _ in message_texts]- roles = [MessageRole.assistant] * len(message_texts)- created_ats = [datetime.now(timezone.utc) for _ in message_texts]-- # Insert messages- await client.insert_messages(- agent_id=agent_id,- message_texts=message_texts,- message_ids=message_ids,- organization_id=org_id,- actor=default_user,- roles=roles,- created_ats=created_ats,- )+ await client.delete_all_messages(agent_id)+ except:+ pass- # Hybrid search - text search for "quick"- results = await client.query_messages_by_agent_id(- agent_id=agent_id,- organization_id=org_id,- actor=default_user,- query_text="quick", # Text search for "quick"- search_mode="hybrid",- top_k=3,- vector_weight=0.5,- fts_weight=0.5,- )- assert len(results) > 0- # Should get a mix of results based on both vector and text similarity- result_texts = [msg["text"] for msg, _, _ in results]- # At least one result should contain "quick" due to FTS- assert any("quick" in text.lower() for text in result_texts)-- finally:- # Clean up namespace- try:- await client.delete_all_messages(agent_id)- except:- pass-- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_message_role_filtering_with_real_tpuf(self, enable_message_embedding, default_user):- """Test filtering messages by role"""- import uuid- from datetime import datetime, timezone-- from letta.helpers.tpuf_client import TurbopufferClient- from letta.schemas.enums import MessageRole-- client = TurbopufferClient()- agent_id = f"test-agent-{uuid.uuid4()}"- org_id = str(uuid.uuid4())[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_hybrid_search_with_real_tpuf(enable_message_embedding, default_user):+ """Test hybrid search combining vector and FTS for messages"""+ import uuid+ from datetime import datetime, timezone++ from letta.helpers.tpuf_client import TurbopufferClient+ from letta.schemas.enums import MessageRole++ client = TurbopufferClient()+ agent_id = f"test-agent-{uuid.uuid4()}"+ org_id = str(uuid.uuid4())++ try:+ # Insert diverse messages+ message_texts = [+ "The quick brown fox jumps over the lazy dog",+ "Machine learning algorithms are fascinating",+ "Quick tutorial on Python programming",+ "Deep learning with neural networks",+ ]+ message_ids = [str(uuid.uuid4()) for _ in message_texts]+ roles = [MessageRole.assistant] * len(message_texts)+ created_ats = [datetime.now(timezone.utc) for _ in message_texts]++ # Insert messages+ await client.insert_messages(+ agent_id=agent_id,+ message_texts=message_texts,+ message_ids=message_ids,+ organization_id=org_id,+ actor=default_user,+ roles=roles,+ created_ats=created_ats,+ )++ # Hybrid search - text search for "quick"+ results = await client.query_messages_by_agent_id(+ agent_id=agent_id,+ organization_id=org_id,+ actor=default_user,+ query_text="quick", # Text search for "quick"+ search_mode="hybrid",+ top_k=3,+ vector_weight=0.5,+ fts_weight=0.5,+ )++ assert len(results) > 0+ # Should get a mix of results based on both vector and text similarity+ result_texts = [msg["text"] for msg, _, _ in results]+ # At least one result should contain "quick" due to FTS+ assert any("quick" in text.lower() for text in result_texts)+ finally:+ # Clean up namespacetry:- # Insert messages with different roles- message_data = [- ("Hello! How can I help?", MessageRole.assistant),- ("I need help with Python", MessageRole.user),- ("Here's a Python example", MessageRole.assistant),- ("Can you explain this?", MessageRole.user),- ("System message here", MessageRole.system),- ]-- message_texts = [text for text, _ in message_data]- roles = [role for _, role in message_data]- message_ids = [str(uuid.uuid4()) for _ in message_texts]- created_ats = [datetime.now(timezone.utc) for _ in message_texts]-- # Insert messages- await client.insert_messages(- agent_id=agent_id,- message_texts=message_texts,- message_ids=message_ids,- organization_id=org_id,- actor=default_user,- roles=roles,- created_ats=created_ats,- )+ await client.delete_all_messages(agent_id)+ except:+ pass- # Query only user messages- user_results = await client.query_messages_by_agent_id(- agent_id=agent_id, organization_id=org_id, search_mode="timestamp", top_k=10, roles=[MessageRole.user], actor=default_user- )- assert len(user_results) == 2- for msg, _, _ in user_results:- assert msg["role"] == "user"- assert msg["text"] in ["I need help with Python", "Can you explain this?"][email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_role_filtering_with_real_tpuf(enable_message_embedding, default_user):+ """Test filtering messages by role"""+ import uuid+ from datetime import datetime, timezone- # Query assistant and system messages- non_user_results = await client.query_messages_by_agent_id(- agent_id=agent_id,- organization_id=org_id,- search_mode="timestamp",- top_k=10,- roles=[MessageRole.assistant, MessageRole.system],- actor=default_user,- )+ from letta.helpers.tpuf_client import TurbopufferClient+ from letta.schemas.enums import MessageRole- assert len(non_user_results) == 3- for msg, _, _ in non_user_results:- assert msg["role"] in ["assistant", "system"]+ client = TurbopufferClient()+ agent_id = f"test-agent-{uuid.uuid4()}"+ org_id = str(uuid.uuid4())- finally:- # Clean up namespace- try:- await client.delete_all_messages(agent_id)- except:- pass+ try:+ # Insert messages with different roles+ message_data = [+ ("Hello! How can I help?", MessageRole.assistant),+ ("I need help with Python", MessageRole.user),+ ("Here's a Python example", MessageRole.assistant),+ ("Can you explain this?", MessageRole.user),+ ("System message here", MessageRole.system),+ ]- @pytest.mark.asyncio- async def test_message_search_fallback_to_sql(self, server, default_user, sarah_agent):- """Test that message search falls back to SQL when Turbopuffer is disabled"""- # Save original settings- original_use_tpuf = settings.use_tpuf- original_embed_messages = settings.embed_all_messages+ message_texts = [text for text, _ in message_data]+ roles = [role for _, role in message_data]+ message_ids = [str(uuid.uuid4()) for _ in message_texts]+ created_ats = [datetime.now(timezone.utc) for _ in message_texts]++ # Insert messages+ await client.insert_messages(+ agent_id=agent_id,+ message_texts=message_texts,+ message_ids=message_ids,+ organization_id=org_id,+ actor=default_user,+ roles=roles,+ created_ats=created_ats,+ )- try:- # Disable Turbopuffer for messages- settings.use_tpuf = False- settings.embed_all_messages = False+ # Query only user messages+ user_results = await client.query_messages_by_agent_id(+ agent_id=agent_id, organization_id=org_id, search_mode="timestamp", top_k=10, roles=[MessageRole.user], actor=default_user+ )- # Create messages- messages = await server.message_manager.create_many_messages_async(- pydantic_msgs=[- PydanticMessage(- role=MessageRole.user,- content=[TextContent(text="Test message for SQL fallback")],- agent_id=sarah_agent.id,- )- ],- actor=default_user,- )+ assert len(user_results) == 2+ for msg, _, _ in user_results:+ assert msg["role"] == "user"+ assert msg["text"] in ["I need help with Python", "Can you explain this?"]- # Search should use SQL backend (not Turbopuffer)- results = await server.message_manager.search_messages_async(- actor=default_user,- agent_id=sarah_agent.id,- query_text="fallback",- limit=10,- )+ # Query assistant and system messages+ non_user_results = await client.query_messages_by_agent_id(+ agent_id=agent_id,+ organization_id=org_id,+ search_mode="timestamp",+ top_k=10,+ roles=[MessageRole.assistant, MessageRole.system],+ actor=default_user,+ )- # Should return results from SQL search- assert len(results) > 0- # Extract text from messages and check for "fallback"- for msg, metadata in results:- text = server.message_manager._extract_message_text(msg)- if "fallback" in text.lower():- break- else:- assert False, "No messages containing 'fallback' found"-- finally:- # Restore settings- settings.use_tpuf = original_use_tpuf- settings.embed_all_messages = original_embed_messages-- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_message_update_reindexes_in_turbopuffer(self, server, default_user, sarah_agent, enable_message_embedding):- """Test that updating a message properly deletes and re-inserts with new embedding in Turbopuffer"""- from letta.schemas.message import MessageUpdate+ assert len(non_user_results) == 3+ for msg, _, _ in non_user_results:+ assert msg["role"] in ["assistant", "system"]- embedding_config = sarah_agent.embedding_config or EmbeddingConfig.default_config(provider="openai")+ finally:+ # Clean up namespace+ try:+ await client.delete_all_messages(agent_id)+ except:+ pass+++async def test_message_search_fallback_to_sql(server, default_user, sarah_agent):+ """Test that message search falls back to SQL when Turbopuffer is disabled"""+ # Save original settings+ original_use_tpuf = settings.use_tpuf+ original_embed_messages = settings.embed_all_messages- # Create initial message+ try:+ # Disable Turbopuffer for messages+ settings.use_tpuf = False+ settings.embed_all_messages = False++ # Create messagesmessages = await server.message_manager.create_many_messages_async(pydantic_msgs=[PydanticMessage(role=MessageRole.user,- content=[TextContent(text="Original content about Python programming")],+ content=[TextContent(text="Test message for SQL fallback")],agent_id=sarah_agent.id,)],actor=default_user,- strict_mode=True,)- assert len(messages) == 1- message_id = messages[0].id-- # Search for "Python" - should find it- python_results = await server.message_manager.search_messages_async(- agent_id=sarah_agent.id,+ # Search should use SQL backend (not Turbopuffer)+ results = await server.message_manager.search_messages_async(actor=default_user,- query_text="Python",- search_mode="fts",+ agent_id=sarah_agent.id,+ query_text="fallback",limit=10,)- assert len(python_results) > 0- assert any(msg.id == message_id for msg, metadata in python_results)- # Update the message content- updated_message = await server.message_manager.update_message_by_id_async(- message_id=message_id,- message_update=MessageUpdate(content="Updated content about JavaScript development"),- actor=default_user,- strict_mode=True,- )+ # Should return results from SQL search+ assert len(results) > 0+ # Extract text from messages and check for "fallback"+ for msg, metadata in results:+ text = server.message_manager._extract_message_text(msg)+ if "fallback" in text.lower():+ break+ else:+ assert False, "No messages containing 'fallback' found"- assert updated_message.id == message_id # ID should remain the same+ finally:+ # Restore settings+ settings.use_tpuf = original_use_tpuf+ settings.embed_all_messages = original_embed_messages- # Search for "Python" - should NOT find it anymore- python_results_after = await server.message_manager.search_messages_async(- agent_id=sarah_agent.id,+[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_update_reindexes_in_turbopuffer(server, default_user, sarah_agent, enable_message_embedding):+ """Test that updating a message properly deletes and re-inserts with new embedding in Turbopuffer"""+ from letta.schemas.message import MessageUpdate++ embedding_config = sarah_agent.embedding_config or EmbeddingConfig.default_config(provider="openai")++ # Create initial message+ messages = await server.message_manager.create_many_messages_async(+ pydantic_msgs=[+ PydanticMessage(+ role=MessageRole.user,+ content=[TextContent(text="Original content about Python programming")],+ agent_id=sarah_agent.id,+ )+ ],+ actor=default_user,+ strict_mode=True,+ )++ assert len(messages) == 1+ message_id = messages[0].id++ # Search for "Python" - should find it+ python_results = await server.message_manager.search_messages_async(+ agent_id=sarah_agent.id,+ actor=default_user,+ query_text="Python",+ search_mode="fts",+ limit=10,+ )+ assert len(python_results) > 0+ assert any(msg.id == message_id for msg, metadata in python_results)++ # Update the message content+ updated_message = await server.message_manager.update_message_by_id_async(+ message_id=message_id,+ message_update=MessageUpdate(content="Updated content about JavaScript development"),+ actor=default_user,+ strict_mode=True,+ )++ assert updated_message.id == message_id # ID should remain the same++ # Search for "Python" - should NOT find it anymore+ python_results_after = await server.message_manager.search_messages_async(+ agent_id=sarah_agent.id,+ actor=default_user,+ query_text="Python",+ search_mode="fts",+ limit=10,+ )+ # Should either find no results or results that don't include our message+ assert not any(msg.id == message_id for msg, metadata in python_results_after)++ # Search for "JavaScript" - should find the updated message+ js_results = await server.message_manager.search_messages_async(+ agent_id=sarah_agent.id,+ actor=default_user,+ query_text="JavaScript",+ search_mode="fts",+ limit=10,+ )+ assert len(js_results) > 0+ assert any(msg.id == message_id for msg, metadata in js_results)++ # Clean up+ await server.message_manager.delete_messages_by_ids_async([message_id], default_user, strict_mode=True)++[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_deletion_syncs_with_turbopuffer(server, default_user, enable_message_embedding):+ """Test that all deletion methods properly sync with Turbopuffer"""+ from letta.schemas.agent import CreateAgent+ from letta.schemas.llm_config import LLMConfig++ # Create two test agents+ agent_a = await server.agent_manager.create_agent_async(+ agent_create=CreateAgent(+ name="Agent A",+ memory_blocks=[],+ llm_config=LLMConfig.default_config("gpt-4o-mini"),+ embedding_config=EmbeddingConfig.default_config(provider="openai"),+ include_base_tools=False,+ ),+ actor=default_user,+ )++ agent_b = await server.agent_manager.create_agent_async(+ agent_create=CreateAgent(+ name="Agent B",+ memory_blocks=[],+ llm_config=LLMConfig.default_config("gpt-4o-mini"),+ embedding_config=EmbeddingConfig.default_config(provider="openai"),+ include_base_tools=False,+ ),+ actor=default_user,+ )++ embedding_config = agent_a.embedding_config++ try:+ # Create 5 messages for agent A+ agent_a_messages = []+ for i in range(5):+ msgs = await server.message_manager.create_many_messages_async(+ pydantic_msgs=[+ PydanticMessage(+ role=MessageRole.user,+ content=[TextContent(text=f"Agent A message {i + 1}")],+ agent_id=agent_a.id,+ )+ ],+ actor=default_user,+ strict_mode=True,+ )+ agent_a_messages.extend(msgs)++ # Create 3 messages for agent B+ agent_b_messages = []+ for i in range(3):+ msgs = await server.message_manager.create_many_messages_async(+ pydantic_msgs=[+ PydanticMessage(+ role=MessageRole.user,+ content=[TextContent(text=f"Agent B message {i + 1}")],+ agent_id=agent_b.id,+ )+ ],+ actor=default_user,+ strict_mode=True,+ )+ agent_b_messages.extend(msgs)++ # Verify initial state - all messages are searchable+ agent_a_search = await server.message_manager.search_messages_async(+ agent_id=agent_a.id,actor=default_user,- query_text="Python",+ query_text="Agent A",search_mode="fts",limit=10,)- # Should either find no results or results that don't include our message- assert not any(msg.id == message_id for msg, metadata in python_results_after)+ assert len(agent_a_search) == 5- # Search for "JavaScript" - should find the updated message- js_results = await server.message_manager.search_messages_async(- agent_id=sarah_agent.id,+ agent_b_search = await server.message_manager.search_messages_async(+ agent_id=agent_b.id,actor=default_user,- query_text="JavaScript",+ query_text="Agent B",search_mode="fts",limit=10,)- assert len(js_results) > 0- assert any(msg.id == message_id for msg, metadata in js_results)+ assert len(agent_b_search) == 3- # Clean up- await server.message_manager.delete_messages_by_ids_async([message_id], default_user, strict_mode=True)-- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_message_deletion_syncs_with_turbopuffer(self, server, default_user, enable_message_embedding):- """Test that all deletion methods properly sync with Turbopuffer"""- from letta.schemas.agent import CreateAgent- from letta.schemas.llm_config import LLMConfig-- # Create two test agents- agent_a = await server.agent_manager.create_agent_async(- agent_create=CreateAgent(- name="Agent A",- memory_blocks=[],- llm_config=LLMConfig.default_config("gpt-4o-mini"),- embedding_config=EmbeddingConfig.default_config(provider="openai"),- include_base_tools=False,- ),- actor=default_user,+ # Test 1: Delete single message from agent A+ await server.message_manager.delete_message_by_id_async(agent_a_messages[0].id, default_user, strict_mode=True)++ # Test 2: Batch delete 2 messages from agent A+ await server.message_manager.delete_messages_by_ids_async(+ [agent_a_messages[1].id, agent_a_messages[2].id], default_user, strict_mode=True)- agent_b = await server.agent_manager.create_agent_async(- agent_create=CreateAgent(- name="Agent B",- memory_blocks=[],- llm_config=LLMConfig.default_config("gpt-4o-mini"),- embedding_config=EmbeddingConfig.default_config(provider="openai"),- include_base_tools=False,- ),+ # Test 3: Delete all messages for agent B+ await server.message_manager.delete_all_messages_for_agent_async(agent_b.id, default_user, strict_mode=True)++ # Verify final state+ # Agent A should have 2 messages left (5 - 1 - 2 = 2)+ agent_a_final = await server.message_manager.search_messages_async(+ agent_id=agent_a.id,+ actor=default_user,+ query_text="Agent A",+ search_mode="fts",+ limit=10,+ )+ assert len(agent_a_final) == 2+ # Verify the remaining messages are the correct ones+ remaining_ids = {msg.id for msg, metadata in agent_a_final}+ assert agent_a_messages[3].id in remaining_ids+ assert agent_a_messages[4].id in remaining_ids++ # Agent B should have 0 messages+ agent_b_final = await server.message_manager.search_messages_async(+ agent_id=agent_b.id,actor=default_user,+ query_text="Agent B",+ search_mode="fts",+ limit=10,)+ assert len(agent_b_final) == 0- embedding_config = agent_a.embedding_config+ finally:+ # Clean up agents+ await server.agent_manager.delete_agent_async(agent_a.id, default_user)+ await server.agent_manager.delete_agent_async(agent_b.id, default_user)- try:- # Create 5 messages for agent A- agent_a_messages = []- for i in range(5):- msgs = await server.message_manager.create_many_messages_async(- pydantic_msgs=[- PydanticMessage(- role=MessageRole.user,- content=[TextContent(text=f"Agent A message {i + 1}")],- agent_id=agent_a.id,- )- ],- actor=default_user,- strict_mode=True,- )- agent_a_messages.extend(msgs)-- # Create 3 messages for agent B- agent_b_messages = []- for i in range(3):- msgs = await server.message_manager.create_many_messages_async(- pydantic_msgs=[- PydanticMessage(- role=MessageRole.user,- content=[TextContent(text=f"Agent B message {i + 1}")],- agent_id=agent_b.id,- )- ],- actor=default_user,- strict_mode=True,- )- agent_b_messages.extend(msgs)- # Verify initial state - all messages are searchable- agent_a_search = await server.message_manager.search_messages_async(- agent_id=agent_a.id,- actor=default_user,- query_text="Agent A",- search_mode="fts",- limit=10,- )- assert len(agent_a_search) == 5[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_turbopuffer_failure_does_not_break_postgres(server, default_user, sarah_agent, enable_message_embedding):+ """Test that postgres operations succeed even if turbopuffer fails"""+ from unittest.mock import AsyncMock, patch- agent_b_search = await server.message_manager.search_messages_async(- agent_id=agent_b.id,- actor=default_user,- query_text="Agent B",- search_mode="fts",- limit=10,- )- assert len(agent_b_search) == 3+ from letta.schemas.message import MessageUpdate- # Test 1: Delete single message from agent A- await server.message_manager.delete_message_by_id_async(agent_a_messages[0].id, default_user, strict_mode=True)+ embedding_config = sarah_agent.embedding_config or EmbeddingConfig.default_config(provider="openai")- # Test 2: Batch delete 2 messages from agent A- await server.message_manager.delete_messages_by_ids_async(- [agent_a_messages[1].id, agent_a_messages[2].id], default_user, strict_mode=True+ # Create initial messages+ messages = await server.message_manager.create_many_messages_async(+ pydantic_msgs=[+ PydanticMessage(+ role=MessageRole.user,+ content=[TextContent(text="Test message for error handling")],+ agent_id=sarah_agent.id,)+ ],+ actor=default_user,+ )- # Test 3: Delete all messages for agent B- await server.message_manager.delete_all_messages_for_agent_async(agent_b.id, default_user, strict_mode=True)+ assert len(messages) == 1+ message_id = messages[0].id- # Verify final state- # Agent A should have 2 messages left (5 - 1 - 2 = 2)- agent_a_final = await server.message_manager.search_messages_async(- agent_id=agent_a.id,+ # Mock turbopuffer client to raise exceptions+ with patch(+ "letta.helpers.tpuf_client.TurbopufferClient.delete_messages",+ new=AsyncMock(side_effect=Exception("Turbopuffer connection failed")),+ ):+ with patch(+ "letta.helpers.tpuf_client.TurbopufferClient.insert_messages",+ new=AsyncMock(side_effect=Exception("Turbopuffer insert failed")),+ ):+ # Test 1: Update should succeed in postgres despite turbopuffer failure+ # NOTE: strict_mode=False here because we're testing error resilience+ updated_message = await server.message_manager.update_message_by_id_async(+ message_id=message_id,+ message_update=MessageUpdate(content="Updated despite turbopuffer failure"),actor=default_user,- query_text="Agent A",- search_mode="fts",- limit=10,+ strict_mode=False, # Don't fail on turbopuffer errors - that's what we're testing!)- assert len(agent_a_final) == 2- # Verify the remaining messages are the correct ones- remaining_ids = {msg.id for msg, metadata in agent_a_final}- assert agent_a_messages[3].id in remaining_ids- assert agent_a_messages[4].id in remaining_ids-- # Agent B should have 0 messages- agent_b_final = await server.message_manager.search_messages_async(- agent_id=agent_b.id,++ # Verify postgres was updated successfully+ assert updated_message.id == message_id+ updated_text = server.message_manager._extract_message_text(updated_message)+ assert "Updated despite turbopuffer failure" in updated_text++ # Test 2: Delete should succeed in postgres despite turbopuffer failure+ # First create another message to delete+ messages2 = await server.message_manager.create_many_messages_async(+ pydantic_msgs=[+ PydanticMessage(+ role=MessageRole.user,+ content=[TextContent(text="Message to delete")],+ agent_id=sarah_agent.id,+ )+ ],actor=default_user,- query_text="Agent B",- search_mode="fts",- limit=10,)- assert len(agent_b_final) == 0+ message_to_delete_id = messages2[0].id- finally:- # Clean up agents- await server.agent_manager.delete_agent_async(agent_a.id, default_user)- await server.agent_manager.delete_agent_async(agent_b.id, default_user)+ # Delete with mocked turbopuffer failure+ # NOTE: strict_mode=False here because we're testing error resilience+ deletion_result = await server.message_manager.delete_message_by_id_async(message_to_delete_id, default_user, strict_mode=False)+ assert deletion_result == True- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_turbopuffer_failure_does_not_break_postgres(self, server, default_user, sarah_agent, enable_message_embedding):- """Test that postgres operations succeed even if turbopuffer fails"""- from unittest.mock import AsyncMock, patch+ # Verify message is deleted from postgres+ deleted_msg = await server.message_manager.get_message_by_id_async(message_to_delete_id, default_user)+ assert deleted_msg is None- from letta.schemas.message import MessageUpdate+ # Clean up remaining message (use strict_mode=False since turbopuffer might be mocked)+ await server.message_manager.delete_messages_by_ids_async([message_id], default_user, strict_mode=False)- embedding_config = sarah_agent.embedding_config or EmbeddingConfig.default_config(provider="openai")- # Create initial messages- messages = await server.message_manager.create_many_messages_async(- pydantic_msgs=[- PydanticMessage(- role=MessageRole.user,- content=[TextContent(text="Test message for error handling")],- agent_id=sarah_agent.id,- )- ],- actor=default_user,- )[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_creation_background_mode(server, default_user, sarah_agent, enable_message_embedding):+ """Test that messages are embedded in background when strict_mode=False"""+ embedding_config = sarah_agent.embedding_config or EmbeddingConfig.default_config(provider="openai")- assert len(messages) == 1- message_id = messages[0].id+ # Create message in background mode+ messages = await server.message_manager.create_many_messages_async(+ pydantic_msgs=[+ PydanticMessage(+ role=MessageRole.user,+ content=[TextContent(text="Background test message about Python programming")],+ agent_id=sarah_agent.id,+ )+ ],+ actor=default_user,+ strict_mode=False, # Background mode+ )- # Mock turbopuffer client to raise exceptions- with patch(- "letta.helpers.tpuf_client.TurbopufferClient.delete_messages",- new=AsyncMock(side_effect=Exception("Turbopuffer connection failed")),- ):- with patch(- "letta.helpers.tpuf_client.TurbopufferClient.insert_messages",- new=AsyncMock(side_effect=Exception("Turbopuffer insert failed")),- ):- # Test 1: Update should succeed in postgres despite turbopuffer failure- # NOTE: strict_mode=False here because we're testing error resilience- updated_message = await server.message_manager.update_message_by_id_async(- message_id=message_id,- message_update=MessageUpdate(content="Updated despite turbopuffer failure"),- actor=default_user,- strict_mode=False, # Don't fail on turbopuffer errors - that's what we're testing!- )+ assert len(messages) == 1+ message_id = messages[0].id- # Verify postgres was updated successfully- assert updated_message.id == message_id- updated_text = server.message_manager._extract_message_text(updated_message)- assert "Updated despite turbopuffer failure" in updated_text-- # Test 2: Delete should succeed in postgres despite turbopuffer failure- # First create another message to delete- messages2 = await server.message_manager.create_many_messages_async(- pydantic_msgs=[- PydanticMessage(- role=MessageRole.user,- content=[TextContent(text="Message to delete")],- agent_id=sarah_agent.id,- )- ],- actor=default_user,- )- message_to_delete_id = messages2[0].id+ # Message should be in PostgreSQL immediately+ sql_message = await server.message_manager.get_message_by_id_async(message_id, default_user)+ assert sql_message is not None+ assert sql_message.id == message_id- # Delete with mocked turbopuffer failure- # NOTE: strict_mode=False here because we're testing error resilience- deletion_result = await server.message_manager.delete_message_by_id_async(- message_to_delete_id, default_user, strict_mode=False- )- assert deletion_result == True-- # Verify message is deleted from postgres- deleted_msg = await server.message_manager.get_message_by_id_async(message_to_delete_id, default_user)- assert deleted_msg is None-- # Clean up remaining message (use strict_mode=False since turbopuffer might be mocked)- await server.message_manager.delete_messages_by_ids_async([message_id], default_user, strict_mode=False)-- async def wait_for_embedding(- self, agent_id: str, message_id: str, organization_id: str, actor, max_wait: float = 10.0, poll_interval: float = 0.5- ) -> bool:- """Poll Turbopuffer directly to check if a message has been embedded.-- Args:- agent_id: Agent ID for the message- message_id: ID of the message to find- organization_id: Organization ID- max_wait: Maximum time to wait in seconds- poll_interval: Time between polls in seconds-- Returns:- True if message was found in Turbopuffer within timeout, False otherwise- """- import asyncio-- from letta.helpers.tpuf_client import TurbopufferClient-- client = TurbopufferClient()- start_time = asyncio.get_event_loop().time()-- while asyncio.get_event_loop().time() - start_time < max_wait:- try:- # Query Turbopuffer directly using timestamp mode to get all messages- results = await client.query_messages_by_agent_id(- agent_id=agent_id,- organization_id=organization_id,- actor=actor,- search_mode="timestamp",- top_k=100, # Get more messages to ensure we find it- )+ # Poll for embedding completion by querying Turbopuffer directly+ embedded = await wait_for_embedding(+ agent_id=sarah_agent.id,+ message_id=message_id,+ organization_id=default_user.organization_id,+ actor=default_user,+ max_wait=10.0,+ poll_interval=0.5,+ )+ assert embedded, "Message was not embedded in Turbopuffer within timeout"- # Check if our message ID is in the results- if any(msg["id"] == message_id for msg, _, _ in results):- return True+ # Now verify it's also searchable through the search API+ search_results = await server.message_manager.search_messages_async(+ agent_id=sarah_agent.id,+ actor=default_user,+ query_text="Python programming",+ search_mode="fts",+ limit=10,+ )+ assert len(search_results) > 0+ assert any(msg.id == message_id for msg, _ in search_results)- except Exception as e:- # Log but don't fail - Turbopuffer might still be processing- pass+ # Clean up+ await server.message_manager.delete_messages_by_ids_async([message_id], default_user, strict_mode=True)- await asyncio.sleep(poll_interval)- return False[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_update_background_mode(server, default_user, sarah_agent, enable_message_embedding):+ """Test that message updates work in background mode"""+ from letta.schemas.message import MessageUpdate- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_message_creation_background_mode(self, server, default_user, sarah_agent, enable_message_embedding):- """Test that messages are embedded in background when strict_mode=False"""- embedding_config = sarah_agent.embedding_config or EmbeddingConfig.default_config(provider="openai")+ embedding_config = sarah_agent.embedding_config or EmbeddingConfig.default_config(provider="openai")- # Create message in background mode- messages = await server.message_manager.create_many_messages_async(- pydantic_msgs=[- PydanticMessage(- role=MessageRole.user,- content=[TextContent(text="Background test message about Python programming")],- agent_id=sarah_agent.id,- )- ],- actor=default_user,- strict_mode=False, # Background mode- )+ # Create initial message with strict_mode=True to ensure it's embedded+ messages = await server.message_manager.create_many_messages_async(+ pydantic_msgs=[+ PydanticMessage(+ role=MessageRole.user,+ content=[TextContent(text="Original content about databases")],+ agent_id=sarah_agent.id,+ )+ ],+ actor=default_user,+ strict_mode=True, # Ensure initial embedding+ )- assert len(messages) == 1- message_id = messages[0].id+ assert len(messages) == 1+ message_id = messages[0].id- # Message should be in PostgreSQL immediately- sql_message = await server.message_manager.get_message_by_id_async(message_id, default_user)- assert sql_message is not None- assert sql_message.id == message_id+ # Verify initial content is searchable+ initial_results = await server.message_manager.search_messages_async(+ agent_id=sarah_agent.id,+ actor=default_user,+ query_text="databases",+ search_mode="fts",+ limit=10,+ )+ assert any(msg.id == message_id for msg, _ in initial_results)- # Poll for embedding completion by querying Turbopuffer directly- embedded = await self.wait_for_embedding(- agent_id=sarah_agent.id,- message_id=message_id,- organization_id=default_user.organization_id,- actor=default_user,- max_wait=10.0,- poll_interval=0.5,- )- assert embedded, "Message was not embedded in Turbopuffer within timeout"+ # Update message in background mode+ updated_message = await server.message_manager.update_message_by_id_async(+ message_id=message_id,+ message_update=MessageUpdate(content="Updated content about machine learning"),+ actor=default_user,+ strict_mode=False, # Background mode+ )- # Now verify it's also searchable through the search API- search_results = await server.message_manager.search_messages_async(- agent_id=sarah_agent.id,- actor=default_user,- query_text="Python programming",- search_mode="fts",- limit=10,- )- assert len(search_results) > 0- assert any(msg.id == message_id for msg, _ in search_results)+ assert updated_message.id == message_id- # Clean up- await server.message_manager.delete_messages_by_ids_async([message_id], default_user, strict_mode=True)+ # PostgreSQL should be updated immediately+ sql_message = await server.message_manager.get_message_by_id_async(message_id, default_user)+ assert "machine learning" in server.message_manager._extract_message_text(sql_message)- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_message_update_background_mode(self, server, default_user, sarah_agent, enable_message_embedding):- """Test that message updates work in background mode"""- from letta.schemas.message import MessageUpdate+ # Wait a bit for the background update to process+ await asyncio.sleep(1.0)- embedding_config = sarah_agent.embedding_config or EmbeddingConfig.default_config(provider="openai")+ # Poll for the update to be reflected in Turbopuffer+ # We check by searching for the new content+ embedded = await wait_for_embedding(+ agent_id=sarah_agent.id,+ message_id=message_id,+ organization_id=default_user.organization_id,+ actor=default_user,+ max_wait=10.0,+ poll_interval=0.5,+ )+ assert embedded, "Updated message was not re-embedded within timeout"- # Create initial message with strict_mode=True to ensure it's embedded- messages = await server.message_manager.create_many_messages_async(- pydantic_msgs=[- PydanticMessage(- role=MessageRole.user,- content=[TextContent(text="Original content about databases")],- agent_id=sarah_agent.id,- )- ],- actor=default_user,- strict_mode=True, # Ensure initial embedding- )+ # Now verify the new content is searchable+ new_results = await server.message_manager.search_messages_async(+ agent_id=sarah_agent.id,+ actor=default_user,+ query_text="machine learning",+ search_mode="fts",+ limit=10,+ )+ assert any(msg.id == message_id for msg, _ in new_results)- assert len(messages) == 1- message_id = messages[0].id+ # Old content should eventually no longer be searchable+ # (may take a moment for the delete to process)+ await asyncio.sleep(2.0)+ old_results = await server.message_manager.search_messages_async(+ agent_id=sarah_agent.id,+ actor=default_user,+ query_text="databases",+ search_mode="fts",+ limit=10,+ )+ # The message shouldn't match the old search term anymore+ if len(old_results) > 0:+ # If we find results, verify our message doesn't contain the old content+ for msg, _ in old_results:+ if msg.id == message_id:+ text = server.message_manager._extract_message_text(msg)+ assert "databases" not in text.lower()- # Verify initial content is searchable- initial_results = await server.message_manager.search_messages_async(- agent_id=sarah_agent.id,- actor=default_user,- query_text="databases",- search_mode="fts",- limit=10,- )- assert any(msg.id == message_id for msg, _ in initial_results)+ # Clean up+ await server.message_manager.delete_messages_by_ids_async([message_id], default_user, strict_mode=True)- # Update message in background mode- updated_message = await server.message_manager.update_message_by_id_async(- message_id=message_id,- message_update=MessageUpdate(content="Updated content about machine learning"),- actor=default_user,- strict_mode=False, # Background mode- )- assert updated_message.id == message_id[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_date_filtering_with_real_tpuf(enable_message_embedding, default_user):+ """Test filtering messages by date range"""+ import uuid+ from datetime import datetime, timedelta, timezone- # PostgreSQL should be updated immediately- sql_message = await server.message_manager.get_message_by_id_async(message_id, default_user)- assert "machine learning" in server.message_manager._extract_message_text(sql_message)+ from letta.helpers.tpuf_client import TurbopufferClient+ from letta.schemas.enums import MessageRole- # Wait a bit for the background update to process- await asyncio.sleep(1.0)+ client = TurbopufferClient()+ agent_id = f"test-agent-{uuid.uuid4()}"+ org_id = str(uuid.uuid4())- # Poll for the update to be reflected in Turbopuffer- # We check by searching for the new content- embedded = await self.wait_for_embedding(- agent_id=sarah_agent.id,- message_id=message_id,- organization_id=default_user.organization_id,- actor=default_user,- max_wait=10.0,- poll_interval=0.5,+ try:+ # Create messages with different timestamps+ now = datetime.now(timezone.utc)+ yesterday = now - timedelta(days=1)+ last_week = now - timedelta(days=7)+ last_month = now - timedelta(days=30)++ message_data = [+ ("Today's message", now),+ ("Yesterday's message", yesterday),+ ("Last week's message", last_week),+ ("Last month's message", last_month),+ ]++ for text, timestamp in message_data:+ await client.insert_messages(+ agent_id=agent_id,+ message_texts=[text],+ message_ids=[str(uuid.uuid4())],+ organization_id=org_id,+ actor=default_user,+ roles=[MessageRole.assistant],+ created_ats=[timestamp],+ )++ # Query messages from the last 3 days+ three_days_ago = now - timedelta(days=3)+ recent_results = await client.query_messages_by_agent_id(+ agent_id=agent_id, organization_id=org_id, search_mode="timestamp", top_k=10, start_date=three_days_ago, actor=default_user)- assert embedded, "Updated message was not re-embedded within timeout"- # Now verify the new content is searchable- new_results = await server.message_manager.search_messages_async(- agent_id=sarah_agent.id,+ # Should get today's and yesterday's messages+ assert len(recent_results) == 2+ result_texts = [msg["text"] for msg, _, _ in recent_results]+ assert "Today's message" in result_texts+ assert "Yesterday's message" in result_texts++ # Query messages between 2 weeks ago and 1 week ago+ two_weeks_ago = now - timedelta(days=14)+ week_results = await client.query_messages_by_agent_id(+ agent_id=agent_id,+ organization_id=org_id,+ search_mode="timestamp",+ top_k=10,+ start_date=two_weeks_ago,+ end_date=last_week + timedelta(days=1), # Include last week's messageactor=default_user,- query_text="machine learning",- search_mode="fts",- limit=10,)- assert any(msg.id == message_id for msg, _ in new_results)- # Old content should eventually no longer be searchable- # (may take a moment for the delete to process)- await asyncio.sleep(2.0)- old_results = await server.message_manager.search_messages_async(- agent_id=sarah_agent.id,+ # Should get only last week's message+ assert len(week_results) == 1+ assert week_results[0][0]["text"] == "Last week's message"++ # Query with vector search and date filtering+ filtered_vector_results = await client.query_messages_by_agent_id(+ agent_id=agent_id,+ organization_id=org_id,actor=default_user,- query_text="databases",- search_mode="fts",- limit=10,+ query_text="message",+ search_mode="vector",+ top_k=10,+ start_date=three_days_ago,)- # The message shouldn't match the old search term anymore- if len(old_results) > 0:- # If we find results, verify our message doesn't contain the old content- for msg, _ in old_results:- if msg.id == message_id:- text = server.message_manager._extract_message_text(msg)- assert "databases" not in text.lower()- # Clean up- await server.message_manager.delete_messages_by_ids_async([message_id], default_user, strict_mode=True)+ # Should get only recent messages+ assert len(filtered_vector_results) == 2+ for msg, _, _ in filtered_vector_results:+ assert msg["text"] in ["Today's message", "Yesterday's message"]- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_message_date_filtering_with_real_tpuf(self, enable_message_embedding, default_user):- """Test filtering messages by date range"""- import uuid- from datetime import datetime, timedelta, timezone+ finally:+ # Clean up namespace+ try:+ await client.delete_all_messages(agent_id)+ except:+ pass- from letta.helpers.tpuf_client import TurbopufferClient- from letta.schemas.enums import MessageRole- client = TurbopufferClient()- agent_id = f"test-agent-{uuid.uuid4()}"- org_id = str(uuid.uuid4())+async def test_archive_namespace_tracking(server, default_user, enable_turbopuffer):+ """Test that archive namespaces are properly tracked in database"""+ # Create an archive+ archive = await server.archive_manager.create_archive_async(name="Test Archive for Namespace", actor=default_user)- try:- # Create messages with different timestamps- now = datetime.now(timezone.utc)- yesterday = now - timedelta(days=1)- last_week = now - timedelta(days=7)- last_month = now - timedelta(days=30)-- message_data = [- ("Today's message", now),- ("Yesterday's message", yesterday),- ("Last week's message", last_week),- ("Last month's message", last_month),- ]-- for text, timestamp in message_data:- await client.insert_messages(- agent_id=agent_id,- message_texts=[text],- message_ids=[str(uuid.uuid4())],- organization_id=org_id,- actor=default_user,- roles=[MessageRole.assistant],- created_ats=[timestamp],- )+ # Get namespace - should be generated and stored+ namespace = await server.archive_manager.get_or_set_vector_db_namespace_async(archive.id)- # Query messages from the last 3 days- three_days_ago = now - timedelta(days=3)- recent_results = await client.query_messages_by_agent_id(- agent_id=agent_id, organization_id=org_id, search_mode="timestamp", top_k=10, start_date=three_days_ago, actor=default_user- )+ # Should have archive_ prefix and environment suffix+ expected_prefix = "archive_"+ assert namespace.startswith(expected_prefix)+ assert archive.id in namespace+ if settings.environment:+ assert settings.environment.lower() in namespace- # Should get today's and yesterday's messages- assert len(recent_results) == 2- result_texts = [msg["text"] for msg, _, _ in recent_results]- assert "Today's message" in result_texts- assert "Yesterday's message" in result_texts+ # Call again - should return same namespace from database+ namespace2 = await server.archive_manager.get_or_set_vector_db_namespace_async(archive.id)+ assert namespace == namespace2- # Query messages between 2 weeks ago and 1 week ago- two_weeks_ago = now - timedelta(days=14)- week_results = await client.query_messages_by_agent_id(- agent_id=agent_id,- organization_id=org_id,- search_mode="timestamp",- top_k=10,- start_date=two_weeks_ago,- end_date=last_week + timedelta(days=1), # Include last week's message- actor=default_user,- )- # Should get only last week's message- assert len(week_results) == 1- assert week_results[0][0]["text"] == "Last week's message"+async def test_namespace_consistency_with_tpuf_client(server, default_user, enable_turbopuffer):+ """Test that the namespace from managers matches what tpuf_client would generate"""+ # Create archive and agent+ archive = await server.archive_manager.create_archive_async(name="Test Consistency Archive", actor=default_user)- # Query with vector search and date filtering- filtered_vector_results = await client.query_messages_by_agent_id(- agent_id=agent_id,- organization_id=org_id,- actor=default_user,- query_text="message",- search_mode="vector",- top_k=10,- start_date=three_days_ago,- )+ # Get namespace from manager+ archive_namespace = await server.archive_manager.get_or_set_vector_db_namespace_async(archive.id)- # Should get only recent messages- assert len(filtered_vector_results) == 2- for msg, _, _ in filtered_vector_results:- assert msg["text"] in ["Today's message", "Yesterday's message"]-- finally:- # Clean up namespace- try:- await client.delete_all_messages(agent_id)- except:- pass---class TestNamespaceTracking:- """Test the new namespace tracking functionality"""-- @pytest.mark.asyncio- async def test_archive_namespace_tracking(self, server, default_user, enable_turbopuffer):- """Test that archive namespaces are properly tracked in database"""- # Create an archive- archive = await server.archive_manager.create_archive_async(name="Test Archive for Namespace", actor=default_user)-- # Get namespace - should be generated and stored- namespace = await server.archive_manager.get_or_set_vector_db_namespace_async(archive.id)-- # Should have archive_ prefix and environment suffix- expected_prefix = "archive_"- assert namespace.startswith(expected_prefix)- assert archive.id in namespace- if settings.environment:- assert settings.environment.lower() in namespace-- # Call again - should return same namespace from database- namespace2 = await server.archive_manager.get_or_set_vector_db_namespace_async(archive.id)- assert namespace == namespace2-- @pytest.mark.asyncio- async def test_namespace_consistency_with_tpuf_client(self, server, default_user, enable_turbopuffer):- """Test that the namespace from managers matches what tpuf_client would generate"""- # Create archive and agent- archive = await server.archive_manager.create_archive_async(name="Test Consistency Archive", actor=default_user)-- # Get namespace from manager- archive_namespace = await server.archive_manager.get_or_set_vector_db_namespace_async(archive.id)-- # Create TurbopufferClient and get what it would generate- client = TurbopufferClient()- tpuf_namespace = await client._get_archive_namespace_name(archive.id)-- # Should match- assert archive_namespace == tpuf_namespace-- @pytest.mark.asyncio- async def test_environment_namespace_variation(self, server, default_user):- """Test namespace generation with different environment settings"""- # Test with no environment- original_env = settings.environment- try:- settings.environment = None+ # Create TurbopufferClient and get what it would generate+ client = TurbopufferClient()+ tpuf_namespace = await client._get_archive_namespace_name(archive.id)- archive = await server.archive_manager.create_archive_async(name="No Env Archive", actor=default_user)- namespace_no_env = await server.archive_manager.get_or_set_vector_db_namespace_async(archive.id)- assert namespace_no_env == f"archive_{archive.id}"+ # Should match+ assert archive_namespace == tpuf_namespace- # Test with environment- settings.environment = "TESTING"- archive2 = await server.archive_manager.create_archive_async(name="With Env Archive", actor=default_user)- namespace_with_env = await server.archive_manager.get_or_set_vector_db_namespace_async(archive2.id)- assert namespace_with_env == f"archive_{archive2.id}_testing"+async def test_environment_namespace_variation(server, default_user):+ """Test namespace generation with different environment settings"""+ # Test with no environment+ original_env = settings.environment+ try:+ settings.environment = None- finally:- settings.environment = original_env+ archive = await server.archive_manager.create_archive_async(name="No Env Archive", actor=default_user)+ namespace_no_env = await server.archive_manager.get_or_set_vector_db_namespace_async(archive.id)+ assert namespace_no_env == f"archive_{archive.id}"- @pytest.mark.asyncio- @pytest.mark.skipif(not settings.tpuf_api_key, reason="Turbopuffer API key not configured")- async def test_message_project_id_filtering(self, server, sarah_agent, default_user, enable_turbopuffer, enable_message_embedding):- """Test that project_id filtering works correctly in query_messages_by_agent_id"""- from letta.schemas.letta_message_content import TextContent+ # Test with environment+ settings.environment = "TESTING"- # Create two project IDs- project_a_id = str(uuid.uuid4())- project_b_id = str(uuid.uuid4())+ archive2 = await server.archive_manager.create_archive_async(name="With Env Archive", actor=default_user)+ namespace_with_env = await server.archive_manager.get_or_set_vector_db_namespace_async(archive2.id)+ assert namespace_with_env == f"archive_{archive2.id}_testing"- # Create messages with different project IDs- message_a = PydanticMessage(- agent_id=sarah_agent.id,- role=MessageRole.user,- content=[TextContent(text="Message for project A about Python")],- )+ finally:+ settings.environment = original_env- message_b = PydanticMessage(- agent_id=sarah_agent.id,- role=MessageRole.user,- content=[TextContent(text="Message for project B about JavaScript")],- )- # Insert messages with their respective project IDs- tpuf_client = TurbopufferClient()[email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_project_id_filtering(server, sarah_agent, default_user, enable_turbopuffer, enable_message_embedding):+ """Test that project_id filtering works correctly in query_messages_by_agent_id"""+ from letta.schemas.letta_message_content import TextContent++ # Create two project IDs+ project_a_id = str(uuid.uuid4())+ project_b_id = str(uuid.uuid4())- # Embeddings will be generated automatically by the client+ # Create messages with different project IDs+ message_a = PydanticMessage(+ agent_id=sarah_agent.id,+ role=MessageRole.user,+ content=[TextContent(text="Message for project A about Python")],+ )++ message_b = PydanticMessage(+ agent_id=sarah_agent.id,+ role=MessageRole.user,+ content=[TextContent(text="Message for project B about JavaScript")],+ )++ # Insert messages with their respective project IDs+ tpuf_client = TurbopufferClient()++ # Embeddings will be generated automatically by the client++ # Insert message A with project_a_id+ await tpuf_client.insert_messages(+ agent_id=sarah_agent.id,+ message_texts=[message_a.content[0].text],+ message_ids=[message_a.id],+ organization_id=default_user.organization_id,+ actor=default_user,+ roles=[message_a.role],+ created_ats=[message_a.created_at],+ project_id=project_a_id,+ )++ # Insert message B with project_b_id+ await tpuf_client.insert_messages(+ agent_id=sarah_agent.id,+ message_texts=[message_b.content[0].text],+ message_ids=[message_b.id],+ organization_id=default_user.organization_id,+ actor=default_user,+ roles=[message_b.role],+ created_ats=[message_b.created_at],+ project_id=project_b_id,+ )- # Insert message A with project_a_id- await tpuf_client.insert_messages(+ # Poll for message A with project_a_id filter+ max_retries = 10+ for i in range(max_retries):+ results_a = await tpuf_client.query_messages_by_agent_id(agent_id=sarah_agent.id,- message_texts=[message_a.content[0].text],- message_ids=[message_a.id],organization_id=default_user.organization_id,- actor=default_user,- roles=[message_a.role],- created_ats=[message_a.created_at],+ search_mode="timestamp", # Simple timestamp retrieval+ top_k=10,project_id=project_a_id,+ actor=default_user,)+ if len(results_a) == 1 and results_a[0][0]["id"] == message_a.id:+ break+ await asyncio.sleep(0.5)+ else:+ pytest.fail(f"Message A not found after {max_retries} retries")++ assert "Python" in results_a[0][0]["text"]- # Insert message B with project_b_id- await tpuf_client.insert_messages(+ # Poll for message B with project_b_id filter+ for i in range(max_retries):+ results_b = await tpuf_client.query_messages_by_agent_id(agent_id=sarah_agent.id,- message_texts=[message_b.content[0].text],- message_ids=[message_b.id],organization_id=default_user.organization_id,- actor=default_user,- roles=[message_b.role],- created_ats=[message_b.created_at],+ search_mode="timestamp",+ top_k=10,project_id=project_b_id,+ actor=default_user,)+ if len(results_b) == 1 and results_b[0][0]["id"] == message_b.id:+ break+ await asyncio.sleep(0.5)+ else:+ pytest.fail(f"Message B not found after {max_retries} retries")++ assert "JavaScript" in results_b[0][0]["text"]++ # Query without project filter - should find both+ results_all = await tpuf_client.query_messages_by_agent_id(+ agent_id=sarah_agent.id,+ organization_id=default_user.organization_id,+ search_mode="timestamp",+ top_k=10,+ project_id=None, # No filter+ actor=default_user,+ )- # Poll for message A with project_a_id filter- max_retries = 10- for i in range(max_retries):- results_a = await tpuf_client.query_messages_by_agent_id(- agent_id=sarah_agent.id,- organization_id=default_user.organization_id,- search_mode="timestamp", # Simple timestamp retrieval- top_k=10,- project_id=project_a_id,- actor=default_user,- )- if len(results_a) == 1 and results_a[0][0]["id"] == message_a.id:- break- await asyncio.sleep(0.5)- else:- pytest.fail(f"Message A not found after {max_retries} retries")+ assert len(results_all) >= 2 # May have other messages from setup+ message_ids = [r[0]["id"] for r in results_all]+ assert message_a.id in message_ids+ assert message_b.id in message_ids- assert "Python" in results_a[0][0]["text"]+ # Clean up+ await tpuf_client.delete_messages(+ agent_id=sarah_agent.id, organization_id=default_user.organization_id, message_ids=[message_a.id, message_b.id]+ )- # Poll for message B with project_b_id filter- for i in range(max_retries):- results_b = await tpuf_client.query_messages_by_agent_id(- agent_id=sarah_agent.id,- organization_id=default_user.organization_id,- search_mode="timestamp",- top_k=10,- project_id=project_b_id,- actor=default_user,- )- if len(results_b) == 1 and results_b[0][0]["id"] == message_b.id:- break- await asyncio.sleep(0.5)- else:- pytest.fail(f"Message B not found after {max_retries} retries")- assert "JavaScript" in results_b[0][0]["text"][email protected](not settings.tpuf_api_key, reason="Turbopuffer API key not configured")+async def test_message_template_id_filtering(server, sarah_agent, default_user, enable_turbopuffer, enable_message_embedding):+ """Test that template_id filtering works correctly in message queries"""+ from letta.schemas.letta_message_content import TextContent- # Query without project filter - should find both- results_all = await tpuf_client.query_messages_by_agent_id(- agent_id=sarah_agent.id,- organization_id=default_user.organization_id,- search_mode="timestamp",- top_k=10,- project_id=None, # No filter- actor=default_user,- )+ # Create two template IDs+ template_a_id = str(uuid.uuid4())+ template_b_id = str(uuid.uuid4())- assert len(results_all) >= 2 # May have other messages from setup- message_ids = [r[0]["id"] for r in results_all]- assert message_a.id in message_ids- assert message_b.id in message_ids+ # Create messages with different template IDs+ message_a = PydanticMessage(+ agent_id=sarah_agent.id,+ role=MessageRole.user,+ content=[TextContent(text="Message for template A")],+ )- # Clean up- await tpuf_client.delete_messages(- agent_id=sarah_agent.id, organization_id=default_user.organization_id, message_ids=[message_a.id, message_b.id]- )+ message_b = PydanticMessage(+ agent_id=sarah_agent.id,+ role=MessageRole.user,+ content=[TextContent(text="Message for template B")],+ )++ # Insert messages with their respective template IDs+ tpuf_client = TurbopufferClient()++ await tpuf_client.insert_messages(+ agent_id=sarah_agent.id,+ message_texts=[message_a.content[0].text],+ message_ids=[message_a.id],+ organization_id=default_user.organization_id,+ actor=default_user,+ roles=[message_a.role],+ created_ats=[message_a.created_at],+ template_id=template_a_id,+ )++ await tpuf_client.insert_messages(+ agent_id=sarah_agent.id,+ message_texts=[message_b.content[0].text],+ message_ids=[message_b.id],+ organization_id=default_user.organization_id,+ actor=default_user,+ roles=[message_b.role],+ created_ats=[message_b.created_at],+ template_id=template_b_id,+ )++ # Wait for indexing+ await asyncio.sleep(1)++ # Query for template A - should find only message A+ results_a = await tpuf_client.query_messages_by_agent_id(+ agent_id=sarah_agent.id,+ organization_id=default_user.organization_id,+ search_mode="timestamp",+ top_k=10,+ template_id=template_a_id,+ actor=default_user,+ )++ assert len(results_a) == 1+ assert results_a[0][0]["id"] == message_a.id+ assert "template A" in results_a[0][0]["text"]++ # Query for template B - should find only message B+ results_b = await tpuf_client.query_messages_by_agent_id(+ agent_id=sarah_agent.id,+ organization_id=default_user.organization_id,+ search_mode="timestamp",+ top_k=10,+ template_id=template_b_id,+ actor=default_user,+ )++ assert len(results_b) == 1+ assert results_b[0][0]["id"] == message_b.id+ assert "template B" in results_b[0][0]["text"]++ # Clean up+ await tpuf_client.delete_messages(+ agent_id=sarah_agent.id, organization_id=default_user.organization_id, message_ids=[message_a.id, message_b.id]+ )