Outlook Email Processor

🚀 Email Processing MCP Server

This MCP server offers email processing capabilities, integrating MongoDB for semantic search and SQLite for efficient storage and retrieval.

🚀 Quick Start

This MCP server provides email processing functions, integrating MongoDB for semantic search and SQLite for efficient storage and retrieval.

✨ Features

• Process Outlook emails with date range filtering.
• Store emails in the SQLite database with proper connection management.
• Generate vector embeddings using Ollama.
• Support multiple mailboxes.
• Support Inbox, Sent Items, and optionally Deleted Items folders.

🚀 Next Features

• Email search with semantic capabilities.
• Email summarization using LLMs.
• Automatic email classification.
• Customizable email reports.
• Advanced filtering options.
• Draft email responses in Outlook.
• Outlook rule suggestions.
• Expand database options by integrating Neo4j and ChromaDB.

📦 Installation

Prerequisites

• Python 3.10 or higher.
• Ollama running locally (for embeddings).
• Microsoft Outlook installed.
• Windows operating system (for Outlook integration).
• MongoDB server (for storing embeddings).

Steps

1. Install uv (if not already installed):

   pip install uv
   

2. Create a virtual environment:

   uv venv .venv
   

3. Activate the virtual environment:

   Windows:

   .venv\Scripts\activate
   

   macOS/Linux:

   source .venv/bin/activate
   

4. Install dependencies:

uv pip install -e .

5. Install the fastmcp package:

uv pip install fastmcp

6. Ensure Ollama is running locally and install the required model:

ollama pull nomic-embed-text

📚 Documentation

Configuration

Add the server to your Claude for Desktop configuration file:

• Windows: %APPDATA%\Claude\claude_desktop_config.json
• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "outlook-email": {
      "command": "C:/Users/username/path/to/mcp-server-outlook-email/.venv/Scripts/python",
      "args": [
        "C:/Users/username/path/to/mcp-server-outlook-email/src/mcp_server.py"
      ],
      "env": {
        "MONGODB_URI": "mongodb://localhost:27017/MCP?authSource=admin",
        "SQLITE_DB_PATH": "email_processing.db",
        "OLLAMA_HOST": "localhost",
        "OLLAMA_PORT": 11434
      }
    }
  }
}

Example Usage in Claude

"Process emails from February 1st to February 17th from all mailboxes"

Architecture

The server adopts a hybrid search approach:

1. SQLite database is used for:

   • Main email storage.
   • Full-text search functionality.
   • Processing status tracking.
   • Efficient filtering.
   • Automatic directory creation (if it doesn't exist).
   • Properly closing connections when the server shuts down to prevent "cannot operate on a closed database" errors.

2. MongoDB is used for:

   • Storing embedded vectors.
   • Semantic similarity search.
   • Metadata filtering.
   • Efficient retrieval.
   • Properly closing connections after the server shuts down.

Error Handling

The server provides detailed error messages for common issues:

• Invalid date format.
• Connection problems with Outlook.
• MongoDB errors.
• Embedding generation failures with retry logic.
• SQLite storage errors.
• Automatic retry for Ollama server connection issues.

Resource Management

The server implements proper resource management to prevent problems:

• Database connections (SQLite and MongoDB) remain open throughout the server's lifecycle to prevent "cannot operate on a closed database" errors.
• Connections are only closed when the server shuts down, using an atexit processor.
• Destructors and context managers are used as a last resort to ensure connections are closed when objects are garbage - collected.
• Connection management aims to balance resource usage with operational reliability.
• Robust retry logic is used for external services (such as Ollama) to handle temporary connection issues.

Security Considerations

• The server only processes emails from specified mailboxes.
• All data is stored locally (SQLite) and in MongoDB.
• No external API calls are made except to the local Ollama server.
• Explicit user approval is required for email processing.
• No sensitive email data is exposed through the MCP interface.

Debugging

When encountering issues:

1. Verify that emails are processed successfully (check the process_emails response).
2. Ensure the Ollama server is running during embedding generation.
3. Check if the SQLite database is accessible.
4. Verify that the MongoDB connection is working properly.