afrom letta import Client, Agent, Tool
client = Client(api_key=os.environ.
## Using Letta ADE (No-Code/Low-Code Path)
If you prefer visual prototyping, the ADE lets you compose agents, memory, and tools without writing code.
- Start a new agent project in ADE.
- Define the agent’s role (system prompt), tone, boundaries.
- Configure memory persistence and retrieval strategies.
- Add tools by selecting from connectors or defining custom actions.
- Test conversations inline, observe memory writes, adjust thresholds.
- Export or handoff to developers once your prototype behaves correctly.
See the ADE announcement and tutorial for a walkthrough and a quick intro video.
## Designing Great Letta Agents: Opinionated Best Practices
1) Start with the job-to-be-done
- Define a narrow scope (e.g., “triage support tickets for web errors”), not a vague generalist.
2) Encode operating procedures
- Put your SOPs into the system prompt. Example: “When triage suggests production impact, escalate and set priority=high. Always include reproduction steps if available.”
3) Make tool schemas strict
- Enforce enums and required fields. This reduces hallucinated parameters.
4) Treat memory like a product surface
- Decide what should be memorable (contacts, preferences, prior resolutions) and what should be ephemeral (one-off calculations). Inspect memory traces regularly.
5) Test with real data
- Seed the agent with anonymized tickets, docs, and examples. Observe failure modes (missing context, wrong priority) and refine prompts/tools.
6) Guardrails > after-the-fact cleanup
- Add validation in tools. If the agent proposes invalid inputs, your handler should catch and respond with guidance.
7) Instrument everything
- Log tool calls, memory writes, and message-level telemetry. Create dashboards for key metrics (success rate, time-to-resolution).
8) Version your agents
- Track changes to prompts, tools, and memory policies. Pin known-good versions for production, iterate in staging.
## Common Workflows You Can Ship with Letta
- Customer Support
- Summarize threads, propose resolution, create tickets, notify stakeholders.
- Research Assistant
- Plan queries, search sources, synthesize, store source notes in memory.
- Sales/CS Ops
- Parse call notes, extract next steps, update CRM via tools, follow up with templated emails.
- Internal Automation
- Monitor queues, trigger runbooks, file status updates, and keep context across shifts.
## Troubleshooting: When Things Don’t Behave
- The agent forgets things
- Verify memory is enabled and the retrieval thresholds are appropriate. Check if your items are actually being persisted.
- Tool calls are malformed
- Tighten schemas, add enums, and return structured errors with corrective hints.
- Agent is too verbose or too brief
- Adjust the system prompt style guide and provide 2–3 inline examples.
- Conflicting instructions
- Consolidate your operating rules. Use explicit priorities: “Always do X before Y.”
- Drift after updates
- Version-lock in production. Roll out changes with canaries.
## Security and Compliance Quick Notes
- Treat tools as trusted code paths—authenticate and scope them.
- Redact sensitive data before logging memory traces.
- Consider PII in memory: retention policies, access controls, encryption.
## From Prototype to Production: A Short Checklist
- Clear OKRs for the agent (what is success?).
- Narrow scope and SOP-driven system prompt.
- Strict tool schemas with validation and tests.
- Memory strategy documented and validated with real tasks.
- Observability (logs, metrics, alerts) wired up.
- Versioning and rollback plan.
- Staging and production environments separated.
## Extra Learning Resources
- Intro video: create your first persistent agent.
- Quickstart (Python/TS) with code snippets.
- Agent architecture and best practices.
- ADE announcement and walkthrough.
- Package rename and compatibility notes.
- Open-source repo and background.
## By the way: Faster iteration with [Sider.AI](https://sider.ai)
If you’re documenting prompts, testing examples, or comparing outputs across agent versions, it’s handy to keep artifacts side-by-side and iterate quickly. Worth noting, [Sider.AI](https://sider.ai) (https://sider.ai/) can help teams capture prompts, notes, and diffs while you build and test agents—useful when multiple people are refining an SOP or evaluating tool schemas.
## Key Takeaways
- Letta helps you build stateful agents with memory, tools, and persistent state.
- Start with a narrow job-to-be-done and strict schemas for stability.
- Use the SDK for code-first workflows or ADE for visual prototyping.
- Instrument, version, and test with real data before going live.
- Leverage the official quickstart and agent guides to stay aligned with best practices.
### FAQ
Q1:What is Letta and how is it different from a regular chatbot?
Letta is a platform for building stateful AI agents with persistent memory and tool orchestration, not just a stateless chat wrapper. It stores agent state, enforces tool schemas, and lets you manage memory and workflows across sessions.
Q2:How do I get started using Letta quickly?
Follow the developer quickstart for Python or TypeScript to create your first agent and add tools. If you prefer a visual path, use the ADE to configure memory, prompts, and tools before exporting your setup.
Q3:Can Letta remember user preferences and past tasks?
Yes. Letta supports persistent memory so agents can store preferences, decisions, and outcomes, then retrieve them contextually in future interactions. Configure memory policies and validate with real tasks.
Q4:How do tools work in Letta agents?
You register functions with strict input schemas so the agent can call them reliably. Add validation, use enums, and return structured errors to guide corrective behavior when inputs are off.
Q5:Is Letta the same as MemGPT?
Letta builds on the MemGPT research and ecosystem but is the current platform and package you should use. The package rename notes and open repo explain the transition and updated APIs.