Mcp Servers

MCP Servers

A collection of Model Context Protocol (MCP) servers built with Rust.

Available Servers

LTM-MCP (Long-Term Memory)

A powerful long-term memory server for AI assistants, providing persistent storage and retrieval of conversational context and information.

Features:

• PostgreSQL-backed persistent storage with full-text search
• HTTP/SSE transport for remote MCP access
• API key authentication
• Automatic database migrations
• Docker and Kubernetes deployment ready
• Multi-platform support (linux/amd64, linux/arm64)

MCP Tools:

• store_memory - Store new memories with content, context, tags, and metadata
• get_memory - Retrieve a specific memory by ID
• search_memories - Full-text search across memory content
• list_memories - List memories with filtering by collection and tags
• update_memory - Update existing memory fields
• delete_memory - Remove a memory from storage
• add_tags - Add tags to an existing memory
• remove_tags - Remove tags from a memory
• list_tags - Get all unique tags across memories
• list_collections - Get all unique collection names

Quick Start

Using Docker (Recommended)

# Pull the latest image
docker pull ghcr.io/kagchi/mcp-servers-ltm-mcp:latest

# Run with PostgreSQL
docker run -d \
  --name ltm-mcp \
  -p 3000:3000 \
  -e LTM_DATABASE_URL="postgresql://user:password@postgres:5432/ltm" \
  -e LTM_AUTH_API_KEY="your-secret-api-key" \
  ghcr.io/kagchi/mcp-servers-ltm-mcp:latest

From Source

# Clone the repository
git clone https://github.com/KagChi/mcp-servers.git
cd mcp-servers

# Set environment variables
export LTM_DATABASE_URL="postgresql://localhost:5432/ltm"
export LTM_AUTH_API_KEY="your-secret-api-key"

# Build and run
cargo run --package ltm-mcp

Configuration

All configuration is done through environment variables with the LTM_ prefix. For local development, create a .env file in crates/ltm-mcp/ (see .env.example).

Required Configuration

• LTM_DATABASE_URL - PostgreSQL connection URL
• Format: postgresql://user:password@host:port/database
• Example: postgresql://postgres:password@localhost:5432/ltm-mcp
• LTM_AUTH_API_KEY - API key for authentication
• Example: your-secret-api-key-here

Optional Configuration

• LTM_SERVER_HOST - Server bind address (default: 0.0.0.0)
• LTM_SERVER_PORT - Server port (default: 3000)
• LTM_LOG_LEVEL - Log level (default: info)
• Options: trace, debug, info, warn, error

Connecting to LTM-MCP

LTM-MCP uses the Model Context Protocol (MCP) over HTTP/SSE for remote access. The MCP endpoint is available at /mcp.

Authentication

The server requires API key authentication using Bearer tokens. All requests to the /mcp endpoint must include the API key in the Authorization header:

Authorization: Bearer your-secret-api-key

The /health endpoint does not require authentication and can be used for Kubernetes health checks.

Remote MCP Configuration

To connect from an MCP client (such as Claude Desktop or other MCP-compatible tools), configure the connection with:

Endpoint URL: http://your-server:3000/mcp

Authentication: Include the LTM_AUTH_API_KEY value as a Bearer token in the Authorization header.

Example: Connecting from Claude Desktop

Add to your MCP client configuration:

{
  "mcpServers": {
    "ltm-mcp": {
      "url": "http://your-ltm-server:3000/mcp",
      "transport": "sse",
      "headers": {
        "Authorization": "Bearer your-secret-api-key"
      }
    }
  }
}

Security Notes:

• Always use HTTPS in production deployments to protect the API key in transit
• Keep your API key secret and rotate it regularly
• Consider using a reverse proxy (nginx, Traefik) or API gateway for additional security features

API Endpoints

MCP Protocol Endpoint

GET/POST /mcp

The main MCP endpoint supporting HTTP/SSE transport. This endpoint handles all MCP protocol messages including:

• Server initialization and capability negotiation
• Tool listing and execution
• Session management

Health Check

GET /health

Verifies server and database connectivity.

Note: The server uses session-based MCP protocol. Connect via an MCP client (such as Claude Desktop) rather than calling endpoints directly.

Development

Prerequisites

• Rust 1.95.0 or later
• PostgreSQL 14 or later
• Docker (for containerized deployment)

Building

# Build all crates
cargo build --workspace

# Build specific crate
cargo build --package ltm-mcp

# Build for release
cargo build --release --workspace

Testing

# Run all tests
cargo test --workspace

# Run tests for specific crate
cargo test --package ltm-mcp

Code Quality

# Format code
cargo fmt --all

# Run linter
cargo clippy --all-targets --all-features -- -D warnings

Docker Deployment

Building Images

# Build ltm-mcp image
docker build -f crates/ltm-mcp/Dockerfile -t ltm-mcp:latest .

Multi-Platform Builds

docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -f crates/ltm-mcp/Dockerfile \
  -t ltm-mcp:latest \
  .

Project Structure

mcp-servers/
├── Cargo.toml                 # Workspace configuration
├── LICENSE                    # Apache-2.0 license
├── README.md                  # This file
├── .github/
│   └── workflows/
│       ├── check.yml          # Rust and Docker validation
│       └── docker.yml         # Docker build and push
└── crates/
    ├── mcp-common/            # Shared utilities
    │   ├── Cargo.toml
    │   └── src/
    │       ├── lib.rs
    │       └── error.rs       # Common error types
    └── ltm-mcp/               # Long-term memory server
        ├── Cargo.toml
        ├── Dockerfile
        ├── migrations/        # Database migrations
        │   └── 20260706000001_create_memories.sql
        └── src/
            ├── main.rs        # Application entry point
            ├── config.rs      # Environment configuration
            ├── server.rs      # HTTP server and routes
            ├── tools/         # MCP tool implementations
            │   └── mod.rs
            └── memory/        # Memory storage layer
                ├── mod.rs
                ├── types.rs   # Data models
                ├── store.rs   # Storage trait
                └── postgres.rs # PostgreSQL implementation

CI/CD

The project uses GitHub Actions for continuous integration and deployment:

• Rust Check (check.yml) - Validates Rust toolchain, formatting, linting, and tests
• Docker Build (docker.yml) - Builds and pushes multi-platform Docker images to GitHub Container Registry

Images are automatically published to ghcr.io/kagchi/mcp-servers-{crate} on:

• Push to main branch (tagged as latest)
• Version tags (e.g., v1.0.0)

License

This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

Author

KagChi

Repository

https://github.com/KagChi/mcp-servers

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: KagChi
• Source: KagChi/mcp-servers
• License: Apache-2.0

Install and usage instructions live in the source repository linked above.