de en es ja ko ru zh

Letta MCP Server

Name: Letta MCP Server
Author: oculairmedia

by oculairmedia

Overview Schema Related Servers Score Discussions

Rust

Hybrid

Letta MCP-Server

npm version Rust Tests Coverage Docker Build License: MIT

Ein hochperformanter Model Context Protocol (MCP) Server für Letta AI, erstellt mit Rust und dem TurboMCP Framework.

Funktionen

7 konsolidierte Tools, die 103 Operationen unter Verwendung des Diskriminator-Musters abdecken
Hohe Performance -- Rust, ~10-30MB Speicherverbrauch, <500ms Startzeit, paralleles Fan-out via tokio::join! und buffer_unordered
Dualer Transport -- stdio (Claude Desktop, Cursor, etc.) und HTTP (Produktionsbereitstellungen)
Optimierung der Antwortgröße -- 68-96% Reduzierung der Antwortgrößen für LLM-Kontexteffizienz
Typ-eingeschränkte Schemas -- spezifische object/array-Typen mit Beschreibungen pro Parameter (keine generischen Value-Parameter)
Multi-Plattform -- macOS, Linux, Windows (x64 und arm64)
Letta 0.16.x kompatibel -- Archive, Konversationen, MCP-Server v2
MCP 2025-11-25 konform -- streambarer HTTP-Transport mit SSE
Kompilierzeit-Routing -- null Laufzeit-Overhead für Tool-Dispatch via TurboMCP v3 Makros

Related MCP server: A2A Client MCP Server

Schnellstart

npm (Empfohlen)

npm install -g letta-mcp-server

Die korrekte Binärdatei für Ihre Plattform wird automatisch installiert.

Plattform	Paket
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

Umgebungsvariablen

Variable	Erforderlich	Standard	Beschreibung
`LETTA_BASE_URL`	Ja	—	Letta API-URL (z. B. `http://localhost:8283`)
`LETTA_PASSWORD`	Ja	—	Letta API-Passwort
`TRANSPORT`	Nein	`stdio`	Transportmodus: `stdio` oder `http`
`PORT`	Nein	`6507`	HTTP-Port (wenn `TRANSPORT=http`)
`RUST_LOG`	Nein	`info`	Log-Level: `debug`, `info`, `warn`, `error`
`RUST_BACKTRACE`	Nein	`0`	Backtraces aktivieren (`0` oder `1`)

Verfügbare Tools

Der Server bietet 7 konsolidierte Tools mit 103 Operationen:

Tool	Operationen	Beschreibung
`letta_agent_advanced`	28	Agenten-Lebenszyklus, Messaging, Konversationen, Kontext, Export/Import
`letta_memory_unified`	24	Kernspeicher, Blöcke, Archiv-Passagen, Archive, Suche
`letta_tool_manager`	13	Tool-CRUD, Anhängen/Trennen, Massenoperationen
`letta_source_manager`	15	Datenquellen, Dateien, Passagen, Anhänge
`letta_job_monitor`	4	Job-Verfolgung, Abbruch, aktive Überwachung
`letta_file_folder_ops`	8	Dateisitzungen, Ordnerverwaltung
`letta_mcp_ops`	11	MCP-Server-Lebenszyklus, Tool-Erkennung, v2 API-Unterstützung

Tool-Operationen

letta_agent_advanced (28 Operationen)

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

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

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

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

list, get, cancel, list_active

letta_file_folder_ops (8 Operationen)

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

letta_mcp_ops (11 Operationen)

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

Optimierungen der Antwortgröße

Die Rust-Implementierung enthält signifikante Optimierungen der Antwortgröße für die Effizienz des LLM-Kontexts:

Operation	Optimierung	Größenreduzierung
Agentenliste	Standard-Paginierung (15 Elemente), Zusammenfassungsmodus	68-85%
Tool-Liste	Standard-Paginierung (25 Elemente), gekürzte Beschreibungen	70-90%
Speicherblöcke	Schließt schwere Felder im Listenmodus aus	60-80%
Quellenliste	Zusammenfassungsmodus, Paginierung	75-95%

Paginierung

Alle Listenoperationen unterstützen Paginierung:

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

Zusammenfassungs- vs. Vollmodus

Listenoperationen geben standardmäßig Zusammenfassungsdaten zurück. Verwenden Sie die get-Operation mit einer spezifischen ID für vollständige 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-Konfiguration

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

Aus Quellcode bauen

Voraussetzungen

Rust nightly (Unterstützung für Edition 2024) - Installation via rustup
Docker (optional, für containerisierte Builds)

Lokaler 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

Architektur

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

Wichtige Abhängigkeiten

TurboMCP v3 -- MCP-Framework mit Kompilierzeit-Routing und streambarem HTTP
letta-rs -- Vendored Rust Letta API-Client (0.16.x)
Tokio -- Asynchrone Laufzeitumgebung
Futures -- Stream-Kombinatoren (buffer_unordered für paralleles Fan-out)
Serde -- Serialisierung/Deserialisierung

Fehlerbehebung

Verbindung verweigert

Stellen Sie sicher, dass der Server läuft: docker ps | grep letta-mcp
Überprüfen Sie die Logs: docker logs letta-mcp
Überprüfen Sie, ob der Port erreichbar ist: curl http://localhost:6507/mcp

Authentifizierungsfehler

Überprüfen Sie, ob LETTA_BASE_URL auf Ihre Letta-Instanz zeigt
Überprüfen Sie, ob LETTA_PASSWORD korrekt ist
Stellen Sie sicher, dass der Letta-Server vom Container aus erreichbar ist

Tool nicht gefunden

Listen Sie verfügbare Tools via MCP auf: tools/list
Überprüfen Sie, ob Sie die korrekten Operationsnamen verwenden (z. B. list statt list_agents)

Logs

# View server logs
docker logs -f letta-mcp

# Enable debug logging
RUST_LOG=debug letta-mcp

Mitwirken

Forken Sie das Repository
Erstellen Sie einen Feature-Branch: git checkout -b feature/my-feature
Nehmen Sie Änderungen vor und fügen Sie Tests hinzu
Führen Sie Tests aus: cargo test
Senden Sie einen Pull Request

Lizenz

MIT-Lizenz - siehe LICENSE-Datei für Details.

Latest Blog Posts

Tool Definition Quality Score (TDQS)
By punkpeye on April 3, 2026.
mcp
The Hackers Who Tracked My Sleep Cycle
By punkpeye on March 26, 2026.
security
Open Source Has a Bot Problem
By punkpeye on March 19, 2026.
open source

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