# Letta
Types:
```python
from letta_client.types import HealthResponse
```
Methods:
- client.health() -> HealthResponse
# Agents
Types:
```python
from letta_client.types import (
AgentEnvironmentVariable,
AgentState,
AgentType,
AnthropicModelSettings,
AzureModelSettings,
BedrockModelSettings,
ChildToolRule,
ConditionalToolRule,
ContinueToolRule,
DeepseekModelSettings,
GoogleAIModelSettings,
GoogleVertexModelSettings,
GroqModelSettings,
InitToolRule,
JsonObjectResponseFormat,
JsonSchemaResponseFormat,
LettaMessageContentUnion,
MaxCountPerStepToolRule,
MessageCreate,
OpenAIModelSettings,
ParentToolRule,
RequiredBeforeExitToolRule,
RequiresApprovalToolRule,
TerminalToolRule,
TextResponseFormat,
TogetherModelSettings,
XaiModelSettings,
AgentExportFileResponse,
AgentImportFileResponse,
AgentRecompileResponse,
)
```
Methods:
- client.agents.create(\*\*params) -> AgentState
- client.agents.retrieve(agent_id, \*\*params) -> AgentState
- client.agents.update(agent_id, \*\*params) -> AgentState
- client.agents.list(\*\*params) -> SyncArrayPage[AgentState]
- client.agents.delete(agent_id) -> object
- client.agents.export_file(agent_id, \*\*params) -> str
- client.agents.import_file(\*\*params) -> AgentImportFileResponse
- client.agents.recompile(agent_id, \*\*params) -> str
## Messages
Types:
```python
from letta_client.types.agents import (
ApprovalCreate,
ApprovalRequestMessage,
ApprovalResponseMessage,
ApprovalReturn,
AssistantMessage,
EventMessage,
HiddenReasoningMessage,
ImageContent,
InternalMessage,
JobStatus,
JobType,
LettaAssistantMessageContentUnion,
LettaRequest,
LettaResponse,
LettaStreamingRequest,
LettaStreamingResponse,
LettaUserMessageContentUnion,
Message,
MessageRole,
MessageType,
OmittedReasoningContent,
ReasoningContent,
ReasoningMessage,
RedactedReasoningContent,
Run,
SummaryMessage,
SystemMessage,
TextContent,
ToolCall,
ToolCallContent,
ToolCallDelta,
ToolCallMessage,
ToolReturn,
ToolReturnContent,
UpdateAssistantMessage,
UpdateReasoningMessage,
UpdateSystemMessage,
UpdateUserMessage,
UserMessage,
MessageCancelResponse,
)
```
Methods:
- client.agents.messages.create(agent_id, \*\*params) -> LettaResponse
- client.agents.messages.list(agent_id, \*\*params) -> SyncArrayPage[Message]
- client.agents.messages.cancel(agent_id, \*\*params) -> MessageCancelResponse
- client.agents.messages.compact(agent_id, \*\*params) -> CompactionResponse
- client.agents.messages.create_async(agent_id, \*\*params) -> Run
- client.agents.messages.reset(agent_id, \*\*params) -> Optional[AgentState]
- client.agents.messages.stream(agent_id, \*\*params) -> LettaStreamingResponse
## Schedule
Types:
```python
from letta_client.types.agents import (
ScheduleCreateResponse,
ScheduleRetrieveResponse,
ScheduleListResponse,
ScheduleDeleteResponse,
)
```
Methods:
- client.agents.schedule.create(agent_id, \*\*params) -> ScheduleCreateResponse
- client.agents.schedule.retrieve(scheduled_message_id, \*, agent_id) -> ScheduleRetrieveResponse
- client.agents.schedule.list(agent_id, \*\*params) -> ScheduleListResponse
- client.agents.schedule.delete(scheduled_message_id, \*, agent_id) -> ScheduleDeleteResponse
## Blocks
Types:
```python
from letta_client.types.agents import Block, BlockUpdate
```
Methods:
- client.agents.blocks.retrieve(block_label, \*, agent_id) -> BlockResponse
- client.agents.blocks.update(block_label, \*, agent_id, \*\*params) -> BlockResponse
- client.agents.blocks.list(agent_id, \*\*params) -> SyncArrayPage[BlockResponse]
- client.agents.blocks.attach(block_id, \*, agent_id) -> AgentState
- client.agents.blocks.detach(block_id, \*, agent_id) -> AgentState
## Tools
Types:
```python
from letta_client.types.agents import ToolExecuteRequest, ToolExecutionResult
```
Methods:
- client.agents.tools.list(agent_id, \*\*params) -> SyncArrayPage[Tool]
- client.agents.tools.attach(tool_id, \*, agent_id) -> Optional[AgentState]
- client.agents.tools.detach(tool_id, \*, agent_id) -> Optional[AgentState]
- client.agents.tools.run(tool_name, \*, agent_id, \*\*params) -> ToolExecutionResult
- client.agents.tools.update_approval(tool_name, \*, agent_id, \*\*params) -> Optional[AgentState]
## Folders
Types:
```python
from letta_client.types.agents import FolderListResponse
```
Methods:
- client.agents.folders.list(agent_id, \*\*params) -> SyncArrayPage[FolderListResponse]
- client.agents.folders.attach(folder_id, \*, agent_id) -> Optional[AgentState]
- client.agents.folders.detach(folder_id, \*, agent_id) -> Optional[AgentState]
## Files
Types:
```python
from letta_client.types.agents import FileListResponse, FileCloseAllResponse, FileOpenResponse
```
Methods:
- client.agents.files.list(agent_id, \*\*params) -> SyncNextFilesPage[FileListResponse]
- client.agents.files.close(file_id, \*, agent_id) -> object
- client.agents.files.close_all(agent_id) -> FileCloseAllResponse
- client.agents.files.open(file_id, \*, agent_id) -> FileOpenResponse
## Archives
Methods:
- client.agents.archives.attach(archive_id, \*, agent_id) -> object
- client.agents.archives.detach(archive_id, \*, agent_id) -> object
## Passages
Types:
```python
from letta_client.types.agents import (
PassageCreateResponse,
PassageListResponse,
PassageSearchResponse,
)
```
Methods:
- client.agents.passages.create(agent_id, \*\*params) -> PassageCreateResponse
- client.agents.passages.list(agent_id, \*\*params) -> PassageListResponse
- client.agents.passages.delete(memory_id, \*, agent_id) -> object
- client.agents.passages.search(agent_id, \*\*params) -> PassageSearchResponse
## Identities
Methods:
- client.agents.identities.attach(identity_id, \*, agent_id) -> object
- client.agents.identities.detach(identity_id, \*, agent_id) -> object
# Tools
Types:
```python
from letta_client.types import (
NpmRequirement,
PipRequirement,
Tool,
ToolCreate,
ToolReturnMessage,
ToolSearchRequest,
ToolSearchResult,
ToolType,
ToolSearchResponse,
)
```
Methods:
- client.tools.create(\*\*params) -> Tool
- client.tools.retrieve(tool_id) -> Tool
- client.tools.update(tool_id, \*\*params) -> Tool
- client.tools.list(\*\*params) -> SyncArrayPage[Tool]
- client.tools.delete(tool_id) -> object
- client.tools.search(\*\*params) -> ToolSearchResponse
- client.tools.upsert(\*\*params) -> Tool
# Blocks
Types:
```python
from letta_client.types import BlockResponse, CreateBlock
```
Methods:
- client.blocks.create(\*\*params) -> BlockResponse
- client.blocks.retrieve(block_id) -> BlockResponse
- client.blocks.update(block_id, \*\*params) -> BlockResponse
- client.blocks.list(\*\*params) -> SyncArrayPage[BlockResponse]
- client.blocks.delete(block_id) -> object
## Agents
Methods:
- client.blocks.agents.list(block_id, \*\*params) -> SyncArrayPage[AgentState]
# Archives
Types:
```python
from letta_client.types import Archive, VectorDBProvider
```
Methods:
- client.archives.create(\*\*params) -> Archive
- client.archives.retrieve(archive_id) -> Archive
- client.archives.update(archive_id, \*\*params) -> Archive
- client.archives.list(\*\*params) -> SyncArrayPage[Archive]
- client.archives.delete(archive_id) -> None
## Passages
Types:
```python
from letta_client.types.archives import PassageCreateManyResponse
```
Methods:
- client.archives.passages.create(archive_id, \*\*params) -> Passage
- client.archives.passages.delete(passage_id, \*, archive_id) -> None
- client.archives.passages.create_many(archive_id, \*\*params) -> PassageCreateManyResponse
# Folders
Types:
```python
from letta_client.types import Folder
```
Methods:
- client.folders.create(\*\*params) -> Folder
- client.folders.retrieve(folder_id) -> Folder
- client.folders.update(folder_id, \*\*params) -> Folder
- client.folders.list(\*\*params) -> SyncArrayPage[Folder]
- client.folders.delete(folder_id) -> object
## Files
Types:
```python
from letta_client.types.folders import FileRetrieveResponse, FileListResponse, FileUploadResponse
```
Methods:
- client.folders.files.retrieve(file_id, \*, folder_id, \*\*params) -> FileRetrieveResponse
- client.folders.files.list(folder_id, \*\*params) -> SyncArrayPage[FileListResponse]
- client.folders.files.delete(file_id, \*, folder_id) -> None
- client.folders.files.upload(folder_id, \*\*params) -> FileUploadResponse
## Agents
Types:
```python
from letta_client.types.folders import AgentListResponse
```
Methods:
- client.folders.agents.list(folder_id, \*\*params) -> AgentListResponse
# Models
Types:
```python
from letta_client.types import (
EmbeddingConfig,
EmbeddingModel,
LlmConfig,
Model,
ProviderCategory,
ProviderType,
ModelListResponse,
)
```
Methods:
- client.models.list(\*\*params) -> ModelListResponse
## Embeddings
Types:
```python
from letta_client.types.models import EmbeddingListResponse
```
Methods:
- client.models.embeddings.list() -> EmbeddingListResponse
# McpServers
Types:
```python
from letta_client.types import (
CreateSseMcpServer,
CreateStdioMcpServer,
CreateStreamableHTTPMcpServer,
SseMcpServer,
StdioMcpServer,
StreamableHTTPMcpServer,
UpdateSseMcpServer,
UpdateStdioMcpServer,
UpdateStreamableHTTPMcpServer,
McpServerCreateResponse,
McpServerRetrieveResponse,
McpServerUpdateResponse,
McpServerListResponse,
)
```
Methods:
- client.mcp_servers.create(\*\*params) -> McpServerCreateResponse
- client.mcp_servers.retrieve(mcp_server_id) -> McpServerRetrieveResponse
- client.mcp_servers.update(mcp_server_id, \*\*params) -> McpServerUpdateResponse
- client.mcp_servers.list() -> McpServerListResponse
- client.mcp_servers.delete(mcp_server_id) -> None
- client.mcp_servers.refresh(mcp_server_id, \*\*params) -> object
## Tools
Types:
```python
from letta_client.types.mcp_servers import ToolListResponse
```
Methods:
- client.mcp_servers.tools.retrieve(tool_id, \*, mcp_server_id) -> Tool
- client.mcp_servers.tools.list(mcp_server_id) -> ToolListResponse
- client.mcp_servers.tools.run(tool_id, \*, mcp_server_id, \*\*params) -> ToolExecutionResult
# Runs
Types:
```python
from letta_client.types import Job, StopReasonType
```
Methods:
- client.runs.retrieve(run_id) -> Run
- client.runs.list(\*\*params) -> SyncArrayPage[Run]
## Messages
Methods:
- client.runs.messages.list(run_id, \*\*params) -> SyncArrayPage[Message]
- client.runs.messages.stream(path_run_id, \*\*params) -> object
## Usage
Types:
```python
from letta_client.types.runs import UsageRetrieveResponse
```
Methods:
- client.runs.usage.retrieve(run_id) -> UsageRetrieveResponse
## Steps
Methods:
- client.runs.steps.list(run_id, \*\*params) -> SyncArrayPage[Step]
## Trace
Types:
```python
from letta_client.types.runs import TraceRetrieveResponse
```
Methods:
- client.runs.trace.retrieve(run_id, \*\*params) -> TraceRetrieveResponse
# Steps
Types:
```python
from letta_client.types import ProviderTrace, Step
```
Methods:
- client.steps.retrieve(step_id) -> Step
- client.steps.list(\*\*params) -> SyncArrayPage[Step]
## Metrics
Types:
```python
from letta_client.types.steps import MetricRetrieveResponse
```
Methods:
- client.steps.metrics.retrieve(step_id) -> MetricRetrieveResponse
## Trace
Methods:
- client.steps.trace.retrieve(step_id) -> Optional[ProviderTrace]
## Feedback
Methods:
- client.steps.feedback.create(step_id, \*\*params) -> Step
## Messages
Types:
```python
from letta_client.types.steps import MessageListResponse
```
Methods:
- client.steps.messages.list(step_id, \*\*params) -> SyncArrayPage[MessageListResponse]
# Templates
Types:
```python
from letta_client.types import (
TemplateCreateResponse,
TemplateUpdateResponse,
TemplateDeleteResponse,
TemplateRollbackResponse,
TemplateSaveResponse,
)
```
Methods:
- client.templates.create(\*\*params) -> TemplateCreateResponse
- client.templates.update(template_name, \*\*params) -> TemplateUpdateResponse
- client.templates.delete(template_name) -> TemplateDeleteResponse
- client.templates.rollback(template_name, \*\*params) -> TemplateRollbackResponse
- client.templates.save(template_name, \*\*params) -> TemplateSaveResponse
## Agents
Types:
```python
from letta_client.types.templates import AgentCreateResponse
```
Methods:
- client.templates.agents.create(template_version, \*\*params) -> AgentCreateResponse
# Tags
Types:
```python
from letta_client.types import TagListResponse
```
Methods:
- client.tags.list(\*\*params) -> TagListResponse
# Messages
Types:
```python
from letta_client.types import (
MessageSearchRequest,
MessageSearchResult,
MessageRetrieveResponse,
MessageListResponse,
MessageSearchResponse,
)
```
Methods:
- client.messages.retrieve(message_id) -> MessageRetrieveResponse
- client.messages.list(\*\*params) -> MessageListResponse
- client.messages.search(\*\*params) -> MessageSearchResponse
# Passages
Types:
```python
from letta_client.types import Passage, PassageSearchResponse
```
Methods:
- client.passages.search(\*\*params) -> PassageSearchResponse
# Conversations
Types:
```python
from letta_client.types import (
Conversation,
CreateConversation,
UpdateConversation,
ConversationListResponse,
ConversationCancelResponse,
ConversationRecompileResponse,
)
```
Methods:
- client.conversations.create(\*\*params) -> Conversation
- client.conversations.retrieve(conversation_id) -> Conversation
- client.conversations.update(conversation_id, \*\*params) -> Conversation
- client.conversations.list(\*\*params) -> ConversationListResponse
- client.conversations.delete(conversation_id) -> object
- client.conversations.cancel(conversation_id, \*\*params) -> ConversationCancelResponse
- client.conversations.fork(conversation_id, \*\*params) -> Conversation
- client.conversations.recompile(conversation_id, \*\*params) -> str
## Messages
Types:
```python
from letta_client.types.conversations import CompactionRequest, CompactionResponse
```
Methods:
- client.conversations.messages.create(conversation_id, \*\*params) -> LettaResponse
- client.conversations.messages.list(conversation_id, \*\*params) -> SyncArrayPage[Message]
- client.conversations.messages.compact(conversation_id, \*\*params) -> CompactionResponse
- client.conversations.messages.stream(conversation_id, \*\*params) -> object
# Environments
Types:
```python
from letta_client.types import (
EnvironmentRetrieveResponse,
EnvironmentListResponse,
EnvironmentSendMessageResponse,
)
```
Methods:
- client.environments.retrieve(device_id) -> EnvironmentRetrieveResponse
- client.environments.list(\*\*params) -> EnvironmentListResponse
- client.environments.send_message(connection_id, \*\*params) -> EnvironmentSendMessageResponse
# AccessTokens
Types:
```python
from letta_client.types import AccessTokenCreateResponse, AccessTokenListResponse
```
Methods:
- client.access_tokens.create(\*\*params) -> AccessTokenCreateResponse
- client.access_tokens.list(\*\*params) -> AccessTokenListResponse
- client.access_tokens.delete(token, \*\*params) -> object