Letta — The AI Toolchain

Letta 0.16.7

Tue, 31 Mar 2026 19:28:24 GMT

Letta 0.16.7 raises the default context window to 128k, adds conversation forking, new model support, and a recompile endpoint. • Adds `POST /v1/conversations/{id}/recompile` endpoint to trigger system-prompt recompilation after manual block edits. • Adds conversation forking — fork any conversation, including the default, with shared message history. • Adds `is_byok` flag to error responses for easier debugging of Bring-Your-Own-Key failures. • Raises the global context window default from 32k to 128k for self-hosted servers with unknown models. • Adds sort-by-`last_message_at` for conversation listings. • Adds OTID-based idempotent conversation streaming for retry safety. • Adds per-request system prompt overrides via request-scoped system overrides. • Adds Baseten as a provider with full frontend integration, serverless auto mode, and reasoning support. • Adds full support for GPT-5.4, including mini, nano, and fast variants. • Adds GLM-5, GLM-5.1, GLM-5 Turbo, and GLM-4.7 model support. • Adds MiniMax M2.7 model support. • Adds Fireworks and zAI coding provider support. • Adds projection-style rendering for git memory (memfs) content in system prompts. • Blocks internal MCP server targets. • Adds WebSocket transport for the OpenAI Responses API. • Adds readiness enforcement scaffold with request pressure, DB pool, SSE lifecycle, and event loop lag monitoring (M1-M3 metrics pipeline). • Moves multi-agent tools to a less-privileged execution environment. Breaking changes: • Block limit validation has been removed from the git memory sync path — blocks can now grow freely, and any per-turn cost caps you enforced via block limits must be managed by other means.

Letta 0.16.6

Wed, 04 Mar 2026 03:14:10 GMT

Letta 0.16.6 expands the Conversations API with agent-direct mode, adds GPT-5.3 models, and raises context and memory limits. • Adds `conversation_id="default"` + `agent_id` parameter support across conversation endpoints (`send`, `list`, `cancel`, `compact`, `stream retrieve`) for agent-direct mode. • Adds model support for `gpt-5.3-codex` and `gpt-5.3-chat-latest`. • Raises the default context window from 32k to 128k tokens. • Raises `CORE_MEMORY_BLOCK_CHAR_LIMIT` default from 20k to 100k characters. • Adds `effort="max"` support in Anthropic model settings where the model supports it. • Increases the Gemini request timeout default to 600s. • Conversation creation now compiles and persists a system message immediately at creation time, capturing current memory state. • Maintains backwards compatibility for the deprecated `conversation_id=agent-*` path. • Skills sync in the memory filesystem now maps only `skills/{name}/SKILL.md` to `skills/{name}` block labels; other markdown under `skills/` is intentionally ignored. Breaking changes: • The default context window has changed from 32k to 128k — any configuration relying on the old 32k default will now use 128k instead. • `CORE_MEMORY_BLOCK_CHAR_LIMIT` default has changed from 20k to 100k — deployments that expected the 20k cap may now allow significantly larger memory blocks. • Git-backed memory frontmatter no longer emits the `limit` key; legacy `limit` keys are removed on merge — any tooling that reads or depends on `limit` in memory frontmatter will stop seeing it. • Skills sync now maps ONLY `skills/{name}/SKILL.md` to block labels; other markdown files under `skills/` are ignored — any skills content previously synced via other filenames will no longer appear as blocks.

Letta 0.15.0

Tue, 25 Nov 2025 03:16:16 GMT

Letta 0.15.0 adds context window support for grok-4 models. • Adds context window definitions for grok-4 models, enabling Letta agents to run against xAI's grok-4 model family.

Letta 0.13.0

Fri, 24 Oct 2025 22:29:49 GMT

Letta 0.13.0 adds Claude Haiku 4.5 as a supported reasoning model. • Adds Claude Haiku 4.5 as a supported reasoning model option.

Letta 0.12.1

Thu, 09 Oct 2025 22:41:59 GMT

Letta 0.12.1 adds letta_v1_agent architecture, human-in-the-loop approval, parallel tool calling, and a Runs API. • New `letta_v1_agent` architecture eliminates the `send_message` tool requirement, drops the heartbeat system, and supports all inference providers (OpenRouter, Azure, Together, Ollama, etc.), including non-tool-calling models. • Supports OpenAI's Responses API for GPT-5 models via the new `letta_v1_agent` architecture, enabling drastically improved performance. • Human-in-the-Loop (HITL): tools can now require human approval before execution, configurable via API or the ADE. • Parallel tool calling: agents now execute multiple tool calls simultaneously, each in its own sandbox, when the inference provider supports it. • New Runs API provides observability and debugging tracking for agent runs. • New `fetch_webpage` tool retrieves LLM-friendly webpage content for agents. • New Memory Omni-Tool provides a unified memory interface for agent memory management. • Agentfile v2 schema now supports groups and folders; templates can be updated via agentfiles. • Cursor-based pagination now available across many endpoints for handling large result sets. • Enhanced Archival Memory (Letta Cloud only): adds hybrid search (full-text + semantic), DateTime filtering, and a Search API endpoint. Breaking changes: • `get_folder_by_name` is deprecated — use client.folders.list(name=...) instead. • All `sources` routes have been renamed to `folders`.

Letta 0.11.7

Thu, 04 Sep 2025 04:56:36 GMT

Letta 0.11.7 adds human-in-the-loop tool approvals, Agent File v2 with multi-agent support, and hybrid archival memory search. • Introduces `ApprovalRequestMessage` and `ApprovalResponseMessage` as two new `LettaMessage` types, enabling human-in-the-loop approval flows where agents request approval before executing tools and clients respond via `client.agents.messages.create` with `type: 'approval'`, `approve`, and `approval_request_id` fields. • Upgrades the Agent File (`.af`) schema to v2, adding support for groups (multi-agent) and files. • Adds tag-based insert and search for archival memories, allowing agents to attach and query arbitrary string tags on memory entries. • Adds timestamp-based temporal filtering for archival memory search. • Adds a new archival search endpoint with hybrid search functionality. • Adds the ability to list and filter tools by type. • Enables overriding the embedding config when importing an Agent File. • Adds GPT-5 support with proper context window handling and reasoning effort configuration. • Adds DeepSeek provider support via the new agent loop architecture. • Enhances Anthropic provider support with native reasoning and improved tool schema formatting. • Adds automatic de-duplication of tool rules.

Letta 0.11.5

Tue, 26 Aug 2025 23:34:38 GMT

Letta 0.11.5 adds background mode for message streaming. • Adds background mode for message streaming, enabling stream consumption without blocking the caller.

Letta 0.11.4

Wed, 20 Aug 2025 21:34:30 GMT

Letta 0.11.4 adds step metrics recording and asyncio stream-timeout protection. • Records step metrics to a database table, enabling persistent tracking of per-step performance data. • Introduces asyncio shield around streaming calls to prevent stream timeouts under async workloads. Breaking changes: • Legacy provider paths for Azure and Together AI are deprecated and may break configurations that relied on those routes.

Letta 0.11.2

Fri, 08 Aug 2025 21:02:33 GMT

Letta 0.11.2 adds `max_steps` parameter to agent export for step-capped runs. • Adds `max_steps` parameter to the agent export API, enabling callers to cap the number of steps an exported agent will execute.

Letta 0.11.1

Fri, 08 Aug 2025 05:53:54 GMT

Letta 0.11.1 adds Claude Opus 4.1 and GPT-5 support, a new `minimal` reasoning effort option, and paginated file grep. • Adds `minimal` as a valid value for the `reasoning_effort` parameter in `LLMConfig`, giving finer control over model reasoning cost. • Adds support for Claude Opus 4.1 and GPT-5 models. • Makes the built-in `grep` tool for files paginated, enabling traversal of large file search results.

Letta 0.11.0

Thu, 07 Aug 2025 00:08:19 GMT

Letta 0.11.0 adds SigNoz OTEL trace export and a filesystem demo with file upload and streaming. • Adds SigNoz integration for exporting OpenTelemetry traces by setting `SIGNOZ_ENDPOINT`, `SIGNOZ_INGESTION_KEY`, and `LETTA_OTEL_EXPORTER_OTLP_ENDPOINT` environment variables. • Adds filesystem demo with file upload and streaming support. • Jinja template rendering is now offloaded to the thread pool, reducing CPU-bound blocking of the async event loop. Breaking changes: • The legacy `LocalClient` and `RestClient` are fully removed; callers must migrate to the new Letta SDK clients (Python and TypeScript). • Minimum supported Python version for the `letta` package is now `3.11`; Python 3.10 is no longer supported or tested.

Letta 0.10.0

Fri, 01 Aug 2025 01:04:21 GMT

Letta 0.10.0 adds LettaPing keepalives for long streaming connections, MCP OAuth support, and a new default agent architecture. • Adds `LettaPing` message type sent every 90 seconds on streaming endpoints to prevent connection termination during long-running tool calls. • Adds `not_indexable` property to agents, allowing agents to be excluded from indexing. • Defaults to the new `memgpt_v2_agent` base architecture; archival memory tools are no longer added by default but can be added explicitly. • Adds OAuth support for MCP providers, enabling integrations with services such as Linear and GitHub. • Adds LMStudio support for Qwen and Llama models with manual token counting for streaming. • Adds modal sandbox functionality with conditional imports. • Moves Ollama integration to the new agent loop architecture. Breaking changes: • The default agent architecture is now `memgpt_v2_agent`; archival memory tools are no longer added by default and must be added explicitly. • Applications consuming streaming endpoints must add handling for the new `LettaPing` message type to avoid errors on long-running tool calls; the ping interval is currently 90 seconds and will be reduced to 50 seconds in a future release.

Letta 0.9.0

Thu, 24 Jul 2025 08:13:45 GMT

Letta 0.9.0 introduces Letta Filesystem for folder/file-based document context management with OCR options. • Adds client.folders.files.upload(folder_id=..., file=...) to upload documents (PDFs, text files) into named folders that appear in the agent's context window as openable/closable files. • Adds client.jobs.retrieve(job.id) for polling async file-processing jobs by status (`'completed'`, `'failed'`). • Supports two document-to-markdown parsing backends: the default `markitdown` package, or Mistral's OCR endpoint, selected by setting the `LETTA_MISTRAL_API_KEY` environment variable.

Letta 0.8.9

Thu, 03 Jul 2025 19:11:58 GMT

Letta 0.8.9 adds multi-provider summarization, agent loop cancellation, and MCP custom headers • Supports custom headers for MCP (Model Context Protocol) connections. • Enables agent loop run cancellation, allowing in-flight agent executions to be stopped. • Supports configuring different providers for summarization, decoupling summary generation from the primary model provider. • Improvements to file management capabilities.

Letta 0.8.8

Sun, 29 Jun 2025 22:56:47 GMT

Letta 0.8.8 adds Feedback APIs for rating agent steps positive or negative. • Adds Feedback APIs to submit positive/negative ratings on individual agent steps and list existing step feedback, accessible via the `/steps` endpoint family (see `add-feedback` reference).

Letta 0.7.29

Sun, 01 Jun 2025 19:02:18 GMT

Letta 0.7.29 adds configurable batch size and lookback for batch operations. • Adds configurable batch size and lookback parameters to batch processing.

Letta 0.7.20

Sat, 17 May 2025 02:58:02 GMT

Letta 0.7.20 adds Node.js support to enable node-based MCP integrations. • Bundles Node.js into the runtime environment to support node-based MCP (Model Context Protocol) servers.

Letta 0.7.5

Fri, 25 Apr 2025 01:02:43 GMT

Letta 0.7.5 adds count endpoints for agents, identities, sources, and tools. • Adds API endpoints to retrieve counts of agents, identities, sources, and tools.

Letta 0.7.1

Wed, 23 Apr 2025 00:30:37 GMT

Letta 0.7.1 adds a database Docker Compose file and reasoning token support for Gemini Flash. • Adds a database Docker Compose file for easier local database setup. • Enables reasoning tokens when using Gemini Flash as the backing model. • Improves conversation search message filtering to work correctly with SQLite3.

Letta 0.6.46

Sun, 30 Mar 2025 05:09:16 GMT

Letta 0.6.46 lets conversation search find messages sent by the agent itself. • Conversation search now finds an agent's own messages, not just user messages.

Letta 0.6.41

Fri, 14 Mar 2025 23:30:19 GMT

Letta 0.6.41 bakes the OpenTelemetry collector into the Letta container image. • Bundles the OpenTelemetry (OTEL) collector directly into the Letta Docker image, enabling telemetry collection without a separate sidecar or external collector deployment.

Letta 0.6.39

Thu, 13 Mar 2025 16:25:44 GMT

Letta 0.6.39 adds MCP (Model Context Protocol) support and latest Anthropic model tags. • Adds MCP (Model Context Protocol) support, enabling agents to connect to MCP-compatible tool servers. • Adds latest-version tags for Anthropic models, allowing configurations to track current Claude releases without pinning exact versions.

Letta 0.6.33

Wed, 26 Feb 2025 01:53:29 GMT

Letta 0.6.33 adds partial support for `claude-3-7-sonnet-20250219` and complex type resolution in schema generation. • Adds partial support for `claude-3-7-sonnet-20250219` as a usable model. • Adds type resolution support for complex types in schema generation.

Letta 0.6.29

Fri, 21 Feb 2025 03:35:04 GMT

Letta 0.6.29 adds user identities support with a user ID header on the identities GET request. • Adds user identities support, enabling identity records to be associated with users in the Letta system. • Passes a user ID header on the identities GET request to scope identity lookups to the calling user.

Letta 0.6.28

Thu, 20 Feb 2025 16:37:51 GMT

Letta 0.6.28 adds AWS Bedrock and DeepSeek as new LLM providers and maps context length for gpt-4o-mini. • Adds AWS Bedrock and DeepSeek as supported LLM providers. • Adds model-to-context-length mapping for `gpt-4o-mini`.

Letta 0.6.26

Fri, 14 Feb 2025 01:33:43 GMT

Letta 0.6.26 adds a tool-rules example notebook and patches Google Vertex support. • Adds an example notebook demonstrating tool rules configuration.

Letta 0.6.23

Thu, 06 Feb 2025 17:52:26 GMT

Letta 0.6.23 adds configuration settings for multi-agent setups. • Adds new settings to support multi-agent configuration in Letta.

Letta 0.6.22

Wed, 05 Feb 2025 22:32:19 GMT

Letta 0.6.22 refactors multi-agent support with API changes. • Refactors multi-agent internals and introduces associated API changes.

Letta 0.6.9

Sat, 11 Jan 2025 03:29:41 GMT

Letta 0.6.9 adds tag-matching, new types, and improved provider integration in the client. • Adds support for matching all tags when querying agents via the client. • Introduces new types and updates `Tool` schemas with improved provider integration.

Letta 0.6.8

Thu, 09 Jan 2025 01:11:59 GMT

Letta 0.6.8 adds provider persistence so configured providers survive restarts. • Adds provider persistence so that configured LLM/embedding providers are saved and restored across server restarts.

Letta 0.6.7

Tue, 31 Dec 2024 08:26:40 GMT

Letta 0.6.7 adds error codes to Composio errors, a template ID field for agent creation, and message type literals to usage stats. • Adds `template_id` field to the create agent request, enabling agents to be created from templates. • Adds message type literal to usage stats responses for finer-grained consumption tracking. • Adds error codes to Composio errors and makes Composio error catching more verbose and granular. • Stores handle in configs for improved identity tracking across configurations.

Letta 0.6.6

Fri, 20 Dec 2024 19:03:11 GMT

Letta 0.6.6 adds ConditionalToolRules, two new error types, non-pro model support, and SDK renames for tools and inner monologue. • Adds `ConditionalToolRules` to the SDK for expressing conditional logic around tool execution order and constraints. • Adds `RateLimitExceededError` error class to surface rate-limit failures explicitly in application code. • Adds `ContextWindowExceededError` error class to surface context-window overflow failures explicitly in application code. • Renames `function` to `tool` throughout the SDK, aligning SDK terminology with the tool abstraction. • Renames `internal_monologue` field in the SDK (internal monologue surface renamed). • Extends model support to non-pro model tiers. Breaking changes: • The `function` naming in the SDK is renamed to `tool` — any code referencing the old `function`-named surfaces will need to be updated. • The `internal_monologue` field is renamed in the SDK — any code referencing the old name will break.

Letta 0.6.5

Wed, 18 Dec 2024 05:55:09 GMT

Letta 0.6.5 adds tool call stdout/stderr logs in FunctionResponse and simplifies agent creation with `/` shorthand. • Simplifies agent creation via `POST /v1/agents/` by accepting `llm` and `embedding` fields in `/` format (e.g. `anthropic/claude-3-5-sonnet-20241022`, `openai/text-embedding-ada-002`) instead of full configuration objects. • Adds `context_window_limit` field and per-block `limit` field to `POST /v1/agents/` request body, allowing callers to cap the context window size and set character limits on individual memory blocks (e.g. `human`/`persona`). • Exposes `stdout` and `stderr` logs from tool execution in the `FunctionResponse` object, viewable in the ADE alongside the tool response. • Adds an init tool rule for the Anthropic endpoint. • Publishes multiplatform Docker images. • Separates Passages into distinct database tables.

Letta 0.6.3

Wed, 11 Dec 2024 05:01:13 GMT

Letta 0.6.3 adds Python 3.13 support, local HTTPS mode, file support, and a simplified agent-creation REST API. • Simplifies the `POST /v1/agents/` REST API for agent creation — tools and agent type now have defaults, reducing the required payload to `memory_blocks`, `llm_config`, and `embedding_config`. • Adds local HTTPS mode support to the server. • Adds file support via the new files feature. • Adds logs to the response for tool runs. • Supports Python 3.13, with upgraded dependencies to match.

Letta 0.6.2

Tue, 10 Dec 2024 03:03:05 GMT

Letta 0.6.2 adds an async messages API route, system message support for OSS and Anthropic models, and a streamlined Docker single-command setup. • Adds async messages API endpoint `POST /agent/{agent_id}/messages/async` to support long-running agent execution without blocking. • Adds `system` message support for OSS models (via ChatML wrapper) and Anthropic models in the `send_message` route. • Updates `Dockerfile` so the Letta service can be run with a single `docker run` command, mounting a data volume at `/var/lib/postgresql/data` and accepting credentials via `OPENAI_API_KEY` env var or `--env-file .env`. • Introduces an offline memory agent capability.

Letta 0.6.1

Thu, 05 Dec 2024 21:11:51 GMT

Letta 0.6.1 adds external codebase sandboxes for tool execution and improved venv error surfacing. • Supports external codebases as a tool execution sandbox, enabling tools to run inside third-party code environments. • Parses and surfaces errors from venv local sandbox execution so failures are visible rather than silent. • Returns HTTP 404 when a requested source does not exist, making missing-resource errors explicit.

Letta 0.6.0

Wed, 04 Dec 2024 05:40:39 GMT

Letta 0.6.0 adds E2B tool sandboxing, ADE server password protection, Composio sandbox support, and new memory-block and tool-test APIs. • Enables E2B tool sandboxing by setting `E2B_API_KEY` and `E2B_SANDBOX_TEMPLATE_ID` environment variables, isolating tool execution in a remote sandbox. • Adds `--secure` flag and `LETTA_SERVER_PASSWORD` environment variable to `letta server` so a password-protected local server can still connect to the ADE. • Adds endpoints to add default E2B and local sandbox configurations (via the sandbox config API). • Adds a `POST /v1/tools/run` route for testing tool execution by `tool_id` without running a full agent loop. • Adds endpoints to list Composio apps and actions, and adds Composio tools compatibility inside sandboxes. • Adds routes for adding/linking new memory blocks to agents and unlinking blocks from agents. • Adds a dedicated streaming route, separating streaming from the standard send-message path. • Adds per-agent locking on `send_message` to prevent concurrent state corruption. • Supports Pydantic models in tool uploads, plus patched `dict`/`list` type handling in tool schemas. • Supports passing custom headers to `RESTClient` for downstream API calls. Breaking changes: • The `POST /v1/tools` (create_tool) endpoint on v1 routes now errors on duplicate tools instead of upserting.

Letta 0.5.4

Thu, 21 Nov 2024 02:21:09 GMT

Letta 0.5.4 adds tag support to client.create_agent() for labeling agents at creation time. • Adds `tags` parameter to client.create_agent(tags=[..]) to attach labels to agents at creation time.

Letta 0.5.3

Wed, 20 Nov 2024 01:08:05 GMT

Letta 0.5.3 adds a CLI token counter, Together AI support, and password-protected server endpoints. • Adds `letta server --secure` flag to password-protect Letta server endpoints. • Adds `/tokens` command to the Letta CLI to display a token counter for the current context. • Adds support for Together AI endpoints via the `/completions` API. • Migrates the Letta Docker image to the `letta/letta` Dockerhub repository. Breaking changes: • The Letta Docker image has moved from its previous Dockerhub repository to `letta/letta` — any pipelines or compose files referencing the old image name will need to be updated.

Letta 0.5.2

Thu, 07 Nov 2024 07:00:40 GMT

Letta 0.5.2 adds agent tags for user association, tool rules to constrain agent execution order, and agent listing by name. • Adds `AgentState.tags` field plus `tags` parameter to client.create_agent() and client.get_agents() for associating agents with end users or other identifiers. • Introduces TerminalToolRule(tool_name=...), InitToolRule(tool_name=...), and ToolRule(tool_name=..., children=[...]) tool rule classes, passed via `tool_rules` in client.create_agent(), to enforce required call order and termination conditions per agent. • Adds ability to list agents by `name` via the REST API and Python SDK. • Adds ability to disable the initial message sequence during agent creation. • Moves `docker run letta/letta` to run on port `8283` (previously `8083`). • Adds HTML rendering of messages into `LettaResponse`. • Adds endpoint to add base tools to an organization. Breaking changes: • `Block.name` is deprecated in favor of `Block.template_name` (only required for templated blocks). • `docker run letta/letta` now binds to port `8283` instead of the previous `8083`, requiring updates to any firewall rules, reverse proxies, or client configurations that referenced port `8083`.

Letta 0.5.1

Wed, 23 Oct 2024 19:30:12 GMT

Letta 0.5.1 adds Composio/CrewAI/LangChain tool auto-loading, multi-agent swarm support, and new context-window and tool APIs. • Adds `LETTA_LOAD_DEFAULT_EXTERNAL_TOOLS=true` environment variable to auto-load tools from Composio, CrewAI, and LangChain when running `letta server` (install via `letta[external-tools,server]`). • Adds `put_inner_thoughts_in_kwargs` field to `LLMConfig` so models like `gpt-4o-mini` that require inner thoughts as keyword arguments in tool calls work correctly, including streaming support. • Adds a `GET` route to retrieve the breakdown of an agent's context window, plus library functions to get a context window overview. • Adds a DELETE endpoint to remove a file from a source. • Adds an endpoint to retrieve full `Tool` objects belonging to an agent. • Adds pagination support for the list-tools endpoint. • Adds function IDs to `LettaMessage` function calls and responses. • Adds support for agent 'swarm' (multi-agent) orchestration. • Removes the requirement for authentication to use the Letta server and ADE; agents are now assigned a default `user_id` automatically, and `user_id` can still be passed via `BEARER_TOKEN`. Breaking changes: • The `Admin` client and admin authentication are removed; Letta server no longer requires creating a user before creating an agent, and external services are now expected to manage users and authentication.

Letta 0.5.0

Tue, 15 Oct 2024 01:47:55 GMT

Letta 0.5.0 adds env-var-driven multi-provider model listing, Groq/Mistral/vLLM support, agent types, automated DB migrations, and a multi-message POST API. • Enables model providers via environment variables (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `OLLAMA_BASE_URL`) so a single `letta server` can serve agents with different model configurations concurrently without restart. • Adds `VLLMProvider` support, enabling vLLM-served models to appear in the CLI and ADE model dropdowns when configured. • Adds Groq as a provider option, with Llama 3.1 70b available for selection. • Adds `MistralProvider` as a new model provider option. • Refactors the `POST` `agent/messages` API endpoint to accept multiple messages in a single request. • Adds `AssistantMessage` subtype support for `LettaMessage` in the API. • Introduces agent types via a new `agent types` capability. • Supports automated database migrations via Alembic, enabling future schema changes without manual intervention. • Persists tools to the database when saving an agent. • Lists available LLM and embedding models dynamically for Ollama, Azure OpenAI, and Google AI (Gemini) providers in the CLI and ADE dropdowns. • Enables adding files to agents via the ADE. Breaking changes: • The `letta configure` and `letta quickstart` commands are deprecated and removed; provider configuration is now done via environment variables. • The `~/.letta/config` file is no longer used for specifying default `LLMConfig` and `EmbeddingConfig`; these must now be explicitly specified per agent at creation time. • `LLMConfig` and `EmbeddingConfig` are now required fields for agent creation.

Letta 0.4.1

Fri, 04 Oct 2024 01:23:41 GMT

Letta 0.4.1 adds Composio, LangChain, and CrewAI tool integrations, source detachment, org endpoints, and a health-check route. • Adds `letta[external-tools]` install extra to enable Composio, LangChain, and CrewAI tool integrations with agents. • Adds `user_id` header support to the API, allowing per-request user identification. • Adds `DEFAULT_USER_ID` and `DEFAULT_ORG_ID` environment variables for local usage without explicit user/org setup. • Adds organization endpoints and schemas to the REST API. • Adds a health-check route to the server. • Supports filtering jobs by `source_id`. • Supports detaching data sources from agents. • Makes tags optional (no longer required) when creating tools. • Adds defaults to Docker Compose config and `.env.example` to simplify local deployment.

Letta 0.3.24

Sat, 17 Aug 2024 01:27:15 GMT

Letta 0.3.24 ships an updated alpha revision of the developer portal. • Updates the developer portal to the latest alpha revision.

Letta 0.3.22

Thu, 01 Aug 2024 21:35:10 GMT

Letta 0.3.22 adds templated system prompts, in-session system prompt editing, and a core memory size flag to the CLI and Python client. • Adds `--system` flag to `memgpt run` to specify a custom system prompt when creating a new agent. • Adds `--core-memory-limit` flag to `memgpt run` to override the default core memory size limit (applies to both human and persona sections) for a new agent. • Adds `/systemswap` CLI command to replace the system prompt of an already-running agent mid-session. • Adds `system_prompt=` keyword argument to client.create_agent() in the Python client for programmatic system prompt customization. • Supports f-string-style templated system prompts using the `{CORE_MEMORY}` placeholder, letting practitioners reposition the dynamic core memory block anywhere in the prompt.

Letta 0.3.21

Fri, 26 Jul 2024 22:05:16 GMT

Agent creation API now accepts an optional system prompt, and parallel tool calling can be disabled. • Adds optional `system` field to the create agent API, allowing a custom system prompt to be provided at agent creation time. • Adds support for disabling parallel tool calling.

Letta 0.3.20

Thu, 25 Jul 2024 16:58:41 GMT

Letta 0.3.20 adds character limits for persona/human to `/config` response and fixes inner thoughts for `gpt-4o` models. • Adds character limits for `persona` and `human` fields to the `/config` API response, giving clients the data needed to enforce input constraints. • Improves inner-thought generation for `gpt-4o` and `gpt-4o-mini` models via an updated prompt format, enabling these models to produce non-`None` inner thoughts.

Letta 0.3.19

Sun, 14 Jul 2024 23:48:53 GMT

Letta 0.3.19 adds customizable memory classes via `BaseMemory` and unifies tools/memory in the agent creation API. • Adds `BaseMemory` base class enabling developers to define custom memory fields and custom memory-editing functions beyond the built-in `human`/`persona` fields and `core_memory_append`/`core_memory_replace` tools. • Adds `ChatMemory` as the new default memory class, preserving the original `human`/`persona` fields and `core_memory_append`/`core_memory_replace` editing functions. • Extends client.create_agent() to accept `memory` and `tools` arguments, allowing custom memory classes and tool lists to be specified at agent creation time; memory-editing methods from the `BaseMemory` subclass are automatically registered as agent tools. • Provides a migration script at `scripts/migrate_0.3.18.py` for upgrading agents from v0.3.18 to v0.3.19 due to `AgentState` schema changes. Breaking changes: • Presets are no longer supported as a mechanism to create agents; tool, memory, and system-prompt specification moves into the client.create_agent() interface. • The `AgentState` schema has changed; agents from v0.3.18 require migration using `scripts/migrate_0.3.18.py` before use with v0.3.19.

Letta 0.3.18

Thu, 27 Jun 2024 03:54:38 GMT

Letta 0.3.18 adds Python-side tool creation, usage statistics on message responses, Qdrant storage, token streaming, and cursor-paginated admin users API. • Adds client.create_tool(fn, tags=[...]) to the Python client, letting you register any Python function as an agent tool and immediately pass `tool.name` to client.create_agent(tools=[...]). • Adds `MemGPTUsageStatistics` to message responses, exposing `completion_tokens`, `prompt_tokens`, `total_tokens`, and `step_count` for cost-metric calculations. • Adds cursor pagination to the `GET /admin/users` route for scalable user listing. • Adds a Qdrant storage connector for vector memory backends. • Adds token streaming to the MemGPT API. • Expands tool-calling support in `LocalClient`. • Migrates the `memgpt list`, `memgpt add`, and `memgpt delete` CLI subcommands to run on the MemGPT client.

Letta 0.3.17

Wed, 05 Jun 2024 06:18:10 GMT

Letta 0.3.17 adds Ollama embeddings API support for fully local embedding workflows. • Adds support for the Ollama embeddings API endpoint, enabling fully local embedding generation without an OpenAI dependency.

Letta 0.3.16

Sun, 26 May 2024 23:05:53 GMT

Letta 0.3.16 adds Milvus as a vector database backend and enables JSON response format for all OpenAI calls. • Adds Milvus storage connector, allowing Milvus to back the Letta vector database for agent memory. • Enables JSON response format for all OpenAI API calls.

Letta 0.3.15

Thu, 16 May 2024 22:56:46 GMT

Letta 0.3.15 adds Llama 3 support and expanded tool functionality for the Python client. • Adds Llama 3 model support for local LLM inference. • Expands tool functionality available in the Python client.

Letta 0.3.13

Wed, 01 May 2024 20:43:47 GMT

Letta 0.3.13 ships an alpha MemGPT Dev Portal accessible at `memgpt.localhost` (Docker) or `localhost:8283` (CLI). • Adds an alpha MemGPT Dev Portal accessible at `memgpt.localhost` when running with Docker Compose, or `localhost:8283` when running with `memgpt server`. • Adds a `memgpt server` CLI command to launch the backend service and serve the dev portal locally. • Adds `memgpt quickstart [--backend openai]` as an initialisation path before running the server.

Letta 0.3.12

Tue, 23 Apr 2024 04:42:43 GMT

Letta 0.3.12 overhauls Docker Compose setup with a reverse proxy, dev portal, and background file-upload processing. • Adds reverse proxy to the `docker compose up` workflow, exposing the dev portal at `http://memgpt.localhost`. • Adds `docker compose -f dev-compose.yaml up --build` for local-code Docker development. • Mounts Postgres data to the `.pgdata` folder for persistent local storage in Docker. • Passes OpenAI keys to the server via environment variables in `compose.yaml`. • Processes uploaded files to the REST API using background tasks, enabling non-blocking file ingestion. • Enforces unique tool names server-side, disallowing creation of tools with a duplicate name.

Letta 0.3.11

Fri, 19 Apr 2024 03:48:39 GMT

Letta 0.3.11 adds CLI streaming support for OpenAI and OpenAI-compatible endpoints via `memgpt run --stream` • Adds `--stream` flag to `memgpt run` to enable streaming output in the CLI when using OpenAI or OpenAI-compatible (proxy) endpoints.

Letta 0.3.10

Sat, 13 Apr 2024 05:35:57 GMT

Letta 0.3.10 adds support for Anthropic Claude, Cohere Command-R+, and Groq LLM APIs. • Adds Anthropic Claude API support as a new LLM backend. • Adds Cohere API support, including the Command-R+ model.

Letta 0.3.9

Thu, 11 Apr 2024 02:53:24 GMT

Letta 0.3.9 adds Google AI Gemini Pro as an LLM provider, REST API tool creation, a dev portal, and Python 3.12 support. • Adds `google_ai` as a selectable LLM inference provider in `memgpt configure`, with support for the `gemini-pro` model (30720-token context window) via the `generativelanguage` service endpoint. • Adds REST API support for tool creation, enabling programmatic management of agent tools. • Adds a dev portal for local development and inspection. • Adds Python 3.12 compatibility.

Letta 0.3.8

Wed, 03 Apr 2024 20:10:15 GMT

Letta 0.3.8 adds Docker Compose server support, Groq integration, and richer source metadata. • Supports spinning up a MemGPT server with a PostgreSQL database via `docker compose up` using `compose.yaml`. • Adds Groq as a supported LLM provider via the local option with authentication. • Returns `num_passages` in `Source.metadata_` from the REST list sources endpoint. • Adds a `description` field to `Source` objects. • Moves quickstart configuration to use `inference.memgpt.ai` as the default inference endpoint.

Letta 0.3.7

Thu, 21 Mar 2024 05:06:35 GMT

Letta 0.3.7 adds in-context message flags, cursor-based retrieval, tool selection at agent creation, Preset routes, and expanded Python client coverage. • Adds `in_context` boolean field to message dicts returned by `GET /api/agents/{a_id}/messages`, letting callers see which messages are currently in the agent's context window. • Enables cursor-based retrieval of previous messages via the messages API, supporting paginated history traversal. • Enables tool selection at agent creation time via the `POST` agent creation endpoint. • Adds `Preset` routes to the REST API, allowing programmatic management of presets. • Adds a `source_id` path variable to source-related routes, moving it out of the request body. • Returns source metadata (including attached agents) with the `list sources` API route. • Allows an optional timestamp field in the `send_message` POST endpoint. • Implements remaining `Admin` routes in the Python client. • Adds remaining Python client support for all REST API routes. • Adds a Google Search custom function example demonstrating how to wire external tool calls.

Letta 0.3.6

Mon, 11 Mar 2024 23:49:37 GMT

Letta 0.3.6 expands the REST API with archival memory, data sources, and message UUIDs in SSE streaming. • Adds archival memory endpoints to the REST API: `GET`, `POST`, and `DELETE` under `/api/agents`. • Adds data sources endpoints to the REST API for managing agent data sources. • Adds `last_run` field to the agent state model, available via the REST API. • Adds `persona_name` and `human_name` fields to the `Preset` model. • Adds memory data and tool data to the `GET /api/agents` list response. • Adds list of sources (in dict format) to the agent response object. • Adds metadata to the `GET /api/tools` route response. • Passes message UUIDs during message streaming via `POST` SSE `send_message`. • Enables adding presets via the CLI. Breaking changes: • All `/api/agents` sub-routes now use `{agent_id}` as a path parameter — any client code referencing agent routes with a different parameter convention will break.

Letta 0.3.5

Wed, 06 Mar 2024 06:12:04 GMT

Letta 0.3.5 adds REST endpoints for agents, humans, personas, LLM config, and tools listing. • Adds `GET` REST API route for listing tools. • Adds REST API routes to `GET` information for agents, humans, and personas, and stores humans and personas in the database. • Returns `server.server_llm_config` information via REST endpoint. • Moves `agent_id` from a query parameter to a path variable in REST API routes. • Adds REST API support for creating humans and personas. Breaking changes: • The `agent_id` parameter is moved from a query parameter to a path variable in REST API routes — callers constructing URLs with `?agent_id=...` must update to path-style URLs.

Letta 0.3.4

Fri, 01 Mar 2024 04:57:37 GMT

Letta 0.3.4 adds RESTClient and Admin Python clients, HTTPS support for the server, and a Dockerfile for self-hosted deployments. • Adds `RESTClient` and `Admin` Python client classes for interacting with the Letta server programmatically. • Adds basic HTTPS support to `memgpt server` for development environments that require it. • Adds a Dockerfile for running the Letta server as a container. • Allows admin users to access all API routes, with authentication re-enabled. • Adds authentication support to the Chat UI. • Adds data loading and attaching functionality to the server. • Refactors loading and attaching data sources, upgrading to `llama-index==0.10.6`.

Letta 0.3.3

Mon, 19 Feb 2024 00:56:04 GMT

Letta 0.3.3 adds OpenAI-compatible Assistant API endpoints, API key auth, and admin route password protection to `memgpt server`. • Adds API key support to the `memgpt server` REST API, enabling token-based authentication for server requests. • Adds password protection to `/admin` routes on `memgpt server`, restricting administrative endpoints behind a credential check. • Adds partial support for OpenAI-compatible Assistant API endpoints to `memgpt server`, allowing clients that target the OpenAI Assistants API to connect.

Letta 0.3

Tue, 30 Jan 2024 04:17:41 GMT

Letta 0.3 moves all agent and user state into database storage and adds a hosted multi-user server mode. • Adds `memgpt server` command to run Letta as a hosted service on `http://localhost:8283`, serving multiple users and emitting an `openapi.json` spec on startup. • Adds `memgpt migrate` command to move existing agent state and data sources from `~/.memgpt/config` into the new database-backed storage layer. • All agent, user, and system state is now persisted in database storage (local SQLite and Chroma by default, configurable), enabling multi-user deployments. Breaking changes: • Existing agents and data sources in `~/.memgpt/config` are inaccessible after upgrading to 0.3 until migrated with `memgpt migrate`.

Letta 0.2.11

Wed, 03 Jan 2024 23:13:05 GMT

Letta 0.2.11 adds a new `MemGPT` Python client class for programmatically creating and messaging agents, plus a `chatml-noforce-roles` wrapper. • Adds the `MemGPT` class (imported from `memgpt`) as a new Python client, enabling programmatic creation and management of MemGPT agents without the CLI. • Adds a `chatml-noforce-roles` wrapper for local LLM prompt formatting control.

Letta 0.2.10

Mon, 25 Dec 2023 19:46:03 GMT

Letta 0.2.10 adds two new model wrappers for local LLMs to boost agent proactiveness via `chatml-hints` and `chatml-noforce-hints`. • Adds `chatml-hints` and `chatml-noforce-hints` model wrappers, selectable via `memgpt run --model-wrapper` or `memgpt configure`, to increase agent proactiveness when using local/open LLMs. • Adds heartbeat override heuristics to give agents more control over autonomous scheduling. • Sets a default temperature in common local LLM settings to reduce required manual configuration. • Improves CLI UI visuals for a better interactive experience.

Letta 0.2.8

Fri, 22 Dec 2023 18:04:59 GMT

Letta 0.2.8 adds free hosted LLM endpoints, `memgpt quickstart`, `memgpt server`, `memgpt folder`, `/summarize`, and a REST API. • Adds `memgpt quickstart --latest` to auto-configure MemGPT for the free hosted endpoint, and `memgpt quickstart --latest --backend openai` for OpenAI; writes defaults to `~/.memgpt/config`. • Adds `memgpt server` command to launch the REST API server, with support for passing a custom host. • Adds `memgpt folder` command for folder management. • Adds `/summarize` in-chat command. • Introduces a REST API via API server refactor, with local APIs updated to return usage info. • Adds free hosted LLM and embedding endpoints (running Dolphin 2.5 Mixtral 8x7b) requiring no access key; uptime visible at https://status.memgpt.ai. • Adds `autogen` as an installable extra. • Adds common and custom settings files for completion endpoints. • Migrates to using the completions endpoint by default. • Adds model list pulling for OpenAI-compatible endpoints.

Letta 0.2.7

Mon, 11 Dec 2023 06:37:05 GMT

Letta 0.2.7 adds Chroma vector storage integration and bundles lancedb and chroma as default dependencies. • Adds `skip_verify` parameter to autogen constructors for bypassing verification. • New Chroma vector storage integration for persistent memory backends. • Bundles `lancedb` and `chroma` as default package dependencies, removing the need for separate installation.

Letta 0.2.5

Sat, 02 Dec 2023 00:16:27 GMT

Letta 0.2.5 adds HuggingFace TEI embedding support and vLLM integration, while removing legacy `python main.py` and `BACKEND_TYPE` configuration. • Removes `BACKEND_TYPE` and `OPENAI_BASE_URL` environment variables for configuring local/custom LLMs — use `memgpt configure` and `memgpt run` flags instead. • Removes the `python main.py` command — replaced by `memgpt run`. • Adds support for HuggingFace Text Embeddings Inference (TEI) endpoints as a custom embedding model backend. • Adds documentation and support for vLLM OpenAI-compatible endpoints, including the `user` field for vLLM requests. • Adds a warning when no data sources are loaded on the `/attach` command. Breaking changes: • The `python main.py` command is removed; users must switch to `memgpt run`. • The `BACKEND_TYPE` and `OPENAI_BASE_URL` environment variables are removed; local/custom LLM configuration must be done via `memgpt configure` and `memgpt run` flags.

Letta 0.2.4

Thu, 23 Nov 2023 06:44:54 GMT

Letta 0.2.4 adds custom presets, LanceDB archival storage, and vLLM OpenAI-compatible endpoint support. • Adds LanceDB integration for archival storage as a new vector database backend option. • Adds support for vLLM OpenAI-compatible endpoints as an LLM backend. • Adds custom presets, enabling configuration of the specific set of function calls the agent can make.

Letta 0.2.3

Wed, 15 Nov 2023 18:21:57 GMT

Letta 0.2.3 adds configurable presets, a WebSocket server interface, and version-tracked agent configs. • Adds `memgpt_version` field to stored configs so agents track which version they were saved with, improving cross-version compatibility. • Adds `load` and `load_and_attach` functions to the MemGPT AutoGen agent integration. • Introduces a WebSocket interface via `server.py` for real-time agent communication. • Introduces configurable presets, letting developers customize the function set and system prompts MemGPT agents use. Breaking changes: • Agent and MemGPT configuration storage format has changed; users upgrading from a prior version may need to re-run `memgpt configure` to remain compatible with this version.

Letta 0.2.0

Fri, 10 Nov 2023 16:55:37 GMT

Letta 0.2.0 adds pgvector archival memory, Ollama support, grammar-based sampling, file I/O, and new CLI commands. • Adds `MEMGPT_CONFIG_PATH` environment variable to override the default config location (`~/.memgpt/config`). • Adds `memgpt version` command to print the installed package version. • Adds `/retry` in-chat command to request another answer from the agent. • Adds pgvector (PostgreSQL vector database) support for archival memory storage. • Adds Ollama as a supported local LLM backend. • Adds grammar-based sampling support for webui, llama.cpp, and koboldcpp backends. • Adds ability for agents to read/write text files and make HTTP requests. • Adds support for specifying model inference and embedding endpoints separately in config. • Adds AutoGen + local LLM integration, enabling multi-agent workflows with locally hosted models. • Adds GPT-4 Turbo to the list of supported OpenAI models. • Adds Docker support for simplified deployment. • Adds conversation-shaping in-chat commands (beyond `/retry`). • Defaults to local embeddings automatically when neither OpenAI nor Azure is configured. Breaking changes: • Removes `requirements.txt` and `requirements_local.txt`; dependency management is now handled exclusively via Poetry.

Letta 0.1.12

Tue, 31 Oct 2023 01:25:13 GMT

Letta 0.1.12 adds AutoGen integration, LM Studio inference support, Llama Index archival connectors, and a synchronous agent API. • Adds LM Studio as a supported inference server backend, enabling local LLM inference via LM Studio alongside existing backends. • Supports loading data into archival memory using Llama Index connectors, expanding data ingestion options for long-term agent memory. • Adds integration with AutoGen workflows, allowing Letta agents to participate in multi-agent AutoGen pipelines. • Adds a synchronous agent class, complementing the existing async agent for use in synchronous Python contexts. • Refactors the CLI to use a config file, connect to Llama Index data sources, and support multiple agents in a single session. • Adds a new model wrapper for Zephyr models, extending local/open-source model support. • Adds clearer warnings when `OPENAI_API_BASE` and `BACKEND_TYPE` environment variables are not set.

Letta 0.1.6

Thu, 26 Oct 2023 23:48:45 GMT

Letta 0.1.6 adds local LLM support, Azure, AutoGen integration, CSV/PDF preloading, and on-the-fly embedding generation. • Adds a flag for preloading files into archival memory at startup. • Adds CSV support for preloading files into archival memory. • Adds PDF support for preloading files into archival memory. • Supports generating embeddings on the fly, with parallelized embedding generation. • Adds local LLM support with function calling. • Adds wrappers for Dolphin Mistral and an inner monologue wrapper for local LLM use. • Adds Azure OpenAI support. • Adds `gpt-3.5-turbo` support. • Adds an AutoGen MemGPT agent integration, enabling MemGPT agents inside AutoGen multi-agent workflows. • Adds a LlamaIndex example for chatting with a MemGPT agent over LlamaIndex documentation. • Adds an example SQL integration with MemGPT. • Overhauls the CLI interface. • Autosaves agent state on `/exit`.