Letta Self-Hosting Guide 2026: MemGPT, Ollama, the V1 Catch

By AIFoss · 9 min read
lettamemgptagent-memoryollamaselfhostedai

TL;DR: Letta — the project formerly known as MemGPT, and still the best-known name in persistent agent memory — quietly retired its self-hostable V1 API server in 2026. The code that replaced it, letta-code, is Apache 2.0 and has a local mode, but it is a Cloud-first product: Letta Cloud is the default backend, and running everything on your own hardware against an Ollama-only stack is possible yet visibly under-supported. If you were planning “Letta + Ollama = private MemGPT,” read the catch below before you spend an evening on it.

Letta V1 server (Docker)letta-code local modeLetta Cloud
Status, Oct 2026Retired — lives on the archive branch, old tags still pullableActive, Apache 2.0Active, hosted
Installdocker run letta/letta:latest (port 8283)npm install -g @letta-ai/letta-code/login in the CLI
Ollama supportDocumented (OLLAMA_BASE_URL), with known bugsNot a documented first-class path; Ollama-only setups hit closed issuesn/a — models run on their side
Your data stays homeYesYesNo — memory, identity, conversations stored in Letta Cloud
Maintenance outlookNone — frozenFollows the Cloud product’s prioritiesVendor-managed

Honest take: Letta’s memory architecture is still the reference design — self-editing core memory plus searchable archival memory is what half the 2026 memory tools imitate. But the open-source project has pivoted from “memory server you host” to “agent product with a cloud account.” Self-host it today only if you accept you are on the less-travelled path; for a shared, inspectable memory store, OpenViking or a plain vector DB is currently the safer self-hosted bet.

MemGPT’s 2023 paper introduced the idea most agent-memory tools now copy: give the model a small “core memory” it can edit in-context, plus an “archival memory” it searches via embeddings when something falls out of the window. Letta is that idea productized. This guide covers what self-hosting Letta actually looks like in October 2026 — which is a different answer than it was in the spring.

Is Letta still open source in 2026?

Yes. The active repository is letta-ai/letta-code on GitHub, licensed Apache 2.0 (checked October 20, 2026), and the organization shows active development — last updated October 17, 2026. It contains the agent harness, the terminal UI, the App Server, chat channels (Slack, Telegram, Discord), and the runtime behind Letta’s desktop and web apps. There is no license trap here: Apache 2.0 applies, commercial self-hosted use included.

The structural change is what the original letta-ai/letta repository now says about itself: the current source lives in letta-code, and the archive branch contains the retired Letta V1 API server. Old tags and releases remain available for reproducibility, but the standalone memory server that most 2025-era “self-host MemGPT” tutorials describe is no longer the maintained product. The companion lettabot repo was archived on May 26, 2026, folded into Letta Code’s channels and schedules.

So the license is clean; the self-hosting story is what moved.

What happened to the Letta V1 server?

It was retired, and its Docker image is no longer a supported product surface. Through early 2026, the documented self-hosted deployment was the letta/letta:latest container: Agent Development Environment plus REST API on port 8283, SQLite by default, Postgres via LETTA_PG_URI, and model backends (OpenAI, Anthropic, vLLM, Ollama) wired up through environment variables:

docker run -d --name letta \
  -v ~/.letta/.persist/pgdata:/var/lib/postgresql/data \
  -p 8283:8283 \
  -e OLLAMA_BASE_URL="http://host.docker.internal:11434" \
  letta/letta:latest

On Linux, Letta’s docs recommended --network host with http://localhost:11434 instead of host.docker.internal. That container still starts today — the tags are frozen, not deleted — and if you have a working V1 deployment there is no forced migration. But “frozen” means security patches, model-provider fixes, and bug fixes have stopped. Letta’s own documentation now describes the Docker image as no longer actively maintained and points to the CLI and local mode instead.

For a self-hoster the practical reading is: don’t build anything new on the V1 container. Its known Ollama bugs (below) will never be fixed there.

How do you self-host Letta with letta-code today?

The supported path is the letta-code CLI with its local backend. Install and switch to local mode:

npm install -g @letta-ai/letta-code
# or: uv tool install letta / pipx install letta  (Python 3.9+)
letta backend local
letta

On first launch the CLI asks you to choose between signing in to Letta Cloud and running local; the choice persists, and --backend local forces it per-invocation. letta server starts the App Server so other machines (or the web UI) can reach your agents. Platform support is glibc Linux 2.28+ (x86-64/ARM64), macOS 14+, and Windows x64 — no Alpine/musl, no 32-bit, no Windows ARM64. Node is bundled, so the npm path has no separate Node version requirement.

Two defaults are worth knowing before you call this “self-hosted”:

  • Cloud is the default backend, and remote computers, secrets, and cross-device agent access all route through a Letta Cloud account (/login).
  • The bundled system prompts can be updated automatically from the Cloud side. Set LETTA_CODE_PRESERVE_CLOUD_SYSTEM_PROMPT=1 if you want your deployment’s behavior pinned.

Neither is sinister — it is the standard 2026 agent-product playbook — but it is a different posture from the V1 server, which was a self-contained service that happened to have a hosted option.

Does Letta actually work with Ollama?

Partially, and this is the catch for the privacy-first stack this site cares about. The V1 server documented Ollama as a backend, and for archival memory you also need a local embedding model — the documented pairing used ollama/mxbai-embed-large:

$ ollama pull mxbai-embed-large
pulling manifest
pulling 819c2adf5ce6... 100% ▕████████████████▏ 669 MB
verifying sha256 digest
writing manifest
success

A self-hosted Letta requires an explicit embedding model when creating agents (or a LETTA_DEFAULT_EMBEDDING_MODEL set server-side), because archival memory search is embedding-based. Budget roughly 1.3 GB VRAM for mxbai-embed-large on top of whatever your chat model needs — a 8B chat model plus embeddings fits comfortably on a 12 GB card; our sister site’s GPU buying guide covers the tiers.

The problem shows up when Ollama is your only provider. Issue #1101 on letta-code (opened February 23, 2026) documents a user running exactly the recommended stack — V1 server in Docker on port 8283, OLLAMA_BASE_URL set, models selected via /model — and every message failing with Unhandled LLM error: Invalid port: 'http:', while the server logs showed an OpenAI client being initialized despite Ollama being the sole configured provider. A maintainer acknowledged it was likely a server bug, suggested dropping the /v1 suffix from the base URL as an untested workaround, and clarified that /connect is for bring-your-own-key against hosted APIs, not for Ollama. The issue was closed as “not planned” on July 3, 2026, with no confirmed fix.

If you hit the same error today: first try OLLAMA_BASE_URL without any /v1 suffix (http://localhost:11434), and confirm Ollama is on its default port. If it persists, the realistic options are pinning an older V1 tag that predates the regression, or putting an OpenAI-compatible proxy in front of Ollama so Letta talks to what it expects — both workarounds, neither a fix, because the component they would fix is the one that was retired.

That closed-as-not-planned marker is the single most informative data point in this guide. It tells you where Ollama-only self-hosting sits in the project’s priorities.

When should you NOT use Letta?

Skip Letta if any of these describe you, as of October 2026:

  • You need everything local and supported. The combination “no cloud account, Ollama only, maintained code path” is exactly the corner the 2026 pivot left thin. Open WebUI with its built-in RAG, or AnythingLLM, gives you a duller but fully supported private stack.
  • You want a shared knowledge base, not per-agent memory. Letta’s model is agent-centric: each agent carries its own core and archival memory. For memory that multiple agents browse like a filesystem, OpenViking is the stronger design — mind its AGPL.
  • You are minimizing moving parts. A memory server is one more service to update, back up, and debug. Our maintenance-hours breakdown found each always-on stack component costs real monthly attention; add one only when plain RAG demonstrably fails you. The same logic as when not to self-host at all.

Letta remains the right call if you are building on Letta Cloud anyway and want Apache 2.0 code you can read, or if you are studying memory architectures — the self-editing core memory design is still the clearest implementation of the MemGPT paper there is.

FAQ

Is Letta the same thing as MemGPT? Yes. MemGPT was the 2023 research project and original name; the team renamed the platform Letta. The memory architecture — in-context core memory the agent edits itself, plus embedding-searched archival memory — carried over. In 2026 the active code lives in the letta-code repository under Apache 2.0.

Can I still run the old Letta V1 Docker server? Yes — letta/letta tags remain pullable and the code sits on the archive branch of letta-ai/letta “for reproducibility.” But it is retired: no maintenance, no fixes for its known Ollama URL-handling bug, and Letta’s docs no longer treat the image as a supported surface. Fine for an existing lab deployment, wrong for anything new.

Does Letta run fully offline with Ollama? The pieces exist — local backend, OLLAMA_BASE_URL, local embeddings via ollama pull mxbai-embed-large — but Ollama-only operation has an unresolved history: the “Invalid port” failure in letta-code issue #1101 was closed “not planned” in July 2026. Test your exact stack before committing; keep the base URL free of a /v1 suffix.

Sources

Was this article helpful?

What self-hosting actually costs

Real cost breakdowns for self-hosted AI: hardware floors, power, maintenance hours, and the honest comparison against paying for it. No spam, unsubscribe anytime.