Letta MCP Server

A Model Context Protocol (MCP) server that provides comprehensive tools for agent management, memory operations, and integration with the Letta system. This server implements the full MCP specification including tools, prompts, and resources, with enhanced descriptions, output schemas, and behavioral annotations.

View on npm | View on GitHub

Features

• 🤖 Agent Management - Create, modify, clone, and manage Letta agents

• 🧠 Memory Operations - Handle memory blocks and passages

• 🔧 Tool Integration - Attach and manage tools for agents with full MCP support

• 💬 Prompts - Interactive wizards and assistants for common workflows

• 📚 Resources - Access system information, documentation, and agent data

• 🌐 Multiple Transports - HTTP, SSE, and stdio support

• 🔗 MCP Server Integration - Integrate with other MCP servers

• 📊 Enhanced Metadata - Output schemas and behavioral annotations for all tools

• 📦 Docker Support - Easy deployment with Docker

Related MCP server: A2A Client MCP Server

Environment Configuration

Create a .env file with the following variables:

Installation

Install from npm

Use with Claude Desktop

After installing globally, add to your Claude Desktop configuration:

Quick Start with npm

Implementation Options

This repository provides three different implementations of the Letta MCP server, allowing you to choose the best option for your use case:

🔵 Classic Individual Tools (master branch)

Branch: master

The original implementation with individual tools for each API endpoint.

Best for:

• Users who prefer individual, focused tools

• Compatibility with existing integrations

• Granular tool selection and control

• Learning the Letta API one operation at a time

Docker Images:

Features:

• 70+ individual tools, each handling one specific operation

• Direct mapping to Letta API endpoints

• Simple, straightforward tool names

• Full MCP protocol support (tools, prompts, resources)

• Multiple transport protocols (HTTP, SSE, stdio)

🟢 Node.js Consolidated Tools (Recommended for most users)

Branch: nodejs-consolidated-tools

Modern implementation with 7 consolidated tools using the discriminator pattern.

Best for:

• Production deployments

• Claude Desktop integration

• npm package consumers

• Teams who want fewer tools with more functionality

Docker Images:

Features:

• 7 consolidated tools covering 87 operations

• 93% SDK coverage with official @letta-ai/letta-client

• Discriminator pattern (use operation parameter)

• Enhanced error handling and validation

• Full MCP protocol support (tools, prompts, resources)

• Comprehensive test suite and documentation

🦀 Rust Implementation (Performance-focused alternative)

Branch: rust-implementation

High-performance implementation built with Rust and the TurboMCP framework.

Best for:

• Resource-constrained environments

• Maximum performance requirements

• Low memory footprint needs

• Teams familiar with Rust

Docker Images:

Features:

• Same 7 consolidated tools with full feature parity

• Built on TurboMCP framework for MCP protocol

• Compile-time type safety and validation

• Lower memory usage and faster execution

• Multi-architecture Docker builds (amd64, arm64)

Comparison

Choosing an Implementation

Use Classic (master) if:

• You prefer individual, single-purpose tools

• You're already using the original implementation

• You want simple, straightforward tool names

• You're learning the Letta API

Use Node.js Consolidated if:

• You need a battle-tested, production-ready solution

• You want fewer tools with comprehensive functionality

• You're using npm packages or Claude Desktop

• You want SDK-powered reliability and type safety

Use Rust if:

• You need maximum performance

• You're running in resource-constrained environments (edge, embedded)

• You prefer compile-time safety guarantees

• You're comfortable with Docker-based deployment

All three implementations provide identical functionality and MCP protocol compliance. You can switch between them at any time without changing your Letta instance configuration.

Quick Setup

Option 1: Run from source

Option 2: Run with Docker

Using the prebuilt image from GitHub Container Registry

Available tags:

• latest - Latest stable release

• 2.0.1, 2.0, 2 - Specific version tags

• master - Latest master branch build

Using Docker Compose

Building from source

Option 3: Run with stdio for local MCP

Architecture

See the Architecture Documentation for detailed system diagrams and component relationships.

MCP Protocol Support

This server implements the full MCP specification with all three capabilities:

🔧 Tools

All tools include:

• Enhanced Descriptions: Detailed explanations with use cases and best practices

• Output Schemas: Structured response definitions for predictable outputs

• Behavioral Annotations: Hints about tool behavior (readOnly, costLevel, executionTime, etc.)

💬 Prompts

Interactive prompts for common workflows:

• letta_agent_wizard - Guided agent creation with memory and tool setup

• letta_memory_optimizer - Analyze and optimize agent memory usage

• letta_debug_assistant - Troubleshoot agent issues

• letta_tool_config - Discover, attach, create, or audit tools

• letta_migration - Export, import, upgrade, or clone agents

📚 Resources

Access system information and documentation:

• letta://system/status - System health and version info

• letta://system/models - Available LLM and embedding models

• letta://agents/list - Overview of all agents

• letta://tools/all/docs - Complete tool documentation with examples

• letta://docs/mcp-integration - Integration guide

• letta://docs/api-reference - API quick reference

Resource templates for dynamic content:

• letta://agents/{agent_id}/config - Agent configuration

• letta://agents/{agent_id}/memory/{block_id} - Memory block content

• letta://tools/{tool_name}/docs - Individual tool documentation

Available Tools

Agent Management

Memory Management

Passage Management

Tool Management

Model Management

MCP Integration

Prompt Tools

Directory Structure

• src/index.js - Main entry point

• src/core/ - Core server functionality

• src/handlers/ - Prompt and resource handlers

• src/examples/ - Example prompts and resources

• src/tools/ - Tool implementations organized by category:

  • agents/ - Agent management tools

  • memory/ - Memory block tools

  • passages/ - Passage management tools

  • tools/ - Tool attachment and management

  • mcp/ - MCP server integration tools

  • models/ - Model listing tools

  • enhanced-descriptions.js - Detailed tool descriptions

  • output-schemas.js - Structured output definitions

  • annotations.js - Behavioral hints

• src/transports/ - Server transport implementations

Transport Protocols

The server supports three transport protocols:

1. HTTP (Recommended) - Streamable HTTP transport with full duplex communication

   • Endpoint: http://your-server:3001/mcp

   • Best for production use and remote connections

   • Supports health checks at /health

2. SSE (Server-Sent Events) - Real-time event streaming

   • Endpoint: http://your-server:3001/sse

   • Good for unidirectional server-to-client updates

3. stdio - Standard input/output

   • Direct process communication

   • Best for local development and Claude integration

Configuration with MCP Settings

Add the server to your mcp_settings.json:

For remote instances with HTTP transport (recommended):

Docker Operations

Troubleshooting

Common Issues

1. Connection refused errors

   • Ensure the server is running and accessible

   • Check firewall settings for port 3001

   • Verify the correct transport protocol is being used

2. Authentication failures

   • Verify LETTA_BASE_URL includes /v1 suffix

   • Check LETTA_PASSWORD is correct

   • Ensure environment variables are loaded

   • When self-hosting the Letta-Server, set environment variables accordingly:

     "env": { "LETTA_BASE_URL": "http://localhost:8283", "LETTA_PASSWORD": "", "LOG_LEVEL": "info" }

3. Tool execution timeouts

   • Increase timeout values in MCP configuration

   • Check network latency for remote connections

   • Consider using HTTP transport for better reliability

Health Check

The HTTP transport provides a health endpoint:

Response:

Development

Testing

Contributing

We welcome contributions! Please see our Contributing Guide for details on:

• Development setup

• Code style and standards

• Adding new tools

• Testing requirements

• Pull request process

Security

For security vulnerabilities, please see our Security Policy.

License

MIT License - see LICENSE file for details