Limitless AI MCP Server

An advanced Model Context Protocol (MCP) server that enables AI assistants to interact with Limitless AI Pendant recordings. This server provides a seamless bridge between your AI tools and Limitless API, allowing you to extract insights, search through recordings, and analyze your Pendant data.

> ⚠️ Beta Release: This is an early release (v0.0.1). While core features are implemented and tested, we need community feedback to validate all functionality. Please report any issues!

🌟 Features

Core Capabilities

• Full Limitless API Integration: Access all your Pendant recordings programmatically
• Advanced Search: Search through your recordings with keyword matching
• Flexible Querying: List recordings by date, date range, or get recent recordings
• Rich Content Access: Retrieve markdown content, headings, and metadata
• High Performance: Intelligent caching with LRU eviction and TTL support
• Robust Error Handling: Built-in retry logic and timeout management
• Type Safety: Full TypeScript support with comprehensive type definitions

MCP Protocol Implementation

• 🔧 Tools: 5 specialized tools for searching and retrieving recordings
• 📁 Resources: Browse recordings as structured resources with URI navigation
• 📝 Prompts: Pre-built templates for common analysis tasks
• 🔍 Sampling: AI-powered content analysis and summarization
• 🔎 Discovery: Automatic capability exposure to MCP clients

📋 Requirements

• Node.js 22+
• Limitless Pendant (Required - API only returns Pendant recordings)
• Limitless API Key (Get from limitless.ai/developers)
• MCP-compatible client (Claude Desktop, Windsurf, Cursor, etc.)

🏃 Quick Start

1. Get your API key from limitless.ai/developers

2. Clone and build:

git clone https://github.com/ericbuess/limitless-ai-mcp-server.git
   cd limitless-ai-mcp-server
   npm install
   npm run build

3. Configure Claude Code:

claude mcp add limitless -s user -e LIMITLESS_API_KEY="your-key" -- node $(pwd)/dist/index.js

4. Start chatting: "Show me my recordings from today"

🚀 Installation

Option 1: Install from npm

npm install -g limitless-ai-mcp-server

Option 2: Install from Source

# Clone the repository
git clone https://github.com/ericbuess/limitless-ai-mcp-server.git
cd limitless-ai-mcp-server

# Install dependencies
npm install

# Build the project
npm run build

# Optional: Link globally
npm link

🔧 Configuration

1. Set up your Limitless API key

# Add to your shell profile (.bashrc, .zshrc, etc.)
export LIMITLESS_API_KEY="your-api-key-here"

# Optional: Configure custom settings
export LIMITLESS_TIMEOUT=120000  # Timeout in milliseconds
export LIMITLESS_BASE_URL="https://api.limitless.ai/v1"  # Custom API endpoint
export LOG_LEVEL="INFO"  # Options: DEBUG, INFO, WARN, ERROR

# Optional: Configure caching
export CACHE_MAX_SIZE=100  # Maximum cached items
export CACHE_TTL=300000  # Cache lifetime in ms (5 minutes)
export SEARCH_CACHE_MAX_SIZE=50  # Search cache size
export SEARCH_CACHE_TTL=180000  # Search cache lifetime (3 minutes)

2. Configure your MCP client

Claude Code CLI

If you're using Claude Code (Anthropic's official CLI), run:

# Option 1: Using the command directly (recommended)
npm install -g limitless-ai-mcp-server
claude mcp add limitless -s user -e LIMITLESS_API_KEY="your-api-key-here" -- limitless-ai-mcp-server

# Option 2: Using node with the full path (most reliable with nvm)
npm install -g limitless-ai-mcp-server
# Find where npm installed it:
npm list -g limitless-ai-mcp-server
# Then use the direct path (adjust the node version as needed):
claude mcp add limitless -s user -e LIMITLESS_API_KEY="your-api-key-here" -- node ~/.nvm/versions/node/v22.0.0/lib/node_modules/limitless-ai-mcp-server/dist/index.js

# Option 3: Using local installation
cd /path/to/limitless-ai-mcp-server
npm install && npm run build
claude mcp add limitless -s user -e LIMITLESS_API_KEY="your-api-key-here" -- node /path/to/limitless-ai-mcp-server/dist/index.js

# Verify it's running
claude mcp list

# Remove if needed
claude mcp remove limitless -s user

Claude Desktop Configuration

1. Find your Claude Desktop config file:

2. Open the file (create it if it doesn't exist) and add:

{
  "mcpServers": {
    "limitless": {
      "command": "node",
      "args": ["/path/to/limitless-ai-mcp-server/dist/index.js"],
      "env": {
        "LIMITLESS_API_KEY": "your-api-key-here"
      }
    }
  }
}

3. Replace the placeholders:

4. Restart Claude Desktop for the changes to take effect

5. Verify it's working: Type "Show me my recent recordings" in Claude

Other MCP Clients

Refer to your client's documentation for MCP server configuration.

🛠️ Available Tools

1. `limitless_get_lifelog_by_id`

Retrieves a single recording by its unique ID.

Parameters:

• `lifelog_id` (required): The unique identifier
• `includeMarkdown`: Include markdown content (default: true)
• `includeHeadings`: Include headings (default: true)

2. `limitless_list_lifelogs_by_date`

Lists all recordings for a specific date.

Parameters:

• `date` (required): Date in YYYY-MM-DD format
• `limit`: Maximum results (max: 100)
• `direction`: Sort order ('asc' or 'desc')
• `timezone`: IANA timezone
• `includeMarkdown`: Include markdown content
• `includeHeadings`: Include headings

3. `limitless_list_lifelogs_by_range`

Lists recordings within a date/time range.

Parameters:

• `start` (required): Start date/time
• `end` (required): End date/time
• `limit`: Maximum results
• `direction`: Sort order
• `timezone`: IANA timezone
• `includeMarkdown`: Include markdown content
• `includeHeadings`: Include headings

4. `limitless_list_recent_lifelogs`

Lists the most recent recordings.

Parameters:

• `limit`: Number of recordings (default: 10, max: 100)
• `timezone`: IANA timezone
• `includeMarkdown`: Include markdown content
• `includeHeadings`: Include headings

5. `limitless_search_lifelogs`

Searches for keywords in recent recordings.

Parameters:

• `search_term` (required): Text to search for
• `fetch_limit`: How many recent logs to search (default: 20, max: 100)
• `limit`: Maximum results to return
• `includeMarkdown`: Include markdown content
• `includeHeadings`: Include headings

🔌 MCP Protocol Features

This server implements all five core MCP protocol features to provide multiple ways to access and analyze your Limitless data:

📁 Resources

Browse and access your lifelogs as structured resources. Resources provide a file-system-like interface to your recordings.

Available URIs:

• `lifelog://recent` - Browse recent recordings
• `lifelog://2024-01-15` - Browse recordings from a specific date
• `lifelog://2024-01-15/abc123` - Access a specific recording

Usage in Claude:

"Browse my recent recordings"
"Show me resources from January 15th"
"Open lifelog://recent"

📝 Prompts

Pre-built prompt templates for common analysis tasks. Each prompt can be customized with arguments.

Available Prompts:

1. daily-summary - Summarize all recordings from a specific day

2. action-items - Extract action items from recordings

3. key-topics - Identify main topics discussed

4. meeting-notes - Format recordings as structured meeting notes

5. search-insights - Analyze patterns in search results

Usage in Claude:

"Use the daily-summary prompt for yesterday"
"Extract action items from this week"
"Show me key topics I discussed about the project"

🔍 Sampling

Enable AI-powered content analysis of your recordings. The sampling feature allows the AI to process and analyze lifelog content directly.

Capabilities:

• Summarize long recordings
• Extract specific information
• Identify patterns and trends
• Generate insights from multiple recordings
• Analyze sentiment and tone

Usage in Claude:

"Analyze the tone of my meetings this week"
"Summarize the key decisions from yesterday's recordings"
"Find patterns in how I discuss project timelines"

🔎 Discovery

Automatically exposes server capabilities to MCP clients. This allows Claude and other tools to understand what features are available.

Exposed Information:

• Server name and version
• Available tools, resources, and prompts
• Supported features and limitations
• API capabilities

⚡ Performance & Caching

The server includes an intelligent caching system to optimize performance:

Cache Features:

• LRU (Least Recently Used) eviction strategy
• Configurable TTL (Time To Live)
• Separate caches for lifelogs and search results
• Automatic cache invalidation
• Cache statistics tracking

Configuration (via environment variables):

• `CACHE_MAX_SIZE` - Maximum cached items (default: 100)
• `CACHE_TTL` - Cache lifetime in ms (default: 300000 / 5 minutes)
• `SEARCH_CACHE_MAX_SIZE` - Search cache size (default: 50)
• `SEARCH_CACHE_TTL` - Search cache lifetime (default: 180000 / 3 minutes)

💡 Usage Examples

With Claude Desktop

Once configured, you can interact with your Limitless data naturally:

"Show me all my recordings from yesterday"

"Search for conversations where I discussed 'project timeline'"

"Get the recording with ID abc123 and summarize the key points"

"List my recordings from last week and identify action items"

"What did I discuss in meetings between Monday and Wednesday?"

Programmatic Usage

import { LimitlessClient } from 'limitless-ai-mcp-server';

const client = new LimitlessClient({
  apiKey: process.env.LIMITLESS_API_KEY,
  timeout: 120000,
});

// Get recent recordings
const recentLogs = await client.listRecentLifelogs({ limit: 5 });

// Search for specific content
const results = await client.searchLifelogs({
  searchTerm: 'project update',
  fetchLimit: 50,
});

// Get recordings by date
const todaysLogs = await client.listLifelogsByDate('2024-01-15', {
  includeMarkdown: true,
});

🧪 Development

Setup Development Environment

# Install dependencies
npm install

# Run in development mode
npm run dev

# Run tests
npm test

# Run linting
npm run lint

# Format code
npm run format

Project Structure

limitless-ai-mcp-server/
├── src/
│   ├── core/           # Core business logic
│   │   └── limitless-client.ts
│   ├── tools/          # MCP tool definitions and handlers
│   │   ├── definitions.ts
│   │   ├── handlers.ts
│   │   └── schemas.ts
│   ├── types/          # TypeScript type definitions
│   │   └── limitless.ts
│   ├── utils/          # Utility functions
│   │   ├── date.ts
│   │   ├── format.ts
│   │   ├── logger.ts
│   │   └── retry.ts
│   └── index.ts        # Main server entry point
├── tests/              # Test files
├── examples/           # Usage examples
└── dist/               # Compiled output

Running Tests

# Run all tests
npm test

# Run tests in watch mode
npm run test:watch

# Generate coverage report
npm run test:coverage

🤝 Contributing

Contributions are welcome! Please follow these steps:

1. Fork the repository

2. Create a feature branch (`git checkout -b feature/amazing-feature`)

3. Commit your changes (`git commit -m 'Add amazing feature'`)

4. Push to the branch (`git push origin feature/amazing-feature`)

5. Open a Pull Request

Please ensure:

• All tests pass
• Code follows the existing style (run `npm run lint`)
• Add tests for new features
• Update documentation as needed

🐛 Troubleshooting

Common Issues

1. "No lifelogs found"

2. Timeout errors

3. Authentication errors

Debug Mode

Enable debug logging for more information:

export LOG_LEVEL=DEBUG

Claude Desktop Specific Issues

1. MCP server not showing up

2. "Command failed" errors

3. No data returned

Claude Code CLI Specific Issues

1. "MCP Server Status: failed" with npx

This is a known issue where `npx` doesn't reliably find globally installed packages when using nvm.

Solution: Use the direct command or full path instead:

# Instead of: -- npx limitless-ai-mcp-server
   # Use: -- limitless-ai-mcp-server
   # Or: -- node ~/.nvm/versions/node/vXX.X.X/lib/node_modules/limitless-ai-mcp-server/dist/index.js

2. Finding the correct path with nvm

# First, check which Node version you're using:
   node --version

   # Then find where the package is installed:
   npm list -g limitless-ai-mcp-server

   # The path will be something like:
   # ~/.nvm/versions/node/v22.0.0/lib/node_modules/limitless-ai-mcp-server

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Limitless AI for the amazing Pendant and API
• Anthropic for the MCP protocol
• All contributors to this project

📞 Support

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Author: Eric Buess

Note: This project is not officially affiliated with Limitless AI. It's an independent implementation of an MCP server for the Limitless API.