Letta
The MemGPT agent server - agents live server-side with self-editing persistent memory.
One-click deploy, from $25/mo on a Miget plan.
MemGPT introduced the idea that stuck: agents managing their own memory - editing what they know, paging context in and out. Letta is that research grown into an agent server: agents are server-side entities with persistent, self-editing memory, and your apps converse with them over a REST API.
This template runs the pinned server image on a pgvector Postgres (required), behind an SSE-friendly proxy with password auth. The hosted ADE (Letta’s agent development environment) connects to your server over HTTPS for visual agent building.
The experimental badge is earned honestly: upstream states the Docker image is no longer their primary supported surface (their push is Letta Cloud at $20/month+). It works today, the image is pinned, and the page says exactly this - because finding out from a changelog is worse.
Upstream project: Letta (MemGPT)
#what you get
- Server-side agents with self-editing persistent memory
- REST API: create agents, converse, inspect memory
- Hosted ADE connects to your server for visual building
- pgvector Postgres handled in-template
- Password-protected, SSE-streaming proxy
- Apache-2.0, pinned image (0.16.8)
#topology
| Service | Role | Public |
|---|---|---|
| letta | agent server API (:8283, no port env) | no |
| web | nginx :5000 -> letta (SSE-friendly) | yes (password) |
| db | Postgres + pgvector (required) | no |
#miget sizing
// this stack needs
2.5 GiB RAM · 10 GB disk · 3 services
The server orchestrates; models run at your providers. Pin discipline matters here - read upstream notes before bumping the image.
Hobby - recommended fit
$25/mo
2 vCPU · 4 GiB · 80 GiB disk
Headroom for your own apps: 8 GiB at $49/mo
Professional - production
$43/mo
2 vCPU · 4 GiB · 25 GiB disk
Dedicated resources, production SLOs - plan details
One Miget plan is a fixed pool of compute - the whole stack (managed databases included) deploys inside it, and anything left over runs your other apps. No per-service or per-seat math.
#vs. the managed service
What the hosted equivalents charge, against the flat Miget plan this stack fits on. Prices as of June 2026, sources linked.
| Service | Plan | Monthly | What you get |
|---|---|---|---|
| Letta on Miget ★ | 4 GiB plan | $25 | this whole stack, flat - no usage meters, and room left for your own apps |
| Letta Cloud | paid | ~$20 | from $20/mo + $0.10 per active agent + usage (free tier: 5k credits) |
#vs. other PaaS
Estimated monthly cost of running this exact stack (2.5 GiB RAM, 10 GB disk, 3 containers) elsewhere, from published June 2026 rates.
| Platform | Est. monthly | Notes |
|---|---|---|
| Miget ★ | $25 flat | compose stacks first-class: one deploy, dedicated vCPU, managed Postgres/Valkey, volumes and TLS all included in the plan |
| Heroku | ~$125 | no volumes; nothing between 1 GB ($50) and 2.5 GB ($250) dynos - 2 GB containers cost far more than shown |
| DO App Platform | ~$35 | no persistent volumes - stateful containers need managed DBs/Spaces (base $5 Spaces included here) |
| Render | ~$34 | per-service instances (0.5 GB $7, 2 GB $25) - every container is its own paid service |
| Railway | ~$27 | usage-based ($10/GB RAM-mo); vCPU billed separately at $20/vCPU-mo on top |
| Fly.io | ~$16 | cheapest sticker price - but burstable shared CPUs (1/16 core; dedicated vCPUs cost ~2-3×), no compose deploys (one app per container, manual wiring), managed DBs billed extra |
Estimates assume RAM fully allocated at published on-demand rates - and sticker price isn't the whole comparison: the cheaper rows buy burstable shared CPUs, per-service wiring instead of a compose deploy, and managed databases billed separately. Heroku and DO App Platform have no persistent volumes at all - stateful stacks like this one need workarounds there.
#deploy it
On Miget
- Create a Compose Stack in app.miget.com pointing at the templates repository
- Set the stack path to
letta -
Set the required variables:
LETTA_SERVER_PASSWORD, API bearer passwordOPENAI_API_KEY / ANTHROPIC_API_KEY, at least one provider (billed to you)
- Deploy. Miget layers
compose.miget.yaml(RAM, privacy, volumes, managed services) automatically
Locally first?
Every template is portable, vanilla Docker Compose - the Miget overrides are ignored locally:
git clone https://github.com/deployable-sh/stacks
cd miget-compose-templates/letta
docker compose up -dSame files, same behavior. The template README covers connection strings and scaling notes.
#faq
Letta or Cognee for memory?
Different layers: Letta IS the agent - server-side entities whose memory management is the product. Cognee is memory infrastructure your existing agents query. If you are building on the MemGPT model, Letta; if you are adding memory to agents you already have, Cognee.
Why experimental?
Upstream openly deprioritizes the self-host Docker surface in favor of Letta Cloud - the image still ships versioned releases, but support energy lives elsewhere. We pin 0.16.8, document it, and let you decide with eyes open.
How do I build agents visually?
Connect the hosted ADE (app.letta.com) to your server: HTTPS domain + your server password. Remote servers must be HTTPS, which the platform ingress provides. One upstream quirk: set the embedding model explicitly when creating agents on Docker deployments.
Ship Letta today
One compose stack, 2.5 GiB of RAM, from $25/month flat, and it runs on your laptop with the same files.