Evernote

# Add to your shell profile (.zshrc, .bashrc, etc.) export EVERNOTE_CONSUMER_KEY="your-consumer-key-here" export EVERNOTE_CONSUMER_SECRET="your-consumer-secret-here" # Optional: Enable detailed debug logging for development export DEV_MODE=true # Reload your shell or run: source ~/.zshrc

The server runs over HTTPS and requires SSL certificates for local development:

# Create certificate directory mkdir cert # Generate self-signed certificate (valid for 365 days) openssl req -x509 -newkey rsa:4096 -keyout cert/localhost.key -out cert/localhost.crt -days 365 -nodes -subj "/C=US/ST=Local/L=Local/O=Local/OU=Local/CN=localhost"

The server will start onhttps://localhost:3443. Your browser will show a security warning for the self-signed certificate - this is normal for local development.

The server now automatically checks for expired authentication tokens on startup:

🚀 Starting Evernote MCP Server... 🔍 Token status: Token valid until 8/21/2025, 1:20:00 AM ✅ Using existing valid authentication tokens ✅ Authentication ready 🌐 Evernote MCP Server listening on HTTPS port 3443

🚀 Starting Evernote MCP Server... 🔍 Token status: Token expired on 6/16/2025, 9:55:49 PM ⚠️ Your Evernote authentication tokens have expired. Would you like to re-authenticate now? (y/N): y 🧹 Re-authenticating with Evernote... 🚀 Starting Evernote OAuth flow...

If you chooseN(no), the server will exit gracefully with instructions to restart and chooseywhen ready to re-authenticate.
- Generate SSL certificates(see setup instructions above)
- Set environment variableswith your Evernote API credentials
- Start the server:npx node index.js
- Complete OAuth authentication:

- Server automatically opens your browser to Evernote's authorization page
- Accept the self-signed certificate warning in your browser
- Log in to your Evernote account and authorize the application
- You'll be redirected back to the server with a success message
- Access token is automatically stored in .env file for future use

The server implements Evernote's OAuth 1.0a flow:
- Request Token: Server generates temporary request token
- User Authorization: Browser opens Evernote authorization URL
- Callback: User authorizes app, Evernote redirects to callback URL
- Access Token: Server exchanges request token for permanent access token
- Storage: Access token stored securely in .env file

Note: The server uses Evernote's production environment (sandbox has been decommissioned by Evernote).

The easiest way to run the Evernote MCP server is using Docker with the provided Chainguard-based secure container image:

# Clone the repository git clone https://github.com/brentmid/evernote-mcp-server.git cd evernote-mcp-server # Copy environment template cp .env.example .env # Edit .env with your Evernote API credentials vim .env # Build and run the container docker-compose up --build

The server will be available athttps://localhost:3443.

The Docker setup usesChainguard's secure Node.js base image(cgr.dev/chainguard/node:latest) which provides:

- Zero vulnerabilities- Minimal attack surface with only essential packages
- Signed container images- All images signed with Sigstore for supply chain security
- SBOM included- Software Bill of Materials generated at build time
- Non-root execution- Containers run as non-root user for enhanced security
- Minimal size- Only 145MB compared to 1.12GB for standard Node.js images

The Docker setup includes several key files:

- Builder stage: Usescgr.dev/chainguard/node:latest-devwith git and openssl for setup
- Production stage: Uses minimalcgr.dev/chainguard/node:latestfor runtime
- GitHub integration: Clones latest code directly from your GitHub repository
- SSL certificates: Automatically generates self-signed certificates for HTTPS
- Security: Runs as non-root user with minimal dependencies

- Environment variables: Loads from.envfile or environment
- Port mapping: Exposes HTTPS port 3443 to host
- Health checks: Built-in container health monitoring
- Restart policy: Automatically restarts on failure
- Build arguments: Configurable GitHub repository URL

- Node modules, logs, and development files
- Git repository data and documentation
- Test files and configurations
- SSL certificates (generated in container)

EVERNOTE_CONSUMER_KEY=your_consumer_key_here EVERNOTE_CONSUMER_SECRET=your_consumer_secret_here DEV_MODE=false

# Build and run with compose docker-compose up --build # Run in background docker-compose up -d --build # View logs docker-compose logs -f # Stop and remove docker-compose down

# Build image docker build \ --build-arg GITHUB_REPO_URL=https://github.com/yourusername/evernote-mcp-server.git \ -t evernote-mcp-server . # Run container docker run -d \ --name evernote-mcp \ -p 3443:3443 \ -e EVERNOTE_CONSUMER_KEY=your_key \ -e EVERNOTE_CONSUMER_SECRET=your_secret \ evernote-mcp-server # View logs docker logs -f evernote-mcp

The repository includesevernote-mcp-daily-rebuild.sh, a shell script designed for daily automated rebuilds to keep your Chainguard base images up to date:

# Set up daily rebuild (example cron job) 0 2   * /path/to/your/evernote-mcp-server/evernote-mcp-daily-rebuild.sh >> /tmp/evernote-mcp-rebuild.log 2>&1

- Pulls the latestcgr.dev/chainguard/node:latestbase image
- Rebuilds the container with--no-cacheto ensure fresh dependencies
- Restarts the service with zero downtime using Docker Compose

- Ensures you always have the latest security patches from Chainguard
- Maintains zero-CVE status with automated base image updates
- No manual intervention required for security updates

The container accepts these environment variables:

- EVERNOTE_CONSUMER_KEY- Your Evernote API consumer key (required)
- EVERNOTE_CONSUMER_SECRET- Your Evernote API consumer secret (required)
- DEV_MODE- Enable debug logging (optional, default: false)
- NODE_ENV- Node.js environment (set to production in container)

For persistent token storage across container restarts:

volumes: - ./tokens:/app/tokens # If implementing file-based token storage

The container includes built-in health monitoring:

- Endpoint: Internal HTTPS health check on port 3443
- Interval: Every 30 seconds
- Timeout: 10 seconds
- Retries: 3 attempts before marking unhealthy
- Start period: 40 seconds for initial startup

Build fails with "git not found":

- Ensure your GitHub repository is public or configure authentication
- Check theGITHUB_REPO_URLbuild argument in docker-compose.yml

- Certificates are auto-generated in the container
- Your browser will show security warnings for self-signed certificates (normal)
- Accept the certificate warning to proceed

- Check container logs:docker-compose logs evernote-mcp-server
- Verify environment variables are set correctly
- Ensure Evernote API credentials are valid

Container restart loops (every 2-3 minutes):

- ✅RESOLVED(August 5, 2025): Container stability issue fixed by optimized health check implementation
- ✅Root cause identified: Node.js health check command was creating accumulating timeout processes
- ✅Solution: Simplified Node.js health check with proper timeout handling eliminates process accumulation
- Details: See CLAUDE.md for complete investigation timeline and technical resolution analysis
- Diagnostic Tools: Use provided debugging scripts for similar issues (see Debugging section below)
- Status: Container running stable with proper health checks, no restart cycles detected

- Complete OAuth flow may require running the server locally first
- Container inherits tokens from host if using volume mounts
- Consider runningnode index.jslocally first, then containerize

# View container logs docker-compose logs -f evernote-mcp-server # Enable debug mode echo "DEV_MODE=true" >> .env docker-compose up --build # Execute commands in running container docker-compose exec evernote-mcp-server sh # Check container health docker-compose ps

The Docker setup implements several security best practices:

- Minimal base image: Chainguard's distroless Node.js image
- Non-root execution: Container runs asnodeuser (non-root)
- HTTPS only: All communication over secure HTTPS
- Environment isolation: Secrets passed via environment variables
- Network security: Only necessary port (3443) exposed
- Supply chain security: Signed base images with SBOMs

Docker deployment offers several performance benefits:

- Consistent environment: Identical runtime across different machines
- Resource limits: Can set CPU/memory limits via docker-compose
- Caching: Docker layer caching speeds up rebuilds
- Scaling: Easy to run multiple instances behind a load balancer

The server supports two integration methods with Claude Desktop:

Method 1: Local stdin/stdout Integration (Original)

After completing the server setup above, configure Claude Desktop for direct process execution.

Step 1: Locate Claude Desktop Configuration

~/Library/Application Support/Claude/claude_desktop_config.json

Choose one of these configurations based on your setup:

Option A: Direct Node.js execution (local development)