Skip to main content
Glama

Servidor MCP de Letta

npm version Rust Tests Coverage Docker Build License: MIT

Un servidor de Model Context Protocol (MCP) de alto rendimiento para Letta AI, construido con Rust y el framework TurboMCP.

Características

  • 7 herramientas consolidadas que cubren 103 operaciones utilizando el patrón discriminador

  • Alto rendimiento -- Rust, ~10-30MB de memoria, <500ms de inicio, fan-out paralelo mediante tokio::join! y buffer_unordered

  • Transporte dual -- stdio (Claude Desktop, Cursor, etc.) y HTTP (despliegues en producción)

  • Optimización del tamaño de respuesta -- reducción del 68-96% en el tamaño de las respuestas para la eficiencia del contexto del LLM

  • Esquemas con tipos restringidos -- tipos object/array específicos con descripciones por parámetro (sin parámetros Value genéricos)

  • Multiplataforma -- macOS, Linux, Windows (x64 y arm64)

  • Compatible con Letta 0.16.x -- archivos, conversaciones, servidores MCP v2

  • Cumple con MCP 2025-11-25 -- transporte HTTP transmitible con SSE

  • Enrutamiento en tiempo de compilación -- cero sobrecarga en tiempo de ejecución para el despacho de herramientas mediante macros de TurboMCP v3

Related MCP server: A2A Client MCP Server

Inicio rápido

npm (Recomendado)

npm install -g letta-mcp-server

El binario correcto para su plataforma se instala automáticamente.

Plataforma

Paquete

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

Variables de entorno

Variable

Requerido

Predeterminado

Descripción

LETTA_BASE_URL

URL de la API de Letta (ej. http://localhost:8283)

LETTA_PASSWORD

Contraseña de la API de Letta

TRANSPORT

No

stdio

Modo de transporte: stdio o http

PORT

No

6507

Puerto HTTP (cuando TRANSPORT=http)

RUST_LOG

No

info

Nivel de registro: debug, info, warn, error

RUST_BACKTRACE

No

0

Habilitar trazas de error (0 o 1)

LETTA_MCP_MAX_VALUE_LEN

No

500

Caracteres máximos para valores de bloque/pasajes/búsqueda

LETTA_MCP_CORE_MEMORY_PREVIEW_LEN

No

200

Caracteres máximos para vistas previas de memoria central

Herramientas disponibles

El servidor proporciona 7 herramientas consolidadas con 103 operaciones:

Herramienta

Operaciones

Descripción

letta_agent_advanced

28

Ciclo de vida del agente, mensajería, conversaciones, contexto, exportación/importación

letta_memory_unified

24

Memoria central, bloques, pasajes de archivo, archivos, búsqueda

letta_tool_manager

13

CRUD de herramientas, adjuntar/desadjuntar, operaciones masivas

letta_source_manager

15

Fuentes de datos, archivos, pasajes, adjuntos

letta_job_monitor

4

Seguimiento de trabajos, cancelación, monitoreo activo

letta_file_folder_ops

8

Sesiones de archivos, gestión de carpetas

letta_mcp_ops

11

Ciclo de vida del servidor MCP, descubrimiento de herramientas, soporte de API v2

Operaciones de herramientas

letta_agent_advanced (28 operaciones)

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 operaciones)

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 operaciones)

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 operaciones)

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 operaciones)

list, get, cancel, list_active

letta_file_folder_ops (8 operaciones)

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

letta_mcp_ops (11 operaciones)

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

Optimizaciones del tamaño de respuesta

La implementación en Rust incluye optimizaciones significativas en el tamaño de las respuestas para la eficiencia del contexto del LLM:

Operación

Optimización

Reducción de tamaño

Lista de agentes

Paginación predeterminada (15 elementos), modo resumen

68-85%

Lista de herramientas

Paginación predeterminada (25 elementos), descripciones truncadas

70-90%

Bloques de memoria

Excluye campos pesados en modo lista

60-80%

Lista de fuentes

Modo resumen, paginación

75-95%

Paginación

Todas las operaciones de lista admiten paginación:

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

Modo resumen vs. completo

Las operaciones de lista devuelven datos resumidos de forma predeterminada. Utilice la operación get con el ID específico para obtener detalles completos:

// 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": [...]
}

Configuración del cliente MCP

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
    }
  }
}

Construcción desde el código fuente

Requisitos previos

  • Rust nightly (soporte para la edición 2024) - instalar mediante rustup

  • Docker (opcional, para compilaciones en contenedores)

Construcción local

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

Construcción con Docker

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

Arquitectura

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

Dependencias clave

  • TurboMCP v3 -- Framework MCP con enrutamiento en tiempo de compilación y HTTP transmitible

  • letta-rs -- Cliente de API de Letta para Rust (0.16.x)

  • Tokio -- Entorno de ejecución asíncrono

  • Futures -- Combinadores de flujo (buffer_unordered para fan-out paralelo)

  • Serde -- Serialización/deserialización

Solución de problemas

Conexión rechazada

  1. Asegúrese de que el servidor esté ejecutándose: docker ps | grep letta-mcp

  2. Verifique los registros: docker logs letta-mcp

  3. Verifique que el puerto sea accesible: curl http://localhost:6507/mcp

Errores de autenticación

  1. Verifique que LETTA_BASE_URL apunte a su instancia de Letta

  2. Compruebe que LETTA_PASSWORD sea correcto

  3. Asegúrese de que el servidor Letta sea accesible desde el contenedor

Herramienta no encontrada

  1. Liste las herramientas disponibles mediante MCP: tools/list

  2. Verifique que está utilizando los nombres de operación correctos (ej. list no list_agents)

Registros

# View server logs
docker logs -f letta-mcp

# Enable debug logging
RUST_LOG=debug letta-mcp

Contribución

  1. Bifurque (fork) el repositorio

  2. Cree una rama de características: git checkout -b feature/my-feature

  3. Realice cambios y añada pruebas

  4. Ejecute las pruebas: cargo test

  5. Envíe una solicitud de extracción (pull request)

Licencia

Licencia MIT - consulte el archivo LICENSE para obtener más detalles.

Proyectos relacionados

Install Server
A
license - permissive license
A
quality
A
maintenance

Maintenance

Maintainers
4dResponse time
2wRelease cycle
8Releases (12mo)
Commit activity
Issues opened vs closed

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Servers

View all related MCP servers

Related MCP Connectors

  • MCP server exposing the Backtest360 engine API as tools for AI agents.

  • MCP server for AI dialogue using various LLM models via AceDataCloud

  • Cloud-hosted MCP server for durable AI memory

View all MCP Connectors

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/oculairmedia/Letta-MCP-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server