What can you do with this server?

The Letta MCP Server provides comprehensive tools for agent management, memory operations, and tool integration within the Letta system. * Agent Management: Create, list, prompt, modify, delete, clone, and bulk delete agents with specific configurations * Memory Management: Create, list, read, update, and attach memory blocks to agents * Tool Management: List, attach (individually or in bulk), and upload tools for agents * Additional Features: Manage models (LLM and embedding), archive passages, other MCP servers, and import/export agent configurations * Deployment: Run locally with Node.js or Docker, configurable via mcp_settings.json

Which integrations are available for this server?

Uses .env files for configuration, allowing storage of Letta API credentials and endpoints securely outside of the codebase. Repository hosting for the Letta MCP server, enabling version control, contribution workflows, and distribution of the server code. Provides package management for the Letta MCP server, managing dependencies and offering scripts for building and running the server. Used as the implementation language for the Letta MCP server, with build scripts to compile TypeScript code before execution.

How do I use Letta MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Letta MCP Server list all my agents and their status" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Letta MCP Server

npm version Rust Tests Docker Build License: MIT

A high-performance Model Context Protocol (MCP) server for Letta AI, built with Rust and the TurboMCP framework.

Features

7 Consolidated Tools covering 103 operations using the discriminator pattern
High Performance -- Rust, ~10-30MB memory, <500ms startup, parallel fan-out via tokio::join! and buffer_unordered
Dual Transport -- stdio (Claude Desktop, Cursor, etc.) and HTTP (production deployments)
Response Size Optimization -- 68-96% reduction in response sizes for LLM context efficiency
Type-Narrowed Schemas -- specific object/array types with per-parameter descriptions (no generic Value params)
Multi-Platform -- macOS, Linux, Windows (x64 and arm64)
Letta 0.16.x Compatible -- archives, conversations, MCP servers v2
MCP 2025-11-25 Compliant -- streamable HTTP transport with SSE
Compile-Time Routing -- zero runtime overhead for tool dispatch via TurboMCP v3 macros

Related MCP server: A2A Client MCP Server

Quick Start

npm (Recommended)

npm install -g letta-mcp-server

The correct binary for your platform is installed automatically.

Platform	Package
macOS Intel	`letta-mcp-darwin-x64`
macOS Apple Silicon	`letta-mcp-darwin-arm64`
Linux x64	`letta-mcp-linux-x64`
Linux arm64	`letta-mcp-linux-arm64`
Windows x64	`letta-mcp-windows-x64`

Docker

docker pull ghcr.io/oculairmedia/letta-mcp-server-rust:rust-latest

docker run -d \
  -p 6507:6507 \
  -e LETTA_BASE_URL=http://your-letta-instance:8283 \
  -e LETTA_PASSWORD=your-password \
  -e TRANSPORT=http \
  --name letta-mcp \
  ghcr.io/oculairmedia/letta-mcp-server-rust:rust-latest

Docker Compose

services:
  letta-mcp:
    image: ghcr.io/oculairmedia/letta-mcp-server-rust:rust-latest
    container_name: letta-mcp
    restart: unless-stopped
    ports:
      - '6507:6507'
    environment:
      LETTA_BASE_URL: ${LETTA_BASE_URL}
      LETTA_PASSWORD: ${LETTA_PASSWORD}
      TRANSPORT: http
      PORT: 6507
      RUST_LOG: info
    env_file:
      - .env
    healthcheck:
      test: ['CMD-SHELL', "timeout 1 bash -c '</dev/tcp/localhost/6507' || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 3

Environment Variables

Variable	Required	Default	Description
`LETTA_BASE_URL`	Yes	—	Letta API URL (e.g. `http://localhost:8283`)
`LETTA_PASSWORD`	Yes	—	Letta API password
`TRANSPORT`	No	`stdio`	Transport mode: `stdio` or `http`
`PORT`	No	`6507`	HTTP port (when `TRANSPORT=http`)
`RUST_LOG`	No	`info`	Log level: `debug`, `info`, `warn`, `error`
`RUST_BACKTRACE`	No	`0`	Enable backtraces (`0` or `1`)

Available Tools

The server provides 7 consolidated tools with 103 operations:

Tool	Operations	Description
`letta_agent_advanced`	28	Agent lifecycle, messaging, conversations, context, export/import
`letta_memory_unified`	24	Core memory, blocks, archival passages, archives, search
`letta_tool_manager`	13	Tool CRUD, attach/detach, bulk operations
`letta_source_manager`	15	Data sources, files, passages, attachments
`letta_job_monitor`	4	Job tracking, cancellation, active monitoring
`letta_file_folder_ops`	8	File sessions, folder management
`letta_mcp_ops`	11	MCP server lifecycle, tool discovery, v2 API support

Tool Operations

letta_agent_advanced (28 operations)

list, create, get, update, delete, search, list_tools, send_message,
export, import, clone, get_config, bulk_delete, context, reset_messages,
summarize, stream, async_message, cancel_message, preview_payload,
search_messages, get_message, count, list_conversations,
get_conversation, send_conversation_message, cancel_conversation,
compact_conversation

letta_memory_unified (24 operations)

get_core_memory, update_core_memory, get_block_by_label, list_blocks,
create_block, get_block, update_block, attach_block, detach_block,
list_agents_using_block, search_archival, list_passages, create_passage,
update_passage, delete_passage, search_memory, list_archives,
get_archive, create_archive, update_archive, delete_archive,
attach_archive, detach_archive, list_agents_using_archive

letta_tool_manager (13 operations)

list, get, create, update, delete, upsert, attach, detach, bulk_attach,
generate_from_prompt, generate_schema, run_from_source, add_base_tools

letta_source_manager (15 operations)

list, get, create, update, delete, count, attach, detach, list_attached,
upload, delete_files, list_files, list_folders, get_folder_contents,
list_agents_using

letta_job_monitor (4 operations)

list, get, cancel, list_active

letta_file_folder_ops (8 operations)

list_files, open_file, close_file, close_all_files, list_folders,
attach_folder, detach_folder, list_agents_in_folder

letta_mcp_ops (11 operations)

add, update, delete, test, connect, resync, list_servers, list_tools,
register_tool, execute, attach_mcp_server

Response Size Optimizations

The Rust implementation includes significant response size optimizations for LLM context efficiency:

Operation	Optimization	Size Reduction
Agent List	Default pagination (15 items), summary mode	68-85%
Tool List	Default pagination (25 items), truncated descriptions	70-90%
Memory Blocks	Excludes heavy fields in list mode	60-80%
Source List	Summary mode, pagination	75-95%

Pagination

All list operations support pagination:

{
  "operation": "list",
  "pagination": {
    "limit": 25,
    "offset": 0
  }
}

Summary vs Full Mode

List operations return summary data by default. Use get operation with specific ID for full details:

// Summary (default for list)
{
  "id": "agent-123",
  "name": "My Agent",
  "model": "gpt-4",
  "tool_count": 5
}

// Full (with get operation)
{
  "id": "agent-123",
  "name": "My Agent",
  "model": "gpt-4",
  "system_prompt": "...",
  "tools": [...],
  "memory_blocks": [...]
}

MCP Client Configuration

Claude Desktop

{
  "mcpServers": {
    "letta": {
      "command": "letta-mcp",
      "env": {
        "LETTA_BASE_URL": "http://localhost:8283",
        "LETTA_PASSWORD": "your-password"
      }
    }
  }
}

Cursor / Windsurf

{
  "mcpServers": {
    "letta": {
      "command": "letta-mcp",
      "env": {
        "LETTA_BASE_URL": "http://localhost:8283",
        "LETTA_PASSWORD": "your-password"
      }
    }
  }
}

OpenCode (HTTP)

{
  "mcp": {
    "letta-mcp": {
      "type": "remote",
      "url": "http://localhost:6507/mcp",
      "enabled": true
    }
  }
}

Building from Source

Prerequisites

Rust nightly (edition 2024)
Docker (for containerized builds)

Local Build

git clone https://github.com/oculairmedia/Letta-MCP-server.git
cd Letta-MCP-server

cargo build --release

LETTA_BASE_URL=http://your-letta:8283 \
LETTA_PASSWORD=your-password \
./target/release/letta-server

Docker Build

docker build -f Dockerfile.rust -t letta-mcp .

docker run -d \
  -p 6507:6507 \
  -e LETTA_BASE_URL=http://your-letta:8283 \
  -e LETTA_PASSWORD=your-password \
  -e TRANSPORT=http \
  letta-mcp

Architecture

letta-server/
├── src/
│   ├── main.rs                        # Entry point, transport selection
│   ├── lib.rs                         # Server init, compile-time tool registration
│   └── tools/
│       ├── mod.rs                     # Tool module exports
│       ├── response_utils.rs          # Unified ToolResponse, pagination helpers
│       ├── validation_utils.rs        # require_field, require_id, sdk_err
│       ├── id_utils.rs               # ID parsing utilities
│       ├── agent_advanced/            # Agent operations (28 ops)
│       │   ├── crud.rs               #   list, create, get, update, delete, search
│       │   ├── messaging.rs           #   send_message, stream, async, preview
│       │   ├── conversations.rs       #   list, get, send, cancel, compact
│       │   └── management.rs          #   export, import, clone, config, bulk_delete
│       ├── memory_unified/            # Memory operations (24 ops)
│       │   ├── core.rs               #   get/update core memory
│       │   ├── blocks.rs             #   block CRUD, attach/detach
│       │   ├── passages.rs           #   archival passage CRUD
│       │   ├── archives.rs           #   archive CRUD, attach/detach
│       │   └── search.rs             #   search_archival, search_memory
│       ├── tool_manager.rs            # Tool operations (13 ops)
│       ├── source_manager.rs          # Source operations (15 ops)
│       ├── job_monitor.rs             # Job operations (4 ops)
│       ├── file_folder_ops.rs         # File/folder operations (8 ops)
│       └── mcp_ops.rs                # MCP server v2 operations (11 ops)
├── tests/                             # Integration tests
└── Cargo.toml

Key Dependencies

TurboMCP v3 -- MCP framework with compile-time routing and streamable HTTP
letta-rs -- Vendored Rust Letta API client (0.16.x)
Tokio -- Async runtime
Futures -- Stream combinators (buffer_unordered for parallel fan-out)
Serde -- Serialization/deserialization

Troubleshooting

Connection Refused

Ensure the server is running: docker ps | grep letta-mcp
Check logs: docker logs letta-mcp
Verify port is accessible: curl http://localhost:6507/mcp

Authentication Errors

Verify LETTA_BASE_URL points to your Letta instance
Check LETTA_PASSWORD is correct
Ensure Letta server is accessible from the container

Tool Not Found

List available tools via MCP: tools/list
Verify you're using correct operation names (e.g., list not list_agents)

Logs

# View server logs
docker logs -f letta-mcp

# Enable debug logging
RUST_LOG=debug letta-mcp

Contributing

Fork the repository
Create a feature branch: git checkout -b feature/my-feature
Make changes and add tests
Run tests: cargo test
Submit a pull request

License

MIT License - see LICENSE file for details.

Letta - The Letta AI framework
TurboMCP - MCP framework for Rust
Model Context Protocol - MCP specification

Install Server

security – no known vulnerabilities

license - permissive license

quality - confirmed to work

How are these scores calculated?

Resources

Need Help?

Report Issue

Reddit Discussion

Related Servers

Looking for Admin?

Admins can modify the Dockerfile, update the server description, and track usage metrics. If you are the server author, to access the admin panel.

Tools

View all tools