🌐 Letta MCP Server

Universal MCP server connecting any AI client to Letta.ai's powerful stateful agents.

🚀 Why This Matters

The Problem: AI ecosystems are fragmented. Your favorite AI clients can't easily access Letta's powerful stateful agents. Manual API integration is complex and time-consuming.

The Solution: Letta MCP Server provides universal connectivity to Letta.ai through the Model Context Protocol standard, enabling:

• 💬 Direct agent conversations from any MCP-compatible client

• 🧠 Persistent memory management across platforms

• 🛠️ Tool orchestration and workflow automation

• 📊 Unified agent analytics and monitoring

Who It's For: Developers building AI applications who want to leverage Letta's stateful agents from Claude Desktop, GitHub Copilot, Cursor, Replit, Sourcegraph Cody, OpenAI ChatGPT, or any MCP-compatible client.

Related MCP server: agentforge

⚡ Quick Start (60 seconds)

1. Install

pip install letta-mcp-server

2. Configure Your MCP Client

Claude Desktop

letta-mcp configure

Manual Configuration (Universal)

Add to your MCP client configuration:

{
  "mcpServers": {
    "letta": {
      "command": "letta-mcp",
      "args": ["run"],
      "env": {
        "LETTA_API_KEY": "your-api-key"
      }
    }
  }
}

GitHub Copilot (VS Code)

Enable MCP support via chat.mcp.enabled setting, then configure the server above.

Other Clients

• Cursor: Add server to MCP configuration

• Replit: Use MCP template integration

• Sourcegraph Cody: Configure through OpenCtx

• OpenAI ChatGPT: Use MCP-compatible endpoint

3. Use From Any Client

📎 Use MCP tool: letta_chat_with_agent
Message: "What's the status of our project?"

🎯 Features

Core Capabilities

Available Tools

🤖 Agent Management

• letta_list_agents - List all agents with optional filtering

• letta_create_agent - Create new agents with memory blocks

• letta_get_agent - Get detailed agent information

• letta_update_agent - Update agent configuration

• letta_delete_agent - Safely delete agents

💬 Conversations

• letta_send_message - Send messages to any agent

• letta_stream_message - Stream responses in real-time

• letta_get_history - Retrieve conversation history

• letta_export_chat - Export conversations

🧠 Memory Management

• letta_get_memory - View agent memory blocks

• letta_update_memory - Update memory blocks

• letta_search_memory - Search through agent memories

• letta_create_memory_block - Add custom memory blocks

🛠️ Tools & Workflows

• letta_list_tools - List available tools

• letta_attach_tool - Add tools to agents

• letta_create_tool - Create custom tools

• letta_set_tool_rules - Configure workflow constraints

📚 Documentation & Client Examples

Universal Usage Pattern

All MCP-compatible clients follow the same pattern for using Letta tools:

🔧 letta_list_agents          # List your agents
🔧 letta_send_message         # Chat with agents  
🔧 letta_update_memory        # Manage agent memory
🔧 letta_attach_tool          # Add tools to agents

Client-Specific Examples

Claude Desktop

# Natural language interface
"Use letta_send_message to ask my sales agent about Q4 inventory"

# Direct tool usage  
🔧 letta_send_message
agent_id: "agent-123"
message: "What's our F-150 inventory status?"

GitHub Copilot (VS Code)

// In VS Code chat
@workspace Use letta_send_message to get project status from my agent

// Agent provides code-aware responses based on your repository context

Cursor

// CMD+K interface with agent context
// Agent understands your current codebase for intelligent assistance

// Use in Cursor Chat
Use letta_create_agent to set up a development assistant for this project

Replit

# In Replit workspace
# Configure MCP server, then use agent tools directly in your development environment

# Example: Create coding assistant
letta_create_agent(
    name="replit-dev-assistant", 
    persona="Expert in the current project's tech stack"
)

Sourcegraph Cody

// Enterprise code intelligence with Letta agents
// Agents provide contextual assistance based on your organization's codebase

// Example: Code review with agent memory
"Use letta_send_message to review this PR against our coding standards"

Examples

See our examples directory for working code samples:

• Quickstart guide - Complete setup and basic usage

• Basic usage - Simple configuration and testing

• Setup testing - Verify your installation works

🔧 Configuration

Environment Variables

# Required for Letta Cloud
LETTA_API_KEY=sk-let-...

# Optional configurations
LETTA_BASE_URL=https://api.letta.com  # For self-hosted: http://localhost:8283
LETTA_DEFAULT_MODEL=openai/gpt-4o-mini
LETTA_DEFAULT_EMBEDDING=openai/text-embedding-3-small
LETTA_TIMEOUT=60
LETTA_MAX_RETRIES=3

Configuration File

Create ~/.letta-mcp/config.yaml:

letta:
  api_key: ${LETTA_API_KEY}
  base_url: https://api.letta.com
  
defaults:
  model: openai/gpt-4o-mini
  embedding: openai/text-embedding-3-small
  
performance:
  connection_pool_size: 10
  timeout: 60
  max_retries: 3
  
features:
  streaming: true
  auto_retry: true
  request_logging: false

🏗️ Universal MCP Architecture

The Letta MCP Server provides a standards-compliant bridge between any MCP client and Letta's powerful agent platform:

┌─────────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   MCP Clients       │    │  Letta MCP       │    │   Letta.ai      │
│                     │    │  Server          │    │   Platform      │
│ • Claude Desktop    │◄──►│                  │◄──►│                 │
│ • GitHub Copilot    │    │ • JSON-RPC 2.0   │    │ • Stateful      │
│ • Cursor           │    │ • Connection      │    │   Agents        │
│ • Replit           │    │   Pooling         │    │ • Memory        │
│ • Sourcegraph Cody │    │ • Error Handling  │    │   Management    │
│ • OpenAI ChatGPT   │    │ • Stream Support  │    │ • Tool          │
│ • Any MCP Client   │    │ • 30+ Tools       │    │   Orchestration │
└─────────────────────┘    └──────────────────┘    └─────────────────┘

Key Components:

• MCP Protocol Compliance: Standard JSON-RPC 2.0 implementation works with any client

• Connection Pooling: Maintains 10 persistent connections for optimal performance

• Error Handling: Automatic retry with exponential backoff for reliability

• Streaming Support: Real-time response streaming for better user experience

• Tool Management: Seamless orchestration of 30+ agent tools

🚀 Performance

Benchmarked on typical developer workflows:

Improvements due to connection pooling, optimized serialization, and intelligent caching.

🌐 MCP Ecosystem Compatibility

The Letta MCP Server is built on the Model Context Protocol (MCP) standard, ensuring broad compatibility across the AI ecosystem:

✅ Verified Compatible Clients

🚀 Future-Ready Architecture

• Standards Compliant: Follows MCP JSON-RPC 2.0 specification exactly

• Client Agnostic: Works with any current or future MCP-compatible client

• Enterprise Ready: Scales across development teams and platforms

• Open Source: Transparent implementation, community-driven improvements

📈 Growing MCP Ecosystem

The Model Context Protocol ecosystem has exploded since launch:

• 1000+ community MCP servers available on GitHub

• Major AI companies adopting MCP: OpenAI (March 2025), Google DeepMind, Anthropic

• Development platforms integrating: VS Code, Zed, Codeium, and more

• Enterprise adoption: Block, Apollo, Atlassian using MCP in production

By choosing Letta MCP Server, you're building on the emerging standard for AI tool connectivity.

🛡️ Security

• API Key Protection: Keys are never exposed in logs or errors

• Request Validation: All inputs are validated before API calls

• Rate Limiting: Built-in protection against API abuse

• Secure Transport: All communications use HTTPS/TLS

🤝 Contributing

We love contributions! See CONTRIBUTING.md for guidelines.

Quick contribution ideas:

• 🐛 Report bugs

• 💡 Suggest features

• 📖 Improve documentation

• 🧪 Add tests

• 🎨 Create examples

📖 Resources

• Letta.ai Documentation

• MCP Specification

• API Reference

• Troubleshooting Guide

• Discord Community

📜 License

MIT License - see LICENSE for details.

🙏 Acknowledgments

Built with ❤️ by the community, for the AI ecosystem.

Special thanks to:

• Letta.ai team for the revolutionary stateful agent platform

• Anthropic for creating and open-sourcing the MCP specification

• OpenAI, GitHub, Cursor, Replit, Sourcegraph for MCP ecosystem leadership

• 1000+ MCP community developers building the future of AI connectivity

• All our contributors and users making this project possible

🌟 Join the MCP Revolution

The Model Context Protocol represents the future of AI interoperability. By using Letta MCP Server, you're:

• Building on standards instead of proprietary integrations

• Future-proofing your AI applications for ecosystem growth

• Contributing to the open-source AI community

• Democratizing access to advanced agent capabilities