- 
-
-
-Letta Desktop bundles the Letta server and ADE into a single local application. When running, it provides full access to the Letta API at `https://localhost:8283`.
-
-## Download Letta Desktop
-
-
-
-You can also edit the environment variable file directly, located at `~/.letta/env`.
-
-For this quickstart demo, we'll add an OpenAI API key (once we enter our key and **click confirm**, the Letta server will automatically restart):
-
-
-
-## Beta Status
-
-Letta Desktop is currently in **beta**. View known issues and FAQ [here](/guides/desktop/troubleshooting).
-
-For a more stable development experience, we recommend installing Letta via Docker.
-
-## Support
-
-For bug reports and feature requests, contact us on [Discord](https://discord.gg/letta).
diff --git a/fern/pages/ade-guide/overview.mdx b/fern/pages/ade-guide/overview.mdx
deleted file mode 100644
index dfa6fcc3..00000000
--- a/fern/pages/ade-guide/overview.mdx
+++ /dev/null
@@ -1,118 +0,0 @@
----
-title: Agent Development Environment (ADE)
-slug: guides/ade/overview
----
-
-
-
-
-## Why Use the ADE?
-
-The ADE bridges the gap between development and deployment, providing:
-
-- **Complete Transparency**: See exactly what your agent "sees," thinks, and does
-- **State Control**: Directly read and write to your agent's persistent memory
-- **Rapid Prototyping**: Create and test agents in a fraction of the time required with scripts
-- **Robust Debugging**: Identify and resolve issues by examining your agent's state in real-time
-- **Dynamic Management**: Add or modify tools, memory blocks, and data sources without recreating your agent
-- **Seamless Collaboration**: Share and iterate on agents by importing and exporting with [agent file (.af)](/guides/agents/agent-file), which can be used to checkpoint your agent's state
-
-## Core Components of the ADE
-
-The ADE is organized into three main panels, each focusing on different aspects of agent development:
-
-### 👾 Agent Simulator (Center Panel)
-
-The Agent Simulator is your primary interface for interacting with and testing your agent:
-
-- Chat directly with your agent to test its capabilities
-- Send system messages to simulate events and triggers
-- Monitor the agent's responses, tool usage, and reasoning in real-time
-
-[Learn more about the Agent Simulator →](/guides/ade/simulator)
-
-### ⚙️ Agent Configuration (Left Panel)
-
-The Agent Configuration panel allows you to customize every aspect of your agent:
-
-- **LLM (Model) Selection**: Choose from a variety of language models from providers like OpenAI, Anthropic, and more
-- **System Instructions**: Configure the high-level (read-only) directives that guide your agent's behavior
-- **Tools Management**: Add, remove, and configure the tools available to your agent
-- **Data Sources**: Connect your agent to external knowledge via documents, APIs, and databases
-- **Advanced Settings**: Configure your context window size, temperature, and other parameters
-
-### 🧠 Agent State Visualization (Right Panel)
-
-The State Visualization panel provides real-time insights into your agent's internal state:
-
-- **Context Window Viewer**: Examine exactly what information your agent is currently processing
-- **Core Memory Blocks**: View and edit the persistent knowledge your agent maintains
-- **Archival Memory**: Monitor and search your agent's external (out-of-context) memory store
-
-[Learn more about the Context Window Viewer →](/guides/ade/context-window-viewer)
-
-## Getting Started with the ADE
-
-### Connecting to Your Letta Server
-
-The ADE can connect to:
-
-1. A local Letta server running on your machine
-2. A remote Letta server deployed on your infrastructure
-3. [Letta Cloud](/guides/cloud/overview)
-
-For local development, the ADE automatically detects and connects to your local Letta server. For remote servers, you'll need to configure the connection settings in the ADE.
-
-[Learn how to connect the ADE to your server →](/guides/ade/setup)
-
-### Creating Your First Agent
-
-To create a new agent in the ADE:
-
-1. Click the "Create Agent" button in the agents list
-2. Configure basic settings (name, LLM provider, etc.)
-3. Customize the agent's memory blocks (personality, knowledge, etc.)
-4. Add tools to extend the agent's capabilities
-5. Start chatting with your agent to test its behavior
-
-### Customizing Your Agent
-
-The ADE makes it easy to iterate on your agent design:
-
-- **Adjust LLM Parameters**: Experiment with different base models
-- **Edit Memory Content**: Watch your agent edit its own memory, or manually edit its memory yourself
-- **Add Custom Tools**: Create and test Python tools that extend your agent's capabilities
-- **Connect Data Sources**: Import documents, websites, or other data to enhance your agent's knowledge
-
-## Next Steps
-
-Ready to start building with the ADE? Check out these resources:
-
-
-
-
-## Key Features
-
-### Conversation Visualization
-
-The simulator displays the complete event and conversation (or event) history of your agent, organized chronologically. Each message is color-coded and formatted according to its type for clear differentiation:
-
-- **User Messages**: Messages sent by you (the user) to the agent. These appear on the right side of the conversation view.
-- **Agent Messages**: Responses generated by the agent and directed to the user. These appear on the left side of the conversation view.
-- **System Messages**: Non-user messages that represent events or notifications, such as `[Alert] The user just logged on` or `[Notification] File upload completed`. These provide context about events happening in the environment.
-- **Function (Tool) Messages** : Detailed records of tool executions, including:
- - Tool calls made by the agent
- - Arguments passed to the tools
- - Results returned by the tools
- - Any errors encountered during execution
-
-If an error occurs during tool execution, the agent is given an opportunity to handle the error and continue execution by calling the tool again.
-The simulator supports real-time streaming of agent responses, allowing you to see the agent's thought process as it happens.
-
-
-
-
-## Managing Agent Tools
-
-### Viewing Current Tools
-
-The Tools panel displays all tools currently attached to your agent, showing both built-in Letta tool (which can be detached), as well as custom tools that you have created and attached to the agent.
-
-### Adding Tools
-
-Adding tools to your agent is a straightforward process:
-
-1. Click the "Add Tool" button in the Tools panel
-2. Browse the tool library or search for specific tools
-3. Select a tool to view its details
-4. Click "Add to Agent" to attach it
-
-The tool will immediately become available to your agent without requiring a restart or recreation of the agent.
-
-### Removing Tools
-
-To remove a tool from your agent:
-
-1. Locate the tool in the Tools panel
-2. Click the three-dot menu next to the tool
-3. Select "Remove Tool"
-
-The tool will be detached from your agent but remains in your tool library for future use.
-
-## Creating Custom Tools
-
-For more information on creating custom tools, see our main [tools documentation](/guides/agents/tools).
-
-
-
-
-
-## Connecting to a Remote Server
-
-For production environments or team collaboration, you may want to connect to a Letta server running on a remote machine:
-
-
-
-
-## Managing Server Connections
-
-The ADE allows you to manage multiple server connections:
-
-### Saving Server Connections
-
-Once you add a remote server, it will be saved in your browser's local storage for easy access in future sessions. To manage saved connections:
-
-1. Click on the server dropdown in the left panel
-2. Select "Manage servers" to view all saved connections
-3. Use the options to edit or remove servers from your list
-
-### Switching Between Servers
-
-You can easily switch between different Letta servers:
-
-1. Click on the current server name in the left panel
-2. Select a different server from the dropdown list
-3. The ADE will connect to the selected server and display its agents
-
-This flexibility allows you to work with development, staging, and production environments from a single ADE interface.
diff --git a/fern/pages/advanced/custom_memory.mdx b/fern/pages/advanced/custom_memory.mdx
deleted file mode 100644
index 9c859272..00000000
--- a/fern/pages/advanced/custom_memory.mdx
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: Creating custom memory classes
-subtitle: Learn how to create custom memory classes
-slug: guides/agents/custom-memory
----
-
-
-## Customizing in-context memory management
-
-We can extend both the `BaseMemory` and `ChatMemory` classes to implement custom in-context memory management for agents.
-For example, you can add an additional memory section to "human" and "persona" such as "organization".
-
-In this example, we'll show how to implement in-context memory management that treats memory as a task queue.
-We'll call this `TaskMemory` and extend the `ChatMemory` class so that we have both the original `ChatMemory` tools (`core_memory_replace` & `core_memory_append`) as well as the "human" and "persona" fields.
-
-We show an implementation of `TaskMemory` below:
-```python
-from letta.memory import ChatMemory, MemoryModule
-from typing import Optional, List
-
-class TaskMemory(ChatMemory):
-
- def __init__(self, human: str, persona: str, tasks: List[str]):
- super().__init__(human=human, persona=persona)
- self.memory["tasks"] = MemoryModule(limit=2000, value=tasks) # create an empty list
-
-
-
- def task_queue_push(self, task_description: str) -> Optional[str]:
- """
- Push to a task queue stored in core memory.
-
- Args:
- task_description (str): A description of the next task you must accomplish.
-
- Returns:
- Optional[str]: None is always returned as this function does not produce a response.
- """
- self.memory["tasks"].value.append(task_description)
- return None
-
- def task_queue_pop(self) -> Optional[str]:
- """
- Get the next task from the task queue
-
- Returns:
- Optional[str]: The description of the task popped from the queue,
- if there are still tasks in queue. Otherwise, returns None (the
- task queue is empty)
- """
- if len(self.memory["tasks"].value) == 0:
- return None
- task = self.memory["tasks"].value[0]
- self.memory["tasks"].value = self.memory["tasks"].value[1:]
- return task
-```
-
-To create an agent with this custom memory type, we can simply pass in an instance of `TaskMemory` into the agent creation.
-We also will modify the persona of the agent to explain how the "tasks" section of memory should be used:
-```python
-task_agent_state = client.create_agent(
- name="task_agent",
- memory=TaskMemory(
- human="My name is Sarah",
- persona="You have an additional section of core memory called `tasks`. " \
- + "This section of memory contains of list of tasks you must do." \
- + "Use the `task_queue_push` tool to write down tasks so you don't forget to do them." \
- + "If there are tasks in the task queue, you should call `task_queue_pop` to retrieve and remove them. " \
- + "Keep calling `task_queue_pop` until there are no more tasks in the queue. " \
- + "Do *not* call `send_message` until you have completed all tasks in your queue. " \
- + "If you call `task_queue_pop`, you must always do what the popped task specifies",
- tasks=["start calling yourself Bob", "tell me a haiku with my name"],
- )
-)
-```
diff --git a/fern/pages/advanced/memory_management.mdx b/fern/pages/advanced/memory_management.mdx
deleted file mode 100644
index d6fa46f4..00000000
--- a/fern/pages/advanced/memory_management.mdx
+++ /dev/null
@@ -1,101 +0,0 @@
----
-title: Understanding memory management
-subtitle: Understanding the concept of LLM memory management introduced in MemGPT
-slug: advanced/memory_management
----
-
-
-Letta uses the MemGPT memory management technique to control the context window of the LLM.
-
-The behavior of an agent is determine by two things: the underlying LLM model, and the context window that is passed to that model.
-Letta provides a framework for "programming" how the context is compiled at each reasoning step, a process which we refer to as memory management for agents.
-
-Unlike existing RAG-based frameworks for long-running memory, MemGPT provides a more flexible, powerful framework for memory management by enabling the agent to self-manage memory via tool calls.
-Essentially, the agent itself gets to decide what information to place into its context at any given time. We reserve a section of the context, which we call the in-context memory, which is agent as the ability to directly write to.
-In addition, the agent is given tools to access external storage (i.e. database tables) to enable a larger memory store.
-Combining tools to write to both its in-context and external memory, as well as tools to search external memory and place results into the LLM context, is what allows MemGPT agents to perform memory management.
-
-## In-context memory
-
-The in-context memory is a section of the LLM context window that is reserved to be editable by the agent.
-You can think of this like a system prompt, except the system prompt it editable (MemGPT also has an actual system prompt which is not editable by the agent).
-
-In MemGPT, the in-context memory is defined by extending the BaseMemory class. The memory class consists of:
-* A self.memory dictionary that maps labeled sections of memory (e.g. "human", "persona") to a MemoryModuleobject, which contains the data for that section of memory as well as the character limit (default: 2k)
-* A set of class functions which can be used to edit the data in each MemoryModulecontained in self.memory
-
-We'll show each of these components in the default ChatMemory class described below.
-
-## ChatMemory Memory
-By default, agents have a ChatMemory memory class, which is designed for a 1:1 chat between a human and agent. The ChatMemory class consists of:
-* A "human" and "persona" memory sections each with a 2k character limit
-* Memory editing functions: memory_insert, memory_replace, memory_rethink, and memory_finish_edits
-* Legacy functions (deprecated): core_memory_replace and core_memory_append
-
-We show the implementation of ChatMemory below:
-```python
-from memgpt.memory import BaseMemory
-
-class ChatMemory(BaseMemory):
-
- def __init__(self, persona: str, human: str, limit: int = 2000):
- self.memory = {
- "persona": MemoryModule(name="persona", value=persona, limit=limit),
- "human": MemoryModule(name="human", value=human, limit=limit),
- }
-
- def core_memory_append(self, name: str, content: str) -> Optional[str]:
- """
- Append to the contents of core memory.
-
- Args:
- name (str): Section of the memory to be edited (persona or human).
- content (str): Content to write to the memory. All unicode (including emojis) are supported.
-
- Returns:
- Optional[str]: None is always returned as this function does not produce a response.
- """
- self.memory[name].value += "\n" + content
- return None
-
- def core_memory_replace(self, name: str, old_content: str, new_content: str) -> Optional[str]:
- """
- Replace the contents of core memory. To delete memories, use an empty string for new_content.
-
- Args:
- name (str): Section of the memory to be edited (persona or human).
- old_content (str): String to replace. Must be an exact match.
- new_content (str): Content to write to the memory. All unicode (including emojis) are supported.
-
- Returns:
- Optional[str]: None is always returned as this function does not produce a response.
- """
- self.memory[name].value = self.memory[name].value.replace(old_content, new_content)
- return None
-```
-
-To customize memory, you can implement extensions of the BaseMemory class that customize the memory dictionary and the memory editing functions.
-
-## External memory
-
-In-context memory is inherently limited in size, as all its state must be included in the context window.
-To allow additional memory in external storage, MemGPT by default stores two external tables: archival memory (for long running memories that do not fit into the context) and recall memory (for conversation history).
-
-### Archival memory
-Archival memory is a table in a vector DB that can be used to store long running memories of the agent, as well external data that the agent needs access too (referred to as a "Data Source"). The agent is by default provided with a read and write tool to archival memory:
-* archival_memory_search
-* archival_memory_insert
-
-### Recall memory
-Recall memory is a table which MemGPT logs all the conversational history with an agent. The agent is by default provided with date search and text search tools to retrieve conversational history.
-* conversation_search
-* conversation_search_date
-
-(Note: a tool to insert data is not provided since chat histories are automatically inserted.)
-
-## Orchestrating Tools for Memory Management
-
-We provide the agent with a list of default tools for interacting with both in-context and external memory.
-The way these tools are used to manage memory is controlled by the tool descriptions as well as the MemGPT system prompt.
-None of these tools are required for MemGPT to work, so you can remove or override tools to customize memory.
-We encourage developers to extend the BaseMemory class to customize the in-context memory management for their own applications.
diff --git a/fern/pages/agent-development-environment/ade.mdx b/fern/pages/agent-development-environment/ade.mdx
deleted file mode 100644
index 39c2df98..00000000
--- a/fern/pages/agent-development-environment/ade.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
----
-title: ADE overview
-subtitle: How to use the Agent Development Environment
-slug: agent-development-environment/ade
----
-
-
-
-
-
-
-
-
-The tool creation page allows you to dynamically run your tool (in a sandboxed environment) to help you debug and design your tools.
-Pressing `Run` will attempt to run your tool code with the arguments provided (arguments must be provided in JSON format).
-
-## Agent settings
-
-You can change your agent name and system instructions in the "Agent Settings" panel.
-The agent ID is shown below the agent name, and is what you use to identify your agent when interacting with it via the [Letta APIs / SDKs](https://docs.letta.com/api-reference).
-
-### Changing the LLM model
-You can change the LLM model of your agent to any model registered on the Letta server.
-To enable more models on your Letta server, follow the Letta server [model configuration instructions](/models).
-
-### Changing the embedding model
-
-
-
-## Changing the LLM model
-
-## Configuring the max context length
-
-
-
-## Connecting to an external (self-hosted) server
-
-
diff --git a/fern/pages/agent-development-environment/create.mdx b/fern/pages/agent-development-environment/create.mdx
deleted file mode 100644
index e78a64fc..00000000
--- a/fern/pages/agent-development-environment/create.mdx
+++ /dev/null
@@ -1,4 +0,0 @@
----
-title: Creating Agents in the ADE
-slug: guides/ade/create
----
diff --git a/fern/pages/agent-development-environment/memory.mdx b/fern/pages/agent-development-environment/memory.mdx
deleted file mode 100644
index 664cf181..00000000
--- a/fern/pages/agent-development-environment/memory.mdx
+++ /dev/null
@@ -1,4 +0,0 @@
----
-title: Configuring agent memory
-slug: memory
----
diff --git a/fern/pages/agent-development-environment/sources.mdx b/fern/pages/agent-development-environment/sources.mdx
deleted file mode 100644
index 1c427a8d..00000000
--- a/fern/pages/agent-development-environment/sources.mdx
+++ /dev/null
@@ -1,4 +0,0 @@
----
-title: Connecting data sources
-slug: data-sources
----
diff --git a/fern/pages/agent-development-environment/tools.mdx b/fern/pages/agent-development-environment/tools.mdx
deleted file mode 100644
index 0452c22f..00000000
--- a/fern/pages/agent-development-environment/tools.mdx
+++ /dev/null
@@ -1,4 +0,0 @@
----
-title: Connecting tools to your agent
-slug: tools
----
diff --git a/fern/pages/agent-development-environment/troubleshooting.mdx b/fern/pages/agent-development-environment/troubleshooting.mdx
deleted file mode 100644
index a312f8f2..00000000
--- a/fern/pages/agent-development-environment/troubleshooting.mdx
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: Troubleshooting the web ADE
-subtitle: Resolving issues with the [web ADE](https://app.letta.com)
-slug: guides/ade/troubleshooting
----
-
-
-
-## Agent simulator
-The agent simulator visualizes the event/conversation history of your agent.
-The agent's event history is comprised of *messages*, which can be:
-
-
-
-
-The tool creation page allows you to dynamically run your tool (in a sandboxed environment) to help you debug and design your tools.
-Pressing `Run` will attempt to run your tool code with the arguments provided (arguments must be provided in JSON format).
-
-## Agent settings
-
-You can change your agent name and system instructions in the "Agent Settings" panel.
-The agent ID is shown below the agent name, and is what you use to identify your agent when interacting with it via the [Letta APIs / SDKs](https://docs.letta.com/api-reference).
-
-### Changing the LLM model
-You can change the LLM model of your agent to any model registered on the Letta server.
-To enable more models on your Letta server, follow the Letta server [model configuration instructions](/models).
-
-### Changing the embedding model
-
-
-
-
-## What is Agent File?
-
-Agent Files package all components of a stateful agent:
-- System prompts
-- Editable memory (personality and user information)
-- Tool configurations (code and schemas)
-- LLM settings
-
-By standardizing these elements in a single format, Agent File enables seamless transfer between compatible frameworks, while allowing for easy checkpointing and version control of agent state.
-
-## Why Use Agent File?
-
-The AI ecosystem is experiencing rapid growth in agent development, with each framework implementing its own storage mechanisms. Agent File addresses the need for a standard that enables:
-
-- **Portability**: Move agents between systems or deploy them to new environments
-- **Collaboration**: Share your agents with other developers and the community
-- **Preservation**: Archive agent configurations to preserve your work
-- **Versioning**: Track changes to agents over time through a standardized format
-
-## What State Does `.af` Include?
-
-A `.af` file contains all the state required to re-create the exact same agent:
-
-| Component | Description |
-|-----------|-------------|
-| Model configuration | Context window limit, model name, embedding model name |
-| Message history | Complete chat history with `in_context` field indicating if a message is in the current context window |
-| System prompt | Initial instructions that define the agent's behavior |
-| Memory blocks | In-context memory segments for personality, user info, etc. |
-| Tool rules | Definitions of how tools should be sequenced or constrained |
-| Environment variables | Configuration values for tool execution |
-| Tools | Complete tool definitions including source code and JSON schema |
-
-## Using Agent File with Letta
-
-### Importing Agents
-
-You can import `.af` files using the Agent Development Environment (ADE), REST APIs, or developer SDKs.
-
-#### Using ADE
-
-Upload downloaded `.af` files directly through the ADE interface to easily re-create your agent.
-
-
- 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-### Attaching a Tool to a Letta Agent
-To give your agent access to the tool, you need to click **Attach Tool**. Once the tool is successfully attached (you will see it in the tools panel in the main ADE view), your agent will be able to use the tool.
-Let's try getting the example agent to use the Tavily search tool:
-
-
-If we click on the tool execution button in the chat, we can see the exact inputs to the Composio tool, and the exact outputs from the tool:
-
-
-## Using entities in Composio tools
-
-
-You can also assign tool variables on agent creation in the API with the `tool_exec_environment_variables` parameter (see [examples here](/guides/agents/tool-variables)).
-
-## Entities in Composio tools for multi-user
-In multi-user settings (where you have many users all using different agents), you may want to use the concept of [entities](https://docs.composio.dev/patterns/Auth/connected_account#entities) in Composio, which allow you to scope Composio tool execution to specific users.
-
-For example, let's say you're using Letta to create an application where users each get their own personal secretary that can schedule their calendar. As a developer, you only have one `COMPOSIO_API_KEY` to manage the connection between Letta and Composio, but you want to make associate each Composio tool call from a specific agent with a specific user.
-
-Composio allows you to do this through **entities**: each **user** on your Composio account will have a unique Composio entity ID, and in Letta each **agent** will be associated with a specific Composio entity ID.
-
-## Adding Composio tools to agents in the Python SDK
-
-
-
-## Usage Examples (SDK)
-
-### Sending an Image via URL
-
-
diff --git a/fern/pages/agents/overview.mdx b/fern/pages/agents/overview.mdx
deleted file mode 100644
index 860a49f4..00000000
--- a/fern/pages/agents/overview.mdx
+++ /dev/null
@@ -1,276 +0,0 @@
----
-title: Building Stateful Agents with Letta
-slug: guides/agents/overview
----
-
-
-
-
-
-
-Letta manages a reasoning loop for agents. At each agent step (i.e. iteration of the loop), the state of the agent is checkpointed and persisted to the database.
-
-You can interact with agents from a REST API, the ADE, and TypeScript / Python SDKs.
-As long as they are connected to the same service, all of these interfaces can be used to interact with the same agents.
-
-
-
-
-In Letta, you can create special **sleep-time agents** that share the memory of your primary agents, but run in the background and can modify the memory asynchronously. You can think of sleep-time agents as a special form of multi-agent architecture, where all agents in the system share one or more memory blocks. A single agent can have one or more associated sleep-time agents to process data such as the conversation history or data sources to manage the memory blocks of the primary agent.
-
-To enable sleep-time agents for your agent, create the agent with type `sleeptime_agent`. When you create an agent of this type, this will automatically create:
-* A primary agent (i.e. general-purpose agent) tools for `send_message`, `conversation_search`, and `archival_memory_search`. This is your "main" agent that you configure and interact with.
-* A sleep-time agent with tools to manage the memory blocks of the primary agent. It is possible that additional, ephemeral sleep-time agents will be created when you add data into data sources of the primary agent.
-
-## Background: Memory Blocks
-Sleep-time agents specialize in generating *learned context*. Given some original context (e.g. the conversation history, a set of files) the sleep-time agent will reflect on the original context to iteratively derive a learned context. The learned context will reflect the most important pieces of information or insights from the original context.
-
-In Letta, the learned context is saved in a memory block. A memory block represents a labeled section of the context window with an associated character limit. Memory blocks can be shared between multiple agents. A sleep-time agent will write the learned context to a memory block, which can also be shared with other agents that could benefit from those learnings.
-
-Memory blocks can be access directly through the API to be updated, retrieved, or deleted.
-
-
-
-
-When a `sleeptime_agent` is created, a primary agent and a sleep-time agent are created as part of a multi-agent group under the hood. The sleep-time agent is responsible for generating learned context from the conversation history to update the memory blocks of the primary agent. The group ensures that for every `N` steps taken by the primary agent, the sleep-time agent is invoked with data containing new messages in the primary agent's message history.
-
-
-
-### Configuring the frequency of sleep-time updates
-The sleep-time agent will be triggered every N-steps (default `5`) to update the memory blocks of the primary agent. You can configure the frequency of updates by setting the `sleeptime_agent_frequency` parameter when creating the agent.
-
-
-
-Once in the **Environment Variables** viewer, click **+** to add a new tool variable if one does not exist.
-
-
-
-## Assigning tool variables in the API / SDK
-
-You can also assign tool variables on agent creation in the API with the `tool_exec_environment_variables` parameter:
-
-
-## Using your API key
-
-Once you've created an API key, you can use it with any of the Letta SDKs or framework integrations.
-For example, if you're using the Python or TypeScript (Node.js) SDK, you should set the `token` in the client to be your key (replace `LETTA_API_KEY` with your actual API key):
-
-
-
-Monitor your agents across four key dashboards:
-
-##
-
-
-Track key metrics across four dashboards:
-- **Overview**: Message count, API/tool errors, LLM/tool latency
-- **Activity & Usage**: Usage patterns and resource consumption
-- **Performance**: Response times and throughput
-- **Errors**: Detailed error analysis and debugging info
-
-## [Responses & Tracing](/guides/observability/responses)
-
-
-
-
-Inspect API responses and agent execution:
-- **API Responses**: List of all responses with duration and status
-- **Message Inspection**: Click "Inspect Message" to see the full POST request and agent loop execution sequence
diff --git a/fern/pages/cloud/overview.mdx b/fern/pages/cloud/overview.mdx
deleted file mode 100644
index 12fcdb0d..00000000
--- a/fern/pages/cloud/overview.mdx
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: Letta Cloud
-subtitle: Deploy stateful agents at scale in the cloud
-slug: guides/cloud/overview
----
-Letta Cloud is our fully-managed service for stateful agents. While Letta can be self-hosted, Letta Cloud eliminates all infrastructure management, server optimization, and system administration so you can focus entirely on building agents.
-
-## The fastest way to bring stateful agents to production
-
-**Develop faster with any model and 24/7 agent uptime**: Access to OpenAI, Anthropic Claude, and Google Gemini with high rate limits. Our platform automatically scales to meet demand and ensures 24/7 uptime of your agents. Your agents' state, memory, and conversation history are securely persisted.
-
-**Features designed to help you scale to hundreds of agents**: Letta Cloud includes features designed for applications managing large numbers of agents: agent templates, template versioning, memory variables injected on agent creation, and advanced tooling for managing thousands of agents across many users.
-
-## Model agnostic with zero provider lock-in
-
-Your agent state is stored in a model-agnostic format, allowing you to easily migrate your agents (and their memories, message history, reasoning traces, tool execution traces, etc.) from one model provider to another.
-
-Letta Cloud also supports [agent file](/guides/agents/agent-file), which allows you to move your agents freely between self-hosted instances of Letta and Letta Cloud.
-
-You can upload local agents to Cloud by importing their `.af` files, and run Cloud agents locally by downloading and importing them into your self-hosted server.
-
-## Next steps
-
-
-
-
-Debug and analyze your agent's execution with detailed tracing.
-
-## 
-
-
-Click **"Inspect Message"** to trace agent execution:
-
-### Request Details
-- Original POST request that triggered the agent
-- All parameters and context information
-
-### Agent Loop Trace
-Step-by-step execution flow:
-1. **Input Processing**: How the server interpreted the request
-3. **Tool Invocations**: Each tool called with parameters, timing, and results
-5. **Memory Updates**: How agent memory was modified
-4. **Agent Messages**: Prompts, responses, and token usage
-6. **Response Completion**: Final response construction
-
-### Debugging Features
-- **Performance**: Identify bottlenecks and optimization opportunities
-- **Errors**: Pinpoint failure points with stack traces
-- **Behavior**: Understand agent decision-making process
diff --git a/fern/pages/cloud/templates.mdx b/fern/pages/cloud/templates.mdx
deleted file mode 100644
index ec7da2ee..00000000
--- a/fern/pages/cloud/templates.mdx
+++ /dev/null
@@ -1,131 +0,0 @@
----
-title: Introduction to Agent Templates
-slug: guides/templates/overview
----
-
-
-
-
-**MemGPT** is the name of a [**research paper**](https://arxiv.org/abs/2310.08560) that popularized several of the key concepts behind the "LLM Operating System (OS)":
-1. **Memory management**: In MemGPT, an LLM OS moves data in and out of the context window of the LLM to manage its memory.
-2. **Memory hierarchy**: The "LLM OS" divides the LLM's memory (aka its "virtual context", similar to "[virtual memory](https://en.wikipedia.org/wiki/Virtual_memory)" in computer systems) into two parts: the in-context memory, and out-of-context memory.
-3. **Self-editing memory via tool calling**: In MemGPT, the "OS" that manages memory is itself an LLM. The LLM moves data in and out of the context window using designated memory-editing tools.
-4. **Multi-step reasoning using heartbeats**: MemGPT supports multi-step reasoning (allowing the agent to take multiple steps in sequence) via the concept of "heartbeats". Whenever the LLM outputs a tool call, it has to option to request a heartbeat by setting the keyword argument `request_heartbeat` to `true`. If the LLM requests a heartbeat, the LLM OS continues execution in a loop, allowing the LLM to "think" again.
-
-You can read more about the MemGPT memory hierarchy and memory management system in our [memory concepts guide](/advanced/memory_management).
-
-## MemGPT - the agent architecture
-
-**MemGPT** also refers to a particular **agent architecture** that was popularized by the paper and adopted widely by other LLM chatbots:
-1. **Chat-focused core memory**: The core memory of a MemGPT agent is split into two parts - the agent's own persona, and the user information. Because the MemGPT agent has self-editing memory, it can update its own personality over time, as well as update the user information as it learns new facts about the user.
-2. **Vector database archival memory**: By default, the archival memory connected to a MemGPT agent is backed by a vector database, such as [Chroma](https://www.trychroma.com/) or [pgvector](https://github.com/pgvector/pgvector). Because in MemGPT all connections to memory are driven by tools, it's simple to exchange archival memory to be powered by a more traditional database (you can even make archival memory a flatfile if you want!).
-
-## Creating MemGPT agents in the Letta framework
-
-Because **Letta** was created out of the original MemGPT open source project, it's extremely easy to make MemGPT agents inside of Letta (the default Letta agent architecture is a MemGPT agent).
-See our [agents overview](/agents/overview) for a tutorial on how to create MemGPT agents with Letta.
-
-**The Letta framework also allow you to make agent architectures beyond MemGPT** that differ significantly from the architecture proposed in the research paper - for example, agents with multiple logical threads (e.g. a "concious" and a "subconcious"), or agents with more advanced memory types (e.g. task memory).
-
-Additionally, **the Letta framework also allows you to expose your agents as *services*** (over REST APIs) - so you can use the Letta framework to power your AI applications.
diff --git a/fern/pages/concepts/memory.mdx b/fern/pages/concepts/memory.mdx
deleted file mode 100644
index bcd3b120..00000000
--- a/fern/pages/concepts/memory.mdx
+++ /dev/null
@@ -1,101 +0,0 @@
----
-title: Understanding memory management
-subtitle: Understanding the concept of LLM memory management introduced in MemGPT
-slug: concepts/memory-management
----
-
-
-Letta uses the MemGPT memory management technique to control the context window of the LLM.
-
-The behavior of an agent is determine by two things: the underlying LLM model, and the context window that is passed to that model.
-Letta provides a framework for "programming" how the context is compiled at each reasoning step, a process which we refer to as memory management for agents.
-
-Unlike existing RAG-based frameworks for long-running memory, MemGPT provides a more flexible, powerful framework for memory management by enabling the agent to self-manage memory via tool calls.
-Essentially, the agent itself gets to decide what information to place into its context at any given time. We reserve a section of the context, which we call the in-context memory, which is agent as the ability to directly write to.
-In addition, the agent is given tools to access external storage (i.e. database tables) to enable a larger memory store.
-Combining tools to write to both its in-context and external memory, as well as tools to search external memory and place results into the LLM context, is what allows MemGPT agents to perform memory management.
-
-## In-context memory
-
-The in-context memory is a section of the LLM context window that is reserved to be editable by the agent.
-You can think of this like a system prompt, except the system prompt it editable (MemGPT also has an actual system prompt which is not editable by the agent).
-
-In MemGPT, the in-context memory is defined by extending the BaseMemory class. The memory class consists of:
-* A self.memory dictionary that maps labeled sections of memory (e.g. "human", "persona") to a MemoryModuleobject, which contains the data for that section of memory as well as the character limit (default: 2k)
-* A set of class functions which can be used to edit the data in each MemoryModulecontained in self.memory
-
-We'll show each of these components in the default ChatMemory class described below.
-
-## ChatMemory Memory
-By default, agents have a ChatMemory memory class, which is designed for a 1:1 chat between a human and agent. The ChatMemory class consists of:
-* A "human" and "persona" memory sections each with a 2k character limit
-* Memory editing functions: memory_insert, memory_replace, memory_rethink, and memory_finish_edits
-* Legacy functions (deprecated): core_memory_replace and core_memory_append
-
-We show the implementation of ChatMemory below:
-```python
-from memgpt.memory import BaseMemory
-
-class ChatMemory(BaseMemory):
-
- def __init__(self, persona: str, human: str, limit: int = 2000):
- self.memory = {
- "persona": MemoryModule(name="persona", value=persona, limit=limit),
- "human": MemoryModule(name="human", value=human, limit=limit),
- }
-
- def core_memory_append(self, name: str, content: str) -> Optional[str]:
- """
- Append to the contents of core memory.
-
- Args:
- name (str): Section of the memory to be edited (persona or human).
- content (str): Content to write to the memory. All unicode (including emojis) are supported.
-
- Returns:
- Optional[str]: None is always returned as this function does not produce a response.
- """
- self.memory[name].value += "\n" + content
- return None
-
- def core_memory_replace(self, name: str, old_content: str, new_content: str) -> Optional[str]:
- """
- Replace the contents of core memory. To delete memories, use an empty string for new_content.
-
- Args:
- name (str): Section of the memory to be edited (persona or human).
- old_content (str): String to replace. Must be an exact match.
- new_content (str): Content to write to the memory. All unicode (including emojis) are supported.
-
- Returns:
- Optional[str]: None is always returned as this function does not produce a response.
- """
- self.memory[name].value = self.memory[name].value.replace(old_content, new_content)
- return None
-```
-
-To customize memory, you can implement extensions of the BaseMemory class that customize the memory dictionary and the memory editing functions.
-
-## External memory
-
-In-context memory is inherently limited in size, as all its state must be included in the context window.
-To allow additional memory in external storage, MemGPT by default stores two external tables: archival memory (for long running memories that do not fit into the context) and recall memory (for conversation history).
-
-### Archival memory
-Archival memory is a table in a vector DB that can be used to store long running memories of the agent, as well external data that the agent needs access too (referred to as a "Data Source"). The agent is by default provided with a read and write tool to archival memory:
-* archival_memory_search
-* archival_memory_insert
-
-### Recall memory
-Recall memory is a table which MemGPT logs all the conversational history with an agent. The agent is by default provided with date search and text search tools to retrieve conversational history.
-* conversation_search
-* conversation_search_date
-
-(Note: a tool to insert data is not provided since chat histories are automatically inserted.)
-
-## Orchestrating Tools for Memory Management
-
-We provide the agent with a list of default tools for interacting with both in-context and external memory.
-The way these tools are used to manage memory is controlled by the tool descriptions as well as the MemGPT system prompt.
-None of these tools are required for MemGPT to work, so you can remove or override tools to customize memory.
-We encourage developers to extend the BaseMemory class to customize the in-context memory management for their own applications.
diff --git a/fern/pages/cookbooks.mdx b/fern/pages/cookbooks.mdx
deleted file mode 100644
index c5f24d91..00000000
--- a/fern/pages/cookbooks.mdx
+++ /dev/null
@@ -1,141 +0,0 @@
----
-title: Letta Cookbooks
-# layout: page
-# hide-feedback: true
-# no-image-zoom: true
-slug: cookbooks
----
-
-
-
-
-
-
-
- 
-
-
-
- 
-
-
-## Accessing the deployment via the ADE
-
-Now that the Railway deployment is active, all we need to do to access it via the ADE is add it to as a new remote Letta server.
-The default password set in the template is `password`, which can be changed at the deployment stage or afterwards in the 'variables' page on the Railway deployment.
-
-Click "Add remote server", then enter the details from Railway (use the static IP address shown in the logs, and use the password set via the environment variables):
-
-
-
-
-## Accessing the deployment via the Letta API
-
-Accessing the deployment via the [Letta API](https://docs.letta.com/api-reference) is simple, we just need to swap the base URL of the endpoint with the IP address from the Railway deployment.
-
-For example if the Railway IP address is `https://MYSERVER.up.railway.app` and the password is `banana`, to create an agent on the deployment, we can use the following shell command:
-```sh
-curl --request POST \
- --url https://MYSERVER.up.railway.app/v1/agents/ \
- --header 'X-BARE-PASSWORD: password banana' \
- --header 'Content-Type: application/json' \
- --data '{
- "memory_blocks": [
- {
- "label": "human",
- "value": "The human'\''s name is Bob the Builder"
- },
- {
- "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
- },
- "tools": [
- "send_message",
- "core_memory_append",
- "core_memory_replace",
- "archival_memory_search",
- "archival_memory_insert",
- "conversation_search"
- ]
-}'
-```
-
-This will create an agent with two memory blocks, configured to use `gpt-4o-mini` as the LLM model, and `text-embedding-3-small` as the embedding model. We also include the base Letta tools in the request.
-
-If the Letta server is not password protected, we can omit the `X-BARE-PASSWORD` header.
-
-
-
-## Connecting to Grafana
-We recommend connecting ClickHouse to Grafana to query and view traces. Grafana can be run [locally](https://grafana.com/oss/grafana/), or via [Grafana Cloud](https://grafana.com/grafana/).
-
-
-# Other Integrations
-
-Letta also supports other exporters when running in a containerized environment. To request support for another exporter, please open an issue on [GitHub](https://github.com/letta-ai/letta/issues/new/choose).
-
-## Configuring Signoz
-
-You can configure Signoz by passing the required enviornment variables:
-```sh
-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
-```
diff --git a/fern/pages/desktop/install.mdx b/fern/pages/desktop/install.mdx
deleted file mode 100644
index 2b20e355..00000000
--- a/fern/pages/desktop/install.mdx
+++ /dev/null
@@ -1,185 +0,0 @@
----
-title: Installing Letta Desktop
-subtitle: Install Letta Desktop on your MacOS, Windows, or Linux machine
-slug: guides/ade/desktop
----
-
-
-
-
-**Letta Desktop** allows you to run the ADE (Agent Development Environment) as a local application.
-Letta Desktop also bundles a built-in Letta server, so can run Letta Desktop standalone, or you can connect it to a self-hosted Letta server.
-
-## Download Letta Desktop
-
-
-
-You can also edit the environment variable file directly, located at `~/.letta/env`.
-
-For this quickstart demo, we'll add an OpenAI API key (once we enter our key and **click confirm**, the Letta server will automatically restart):
-
-
-
-## Configuration Modes
-
-Letta Desktop can run in two primary modes, which can be configured from the settings menu in the app, or by manually editing the `~/.letta/desktop_config.json` file.
-
-
-
-
-Unlike simple chatbot interfaces, the ADE gives you complete control over your agent's state across its entire lifecycle:
-- Create and customize agents without writing code
-- Visualize your agent's memory and context window in real-time
-- Add and test custom tools in a sandboxed environment
-- Monitor agent behavior and performance
-
-The ADE provides a graphical interface to agents running in your Letta server.
-These same agents can be accessed via the [Letta APIs](/api-reference/overview), allowing you to integrate them into your applications.
-
-## Read our ADE guide
-Learn more about the ADE in our ADE guide:
-- [Explore the ADEs components in detail](/guides/ade/overview)
-- [Connecting the ADE to local and remote deployments](/guides/ade/setup)
-- [Read our ADE FAQs](/faq#agent-development-environment-ade)
-
-If you have additional questions, feedback, or feature requests, reach out on [Discord](https://discord.gg/letta)!
diff --git a/fern/pages/getting-started/core-concepts.mdx b/fern/pages/getting-started/core-concepts.mdx
deleted file mode 100644
index a57b6ce1..00000000
--- a/fern/pages/getting-started/core-concepts.mdx
+++ /dev/null
@@ -1,274 +0,0 @@
----
-title: Core Concepts
-subtitle: Understanding what makes Letta different
-slug: core-concepts
----
-
-## The Fundamental Limitation of LLMs
-
-Large language models are **stateless by design**. An LLM's knowledge comes from two sources:
-1. **Model weights** - Fixed after training
-2. **Context window** - Ephemeral input provided at inference time
-
-This means LLMs have no persistent memory between interactions. Each API call starts from scratch, with no ability to learn from past experiences or maintain state across sessions.
-
-## What are Stateful Agents?
-
-**Stateful agents overcome this limitation by maintaining persistent memory and identity across all interactions.**
-
-A stateful agent has:
-- **Persistent identity** - Exists as a unique entity with continuity across sessions
-- **Active memory formation** - Autonomously decides what information to store and update
-- **Accumulated state** - Learns through experience rather than just model weights
-- **Long-term context** - Maintains knowledge beyond single conversation windows
-
-Unlike traditional LLM applications where your code manages state, stateful agents **actively manage their own memory** using built-in tools to read, write, and search their persistent storage.
-
-### Why Statefulness Matters
-
-Traditional LLM applications are **stateless** - every interaction starts from scratch. Your application must:
-- Store all conversation history in your own database
-- Send the entire context with every API call
-- Implement memory and personalization logic yourself
-- Manually manage context window limits
-
-**With Letta's stateful agents, all of this is handled for you.** The agent maintains its own persistent state, intelligently manages its context window, and learns from every interaction without requiring you to build a complex state management layer.
-
-## Stateful vs Stateless APIs
-
-The difference between stateful agents and traditional LLM APIs is fundamental:
-
-**Traditional APIs (stateless):** No memory between requests. Your app manages everything.
-
-**Letta (stateful):** Agents maintain their own persistent state. You only send new messages.
-
-### Traditional Stateless API
-
-With stateless APIs, there is no state persistence between requests. The client must send the entire conversation history with every call.
-
-```mermaid
-flowchart LR
- Client["Client Application"]
- API["LLM API
-
-
-## Build agents with intelligent memory, not limited context
-
-Letta's advanced context management system - built by the [researchers behind MemGPT](https://www.letta.com/research) - transforms how agents remember and learn. Unlike basic agents that forget when their context window fills up, Letta agents maintain memories across sessions and continuously improve, even while they [sleep](/guides/agents/sleep-time-agents)
-
-
-## Run agents as services, not libraries
-
-**Letta is fundamentally different from other agent frameworks.** While most frameworks are *libraries* that wrap model APIs, Letta provides a dedicated *service* where agents live and operate autonomously. Agents continue to exist and maintain state even when your application isn't running, with computation happening on the server and all memory, context, and tool connections handled by the Letta server.
-
-
-
-
-## Everything you need for production agents
-
-Letta provides a complete suite of capabilities for building and deploying advanced AI agents:
-
-*
-
- 3. Set your API key as an environment variable:
-
-
-
- [Read our ADE setup guide →](/guides/ade/setup)
-
-
-## Projects
-
-In Letta Cloud, your workspace is organized into projects.
-When you create agents directly (instead of via [templates](/guides/templates/overview)), your agents will get placed in the "Default Project".
-
-## Creating an agent with the Letta API
-Let's create an agent via the Letta API, which we can then view in the ADE (you can also use the ADE to create agents).
-
-To create an agent we'll send a POST request to the Letta server ([API docs](/api-reference/agents/create)).
-In this example, we'll use `gpt-4o-mini` as the base LLM model, and `text-embedding-3-small` as the embedding model (this requires having configured both `OPENAI_API_KEY` on our Letta server).
-
-We'll also artificially set the context window limit to 16k, instead of the 128k default for `gpt-4o-mini` (this can improve stability and performance):
-
-
-## Send a message to the agent with the Letta API
-
-
-## Next steps
-
-Congratulations! 🎉 You just created and messaged your first stateful agent with Letta, using both the Letta ADE, API, and Python/Typescript SDKs.
-
-Now that you've succesfully created a basic agent with Letta, you're ready to start building more complex agents and AI applications.
-
-
-
-If Desktop is not available for your platform you can still use [Letta via Docker](/quickstart/docker) or [pip](/guides/server/pip).
-
-## Run Letta Desktop
-**Letta agents** live inside a **Letta server**, which persists them to a database.
-You can interact with the Letta agents inside your Letta server with the [ADE](/agent-development-environment) (a visual interface), and connect your agents to external application via the [REST API](https://docs.letta.com/api-reference) and Python & TypeScript SDKs.
-
-Letta Desktop bundles together the Letta server and the Agent Development Environment (ADE) into a single application.
-
-
-
-When you launch Letta Desktop, you'll be prompted to wait while the Letta server starts up.
-You can monitor the server startup process by opening the server logs (clicking the 
-
-## Next steps
-
-Congratulations! 🎉 You just created and messaged your first stateful agent with Letta, using both the Letta ADE, API, and Python/Typescript SDKs.
-
-Now that you've succesfully created a basic agent with Letta, you're ready to start building more complex agents and AI applications.
-
-
-
-
-Large Language Models have given us powerful building blocks for intelligent systems.
-By connecting these models to external tools, we can create AI agents that take actions and affect the real world.
-
-Most LLM agents today are held back by a fundamental limitation: while LLMs provide the intelligence, they are inherently stateless - processing each input without memory of past interactions.
-Simply accumulating conversation history leads to agents that lose track of important information or need their memory regularly cleared to continue functioning.
-
-Building truly intelligent agents requires sophisticated context management - the missing piece that transforms stateless LLMs into agents that can intelligently process vast knowledge bases and continuously learn from their experiences.
-
-## Stateful Agents
-
-When an LLM agent interacts with the world, it accumulates state - learned behaviors, facts about its environment, and memories of past interactions.
-A stateful agent is one that can effectively manage this growing knowledge, maintaining consistent behavior while incorporating new experiences.
-
-```mermaid
-graph TD
- subgraph basic["Basic Agent"]
- direction LR
- c1["Context Window:
- Growing History → Context Limit!"] --> llm1[LLM]
- llm1 --> action1[/"Agent Action"/]
- action1 -->|"Append to History"| c1
- end
-
- basic --> stateful
-
- subgraph stateful["Stateful Agent"]
- direction LR
- db[(Persistent State
- All Memory & History)] --> cms["Context Management
- System"]
- cms -->|"Compile Context"| cw["Context Window
- ---------------
- Relevant State"]
- cw --> llm2[LLM]
- llm2 --> action2[/"Agent Action"/]
- action2 -->|"Persist New State"| db
- end
-
- class c1,cw context
- class action1,action2 action
-```
-
-Stateful agents use intelligent context management to organize and prioritize information, enabling them to process large amounts of data while maintaining focus on what's relevant.
-This is a fundamental shift from traditional approaches that simply accumulate information until the agent becomes overwhelmed.
-
-Letta provides the foundation for building stateful agents through its context management system.
-By handling the complexity of state management, Letta lets you (the developer) focus on building agents that can truly learn and evolve through their interactions with the world.
diff --git a/fern/pages/getting-started/troubleshooting_ade.mdx b/fern/pages/getting-started/troubleshooting_ade.mdx
deleted file mode 100644
index e69de29b..00000000
diff --git a/fern/pages/getting-started/troubleshooting_desktop.mdx b/fern/pages/getting-started/troubleshooting_desktop.mdx
deleted file mode 100644
index e69de29b..00000000
diff --git a/fern/pages/index.mdx b/fern/pages/index.mdx
deleted file mode 100644
index 38d10f58..00000000
--- a/fern/pages/index.mdx
+++ /dev/null
@@ -1,118 +0,0 @@
----
-title: Home
-layout: custom
-hide-feedback: true
-no-image-zoom: true
-slug: /
----
-
-
-
-
- 
- - A framework for building stateful AI agents with long-term memory -
- -- AI agents that learn, completely local. -
-
-
- -Letta software is provided under our [Privacy Policy](https://letta.com/privacy-policy) and [Terms of Service](https://letta.com/terms-of-service). -
-
-
-
-## Who is Letta for?
-
-Letta is for developers building stateful LLM applications that require advanced memory, such as:
-* **personalized chatbots** that require long-term memory and personas that should be updated (self-edited) over time (e.g. companions)
-* **agents connected to external data sources**, e.g. private enterprise deployments of ChatGPT-like applications (connected to your company's data), or a medical assistant connected to a patient's medical records
-* **agents connected to custom tools**, e.g. a chatbot that can answer questions about the latest news by searching the web
-* **automated AI workflows**, e.g. an agent that monitors your email inbox and sends you text alerts for urgent emails and a daily email summary
-
-... and countless other use cases!
-
-### [Letta ADE](https://app.letta.com) (Agent Development Environment)
-
-
-
-
-
-| Model | -Overall Score | -Core Memory | -Archival Memory | -
|---|
| Model | -Core Read | -Core Write | -Archival Read | -
|---|
| Model | -Overall Score | -Cost | -
|---|
| Model | -Overall Score | -Cost | -
|---|
| Model | -Overall Score | -Cost | -
|---|
-
-
-**MemGPT** is the name of a [**research paper**](https://arxiv.org/abs/2310.08560) that popularized several of the key concepts behind the "LLM Operating System (OS)":
-1. **Memory management**: In MemGPT, an LLM OS moves data in and out of the context window of the LLM to manage its memory.
-2. **Memory hierarchy**: The "LLM OS" divides the LLM's memory (aka its "virtual context", similar to "[virtual memory](https://en.wikipedia.org/wiki/Virtual_memory)" in computer systems) into two parts: the in-context memory, and out-of-context memory.
-3. **Self-editing memory via tool calling**: In MemGPT, the "OS" that manages memory is itself an LLM. The LLM moves data in and out of the context window using designated memory-editing tools.
-4. **Multi-step reasoning using heartbeats**: MemGPT supports multi-step reasoning (allowing the agent to take multiple steps in sequence) via the concept of "heartbeats". Whenever the LLM outputs a tool call, it has to option to request a heartbeat by setting the keyword argument `request_heartbeat` to `true`. If the LLM requests a heartbeat, the LLM OS continues execution in a loop, allowing the LLM to "think" again.
-
-You can read more about the MemGPT memory hierarchy and memory management system in our [memory concepts guide](/advanced/memory_management).
-
-## MemGPT - the agent architecture
-
-**MemGPT** also refers to a particular **agent architecture** that was popularized by the paper and adopted widely by other LLM chatbots:
-1. **Chat-focused core memory**: The core memory of a MemGPT agent is split into two parts - the agent's own persona, and the user information. Because the MemGPT agent has self-editing memory, it can update its own personality over time, as well as update the user information as it learns new facts about the user.
-2. **Vector database archival memory**: By default, the archival memory connected to a MemGPT agent is backed by a vector database, such as [Chroma](https://www.trychroma.com/) or [pgvector](https://github.com/pgvector/pgvector). Because in MemGPT all connections to memory are driven by tools, it's simple to exchange archival memory to be powered by a more traditional database (you can even make archival memory a flatfile if you want!).
-
-## Creating MemGPT agents in the Letta framework
-
-Because **Letta** was created out of the original MemGPT open source project, it's extremely easy to make MemGPT agents inside of Letta (the default Letta agent architecture is a MemGPT agent).
-See our [agents overview](/guides/agents/overview) for a tutorial on how to create MemGPT agents with Letta.
-
-**The Letta framework also allow you to make agent architectures beyond MemGPT** that differ significantly from the architecture proposed in the research paper - for example, agents with multiple logical threads (e.g. a "concious" and a "subconcious"), or agents with more advanced memory types (e.g. task memory).
-
-Additionally, **the Letta framework also allows you to expose your agents as *services*** (over REST APIs) - so you can use the Letta framework to power your AI applications.
diff --git a/fern/pages/mcp/overview.mdx b/fern/pages/mcp/overview.mdx
deleted file mode 100644
index 55612ecc..00000000
--- a/fern/pages/mcp/overview.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
----
-title: What is Model Context Protocol (MCP)?
-subtitle: What is MCP, and how can it be combined with agents?
-slug: guides/mcp/overview
----
-
-[Model Context Protocol (MCP)](https://modelcontextprotocol.io) is an open protocol that enables seamless integration between LLM applications and external data sources and tools.
-In Letta, you can create your own [custom tools](/guides/agents/custom-tools) that run in the Letta tool sandbox, or use MCP to connect to tools that run on external servers.
-
-**Already familiar with MCP?** Jump to the [setup guide](/guides/mcp/setup).
-
-## Architecture
-
-MCP uses a **host-client-server** model. Letta acts as the **host**, creating **clients** that connect to external **servers**. Each server exposes tools, resources, or prompts through the standardized MCP protocol.
-
-Letta's MCP integration connects your agents to external tools and data sources without requiring custom integrations.
-
-## Integration Flow
-
-```mermaid
-flowchart LR
- subgraph L ["Letta"]
- LH[Host] --> LC1[Client 1]
- LH --> LC2[Client 2]
- LH --> LC3[Client 3]
- end
-
- subgraph S ["MCP Servers"]
- MS1[GitHub]
- MS2[Database]
- MS3[Files]
- end
-
- LC1 <--> MS1
- LC2 <--> MS2
- LC3 <--> MS3
-```
-
-Letta creates isolated clients for each MCP server, maintaining security boundaries while providing agents access to specialized capabilities.
-
-## Connection Methods
-
-- **ADE**: Point-and-click server management through Letta's web interface
-- **API/SDK**: Programmatic integration for production deployments
-
-
-
-**ADE**: Tool Manager → Add MCP Server → Streamable HTTP
-
-### Agent Id Header
-
-When Letta makes tool calls to an MCP server, it includes the following in the HTTP request header:
-
-- **`x-agent-id`**: The ID of the agent making the tool call
-
-If you're implementing your own MCP server, this can be used to make requests against your Letta Agent via our API/SDK.
-
-### Agent Scoped Variables
-
-Letta recognizes templated variables in the custom header and auth token fields to allow for agent-scoped parameters defined in your [tool variables](/guides/agents/tool-variables):
-- For example, **`{{ AGENT_API_KEY }}`** will use the `AGENT_API_KEY` tool variable if available.
-- To provide a default value, **`{{ AGENT_API_KEY | api_key }}`** will fallback to `api_key` if `AGENT_API_KEY` is not set.
-- This is supported in the ADE as well when configuring API key/access tokens and custom headers.
-
-
diff --git a/fern/pages/selfhosting/postgres.mdx b/fern/pages/selfhosting/postgres.mdx
deleted file mode 100644
index 839dcbb2..00000000
--- a/fern/pages/selfhosting/postgres.mdx
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Database Configuration
-subtitle: Configure Letta's Postgres DB backend
-slug: guides/selfhosting/postgres
----
-
-## Connecting your own Postgres instance
-You can set `LETTA_PG_URI` to connect your own Postgres instance to Letta. Your database must have the `pgvector` vector extension installed.
-
-You can enable this extension by running the following SQL command:
-```sql
-CREATE EXTENSION IF NOT EXISTS vector;
-```
diff --git a/fern/pages/selfhosting/supported-models.mdx b/fern/pages/selfhosting/supported-models.mdx
deleted file mode 100644
index 819b58bb..00000000
--- a/fern/pages/selfhosting/supported-models.mdx
+++ /dev/null
@@ -1,219 +0,0 @@
----
-title: Supported Models
-generated: 2025-06-27T14:10:15.033946
----
-
-# Supported Models
-
-## Overview
-
-Letta routinely runs automated scans against available providers and models. These are the results of the latest scan.
-
-Ran 2512 tests against 157 models across 7 providers on June 27th, 2025
-
-
-## anthropic
-
-| Model | Basic | Token Streaming | Multimodal | Context Window | Last Scanned |
-|---------------------------------------------------|:---:|:-------------:|:--------:|:-------:|:----------:|
-| `claude-3-5-haiku-20241022` | ✅ | ✅ | ✅ | 200,000 | 2025-06-27 |
-| `claude-3-5-sonnet-20240620` | ✅ | ✅ | ✅ | 200,000 | 2025-06-27 |
-| `claude-3-5-sonnet-20241022` | ✅ | ✅ | ✅ | 200,000 | 2025-06-27 |
-| `claude-3-7-sonnet-20250219` | ✅ | ✅ | ✅ | 200,000 | 2025-06-27 |
-| `claude-opus-4-20250514` | ✅ | ✅ | ✅ | 200,000 | 2025-06-27 |
-| `claude-sonnet-4-20250514` | ✅ | ✅ | ✅ | 200,000 | 2025-06-27 |
-| `claude-3-opus-20240229` | ❌ | ✅ | ✅ | 200,000 | 2025-06-27 |
-| `claude-3-haiku-20240307` | ❌ | ❌ | ✅ | 200,000 | 2025-06-27 |
-| `claude-3-sonnet-20240229` | ❌ | ❌ | ❌ | 200,000 | 2025-06-27 |
-
----
-
-## openai
-
-| Model | Basic | Token Streaming | Multimodal | Context Window | Last Scanned |
-|---------------------------------------------------|:---:|:-------------:|:--------:|:-------:|:----------:|
-| `gpt-4-turbo` | ✅ | ✅ | ✅ | 128,000 | 2025-06-27 |
-| `gpt-4-turbo-2024-04-09` | ✅ | ✅ | ✅ | 128,000 | 2025-06-27 |
-| `gpt-4.1` | ✅ | ✅ | ✅ | 1,047,576 | 2025-06-27 |
-| `gpt-4.1-2025-04-14` | ✅ | ✅ | ✅ | 1,047,576 | 2025-06-27 |
-| `gpt-4.1-mini` | ✅ | ✅ | ✅ | 1,047,576 | 2025-06-27 |
-| `gpt-4.1-mini-2025-04-14` | ✅ | ✅ | ✅ | 1,047,576 | 2025-06-27 |
-| `gpt-4.1-nano` | ✅ | ✅ | ✅ | 1,047,576 | 2025-06-27 |
-| `gpt-4.1-nano-2025-04-14` | ✅ | ✅ | ✅ | 1,047,576 | 2025-06-27 |
-| `gpt-4o` | ✅ | ✅ | ✅ | 128,000 | 2025-06-27 |
-| `gpt-4o-2024-05-13` | ✅ | ✅ | ✅ | 128,000 | 2025-06-27 |
-| `gpt-4o-2024-08-06` | ✅ | ✅ | ✅ | 128,000 | 2025-06-27 |
-| `gpt-4o-2024-11-20` | ✅ | ✅ | ✅ | 128,000 | 2025-06-27 |
-| `gpt-4o-mini` | ✅ | ✅ | ✅ | 128,000 | 2025-06-27 |
-| `gpt-4o-mini-2024-07-18` | ✅ | ✅ | ✅ | 128,000 | 2025-06-27 |
-| `gpt-4-0613` | ✅ | ✅ | ❌ | 8,192 | 2025-06-27 |
-| `gpt-4-1106-preview` | ✅ | ✅ | ❌ | 128,000 | 2025-06-27 |
-| `gpt-4-turbo-preview` | ✅ | ✅ | ❌ | 128,000 | 2025-06-27 |
-| `gpt-4-0125-preview` | ❌ | ✅ | ❌ | 128,000 | 2025-06-27 |
-| `o1` | ❌ | ❌ | ✅ | 200,000 | 2025-06-27 |
-| `o1-2024-12-17` | ❌ | ❌ | ✅ | 200,000 | 2025-06-27 |
-| `o3` | ❌ | ❌ | ✅ | 200,000 | 2025-06-27 |
-| `o3-2025-04-16` | ❌ | ❌ | ✅ | 200,000 | 2025-06-27 |
-| `o4-mini` | ❌ | ❌ | ✅ | 30,000 | 2025-06-27 |
-| `o4-mini-2025-04-16` | ❌ | ❌ | ✅ | 30,000 | 2025-06-27 |
-| `gpt-4` | ❌ | ❌ | ❌ | 8,192 | 2025-06-27 |
-| `o3-mini` | ❌ | ❌ | ❌ | 200,000 | 2025-06-27 |
-| `o3-mini-2025-01-31` | ❌ | ❌ | ❌ | 200,000 | 2025-06-27 |
-| `o3-pro` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `o3-pro-2025-06-10` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-
----
-
-## google_ai
-
-| Model | Basic | Token Streaming | Multimodal | Context Window | Last Scanned |
-|---------------------------------------------------|:---:|:-------------:|:--------:|:-------:|:----------:|
-| `gemini-1.5-pro` | ✅ | ✅ | ✅ | 2,000,000 | 2025-06-27 |
-| `gemini-1.5-pro-002` | ✅ | ✅ | ✅ | 2,000,000 | 2025-06-27 |
-| `gemini-1.5-pro-latest` | ✅ | ✅ | ✅ | 2,000,000 | 2025-06-27 |
-| `gemini-2.0-flash-thinking-exp` | ✅ | ✅ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-2.5-flash-preview-04-17` | ✅ | ✅ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-2.5-pro` | ✅ | ✅ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-2.5-pro-preview-03-25` | ✅ | ✅ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-2.5-pro-preview-05-06` | ✅ | ✅ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-2.5-flash` | ✅ | ❌ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-2.0-flash-thinking-exp-1219` | ❌ | ✅ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-2.5-flash-preview-04-17-thinking` | ❌ | ✅ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-2.5-flash-preview-05-20` | ❌ | ✅ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-2.5-pro-preview-06-05` | ❌ | ✅ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-2.0-flash-thinking-exp-01-21` | ❌ | ❌ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-2.5-flash-lite-preview-06-17` | ❌ | ❌ | ✅ | 1,048,576 | 2025-06-27 |
-| `gemini-1.0-pro-vision-latest` | ❌ | ❌ | ❌ | 12,288 | 2025-06-27 |
-| `gemini-1.5-flash` | ❌ | ❌ | ❌ | 1,000,000 | 2025-06-27 |
-| `gemini-1.5-flash-002` | ❌ | ❌ | ❌ | 1,000,000 | 2025-06-27 |
-| `gemini-1.5-flash-8b` | ❌ | ❌ | ❌ | 1,000,000 | 2025-06-27 |
-| `gemini-1.5-flash-8b-001` | ❌ | ❌ | ❌ | 1,000,000 | 2025-06-27 |
-| `gemini-1.5-flash-8b-latest` | ❌ | ❌ | ❌ | 1,000,000 | 2025-06-27 |
-| `gemini-1.5-flash-latest` | ❌ | ❌ | ❌ | 1,000,000 | 2025-06-27 |
-| `gemini-2.0-flash` | ❌ | ❌ | ❌ | 1,048,576 | 2025-06-27 |
-| `gemini-2.0-flash-001` | ❌ | ❌ | ❌ | 1,048,576 | 2025-06-27 |
-| `gemini-2.0-flash-exp` | ❌ | ❌ | ❌ | 1,048,576 | 2025-06-27 |
-| `gemini-2.0-flash-exp-image-generation` | ❌ | ❌ | ❌ | 1,048,576 | 2025-06-27 |
-| `gemini-2.0-flash-lite` | ❌ | ❌ | ❌ | 1,048,576 | 2025-06-27 |
-| `gemini-2.0-flash-lite-001` | ❌ | ❌ | ❌ | 1,048,576 | 2025-06-27 |
-| `gemini-2.0-flash-lite-preview` | ❌ | ❌ | ❌ | 1,048,576 | 2025-06-27 |
-| `gemini-2.0-flash-lite-preview-02-05` | ❌ | ❌ | ❌ | 1,048,576 | 2025-06-27 |
-| `gemini-2.0-flash-preview-image-generation` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `gemini-2.0-pro-exp` | ❌ | ❌ | ❌ | 1,048,576 | 2025-06-27 |
-| `gemini-2.0-pro-exp-02-05` | ❌ | ❌ | ❌ | 1,048,576 | 2025-06-27 |
-| `gemini-2.5-flash-preview-tts` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `gemini-2.5-pro-preview-tts` | ❌ | ❌ | ❌ | 65,536 | 2025-06-27 |
-| `gemini-exp-1206` | ❌ | ❌ | ❌ | 1,048,576 | 2025-06-27 |
-| `gemini-pro-vision` | ❌ | ❌ | ❌ | 12,288 | 2025-06-27 |
-
----
-
-## together
-
-| Model | Basic | Token Streaming | Multimodal | Context Window | Last Scanned |
-|---------------------------------------------------|:---:|:-------------:|:--------:|:-------:|:----------:|
-| `arcee-ai/coder-large` | ✅ | ✅ | ✅ | 32,768 | 2025-06-27 |
-| `meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | ✅ | ✅ | ✅ | 1,048,576 | 2025-06-27 |
-| `Qwen/Qwen2.5-Coder-32B-Instruct` | ✅ | ✅ | ❌ | 32,768 | 2025-06-27 |
-| `meta-llama/Llama-3.3-70B-Instruct-Turbo` | ✅ | ✅ | ❌ | 131,072 | 2025-06-27 |
-| `meta-llama/Llama-3.3-70B-Instruct-Turbo-Free` | ✅ | ✅ | ❌ | 131,072 | 2025-06-27 |
-| `meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo` | ✅ | ✅ | ❌ | 130,815 | 2025-06-27 |
-| `meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo` | ✅ | ✅ | ❌ | 131,072 | 2025-06-27 |
-| `deepseek-ai/DeepSeek-V3` | ✅ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo` | ✅ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `Qwen/Qwen2.5-72B-Instruct-Turbo` | ❌ | ✅ | ✅ | 131,072 | 2025-06-27 |
-| `arcee-ai/virtuoso-large` | ❌ | ✅ | ✅ | 131,072 | 2025-06-27 |
-| `arcee-ai/virtuoso-medium-v2` | ❌ | ✅ | ✅ | 131,072 | 2025-06-27 |
-| `meta-llama/Llama-4-Scout-17B-16E-Instruct` | ❌ | ✅ | ✅ | 1,048,576 | 2025-06-27 |
-| `Qwen/Qwen3-235B-A22B-fp8-tput` | ❌ | ✅ | ❌ | 40,960 | 2025-06-27 |
-| `nvidia/Llama-3.1-Nemotron-70B-Instruct-HF` | ❌ | ✅ | ❌ | 32,768 | 2025-06-27 |
-| `scb10x/scb10x-llama3-1-typhoon2-70b-instruct` | ❌ | ✅ | ❌ | 8,192 | 2025-06-27 |
-| `NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO` | ❌ | ❌ | ✅ | 32,768 | 2025-06-27 |
-| `Qwen/QwQ-32B` | ❌ | ❌ | ✅ | 131,072 | 2025-06-27 |
-| `google/gemma-3n-E4B-it` | ❌ | ❌ | ✅ | 32,768 | 2025-06-27 |
-| `mistralai/Mistral-7B-Instruct-v0.2` | ❌ | ❌ | ✅ | 32,768 | 2025-06-27 |
-| `perplexity-ai/r1-1776` | ❌ | ❌ | ✅ | 163,840 | 2025-06-27 |
-| `Qwen/Qwen2-72B-Instruct` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `Qwen/Qwen2-VL-72B-Instruct` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `Qwen/Qwen2.5-7B-Instruct-Turbo` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `Qwen/Qwen2.5-VL-72B-Instruct` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `arcee-ai/AFM-4.5B-Preview` | ❌ | ❌ | ❌ | 65,536 | 2025-06-27 |
-| `arcee-ai/arcee-blitz` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `arcee-ai/caller` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `arcee-ai/maestro-reasoning` | ❌ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `arcee_ai/arcee-spotlight` | ❌ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `deepseek-ai/DeepSeek-R1` | ❌ | ❌ | ❌ | 163,840 | 2025-06-27 |
-| `deepseek-ai/DeepSeek-R1-0528-tput` | ❌ | ❌ | ❌ | 163,840 | 2025-06-27 |
-| `deepseek-ai/DeepSeek-R1-Distill-Llama-70B` | ❌ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `deepseek-ai/DeepSeek-R1-Distill-Llama-70B-free` | ❌ | ❌ | ❌ | 8,192 | 2025-06-27 |
-| `deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B` | ❌ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `deepseek-ai/DeepSeek-R1-Distill-Qwen-14B` | ❌ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `deepseek-ai/DeepSeek-V3-p-dp` | ❌ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `google/gemma-2-27b-it` | ❌ | ❌ | ❌ | 8,192 | 2025-06-27 |
-| `lgai/exaone-3-5-32b-instruct` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `lgai/exaone-deep-32b` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `meta-llama/Llama-3-70b-chat-hf` | ❌ | ❌ | ❌ | 8,192 | 2025-06-27 |
-| `meta-llama/Llama-3-8b-chat-hf` | ❌ | ❌ | ❌ | 8,192 | 2025-06-27 |
-| `meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo` | ❌ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `meta-llama/Llama-3.2-3B-Instruct-Turbo` | ❌ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `meta-llama/Llama-3.2-90B-Vision-Instruct-Turbo` | ❌ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `meta-llama/Llama-Vision-Free` | ❌ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `meta-llama/Meta-Llama-3-70B-Instruct-Turbo` | ❌ | ❌ | ❌ | 8,192 | 2025-06-27 |
-| `meta-llama/Meta-Llama-3-8B-Instruct-Lite` | ❌ | ❌ | ❌ | 8,192 | 2025-06-27 |
-| `mistralai/Mistral-7B-Instruct-v0.1` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `mistralai/Mistral-7B-Instruct-v0.3` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `mistralai/Mistral-Small-24B-Instruct-2501` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `mistralai/Mixtral-8x7B-Instruct-v0.1` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `scb10x/scb10x-typhoon-2-1-gemma3-12b` | ❌ | ❌ | ❌ | 131,072 | 2025-06-27 |
-| `togethercomputer/MoA-1` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `togethercomputer/MoA-1-Turbo` | ❌ | ❌ | ❌ | 32,768 | 2025-06-27 |
-| `togethercomputer/Refuel-Llm-V2` | ❌ | ❌ | ❌ | 16,384 | 2025-06-27 |
-| `togethercomputer/Refuel-Llm-V2-Small` | ❌ | ❌ | ❌ | 8,192 | 2025-06-27 |
-
----
-
-## deepseek
-
-| Model | Basic | Token Streaming | Multimodal | Context Window | Last Scanned |
-|---------------------------------------------------|:---:|:-------------:|:--------:|:-------:|:----------:|
-| `deepseek-chat` | ❌ | ❌ | ❌ | 64,000 | 2025-06-27 |
-| `deepseek-reasoner` | ❌ | ❌ | ❌ | 64,000 | 2025-06-27 |
-
----
-
-## groq
-
-| Model | Basic | Token Streaming | Multimodal | Context Window | Last Scanned |
-|---------------------------------------------------|:---:|:-------------:|:--------:|:-------:|:----------:|
-| `allam-2-7b` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `compound-beta` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `compound-beta-mini` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `deepseek-r1-distill-llama-70b` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `distil-whisper-large-v3-en` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `gemma2-9b-it` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `llama-3.1-8b-instant` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `llama-3.3-70b-versatile` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `llama3-70b-8192` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `llama3-8b-8192` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `meta-llama/llama-4-maverick-17b-128e-instruct` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `meta-llama/llama-4-scout-17b-16e-instruct` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `meta-llama/llama-guard-4-12b` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `meta-llama/llama-prompt-guard-2-22m` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `meta-llama/llama-prompt-guard-2-86m` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `mistral-saba-24b` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `playai-tts` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `playai-tts-arabic` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `qwen-qwq-32b` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `qwen/qwen3-32b` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `whisper-large-v3` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-| `whisper-large-v3-turbo` | ❌ | ❌ | ❌ | 30,000 | 2025-06-27 |
-
----
-
-## letta
-
-| Model | Basic | Token Streaming | Multimodal | Context Window | Last Scanned |
-|---------------------------------------------------|:---:|:-------------:|:--------:|:-------:|:----------:|
-| `letta-free` | ❌ | ❌ | ❌ | 8,192 | 2025-06-27 |
-
----
diff --git a/fern/pages/selfhosting/tool_execution.mdx b/fern/pages/selfhosting/tool_execution.mdx
deleted file mode 100644
index e69de29b..00000000
diff --git a/fern/pages/server/docker.mdx b/fern/pages/server/docker.mdx
deleted file mode 100644
index 09fb3c60..00000000
--- a/fern/pages/server/docker.mdx
+++ /dev/null
@@ -1,119 +0,0 @@
----
-title: Run Letta with Docker
-slug: guides/server/docker
----
-
-
-
-
-This launches the Agent Development Environment (ADE) with three key areas: a center chat simulator for testing, a left sidebar for configuration (template settings, tools, LLM config), and a right panel showing memory architecture with real-time context utilization.
-
-
-
-Rename your template `customer-success-agent` by clicking the **pen icon** next to the **Name** field.
-
-
-
-## Step 2: Set up memory blocks
-
-Memory blocks create your agent's persistent knowledge architecture. In the ADE's right panel, in the **Core Memory** section, click **Advanced** → **+ New block** to add custom memory blocks.
-
-
-
-Create four core memory blocks with the following configurations:
-
-
-
-Your agent needs research, communication, email drafting, and email sending tools to gather customer intelligence and send personalized emails.
-
-### Adding Exa for research tools
-
-Exa provides web search, company research, and LinkedIn lookup capabilities for your agent.
-
-
- 
- 
- 
- 
- 
- 
-
-**From Exa**: Attach `web_search_exa`, `company_research_exa`, and `linkedin_search_exa`.
-
-**From Zapier**: Attach `gmail_create_draft` and `gmail_send_email`.
-
-## Step 4: Save your template
-
-Once you've configured all memory blocks and tools, click the **Save** button in the ADE toolbar. This opens a version modal. Click **Save new version** to save your template for agent creation.
-
-Your `customer-success-agent` template is now ready to create customer-specific agents.
-
-## Step 5: Create a customer identity
-
-Before creating agents from your template, you need to set up customer identities. An identity is the customer contact record that represents a unique user and can be associated with one or more agents. An agent is the AI system created for that identity.
-
-This identity-agent relationship enables multi-user applications where each customer gets their own dedicated agent while maintaining proper user isolation and tracking. In a real-world scenario, each new customer that signs up has their identity created (either manually or via API integration). For this demo, you'll create an identity for yourself to test the complete workflow.
-
-Navigate back to the main Letta dashboard and click **Identities** in the left sidebar, then click **+ Create identity**.
-
-In the modal that opens, configure your customer identity using the three fields:
-
-- **Name**: Enter your own full name (for example, `[Your Full Name]`).
-- **Identity Type**: Select **User** for individual customer contacts.
-- **Unique Identifier**: Create a unique string to identify this customer in your system (for example, `customer_[your_name]`).
-
-Click **Confirm** when all fields are populated.
-
-
-
-
-
-Click **+ Create Agent**. Letta creates the agent and opens the ADE for your new agent instance.
-
-You can see the agent name in the top-left corner of the ADE (for example, **customer-success-agent:1 / random-generated-name**).
-
-
-
-
-
-## Step 7: Test the agent
-
-Once you've set up your agent, test the complete workflow with a customer research prompt.
-
-
-
-Let's call agent 1 "Bob" and agent 2 "Alice" (these are just for us to help keep track of them - the agents themselves will communicate via agent IDs).
-To spice things up, let's make "Bob" (shown in light mode) powered by `gpt-4o-mini`, and "Alice" (shown in dark mode) powered by `claude-3.5-sonnet`.
-
-
-
-
-
-
-### Step 2: Prepare agent 1 (Bob) to receive a message
-Now let's get the agents ready to talk to each other.
-Let's prime Bob to get ready for an incoming message from Alice.
-Without this additional context, Bob may become confused about what's going on (we could also provide this extra context via the memory blocks instead).
-
-> Hey - just letting you know I'm going to connect you with another one of my agent buddies. Hope you enjoy chatting with them (I think they'll reach out directly).
-
-
-
-### Step 3: Ask agent 2 (Alice) to send the first message
-Next, let's ask Alice to send a message to Bob.
-We'll copy Bob's agent ID and use it in the message.
-
-We'll also make sure to include a note to Alice to report her results back to us to - otherwise, we might have to wait a while for them to finish!
-
-> Hey, my other agent friend is lonely and needs someone to chat to. Can you give them a ring? Their ID is agent-af4f8b2b-cb46-4d22-b813-6b3f6659213a. If you can reach them, have a short conversation but let me know after a few messages how they're doing!
-
-### Step 4: Watch the two agents converse!
-As soon as we send the message to Alice, we can see Alice and Bob start to communicate with each other!
-To watch the communication happen live, you can open two tabs on the web ADE - one for each agent - and place them side-by-side.
-If you're using Letta Desktop, you can switch between the agents to monitor their conversation.
-
-
-
-
-