Skip to content

armgit / letta

Public Imported from GitHub
0

Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.

chore(logs): Add resource usage logging to streaming, file uploads, mcp client, and model caches (#5925)

Kian Jones6c377cdc81f2
diff --git a/letta/server/rest_api/interface.py b/letta/server/rest_api/interface.py
index a927611ad..86ffc99ef 100644
--- a/letta/server/rest_api/interface.py
+++ b/letta/server/rest_api/interface.py
@@ -404,6 +404,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
)
self._chunks.append(item)
+ if len(self._chunks) > 100:
+ logger.warning(f"StreamingServerInterface buffer growing large: {len(self._chunks)} chunks")
self._event.set() # Signal that new data is available
def stream_start(self):
@@ -416,12 +418,15 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
self._active = True
self._chunks.clear()
self._event.clear()
+ logger.debug("StreamingServerInterface stream_start: chunks buffer cleared")
def stream_end(self):
"""Clean up the stream by deactivating and clearing chunks."""
+ chunk_count = len(self._chunks)
self.streaming_chat_completion_mode_function_name = None
self.current_function_arguments = ""
self.current_json_parse_result = {}
+ logger.debug(f"StreamingServerInterface stream_end: {chunk_count} chunks in buffer")
# if not self.streaming_chat_completion_mode and not self.nonstreaming_legacy_mode:
# self._push_to_buffer(self.multi_step_gen_indicator)
diff --git a/letta/server/rest_api/routers/v1/agents.py b/letta/server/rest_api/routers/v1/agents.py
index c9a85376b..60f86dd22 100644
--- a/letta/server/rest_api/routers/v1/agents.py
+++ b/letta/server/rest_api/routers/v1/agents.py
@@ -322,6 +322,8 @@ async def import_agent(
try:
serialized_data = file.file.read()
+ file_size_mb = len(serialized_data) / (1024 * 1024)
+ logger.info(f"Agent import: loaded {file_size_mb:.2f} MB into memory")
agent_json = json.loads(serialized_data)
except json.JSONDecodeError:
raise HTTPException(status_code=400, detail="Corrupted agent file format.")
diff --git a/letta/server/rest_api/routers/v1/folders.py b/letta/server/rest_api/routers/v1/folders.py
index 73c5bd916..2c9a95522 100644
--- a/letta/server/rest_api/routers/v1/folders.py
+++ b/letta/server/rest_api/routers/v1/folders.py
@@ -274,6 +274,11 @@ async def upload_file_to_folder(
folder = await server.source_manager.get_source_by_id(source_id=folder_id, actor=actor)
content = await file.read()
+ file_size_mb = len(content) / (1024 * 1024)
+ from letta.log import get_logger
+
+ logger = get_logger(__name__)
+ logger.info(f"File upload to folder: loaded {file_size_mb:.2f} MB into memory, filename: {file.filename}")
# Store original filename and handle duplicate logic
# Use custom name if provided, otherwise use the uploaded file's name
diff --git a/letta/server/rest_api/routers/v1/sources.py b/letta/server/rest_api/routers/v1/sources.py
index d723e3557..f1e2f4529 100644
--- a/letta/server/rest_api/routers/v1/sources.py
+++ b/letta/server/rest_api/routers/v1/sources.py
@@ -254,6 +254,11 @@ async def upload_file_to_source(
source = await server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
content = await file.read()
+ file_size_mb = len(content) / (1024 * 1024)
+ from letta.log import get_logger
+
+ logger = get_logger(__name__)
+ logger.info(f"File upload to source: loaded {file_size_mb:.2f} MB into memory, filename: {file.filename}")
# Store original filename and handle duplicate logic
# Use custom name if provided, otherwise use the uploaded file's name
diff --git a/letta/server/server.py b/letta/server/server.py
index 00fc2031f..4620c7589 100644
--- a/letta/server/server.py
+++ b/letta/server/server.py
@@ -371,6 +371,8 @@ class SyncServer(object):
logger.error(e)
self.mcp_clients.pop(server_name)
+ logger.info(f"MCP clients initialized: {len(self.mcp_clients)} active connections")
+
# Print out the tools that are connected
for server_name, client in self.mcp_clients.items():
logger.info(f"Attempting to fetch tools from MCP server: {server_name}")
@@ -383,6 +385,7 @@ class SyncServer(object):
key = make_key(**kwargs)
if key not in self._llm_config_cache:
self._llm_config_cache[key] = self.get_llm_config_from_handle(actor=actor, **kwargs)
+ logger.info(f"LLM config cache size: {len(self._llm_config_cache)} entries")
return self._llm_config_cache[key]
@trace_method
@@ -390,6 +393,7 @@ class SyncServer(object):
key = make_key(**kwargs)
if key not in self._llm_config_cache:
self._llm_config_cache[key] = await self.get_llm_config_from_handle_async(actor=actor, **kwargs)
+ logger.info(f"LLM config cache size: {len(self._llm_config_cache)} entries")
return self._llm_config_cache[key]
@trace_method
@@ -397,6 +401,7 @@ class SyncServer(object):
key = make_key(**kwargs)
if key not in self._embedding_config_cache:
self._embedding_config_cache[key] = self.get_embedding_config_from_handle(actor=actor, **kwargs)
+ logger.info(f"Embedding config cache size: {len(self._embedding_config_cache)} entries")
return self._embedding_config_cache[key]
# @async_redis_cache(key_func=lambda (actor, **kwargs): actor.id + hash(kwargs))
@@ -405,6 +410,7 @@ class SyncServer(object):
key = make_key(**kwargs)
if key not in self._embedding_config_cache:
self._embedding_config_cache[key] = await self.get_embedding_config_from_handle_async(actor=actor, **kwargs)
+ logger.info(f"Embedding config cache size: {len(self._embedding_config_cache)} entries")
return self._embedding_config_cache[key]
@trace_method
diff --git a/letta/services/tool_manager.py b/letta/services/tool_manager.py
index 264189b2e..33a2e4e46 100644
--- a/letta/services/tool_manager.py
+++ b/letta/services/tool_manager.py
@@ -141,6 +141,17 @@ class ToolManager:
tool_data["organization_id"] = actor.organization_id
tool = ToolModel(**tool_data)
+
+ # Log tool creation with memory footprint
+ import sys
+
+ tool_size_kb = sys.getsizeof(tool_data) / 1024
+ source_code_size_kb = len(pydantic_tool.source_code or "") / 1024
+ schema_size_kb = len(str(pydantic_tool.json_schema or "")) / 1024
+ logger.info(
+ f"Creating tool '{pydantic_tool.name}': total {tool_size_kb:.2f} KB (source: {source_code_size_kb:.2f} KB, schema: {schema_size_kb:.2f} KB)"
+ )
+
await tool.create_async(session, actor=actor) # Re-raise other database-related errors
return tool.to_pydantic()
@@ -193,6 +204,10 @@ class ToolManager:
if tool.description is None:
tool.description = tool.json_schema.get("description", None)
+ # Log bulk tool operation
+ total_source_code_kb = sum(len(t.source_code or "") for t in pydantic_tools) / 1024
+ logger.info(f"Bulk upserting {len(pydantic_tools)} tools: total source code {total_source_code_kb:.2f} KB")
+
if settings.letta_pg_uri_no_default:
# use optimized postgresql bulk upsert
async with db_registry.async_session() as session:
diff --git a/letta/services/tool_schema_generator.py b/letta/services/tool_schema_generator.py
index c06a41fd7..575f3183a 100644
--- a/letta/services/tool_schema_generator.py
+++ b/letta/services/tool_schema_generator.py
@@ -38,12 +38,20 @@ def generate_schema_for_tool_creation(
logger.error("Custom tool is missing source_code field")
raise ValueError("Custom tool is missing source_code field.")
+ source_code_size_kb = len(tool.source_code) / 1024
+ logger.info(f"Generating schema for tool '{tool.name}': source code {source_code_size_kb:.2f} KB")
+
# TypeScript tools
if tool.source_type == ToolSourceType.typescript:
try:
from letta.functions.typescript_parser import derive_typescript_json_schema
- return derive_typescript_json_schema(source_code=tool.source_code)
+ schema = derive_typescript_json_schema(source_code=tool.source_code)
+ import json
+
+ schema_size_kb = len(json.dumps(schema)) / 1024
+ logger.info(f"Generated TypeScript schema for '{tool.name}': {schema_size_kb:.2f} KB")
+ return schema
except Exception as e:
logger.warning(f"Failed to derive TypeScript json schema: {e}")
raise ValueError(f"Failed to derive TypeScript json schema: {e}")
@@ -54,16 +62,26 @@ def generate_schema_for_tool_creation(
if tool.args_json_schema:
name, description = get_function_name_and_docstring(tool.source_code, tool.name)
args_schema = generate_model_from_args_json_schema(tool.args_json_schema)
- return generate_schema_from_args_schema_v2(
+ schema = generate_schema_from_args_schema_v2(
args_schema=args_schema,
name=name,
description=description,
append_heartbeat=False,
)
+ import json
+
+ schema_size_kb = len(json.dumps(schema)) / 1024
+ logger.info(f"Generated Python schema from args_json for '{tool.name}': {schema_size_kb:.2f} KB")
+ return schema
# Otherwise, attempt to parse from docstring with best effort
else:
try:
- return derive_openai_json_schema(source_code=tool.source_code)
+ schema = derive_openai_json_schema(source_code=tool.source_code)
+ import json
+
+ schema_size_kb = len(json.dumps(schema)) / 1024
+ logger.info(f"Generated Python schema from docstring for '{tool.name}': {schema_size_kb:.2f} KB")
+ return schema
except Exception as e:
logger.warning(f"Failed to derive json schema: {e}")
raise ValueError(f"Failed to derive json schema: {e}")