Heads up This site is currently under heavy development.
← all tools
◆ AI Agent Frameworks

Letta

0.16.7 open-source

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

source ↗ website ↗ rss ↗ last repo push Aug 23, 2026

Summary

Letta is an open-source ai-agent-framework that enables the building of stateful agents with memory designed for application developers. It can be run as a command-line interface via npm, or deployed via a self-hosted App Server, and its SDK allows embedding agents into TypeScript applications. Its README positions it alongside other agent frameworks in the category of ai-agent-frameworks, and the project has an active repository showing continuous development.

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

What Letta answers

What channels can agents interact with?

Slack, Telegram, Discord, and custom channels

Can I embed agent functionality into my existing web application?

The agent SDK allows building agents into TypeScript applications

Does the framework maintain conversation history across different devices?

Letta Cloud keeps agent memory, identity, and conversations available across computers

What versions of the framework are available for local testing?

The currently available source code in the main repository supports the agent harness, interactive terminal UI, App Server, channels, and the runtime

Can I replicate the setup from an older version of the agent?

The archive branch preserves the retired Letta V1 API server, though this source is unsupported

How do I use the service if I do not want to self-host the App Server?

Users can access the agent through a browser-based web interface at chat.letta.com

Release history

  1. docs update Aug 29, 2026 · issue 010

    Letta adds scheduled task CLI (letta cron) with cloud/local execution targets and conversation-binding options.

    └──▷ TRY IT
    Schedule a weekday morning briefing that always runs in the Cloud sandbox, avoiding dependency on any connected machine.
    $ letta cron add "daily-brief" --runner cloud "Prepare morning briefing."
    Bind a recurring reminder to your active conversation so replies appear inline rather than in a separate thread.
    $ letta cron add "standup" --conversation self "Remind me to check staging metrics before deploying."
    Review the run history of a scheduled task to check for missed executions (tasks overdue by more than 5 minutes are marked missed).
    $ letta cron runs --id <taskId>
    • ›New letta cron add command schedules recurring or one-time prompts to an agent, stored in Letta Cloud by default.
    • ›Adds --runner cloud flag to letta cron add to force execution in the managed Cloud sandbox regardless of connected machines.
    • ›Adds --runner local flag to store a schedule strictly on the local machine (persisted at ~/.letta/cron.json), firing only while a Letta session is active.
    • ›Adds --conversation default, --conversation <id>, and --conversation self flags to route scheduled runs to an existing conversation thread instead of always starting a new one.
    • ›New letta cron runs --id <taskId> subcommand surfaces run history for a specific scheduled task.
    +3 moreshow less
    • ›New letta cron delete <taskId> subcommand removes a scheduled task.
    • ›Cloud schedules execute in UTC and fall back to the Cloud sandbox when a targeted machine is offline; local schedules evaluate in the local machine timezone and pause when Letta is not running.
    • ›Agents can schedule tasks themselves directly from chat without CLI intervention.
  2. docs update Aug 29, 2026 · issue 010

    Letta CLI gains --ephemeral flag and scheduling options including --runner, --computer, and --conversation controls.

    • ›Adds --ephemeral flag to run a one-shot task without creating or saving an agent.
    • ›Adds --runner cloud to create a cloud schedule that runs in the managed cloud sandbox when no --computer is specified.
    • ›Adds --runner local to store a schedule on the current computer, firing only while a Letta app, CLI session, or process is running.
    • ›Adds --computer <deviceId> to target a cloud schedule at a specific connected computer (deviceId from the CLI), with sandbox fallback if offline; takes precedence over --runner cloud.
    • ›Adds --conversation default to send every scheduled fire to the agent's default conversation.
    +3 moreshow less
    • ›Adds --conversation <id> to send every scheduled fire to one specific conversation.
    • ›Adds --conversation self to capture the conversation ID from the currently active conversation (requires an active conversation).
    • ›Adds --conversation new (default when omitted) to start a new conversation for every scheduled fire.
  3. docs update Aug 29, 2026 · issue 010

    Letta CLI gains --ephemeral flag for stateless one-shot agent runs ideal for CI/CD pipelines.

    └──▷ TRY IT
    Pipe a git diff into an ephemeral Letta run to get a one-shot security review in CI without leaving any persisted agent state.
    $ git diff | letta run --ephemeral "Review these changes for security issues"
    • ›Adds --ephemeral flag to the Letta CLI to run a one-shot task without creating, resuming, or persisting an agent, memory blocks, or MemFS — on the Cloud backend returns "agent_id": null in JSON output; on the local backend executes in a temporary scratch store.
    • ›The --ephemeral flag is mutually exclusive with --resume, --personality, --stateless, --memfs, --memfs-startup, and bidirectional mode flags.
  4. docs update Aug 29, 2026 · issue 010

    Letta Code repositories can now expose agent skills via skills/<skill-name>/SKILL.md files at the repo root.

    • ›Attached repositories can supply skills to agents by placing each skill in a skills/<skill-name>/SKILL.md file at the repository root; skills are automatically unloaded when the repository is detached.
  5. 0.16.7 Mar 31, 2026 · issue -141

    Letta 0.16.7 raises the default context window to 128k, adds conversation forking, new model support, and a recompile endpoint.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.16.7 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.16.7
    └──▷ TRY IT
    Force a recompile of a conversation's system prompt after editing a memory block via the API, so the agent sees the updated context immediately.
    $ curl -X POST https://<your-letta-server>/v1/conversations/<conversation-id>/recompile
    • ›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.
    +12 moreshow less
    • ›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 ON UPGRADE
    • !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.
  6. 0.16.6 Mar 4, 2026 · issue -167

    Letta 0.16.6 expands the Conversations API with agent-direct mode, adds GPT-5.3 models, and raises context and memory limits.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.16.6 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.16.6
    └──▷ TRY IT
    Send a message directly to a known agent without managing a separate conversation ID, using the new agent-direct mode.
    $ POST /v1/conversations/default/messages
{
  "agent_id": "<agent_id>",
  "messages": [{"role": "user", "content": "Summarize my tasks."}]
}
    • ›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.
    +4 moreshow less
    • ›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 ON UPGRADE
    • !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.
  7. 0.15.0 Nov 25, 2025 · issue -265

    Letta 0.15.0 adds context window support for grok-4 models.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.15.0 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.15.0
    • ›Adds context window definitions for grok-4 models, enabling Letta agents to run against xAI's grok-4 model family.
  8. 0.13.0 Oct 24, 2025 · issue -297

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

    └──▷ GET THIS VERSION
    $ git clone --branch 0.13.0 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.13.0
    • ›Adds Claude Haiku 4.5 as a supported reasoning model option.
  9. 0.12.1 Oct 9, 2025 · issue -312

    Letta 0.12.1 adds letta_v1_agent architecture, human-in-the-loop approval, parallel tool calling, and a Runs API.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.12.1 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.12.1
    └──▷ USE IT
    List folders by name using the new API that replaces the deprecated get_folder_by_name call.
    python 
    client.folders.list(name="my-folder")
    • ›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.
    +5 moreshow less
    • ›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 ON UPGRADE
    • !get_folder_by_name is deprecated — use client.folders.list(name=...) instead.
    • !All sources routes have been renamed to folders.
  10. 0.11.7 Sep 4, 2025 · issue -346

    Letta 0.11.7 adds human-in-the-loop tool approvals, Agent File v2 with multi-agent support, and hybrid archival memory search.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.11.7 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.11.7
    └──▷ USE IT
    Approve a pending tool call from an agent that requires human sign-off before execution.
    python 
    response = client.agents.messages.create(
    agent_id=agent.id,
    messages=[{
        "type": "approval",
        "approve": True,
        "approval_request_id": "message-abc123",
    }]
)
    • ›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.
    +6 moreshow less
    • ›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.
  11. 0.11.5 Aug 26, 2025 · issue -355

    Letta 0.11.5 adds background mode for message streaming.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.11.5 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.11.5
    • ›Adds background mode for message streaming, enabling stream consumption without blocking the caller.
  12. 0.11.4 Aug 20, 2025 · issue -361

    Letta 0.11.4 adds step metrics recording and asyncio stream-timeout protection.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.11.4 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.11.4
    • ›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 ON UPGRADE
    • !Legacy provider paths for Azure and Together AI are deprecated and may break configurations that relied on those routes.
  13. 0.11.2 Aug 8, 2025 · issue -363

    Letta 0.11.2 adds max_steps parameter to agent export for step-capped runs.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.11.2 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.11.2
    • ›Adds max_steps parameter to the agent export API, enabling callers to cap the number of steps an exported agent will execute.
  14. 0.11.1 Aug 8, 2025 · issue -363

    Letta 0.11.1 adds Claude Opus 4.1 and GPT-5 support, a new minimal reasoning effort option, and paginated file grep.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.11.1 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.11.1
    └──▷ USE IT
    Cap reasoning cost when running a high-volume agent by setting reasoning_effort to minimal in LLMConfig.
    python 
    from letta import LLMConfig

config = LLMConfig(
    model="gpt-5",
    reasoning_effort="minimal"
)
    • ›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.
  15. 0.11.0 Aug 7, 2025 · issue -363

    Letta 0.11.0 adds SigNoz OTEL trace export and a filesystem demo with file upload and streaming.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.11.0 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.11.0
    └──▷ TRY IT
    Export OTEL traces to SigNoz when self-hosting Letta via Docker, enabling observability into agent execution traces.
    $ docker run \
  -v ~/.letta/.persist/pgdata:/var/lib/postgresql/data \
  -p 8283:8283 \
  -e SIGNOZ_ENDPOINT=${SIGNOZ_ENDPOINT} \
  -e SIGNOZ_INGESTION_KEY=${SIGNOZ_INGESTION_KEY} \
  -e LETTA_OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317 \
  letta/letta:latest
    • ›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 ON UPGRADE
    • !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.
  16. 0.10.0 Aug 1, 2025 · issue -363

    Letta 0.10.0 adds LettaPing keepalives for long streaming connections, MCP OAuth support, and a new default agent architecture.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.10.0 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.10.0
    • ›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.
    +2 moreshow less
    • ›Adds modal sandbox functionality with conditional imports.
    • ›Moves Ollama integration to the new agent loop architecture.
    └──▷ BREAKING ON UPGRADE
    • !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.
  17. 0.9.0 Jul 24, 2025 · issue -364

    Letta 0.9.0 introduces Letta Filesystem for folder/file-based document context management with OCR options.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.9.0 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.9.0
    └──▷ USE IT
    Upload a PDF into a folder so an agent can open and reference it within its context window.
    python 
    job = client.folders.files.upload(
    folder_id=folder.id,
    file=open("my_file.txt", "rb")
)

while True:
    job = client.jobs.retrieve(job.id)
    if job.status == "completed":
        break
    elif job.status == "failed":
        raise ValueError(f"Job failed: {job.metadata}")
    time.sleep(1)
    • ›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.
  18. 0.8.9 Jul 3, 2025 · issue -364

    Letta 0.8.9 adds multi-provider summarization, agent loop cancellation, and MCP custom headers

    └──▷ GET THIS VERSION
    $ git clone --branch 0.8.9 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.8.9
    • ›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.
  19. 0.8.8 Jun 29, 2025 · issue -365

    Letta 0.8.8 adds Feedback APIs for rating agent steps positive or negative.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.8.8 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.8.8
    • ›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).
  20. 0.7.29 Jun 1, 2025 · issue -365

    Letta 0.7.29 adds configurable batch size and lookback for batch operations.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.7.29 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.7.29
    • ›Adds configurable batch size and lookback parameters to batch processing.
  21. 0.7.20 May 17, 2025 · issue -366

    Letta 0.7.20 adds Node.js support to enable node-based MCP integrations.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.7.20 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.7.20
    • ›Bundles Node.js into the runtime environment to support node-based MCP (Model Context Protocol) servers.
  22. 0.7.5 Apr 25, 2025 · issue -367

    Letta 0.7.5 adds count endpoints for agents, identities, sources, and tools.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.7.5 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.7.5
    • ›Adds API endpoints to retrieve counts of agents, identities, sources, and tools.
  23. 0.7.1 Apr 23, 2025 · issue -367

    Letta 0.7.1 adds a database Docker Compose file and reasoning token support for Gemini Flash.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.7.1 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.7.1
    • ›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.
  24. 0.6.46 Mar 30, 2025 · issue -368

    Letta 0.6.46 lets conversation search find messages sent by the agent itself.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.46 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.46
    • ›Conversation search now finds an agent's own messages, not just user messages.
  25. 0.6.41 Mar 14, 2025 · issue -368

    Letta 0.6.41 bakes the OpenTelemetry collector into the Letta container image.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.41 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.41
    • ›Bundles the OpenTelemetry (OTEL) collector directly into the Letta Docker image, enabling telemetry collection without a separate sidecar or external collector deployment.
  26. 0.6.39 Mar 13, 2025 · issue -368

    Letta 0.6.39 adds MCP (Model Context Protocol) support and latest Anthropic model tags.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.39 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.39
    • ›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.
  27. 0.6.33 Feb 26, 2025 · issue -369

    Letta 0.6.33 adds partial support for claude-3-7-sonnet-20250219 and complex type resolution in schema generation.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.33 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.33
    • ›Adds partial support for claude-3-7-sonnet-20250219 as a usable model.
    • ›Adds type resolution support for complex types in schema generation.
  28. 0.6.29 Feb 21, 2025 · issue -369

    Letta 0.6.29 adds user identities support with a user ID header on the identities GET request.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.29 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.29
    • ›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.
  29. 0.6.28 Feb 20, 2025 · issue -369

    Letta 0.6.28 adds AWS Bedrock and DeepSeek as new LLM providers and maps context length for gpt-4o-mini.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.28 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.28
    • ›Adds AWS Bedrock and DeepSeek as supported LLM providers.
    • ›Adds model-to-context-length mapping for gpt-4o-mini.
  30. 0.6.26 Feb 14, 2025 · issue -369

    Letta 0.6.26 adds a tool-rules example notebook and patches Google Vertex support.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.26 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.26
    • ›Adds an example notebook demonstrating tool rules configuration.
  31. 0.6.23 Feb 6, 2025 · issue -369

    Letta 0.6.23 adds configuration settings for multi-agent setups.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.23 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.23
    • ›Adds new settings to support multi-agent configuration in Letta.
  32. 0.6.22 Feb 5, 2025 · issue -369

    Letta 0.6.22 refactors multi-agent support with API changes.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.22 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.22
    • ›Refactors multi-agent internals and introduces associated API changes.
  33. 0.6.9 Jan 11, 2025 · issue -370

    Letta 0.6.9 adds tag-matching, new types, and improved provider integration in the client.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.9 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.9
    • ›Adds support for matching all tags when querying agents via the client.
    • ›Introduces new types and updates Tool schemas with improved provider integration.
  34. 0.6.8 Jan 9, 2025 · issue -370

    Letta 0.6.8 adds provider persistence so configured providers survive restarts.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.8 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.8
    • ›Adds provider persistence so that configured LLM/embedding providers are saved and restored across server restarts.
  35. 0.6.7 Dec 31, 2024 · issue -371

    Letta 0.6.7 adds error codes to Composio errors, a template ID field for agent creation, and message type literals to usage stats.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.7 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.7
    • ›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.
  36. 0.6.6 Dec 20, 2024 · issue -371

    Letta 0.6.6 adds ConditionalToolRules, two new error types, non-pro model support, and SDK renames for tools and inner monologue.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.6 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.6
    • ›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).
    +1 moreshow less
    • ›Extends model support to non-pro model tiers.
    └──▷ BREAKING ON UPGRADE
    • !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.
  37. 0.6.5 Dec 18, 2024 · issue -371

    Letta 0.6.5 adds tool call stdout/stderr logs in FunctionResponse and simplifies agent creation with <provider>/<model> shorthand.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.5 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.5
    └──▷ TRY IT
    Create an agent using the new shorthand llm and embedding fields with a capped context window and per-block memory limits.
    $ curl --request POST \
  --url http://localhost:8283/v1/agents/ \
  --header 'Content-Type: application/json' \
  --data '{
    "memory_blocks": [
      {"value": "Name: Sarah", "limit": 5000, "label": "human"},
      {"value": "I am a helpful assistant", "label": "persona"}
    ],
    "llm": "anthropic/claude-3-5-sonnet-20241022",
    "embedding": "openai/text-embedding-ada-002",
    "context_window_limit": 15000
  }'
    • ›Simplifies agent creation via POST /v1/agents/ by accepting llm and embedding fields in <provider>/<model> 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.
    +1 moreshow less
    • ›Separates Passages into distinct database tables.
  38. 0.6.3 Dec 11, 2024 · issue -371

    Letta 0.6.3 adds Python 3.13 support, local HTTPS mode, file support, and a simplified agent-creation REST API.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.3 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.3
    └──▷ TRY IT
    Create an agent with minimal fields now that tools and agent type default automatically.
    $ curl --request POST \
  --url http://localhost:8283/v1/agents/ \
  --header 'Content-Type: application/json' \
  --data '{
  "memory_blocks": [
    {"value": "The human name is Bob the Builder", "label": "human"},
    {"label": "persona", "value": "My name is Sam, the all-knowing sentient AI."}
  ],
  "llm_config": {
    "model": "gpt-4o-mini",
    "model_endpoint_type": "openai",
    "model_endpoint": "https://api.openai.com/v1",
    "context_window": 16000
  },
  "embedding_config": {
    "embedding_endpoint_type": "openai",
    "embedding_endpoint": "https://api.openai.com/v1",
    "embedding_model": "text-embedding-3-small",
    "embedding_dim": 8191
  }
}'
    • ›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.
  39. 0.6.2 Dec 10, 2024 · issue -371

    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.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.2 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.2
    └──▷ TRY IT
    Run the full Letta service locally with persisted storage and an OpenAI key, no docker-compose required.
    $ docker run \
  -v ~/.letta/.persist/pgdata:/var/lib/postgresql/data \
  -p 8283:8283 \
  -e OPENAI_API_KEY="your_api_key" \
  letta/letta
    • ›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.
  40. 0.6.1 Dec 5, 2024 · issue -371

    Letta 0.6.1 adds external codebase sandboxes for tool execution and improved venv error surfacing.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.1 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.1
    • ›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.
  41. 0.6.0 Dec 4, 2024 · issue -371

    Letta 0.6.0 adds E2B tool sandboxing, ADE server password protection, Composio sandbox support, and new memory-block and tool-test APIs.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.6.0 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.6.0
    └──▷ TRY IT
    Run tool execution in an isolated E2B cloud sandbox instead of the local process — useful when tools run untrusted or side-effectful code.
    $ export E2B_API_KEY=your_e2b_key
export E2B_SANDBOX_TEMPLATE_ID=your_template_id
letta server
    Password-protect your local Letta server so it can still be reached by the ADE without exposing an unauthenticated endpoint.
    $ export LETTA_SERVER_PASSWORD=password
letta server --ade --secure --port=8283
    • ›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.
    +5 moreshow less
    • ›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 ON UPGRADE
    • !The POST /v1/tools (create_tool) endpoint on v1 routes now errors on duplicate tools instead of upserting.
  42. 0.5.4 Nov 21, 2024 · issue -372

    Letta 0.5.4 adds tag support to client.create_agent() for labeling agents at creation time.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.5.4 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.5.4
    └──▷ USE IT
    Label a new agent with environment and role tags so it can be filtered or grouped later.
    python 
    agent = client.create_agent(tags=["production", "customer-support"])
    • ›Adds tags parameter to client.create_agent(tags=[..]) to attach labels to agents at creation time.
  43. 0.5.3 Nov 20, 2024 · issue -372

    Letta 0.5.3 adds a CLI token counter, Together AI support, and password-protected server endpoints.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.5.3 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.5.3
    └──▷ TRY IT
    Lock down a self-hosted Letta server so unauthenticated clients cannot reach its endpoints.
    $ letta server --secure
    Check current token usage mid-session in the Letta CLI to avoid context-window overflows before sending a large request.
    $ /tokens
    • ›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 ON UPGRADE
    • !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.
  44. 0.5.2 Nov 7, 2024 · issue -372

    Letta 0.5.2 adds agent tags for user association, tool rules to constrain agent execution order, and agent listing by name.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.5.2 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.5.2
    └──▷ USE IT
    Associate an agent with a specific end user at creation time and retrieve all agents for that user later.
    python 
    # Create an agent tagged with a user ID
agent = client.create_agent(tags=["user_abc123"])

# Retrieve all agents for that user
agents = client.get_agents(tags=["user_abc123"])
    • ›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).
    +2 moreshow less
    • ›Adds HTML rendering of messages into LettaResponse.
    • ›Adds endpoint to add base tools to an organization.
    └──▷ BREAKING ON UPGRADE
    • !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.
  45. 0.5.1 Oct 23, 2024 · issue -373

    Letta 0.5.1 adds Composio/CrewAI/LangChain tool auto-loading, multi-agent swarm support, and new context-window and tool APIs.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.5.1 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.5.1
    └──▷ TRY IT
    Auto-load Composio tools on server startup so agents can use them without manual registration.
    $ export LETTA_LOAD_DEFAULT_EXTERNAL_TOOLS=true
export COMPOSIO_API_KEY=<your_key>
pip install 'letta[external-tools,server]'
letta server
    • ›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.
    +4 moreshow less
    • ›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 ON UPGRADE
    • !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.
  46. 0.5.0 Oct 15, 2024 · issue -373

    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.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.5.0 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.5.0
    └──▷ TRY IT
    Run a Letta server with multiple providers active simultaneously, so agents can use any available model without restarting.
    $ export OPENAI_API_KEY=sk-...
export ANTHROPIC_API_KEY=sk-ant-...
export OLLAMA_BASE_URL=http://localhost:11434
letta server
    • ›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.
    +6 moreshow less
    • ›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 ON UPGRADE
    • !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.
  47. 0.4.1 Oct 4, 2024 · issue -373

    Letta 0.4.1 adds Composio, LangChain, and CrewAI tool integrations, source detachment, org endpoints, and a health-check route.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.4.1 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.4.1
    └──▷ TRY IT
    Install external tool support and use a LangChain or CrewAI tool with a Letta agent on the same day.
    $ pip install 'letta[external-tools]'
    • ›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.
    +4 moreshow less
    • ›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.
  48. 0.3.24 Aug 17, 2024 · issue -375

    Letta 0.3.24 ships an updated alpha revision of the developer portal.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.24 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.24
    • ›Updates the developer portal to the latest alpha revision.
  49. 0.3.22 Aug 1, 2024 · issue -375

    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.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.22 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.22
    └──▷ TRY IT
    Allow a long custom persona file to load without hitting the default core memory limit.
    $ memgpt run --core-memory-limit 6000 --persona <persona_name>
    • ›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.
  50. 0.3.21 Jul 26, 2024 · issue -376

    Agent creation API now accepts an optional system prompt, and parallel tool calling can be disabled.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.21 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.21
    • ›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.
  51. 0.3.20 Jul 25, 2024 · issue -376

    Letta 0.3.20 adds character limits for persona/human to /config response and fixes inner thoughts for gpt-4o models.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.20 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.20
    • ›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.
  52. 0.3.19 Jul 14, 2024 · issue -376

    Letta 0.3.19 adds customizable memory classes via BaseMemory and unifies tools/memory in the agent creation API.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.19 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.19
    • ›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 ON UPGRADE
    • !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.
  53. 0.3.18 Jun 27, 2024 · issue -377

    Letta 0.3.18 adds Python-side tool creation, usage statistics on message responses, Qdrant storage, token streaming, and cursor-paginated admin users API.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.18 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.18
    └──▷ USE IT
    Register a custom Python function as an agent tool and wire it into a new agent in one script.
    python 
    def print_tool(message: str):
    """
    Args:
        message (str): The message to print.
    Returns:
        str: The message that was printed.
    """
    print(message)
    return message

tool = client.create_tool(print_tool, tags=['extras'])
agent_state = client.create_agent(tools=[tool.name])
    • ›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.
    +2 moreshow less
    • ›Expands tool-calling support in LocalClient.
    • ›Migrates the memgpt list, memgpt add, and memgpt delete CLI subcommands to run on the MemGPT client.
  54. 0.3.17 Jun 5, 2024 · issue -377

    Letta 0.3.17 adds Ollama embeddings API support for fully local embedding workflows.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.17 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.17
    • ›Adds support for the Ollama embeddings API endpoint, enabling fully local embedding generation without an OpenAI dependency.
  55. 0.3.16 May 26, 2024 · issue -378

    Letta 0.3.16 adds Milvus as a vector database backend and enables JSON response format for all OpenAI calls.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.16 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.16
    • ›Adds Milvus storage connector, allowing Milvus to back the Letta vector database for agent memory.
    • ›Enables JSON response format for all OpenAI API calls.
  56. 0.3.15 May 16, 2024 · issue -378

    Letta 0.3.15 adds Llama 3 support and expanded tool functionality for the Python client.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.15 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.15
    • ›Adds Llama 3 model support for local LLM inference.
    • ›Expands tool functionality available in the Python client.
  57. 0.3.13 May 1, 2024 · issue -378

    Letta 0.3.13 ships an alpha MemGPT Dev Portal accessible at memgpt.localhost (Docker) or localhost:8283 (CLI).

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.13 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.13
    └──▷ TRY IT
    Spin up the full MemGPT service stack locally and open the dev portal in your browser — no config file editing required.
    $ memgpt quickstart --backend openai && memgpt server
    Run the MemGPT service with Docker Compose and reach the dev portal at the memgpt.localhost hostname.
    $ git clone [email protected]:cpacker/MemGPT.git && cd MemGPT && docker compose up
    • ›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.
  58. 0.3.12 Apr 23, 2024 · issue -379

    Letta 0.3.12 overhauls Docker Compose setup with a reverse proxy, dev portal, and background file-upload processing.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.12 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.12
    └──▷ TRY IT
    Spin up a local Letta service with the dev portal accessible at http://memgpt.localhost.
    $ docker compose up
    Iterate on local code changes inside Docker without rebuilding the production image.
    $ docker compose -f dev-compose.yaml up --build
    • ›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.
    +1 moreshow less
    • ›Enforces unique tool names server-side, disallowing creation of tools with a duplicate name.
  59. 0.3.11 Apr 19, 2024 · issue -379

    Letta 0.3.11 adds CLI streaming support for OpenAI and OpenAI-compatible endpoints via memgpt run --stream

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.11 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.11
    └──▷ TRY IT
    Get real-time streamed responses in the CLI instead of waiting for the full reply — useful for long agent outputs or latency-sensitive workflows.
    $ memgpt run --stream
    • ›Adds --stream flag to memgpt run to enable streaming output in the CLI when using OpenAI or OpenAI-compatible (proxy) endpoints.
  60. 0.3.10 Apr 13, 2024 · issue -379

    Letta 0.3.10 adds support for Anthropic Claude, Cohere Command-R+, and Groq LLM APIs.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.10 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.10
    • ›Adds Anthropic Claude API support as a new LLM backend.
    • ›Adds Cohere API support, including the Command-R+ model.
  61. 0.3.9 Apr 11, 2024 · issue -379

    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.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.9 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.9
    └──▷ TRY IT
    Configure MemGPT to use Google AI Gemini Pro as the default LLM provider instead of OpenAI.
    $ memgpt configure
# When prompted:
# Select LLM inference provider: google_ai
# Enter your Google AI (Gemini) API key: <your-api-key>
# Enter your Google AI (Gemini) service endpoint: generativelanguage
# Select default model: gemini-pro
    • ›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.
  62. 0.3.8 Apr 3, 2024 · issue -379

    Letta 0.3.8 adds Docker Compose server support, Groq integration, and richer source metadata.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.8 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.8
    └──▷ TRY IT
    Stand up a full MemGPT server backed by PostgreSQL without any manual setup.
    $ docker compose up
    • ›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.
  63. 0.3.7 Mar 21, 2024 · issue -380

    Letta 0.3.7 adds in-context message flags, cursor-based retrieval, tool selection at agent creation, Preset routes, and expanded Python client coverage.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.7 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.7
    • ›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.
    +5 moreshow less
    • ›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.
  64. 0.3.6 Mar 11, 2024 · issue -380

    Letta 0.3.6 expands the REST API with archival memory, data sources, and message UUIDs in SSE streaming.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.6 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.6
    └──▷ TRY IT
    Retrieve all archival memory entries for a specific agent over the REST API.
    $ curl -X GET 'http://localhost:8283/api/agents/{agent_id}/archival' -H 'Authorization: Bearer <api_key>'
    • ›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.
    +4 moreshow less
    • ›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 ON UPGRADE
    • !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.
  65. 0.3.5 Mar 6, 2024 · issue -380

    Letta 0.3.5 adds REST endpoints for agents, humans, personas, LLM config, and tools listing.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.5 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.5
    • ›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 ON UPGRADE
    • !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.
  66. 0.3.4 Mar 1, 2024 · issue -380

    Letta 0.3.4 adds RESTClient and Admin Python clients, HTTPS support for the server, and a Dockerfile for self-hosted deployments.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.4 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.4
    • ›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.
    +2 moreshow less
    • ›Adds data loading and attaching functionality to the server.
    • ›Refactors loading and attaching data sources, upgrading to llama-index==0.10.6.
  67. 0.3.3 Feb 19, 2024 · issue -381

    Letta 0.3.3 adds OpenAI-compatible Assistant API endpoints, API key auth, and admin route password protection to memgpt server.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3.3 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3.3
    • ›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.
  68. 0.3 Jan 30, 2024 · issue -382

    Letta 0.3 moves all agent and user state into database storage and adds a hosted multi-user server mode.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.3 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.3
    └──▷ TRY IT
    Preserve access to pre-0.3 agents and data sources by migrating them into the new database storage before doing anything else.
    $ memgpt migrate
    Spin up a local multi-user Letta server that exposes a REST API (with generated OpenAPI spec) for integrating agents into downstream applications.
    $ memgpt server
    • ›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 ON UPGRADE
    • !Existing agents and data sources in ~/.memgpt/config are inaccessible after upgrading to 0.3 until migrated with memgpt migrate.
  69. 0.2.11 Jan 3, 2024 · issue -382

    Letta 0.2.11 adds a new MemGPT Python client class for programmatically creating and messaging agents, plus a chatml-noforce-roles wrapper.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.2.11 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.2.11
    • ›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.
  70. 0.2.10 Dec 25, 2023 · issue -383

    Letta 0.2.10 adds two new model wrappers for local LLMs to boost agent proactiveness via chatml-hints and chatml-noforce-hints.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.2.10 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.2.10
    └──▷ TRY IT
    Run a MemGPT agent with the new hint wrapper to get more proactive responses from a local LLM.
    $ memgpt run --model-wrapper 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.
  71. 0.2.8 Dec 22, 2023 · issue -383

    Letta 0.2.8 adds free hosted LLM endpoints, memgpt quickstart, memgpt server, memgpt folder, /summarize, and a REST API.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.2.8 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.2.8
    └──▷ TRY IT
    Configure MemGPT instantly using the free hosted Mixtral endpoint — no API key needed.
    $ memgpt quickstart --latest
    Configure MemGPT to use OpenAI as the backend with a single command.
    $ memgpt quickstart --latest --backend openai
    Start the MemGPT REST API server to expose agent interactions over HTTP.
    $ memgpt server
    • ›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.
    +5 moreshow less
    • ›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.
  72. 0.2.7 Dec 11, 2023 · issue -383

    Letta 0.2.7 adds Chroma vector storage integration and bundles lancedb and chroma as default dependencies.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.2.7 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.2.7
    • ›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.
  73. 0.2.5 Dec 2, 2023 · issue -383

    Letta 0.2.5 adds HuggingFace TEI embedding support and vLLM integration, while removing legacy python main.py and BACKEND_TYPE configuration.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.2.5 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.2.5
    • ›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 ON UPGRADE
    • !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.
  74. 0.2.4 Nov 23, 2023 · issue -384

    Letta 0.2.4 adds custom presets, LanceDB archival storage, and vLLM OpenAI-compatible endpoint support.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.2.4 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.2.4
    • ›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.
  75. 0.2.3 Nov 15, 2023 · issue -384

    Letta 0.2.3 adds configurable presets, a WebSocket server interface, and version-tracked agent configs.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.2.3 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.2.3
    └──▷ TRY IT
    Re-initialise your local config after upgrading so the new memgpt_version field and endpoint keys are written correctly.
    $ memgpt configure
    • ›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 ON UPGRADE
    • !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.
  76. 0.2.0 Nov 10, 2023 · issue -384

    Letta 0.2.0 adds pgvector archival memory, Ollama support, grammar-based sampling, file I/O, and new CLI commands.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.2.0 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.2.0
    └──▷ TRY IT
    Check which version of Letta is installed after upgrading, useful in CI or multi-environment setups.
    $ memgpt version
    Start a fresh agent session with a specific persona and model without being prompted to reuse an existing agent.
    $ memgpt run --persona sam --human user --model gpt-4-turbo
    • ›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.
    +8 moreshow less
    • ›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 ON UPGRADE
    • !Removes requirements.txt and requirements_local.txt; dependency management is now handled exclusively via Poetry.
  77. 0.1.12 Oct 31, 2023 · issue -385

    Letta 0.1.12 adds AutoGen integration, LM Studio inference support, Llama Index archival connectors, and a synchronous agent API.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.1.12 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.1.12
    • ›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.
    +2 moreshow less
    • ›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.
  78. 0.1.6 Oct 26, 2023 · issue -385

    Letta 0.1.6 adds local LLM support, Azure, AutoGen integration, CSV/PDF preloading, and on-the-fly embedding generation.

    └──▷ GET THIS VERSION
    $ git clone --branch 0.1.6 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.1.6
    • ›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.
    +8 moreshow less
    • ›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.
my-toolchain — 0 tools
paste an install list to detect your tools

A brew list, a Brewfile, requirements.txt, a Dockerfile — or just the product names, free-form. Nothing leaves your browser.

    browse all tools →