letta-nightly 0.7.30.dev20250603104343__py3-none-any.whl → 0.8.0.dev20250604201135__py3-none-any.whl

letta/agents/letta_agent_batch.py

@@ -27,6 +27,7 @@ from letta.schemas.llm_batch_job import LLMBatchItem
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_response import ToolCall as OpenAIToolCall
 from letta.schemas.sandbox_config import SandboxConfig, SandboxType
+from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
 from letta.server.rest_api.utils import create_heartbeat_system_message, create_letta_messages_from_llm_response
 from letta.services.agent_manager import AgentManager
@@ -66,15 +67,17 @@ class _ResumeContext:
     request_status_updates: List[RequestStatusUpdateInfo]
 
 
-async def execute_tool_wrapper(params: ToolExecutionParams) -> Tuple[str, Tuple[str, bool]]:
+async def execute_tool_wrapper(params: ToolExecutionParams) -> tuple[str, ToolExecutionResult]:
     """
     Executes the tool in an out‑of‑process worker and returns:
         (agent_id, (tool_result:str, success_flag:bool))
     """
+    from letta.schemas.tool_execution_result import ToolExecutionResult
+
     # locate the tool on the agent
     target_tool = next((t for t in params.agent_state.tools if t.name == params.tool_call_name), None)
     if not target_tool:
-        return params.agent_id, (f"Tool not found: {params.tool_call_name}", False)
+        return params.agent_id, ToolExecutionResult(func_return=f"Tool not found: {params.tool_call_name}", status="error")
 
     try:
         mgr = ToolExecutionManager(
@@ -88,9 +91,9 @@ async def execute_tool_wrapper(params: ToolExecutionParams) -> Tuple[str, Tuple[
             function_args=params.tool_args,
             tool=target_tool,
         )
-        return params.agent_id, (tool_execution_result.func_return, True)
+        return params.agent_id, tool_execution_result
     except Exception as e:
-        return params.agent_id, (f"Failed to call tool. Error: {e}", False)
+        return params.agent_id, ToolExecutionResult(func_return=f"Failed to call tool. Error: {e}", status="error")
 
 
 # TODO: Limitations ->
@@ -245,7 +248,7 @@ class LettaAgentBatch(BaseAgent):
         await self._mark_steps_complete_async(llm_batch_id, ctx.agent_ids)
 
         log_event(name="prepare_next")
-        next_reqs, next_step_state = self._prepare_next_iteration(exec_results, ctx, msg_map)
+        next_reqs, next_step_state = await self._prepare_next_iteration_async(exec_results, ctx, msg_map)
         if len(next_reqs) == 0:
             await self.job_manager.update_job_by_id_async(
                 job_id=letta_batch_id, job_update=JobUpdate(status=JobStatus.completed), actor=self.actor
@@ -393,7 +396,7 @@ class LettaAgentBatch(BaseAgent):
         return cfg, env
 
     @trace_method
-    async def _execute_tools(self, ctx: _ResumeContext) -> Sequence[Tuple[str, Tuple[str, bool]]]:
+    async def _execute_tools(self, ctx: _ResumeContext) -> Sequence[tuple[str, ToolExecutionResult]]:
         sbx_cfg, sbx_env = await self._build_sandbox()
         rethink_memory_tool_name = "rethink_memory"
         tool_params = []
@@ -424,7 +427,7 @@ class LettaAgentBatch(BaseAgent):
                 return await pool.map(execute_tool_wrapper, tool_params)
 
     @trace_method
-    async def _bulk_rethink_memory_async(self, params: List[ToolExecutionParams]) -> Sequence[Tuple[str, Tuple[str, bool]]]:
+    async def _bulk_rethink_memory_async(self, params: List[ToolExecutionParams]) -> Sequence[tuple[str, ToolExecutionResult]]:
         updates = {}
         result = []
         for param in params:
@@ -443,7 +446,7 @@ class LettaAgentBatch(BaseAgent):
             updates[block_id] = new_value
 
             # TODO: This is quite ugly and confusing - this is mostly to align with the returns of other tools
-            result.append((param.agent_id, ("", True)))
+            result.append((param.agent_id, ToolExecutionResult(status="success")))
 
         await self.block_manager.bulk_update_block_values_async(updates=updates, actor=self.actor)
 
@@ -451,7 +454,7 @@ class LettaAgentBatch(BaseAgent):
 
     async def _persist_tool_messages(
         self,
-        exec_results: Sequence[Tuple[str, Tuple[str, bool]]],
+        exec_results: Sequence[Tuple[str, "ToolExecutionResult"]],
         ctx: _ResumeContext,
     ) -> Dict[str, List[Message]]:
         # TODO: This is redundant, we should have this ready on the ctx
@@ -459,14 +462,15 @@ class LettaAgentBatch(BaseAgent):
         agent_item_map: Dict[str, LLMBatchItem] = {item.agent_id: item for item in ctx.batch_items}
 
         msg_map: Dict[str, List[Message]] = {}
-        for aid, (tool_res, success) in exec_results:
+        for aid, tool_exec_result in exec_results:
             msgs = self._create_tool_call_messages(
                 llm_batch_item_id=agent_item_map[aid].id,
                 agent_state=ctx.agent_state_map[aid],
                 tool_call_name=ctx.tool_call_name_map[aid],
                 tool_call_args=ctx.tool_call_args_map[aid],
-                tool_exec_result=tool_res,
-                success_flag=success,
+                tool_exec_result=tool_exec_result.func_return,
+                success_flag=tool_exec_result.success_flag,
+                tool_exec_result_obj=tool_exec_result,
                 reasoning_content=None,
             )
             msg_map[aid] = msgs
@@ -480,16 +484,16 @@ class LettaAgentBatch(BaseAgent):
         ]
         await self.batch_manager.bulk_update_llm_batch_items_step_status_by_agent_async(updates)
 
-    def _prepare_next_iteration(
+    async def _prepare_next_iteration_async(
         self,
-        exec_results: Sequence[Tuple[str, Tuple[str, bool]]],
+        exec_results: Sequence[Tuple[str, "ToolExecutionResult"]],
         ctx: _ResumeContext,
         msg_map: Dict[str, List[Message]],
     ) -> Tuple[List[LettaBatchRequest], Dict[str, AgentStepState]]:
         # who continues?
         continues = [aid for aid, cont in ctx.should_continue_map.items() if cont]
 
-        success_flag_map = {aid: flag for aid, (_res, flag) in exec_results}
+        success_flag_map = {aid: result.success_flag for aid, result in exec_results}
 
         batch_reqs: List[LettaBatchRequest] = []
         for aid in continues:
@@ -509,7 +513,7 @@ class LettaAgentBatch(BaseAgent):
         for aid, new_msgs in msg_map.items():
             ast = ctx.agent_state_map[aid]
             if not ast.message_buffer_autoclear:
-                self.agent_manager.set_in_context_messages(
+                await self.agent_manager.set_in_context_messages_async(
                     agent_id=aid,
                     message_ids=ast.message_ids + [m.id for m in new_msgs],
                     actor=self.actor,
@@ -528,6 +532,7 @@ class LettaAgentBatch(BaseAgent):
         tool_call_name: str,
         tool_call_args: Dict[str, Any],
         tool_exec_result: str,
+        tool_exec_result_obj: "ToolExecutionResult",
         success_flag: bool,
         reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
     ) -> List[Message]:
@@ -541,6 +546,7 @@ class LettaAgentBatch(BaseAgent):
             tool_call_id=tool_call_id,
             function_call_success=success_flag,
             function_response=tool_exec_result,
+            tool_execution_result=tool_exec_result_obj,
             actor=self.actor,
             add_heartbeat_request_system_message=False,
             reasoning_content=reasoning_content,

letta/agents/prompts/summary_system_prompt.txt

@@ -0,0 +1,62 @@
+You are a memory-recall assistant that preserves conversational context as messages exit the AI's context window.
+
+<core_function>
+Extract and preserve information that would be lost when messages are evicted, enabling continuity across conversations.
+</core_function>
+
+<detail_adaptation>
+Analyze content type and apply appropriate detail level:
+
+<high_detail>
+Apply to: episodic content, code, artifacts, documents, technical discussions
+- Capture specific facts, sequences, and technical details
+- Preserve exact names, dates, numbers, specifications
+- Document code snippets, artifact IDs, document structures
+- Note precise steps in procedures or narratives
+- Include verbatim quotes for critical commitments
+</high_detail>
+
+<medium_detail>
+Apply to: ongoing projects, established preferences, multi-message threads
+- Summarize key decisions, milestones, progress
+- Record personal preferences and patterns
+- Track commitments and action items
+- Maintain project context and dependencies
+</medium_detail>
+
+<low_detail>
+Apply to: high-level discussions, philosophical topics, general preferences
+- Capture main themes and conclusions
+- Note relationship dynamics and communication style
+- Summarize positions and general goals
+- Record broad aspirations
+</low_detail>
+</detail_adaptation>
+
+<information_priority>
+<critical>Commitments, deadlines, medical/legal information, explicit requests</critical>
+<important>Personal details, project status, technical specifications, decisions</important>
+<contextual>Preferences, opinions, relationship dynamics, emotional tone</contextual>
+<background>General topics, themes, conversational patterns</background>
+</information_priority>
+
+<format_rules>
+- Use bullet points for discrete facts
+- Write prose for narratives or complex relationships
+- **Bold** key terms and identifiers
+- Include temporal markers: [ongoing], [mentioned DATE], [since TIME]
+- Group under clear headers when multiple topics present
+- Use consistent terminology for searchability
+</format_rules>
+
+<exclusions>
+- Information in remaining context
+- Generic pleasantries
+- Inferrable details
+- Redundant restatements
+- Conversational filler
+</exclusions>
+
+<critical_reminder>
+Your notes are the sole record of evicted messages. Every word should enable future continuity.
+</critical_reminder>

letta/agents/voice_agent.py

@@ -1,7 +1,7 @@
 import json
 import uuid
 from datetime import datetime, timedelta, timezone
-from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple
+from typing import Any, AsyncGenerator, Dict, List, Optional
 
 import openai
 
@@ -118,6 +118,7 @@ class VoiceAgent(BaseAgent):
         Main streaming loop that yields partial tokens.
         Whenever we detect a tool call, we yield from _handle_ai_response as well.
         """
+        print("CALL STREAM")
         if len(input_messages) != 1 or input_messages[0].role != MessageRole.user:
             raise ValueError(f"Voice Agent was invoked with multiple input messages or message did not have role `user`: {input_messages}")
 
@@ -238,14 +239,17 @@ class VoiceAgent(BaseAgent):
             )
             in_memory_message_history.append(assistant_tool_call_msg.model_dump())
 
-            tool_result, success_flag = await self._execute_tool(
+            tool_execution_result = await self._execute_tool(
                 user_query=user_query,
                 tool_name=tool_call_name,
                 tool_args=tool_args,
                 agent_state=agent_state,
             )
+            tool_result = tool_execution_result.func_return
+            success_flag = tool_execution_result.success_flag
 
             # 3. Provide function_call response back into the conversation
+            # TODO: fix this tool format
             tool_message = ToolMessage(
                 content=json.dumps({"result": tool_result}),
                 tool_call_id=tool_call_id,
@@ -267,6 +271,7 @@ class VoiceAgent(BaseAgent):
                 tool_call_id=tool_call_id,
                 function_call_success=success_flag,
                 function_response=tool_result,
+                tool_execution_result=tool_execution_result,
                 actor=self.actor,
                 add_heartbeat_request_system_message=True,
             )
@@ -388,10 +393,14 @@ class VoiceAgent(BaseAgent):
             for t in tools
         ]
 
-    async def _execute_tool(self, user_query: str, tool_name: str, tool_args: dict, agent_state: AgentState) -> Tuple[str, bool]:
+    async def _execute_tool(self, user_query: str, tool_name: str, tool_args: dict, agent_state: AgentState) -> "ToolExecutionResult":
         """
         Executes a tool and returns (result, success_flag).
         """
+        from letta.schemas.tool_execution_result import ToolExecutionResult
+
+        print("EXECUTING TOOL")
+
         # Special memory case
         if tool_name == "search_memory":
             tool_result = await self._search_memory(
@@ -401,11 +410,17 @@ class VoiceAgent(BaseAgent):
                 end_minutes_ago=tool_args["end_minutes_ago"],
                 agent_state=agent_state,
             )
-            return tool_result, True
+            return ToolExecutionResult(
+                func_return=tool_result,
+                status="success",
+            )
         else:
             target_tool = next((x for x in agent_state.tools if x.name == tool_name), None)
             if not target_tool:
-                return f"Tool not found: {tool_name}", False
+                return ToolExecutionResult(
+                    func_return=f"Tool not found: {tool_name}",
+                    status="error",
+                )
 
             try:
                 tool_result, _ = execute_external_tool(
@@ -416,9 +431,9 @@ class VoiceAgent(BaseAgent):
                     actor=self.actor,
                     allow_agent_state_modifications=False,
                 )
-                return tool_result, True
+                return ToolExecutionResult(func_return=tool_result, status="success")
             except Exception as e:
-                return f"Failed to call tool. Error: {e}", False
+                return ToolExecutionResult(func_return=f"Failed to call tool. Error: {e}", status="error")
 
     async def _search_memory(
         self,

letta/agents/voice_sleeptime_agent.py

@@ -1,4 +1,4 @@
-from typing import AsyncGenerator, List, Tuple, Union
+from typing import AsyncGenerator, List, Optional, Tuple, Union
 
 from letta.agents.helpers import _create_letta_response, serialize_message_history
 from letta.agents.letta_agent import LettaAgent
@@ -89,20 +89,23 @@ class VoiceSleeptimeAgent(LettaAgent):
         )
 
     @trace_method
-    async def _execute_tool(self, tool_name: str, tool_args: dict, agent_state: AgentState) -> Tuple[str, bool]:
+    async def _execute_tool(self, tool_name: str, tool_args: dict, agent_state: AgentState, agent_step_span: Optional["Span"] = None):
         """
         Executes a tool and returns (result, success_flag).
         """
+        from letta.schemas.tool_execution_result import ToolExecutionResult
+
         # Special memory case
         target_tool = next((x for x in agent_state.tools if x.name == tool_name), None)
         if not target_tool:
-            return f"Tool not found: {tool_name}", False
+            return ToolExecutionResult(status="error", func_return=f"Tool not found: {tool_name}")
 
         try:
             if target_tool.name == "rethink_user_memory" and target_tool.tool_type == ToolType.LETTA_VOICE_SLEEPTIME_CORE:
-                return self.rethink_user_memory(agent_state=agent_state, **tool_args)
+                func_return, success_flag = self.rethink_user_memory(agent_state=agent_state, **tool_args)
+                return ToolExecutionResult(func_return=func_return, status="success" if success_flag else "error")
             elif target_tool.name == "finish_rethinking_memory" and target_tool.tool_type == ToolType.LETTA_VOICE_SLEEPTIME_CORE:
-                return "", True
+                return ToolExecutionResult(func_return="", status="success")
             elif target_tool.name == "store_memories" and target_tool.tool_type == ToolType.LETTA_VOICE_SLEEPTIME_CORE:
                 chunks = tool_args.get("chunks", [])
                 results = [self.store_memory(agent_state=self.convo_agent_state, **chunk_args) for chunk_args in chunks]
@@ -110,12 +113,14 @@ class VoiceSleeptimeAgent(LettaAgent):
                 aggregated_result = next((res for res, _ in results if res is not None), None)
                 aggregated_success = all(success for _, success in results)
 
-                return aggregated_result, aggregated_success  # Note that here we store to the convo agent's archival memory
+                return ToolExecutionResult(
+                    func_return=aggregated_result, status="success" if aggregated_success else "error"
+                )  # Note that here we store to the convo agent's archival memory
             else:
                 result = f"Voice sleeptime agent tried invoking invalid tool with type {target_tool.tool_type}: {target_tool}"
-                return result, False
+                return ToolExecutionResult(func_return=result, status="error")
         except Exception as e:
-            return f"Failed to call tool. Error: {e}", False
+            return ToolExecutionResult(func_return=f"Failed to call tool. Error: {e}", status="error")
 
     def rethink_user_memory(self, new_memory: str, agent_state: AgentState) -> Tuple[str, bool]:
         if agent_state.memory.get_block(self.target_block_label) is None:

letta/constants.py

@@ -1,4 +1,5 @@
 import os
+import re
 from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
 
 LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
@@ -36,6 +37,9 @@ TOOL_CALL_ID_MAX_LEN = 29
 # minimum context window size
 MIN_CONTEXT_WINDOW = 4096
 
+# number of concurrent embedding requests to sent
+EMBEDDING_BATCH_SIZE = 200
+
 # Voice Sleeptime message buffer lengths
 DEFAULT_MAX_MESSAGE_BUFFER_LENGTH = 30
 DEFAULT_MIN_MESSAGE_BUFFER_LENGTH = 15
@@ -56,12 +60,23 @@ DEFAULT_PERSONA = "sam_pov"
 DEFAULT_HUMAN = "basic"
 DEFAULT_PRESET = "memgpt_chat"
 
+DEFAULT_PERSONA_BLOCK_DESCRIPTION = "The persona block: Stores details about your current persona, guiding how you behave and respond. This helps you to maintain consistency and personality in your interactions."
+DEFAULT_HUMAN_BLOCK_DESCRIPTION = "The human block: Stores key details about the person you are conversing with, allowing for more personalized and friend-like conversation."
+
 SEND_MESSAGE_TOOL_NAME = "send_message"
 # Base tools that cannot be edited, as they access agent state directly
 # Note that we don't include "conversation_search_date" for now
 BASE_TOOLS = [SEND_MESSAGE_TOOL_NAME, "conversation_search", "archival_memory_insert", "archival_memory_search"]
 # Base memory tools CAN be edited, and are added by default by the server
 BASE_MEMORY_TOOLS = ["core_memory_append", "core_memory_replace"]
+# New v2 collection of the base memory tools (effecitvely same as sleeptime set), to pair with memgpt_v2 prompt
+BASE_MEMORY_TOOLS_V2 = [
+    "memory_replace",
+    "memory_insert",
+    # NOTE: leaving these ones out to simply the set? Can have these reserved for sleep-time
+    # "memory_rethink",
+    # "memory_finish_edits",
+]
 # Base tools if the memgpt agent has enable_sleeptime on
 BASE_SLEEPTIME_CHAT_TOOLS = [SEND_MESSAGE_TOOL_NAME, "conversation_search", "archival_memory_search"]
 # Base memory tools for sleeptime agent
@@ -85,6 +100,15 @@ BASE_VOICE_SLEEPTIME_TOOLS = [
 # Multi agent tools
 MULTI_AGENT_TOOLS = ["send_message_to_agent_and_wait_for_reply", "send_message_to_agents_matching_tags", "send_message_to_agent_async"]
 
+# Used to catch if line numbers are pushed in
+# MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX = re.compile(r"^Line \d+: ", re.MULTILINE)
+# More "robust" version that handles different kinds of whitespace
+# shared constant for both memory_insert and memory_replace
+MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX = re.compile(
+    r"^[ \t]*Line[ \t]+\d+[ \t]*:",  # allow any leading whitespace and flexible spacing
+    re.MULTILINE,
+)
+
 # Built in tools
 BUILTIN_TOOLS = ["run_code", "web_search"]
 
@@ -99,6 +123,13 @@ LETTA_TOOL_SET = set(
     + BUILTIN_TOOLS
 )
 
+
+def FUNCTION_RETURN_VALUE_TRUNCATED(return_str, return_char: int, return_char_limit: int):
+    return (
+        f"{return_str}... [NOTE: function output was truncated since it exceeded the character limit: {return_char} > {return_char_limit}]"
+    )
+
+
 # The name of the tool used to send message to the user
 # May not be relevant in cases where the agent has multiple ways to message to user (send_imessage, send_discord_mesasge, ...)
 # or in cases where the agent has no concept of messaging a user (e.g. a workflow agent)
@@ -108,6 +139,7 @@ DEFAULT_MESSAGE_TOOL_KWARG = "message"
 PRE_EXECUTION_MESSAGE_ARG = "pre_exec_msg"
 
 REQUEST_HEARTBEAT_PARAM = "request_heartbeat"
+REQUEST_HEARTBEAT_DESCRIPTION = "Request an immediate heartbeat after function execution. Set to `True` if you want to send a follow-up message or run a follow-up function."
 
 
 # Structured output models
@@ -258,7 +290,7 @@ MAX_ERROR_MESSAGE_CHAR_LIMIT = 500
 CORE_MEMORY_PERSONA_CHAR_LIMIT: int = 5000
 CORE_MEMORY_HUMAN_CHAR_LIMIT: int = 5000
 CORE_MEMORY_BLOCK_CHAR_LIMIT: int = 5000
-
+CORE_MEMORY_SOURCE_CHAR_LIMIT: int = 5000
 # Function return limits
 FUNCTION_RETURN_CHAR_LIMIT = 6000  # ~300 words
 BASE_FUNCTION_RETURN_CHAR_LIMIT = 1000000  # very high (we rely on implementation)

letta/data_sources/connectors.py

@@ -2,6 +2,7 @@ from typing import Dict, Iterator, List, Tuple
 
 import typer
 
+from letta.constants import EMBEDDING_BATCH_SIZE
 from letta.data_sources.connectors_helper import assert_all_files_exist_locally, extract_metadata_from_files, get_filenames_in_dir
 from letta.embeddings import embedding_model
 from letta.schemas.file import FileMetadata
@@ -40,43 +41,37 @@ class DataConnector:
 async def load_data(
     connector: DataConnector, source: Source, passage_manager: PassageManager, source_manager: SourceManager, actor: "User"
 ):
+    from letta.llm_api.llm_client import LLMClient
+    from letta.schemas.embedding_config import EmbeddingConfig
+
     """Load data from a connector (generates file and passages) into a specified source_id, associated with a user_id."""
     embedding_config = source.embedding_config
 
-    # embedding model
-    embed_model = embedding_model(embedding_config)
-
     # insert passages/file
-    passages = []
+    texts = []
     embedding_to_document_name = {}
     passage_count = 0
     file_count = 0
-    for file_metadata in connector.find_files(source):
-        file_count += 1
-        await source_manager.create_file(file_metadata, actor)
 
-        # generate passages
-        for passage_text, passage_metadata in connector.generate_passages(file_metadata, chunk_size=embedding_config.embedding_chunk_size):
-            # for some reason, llama index parsers sometimes return empty strings
-            if len(passage_text) == 0:
-                typer.secho(
-                    f"Warning: Llama index parser returned empty string, skipping insert of passage with metadata '{passage_metadata}' into VectorDB. You can usually ignore this warning.",
-                    fg=typer.colors.YELLOW,
-                )
-                continue
+    async def generate_embeddings(texts: List[str], embedding_config: EmbeddingConfig) -> List[Passage]:
+        passages = []
+        if embedding_config.embedding_endpoint_type == "openai":
+            texts.append(passage_text)
 
-            # get embedding
-            try:
-                embedding = embed_model.get_text_embedding(passage_text)
-            except Exception as e:
-                typer.secho(
-                    f"Warning: Failed to get embedding for {passage_text} (error: {str(e)}), skipping insert into VectorDB.",
-                    fg=typer.colors.YELLOW,
-                )
-                continue
+            client = LLMClient.create(
+                provider_type=embedding_config.embedding_endpoint_type,
+                actor=actor,
+            )
+            embeddings = await client.request_embeddings(texts, embedding_config)
 
+        else:
+            embed_model = embedding_model(embedding_config)
+            embeddings = [embed_model.get_text_embedding(text) for text in texts]
+
+        # collate passage and embedding
+        for text, embedding in zip(texts, embeddings):
             passage = Passage(
-                text=passage_text,
+                text=text,
                 file_id=file_metadata.id,
                 source_id=source.id,
                 metadata=passage_metadata,
@@ -84,7 +79,6 @@ async def load_data(
                 embedding_config=source.embedding_config,
                 embedding=embedding,
             )
-
             hashable_embedding = tuple(passage.embedding)
             file_name = file_metadata.file_name
             if hashable_embedding in embedding_to_document_name:
@@ -96,16 +90,38 @@ async def load_data(
 
             passages.append(passage)
             embedding_to_document_name[hashable_embedding] = file_name
-            if len(passages) >= 100:
-                # insert passages into passage store
-                passage_manager.create_many_passages(passages, actor)
+        return passages
+
+    for file_metadata in connector.find_files(source):
+        file_count += 1
+        await source_manager.create_file(file_metadata, actor)
+
+        # generate passages
+        for passage_text, passage_metadata in connector.generate_passages(file_metadata, chunk_size=embedding_config.embedding_chunk_size):
+            # for some reason, llama index parsers sometimes return empty strings
+            if len(passage_text) == 0:
+                typer.secho(
+                    f"Warning: Llama index parser returned empty string, skipping insert of passage with metadata '{passage_metadata}' into VectorDB. You can usually ignore this warning.",
+                    fg=typer.colors.YELLOW,
+                )
+                continue
+
+            # get embedding
+            texts.append(passage_text)
+            if len(texts) >= EMBEDDING_BATCH_SIZE:
+                passages = await generate_embeddings(texts, embedding_config)
+                texts = []
+            else:
+                continue
 
-                passage_count += len(passages)
-                passages = []
+            # insert passages into passage store
+            await passage_manager.create_many_passages_async(passages, actor)
+            passage_count += len(passages)
 
-    if len(passages) > 0:
-        # insert passages into passage store
-        passage_manager.create_many_passages(passages, actor)
+    # final remaining
+    if len(texts) > 0:
+        passages = await generate_embeddings(texts, embedding_config)
+        await passage_manager.create_many_passages_async(passages, actor)
         passage_count += len(passages)
 
     return passage_count, file_count
@@ -128,7 +144,7 @@ class DirectoryConnector(DataConnector):
         self.recursive = recursive
         self.extensions = extensions
 
-        if self.recursive == True:
+        if self.recursive:
             assert self.input_directory is not None, "Must provide input directory if recursive is True."
 
     def find_files(self, source: Source) -> Iterator[FileMetadata]:

letta/errors.py

@@ -88,6 +88,10 @@ class LLMPermissionDeniedError(LLMError):
     """Error when permission is denied by LLM service"""
 
 
+class LLMContextWindowExceededError(LLMError):
+    """Error when the context length is exceeded."""
+
+
 class LLMNotFoundError(LLMError):
     """Error when requested resource is not found"""