fastly-mcp-server

Fastly MCP Server

A Model Context Protocol (MCP) server implementation for the Fastly API that enables AI assistants to interact with Fastly CDN services.

Overview

This package provides an MCP server that allows AI models to interact with the Fastly API through a standardized protocol. It implements the Model Context Protocol specification, enabling AI assistants to execute operations on the Fastly CDN platform like:

• Managing services, versions, domains, and backends
• Configuring cache settings and VCL
• Performing content purging
• Working with edge dictionaries and ACLs
• Accessing stats and metrics
• Managing WAF and rate limiting

Why Use This?

• Seamless AI Integration: Allow AI models to interact directly with your Fastly CDN configuration
• Natural Language Control: Enable conversational interfaces for Fastly administration
• Standardized Protocol: Built on MCP for consistent integration with various AI systems
• Enhanced Capabilities: Exposes all essential Fastly operations through a unified interface

Installation

Recommendation: Bun is the preferred runtime for fastly-mcp-server due to its superior performance and startup time.

Global Installation

# With Bun (recommended)
bun add -g fastly-mcp-server

# With npm
npm install -g fastly-mcp-server

# With yarn
yarn global add fastly-mcp-server

# With pnpm
pnpm add -g fastly-mcp-server

Local Installation

# With Bun (recommended)
bun add fastly-mcp-server

# With npm
npm install fastly-mcp-server

# With yarn
yarn add fastly-mcp-server

# With pnpm
pnpm add fastly-mcp-server

Running the Server

Standalone

# Using bunx (recommended, no installation required)
bunx fastly-mcp-server@latest run

# If installed globally with Bun
fastly-mcp-server run

# Using npx (Node.js alternative)
npx fastly-mcp-server@latest run

Integration with AI Assistants

Usage with Bun (Recommended)

{
 "mcpServers": {
    "fastly api": {
      "command": "bunx",
      "args": ["fastly-mcp-server@latest", "run"],
      "env": {
        "API_KEY_APIKEYAUTH": "your-fastly-api-key"
      }
    }
 }
}

Usage with Node.js

{
 "mcpServers": {
    "fastly": {
      "command": "npx",
      "args": ["-y", "fastly-mcp-server@latest", "run"],
      "env": {
        "API_KEY_APIKEYAUTH": "your-fastly-api-key"
      }
    }
 }
}

Authentication

The server requires a Fastly API key to authenticate with the Fastly API. You can provide this in several ways:

1. Environment Variable

export API_KEY_APIKEYAUTH=your-fastly-api-key

2. .env File

Create a .env file in your project root:

API_KEY_APIKEYAUTH=your-fastly-api-key

3. In AI Assistant Configuration

As shown in the usage examples above, you can provide the API key in the environment variables section of your AI assistant's configuration.

The server will automatically set the Fastly-Key header with your API key for all requests to the Fastly API.

Obtaining a Fastly API Key

To get a Fastly API key for use with the MCP server:

• Log in to your Fastly account at https://manage.fastly.com
• Navigate to "Account" in the top right menu
• Select "Personal API tokens" from the sidebar
• Click the "Create token" button
• Provide a name for your token (e.g., "MCP Server")
• Select the appropriate scope for your needs:
  • For read-only access: Select "global:read"
  • For full access: Select "global:write"
• Set an expiration date if desired (or leave as "never" for permanent tokens)
• Click "Create" to generate your API token
• Copy the displayed token immediately (it will only be shown once)
• Use this token as the value for API_KEY_APIKEYAUTH in your configuration

Important Security Notes:

• Store your API key securely and never commit it to version control
• Consider using environment variables or a secure secrets manager
• Use the most restrictive scope necessary for your application
• Rotate API keys regularly following security best practices

Available Tools

The server provides comprehensive tools for interacting with the Fastly API:

Service Management

• List all services
• Get service details
• Create new services
• Update existing services
• Delete services

Version Management

• List versions
• Clone versions
• Activate versions

Content Delivery Configuration

• Domain management (add, list, delete)
• Origin configuration
• Backend management
• Cache settings

Cache and Purge Operations

• Purge all content
• Purge by URL
• Purge by surrogate key
• Soft purges
• Check purge status

Security Features

• WAF configuration and rule management
• Rate limiting setup and configuration

Edge Logic and Data

• Edge dictionary management
• Dictionary item operations
• VCL file management

Analytics

• Service statistics
• Realtime metrics
• Historical stats

Using Tools with Path Parameters

Many API endpoints require path parameters such as service_id or version_id. When using these tools, you must provide these parameters in your request:

// To get service details
{
  "service_id": "3ELXhLGOuQTQvW9NR3wlWD"
}

// To list versions for a service
{
  "service_id": "3ELXhLGOuQTQvW9NR3wlWD"
}

// To activate a version
{
  "service_id": "3ELXhLGOuQTQvW9NR3wlWD",
  "version_id": "2"
}

// To purge a specific URL
{
  "url": "www.example.com/path/to/resource"
}

Common Workflows

Here are some common workflows you can implement with this MCP server:

Setting Up a New Website on Fastly

• Create a service
• Add domains
• Configure origin server
• Configure backend
• Activate version

Purging Cached Content

• Get service details
• Purge specific URL, surrogate key, or all content

Updating Origin Server

• Get current origins
• Clone active version
• Update origin
• Activate new version

Development

# Clone the repository
git clone https://github.com/jedisct1/fastly-openapi-schema.git
cd fastly-openapi-schema/fastly-mcp-server

# Install dependencies (with Bun, recommended)
bun install

# Or with npm
npm install

# Build the server (with Bun, recommended)
bun run build

# Or with npm
npm run build

# Run type checking (with Bun, recommended)
bun run typecheck

# Or with npm
npm run typecheck

Related Projects

• Fastly OpenAPI Schema - The OpenAPI schema this server is based on
• Model Context Protocol - The protocol specification

License

MIT