* [MCP - AI Agent Example](../examples/mcp_feature_store/README.md)

* [MCP Feature Server](reference/feature-servers/mcp-feature-server.md)

Feast supports the Model Context Protocol (MCP), which enables AI agents and applications to interact with your feature store through standardized MCP interfaces. This allows seamless integration with LLMs and AI agents for GenAI applications.

* **Standardized AI Integration**: Enable AI agents to discover and use features dynamically without hardcoded definitions

* **Easy Setup**: Add MCP support with a simple configuration change and `pip install feast[mcp]`

* **Agent-Friendly APIs**: Expose feature store capabilities through MCP tools that AI agents can understand and use

* **Production Ready**: Built on top of Feast's proven feature serving infrastructure

1. **Install MCP support**:

```bash

pip install feast[mcp]

```

2. **Configure your feature store** to use MCP:

```yaml

feature_server:

type: mcp

enabled: true

mcp_enabled: true

mcp_server_name: "feast-feature-store"

mcp_server_version: "1.0.0"

```

1. **Automatic Discovery**: The integration scans your FastAPI application and discovers all available endpoints

2. **Tool Generation**: Each endpoint becomes an MCP tool with auto-generated schemas and descriptions

3. **Dynamic Access**: AI agents can discover and call these tools dynamically without hardcoded definitions

4. **Standard Protocol**: Uses the Model Context Protocol for standardized AI-to-API communication

The fastapi_mcp integration automatically exposes your Feast feature server's FastAPI endpoints as MCP tools. This means AI assistants can:

This example demonstrates how to enable MCP (Model Context Protocol) support in Feast, allowing AI agents and applications to interact with your features through standardized MCP interfaces.

1. Python 3.8+

2. Feast installed

3. FastAPI MCP library

1. Install Feast with MCP support:

pip install feast[mcp]

Alternatively, you can install the dependencies separately:

pip install feast

pip install fastapi_mcp

1. Navigate to this example directory within your cloned Feast repository:

cd examples/mcp_feature_store

2. Initialize a Feast repository in this directory. We'll use the existing `feature_store.yaml` that's already configured for MCP:

feast init .

This will create a `data` subdirectory and a `feature_repo` subdirectory if they don't exist, and will use the `feature_store.yaml` present in the current directory (`examples/mcp_feature_store`).

3. Apply the feature store configuration:

cd feature_repo

feast apply

cd .. # Go back to examples/mcp_feature_store for the next steps

Start the Feast feature server with MCP support:

feast serve --host 0.0.0.0 --port 6566

If MCP is properly configured, you should see a log message indicating that MCP support has been enabled:

The fastapi_mcp integration automatically exposes your Feast feature server's FastAPI endpoints as MCP tools. This means AI assistants can:

- **Call `/get-online-features`** to retrieve features from the feature store

- **Use `/health`** to check server status

The key configuration that enables MCP support:

feature_server:

type: mcp # Use MCP feature server type

enabled: true # Enable feature server

mcp_enabled: true # Enable MCP protocol support

mcp_server_name: "feast-feature-store"

mcp_server_version: "1.0.0"

project: feast_mcp_example

registry: data/registry.db

provider: local

online_store:

type: sqlite

path: data/online_store.db

offline_store:

type: file

feature_server:

type: mcp

enabled: true

mcp_enabled: true # Enable MCP support - defaults to false

mcp_server_name: "feast-feature-store"

mcp_server_version: "1.0.0"

feature_logging:

enabled: false

entity_key_serialization_version: 3

mcp = ["fastapi_mcp"]

"feast[aws, azure, cassandra, clickhouse, couchbase, delta, docling, duckdb, elasticsearch, faiss, gcp, ge, go, grpcio, hazelcast, hbase, ibis, ikv, k8s, mcp, milvus, mssql, mysql, opentelemetry, spark, trino, postgres, pytorch, qdrant, redis, singlestore, snowflake, sqlite_vec]"

minimal = ["feast[aws, gcp, snowflake, redis, go, mysql, postgres-c, opentelemetry, grpcio, k8s, duckdb, mcp, milvus]"]

# Add MCP support if enabled in feature server configuration

_add_mcp_support_if_enabled(app, store)

def _add_mcp_support_if_enabled(app, store: "feast.FeatureStore"):

"""Add MCP support to the FastAPI app if enabled in configuration."""

try:

# Check if MCP is enabled in feature server config

if (

store.config.feature_server

and hasattr(store.config.feature_server, "type")

and store.config.feature_server.type == "mcp"

and getattr(store.config.feature_server, "mcp_enabled", False)

):

from feast.infra.mcp_servers.mcp_server import add_mcp_support_to_app

mcp_server = add_mcp_support_to_app(app, store, store.config.feature_server)

if mcp_server:

logger.info("MCP support has been enabled for the Feast feature server")

else:

logger.warning("MCP support was requested but could not be enabled")

else:

logger.debug("MCP support is not enabled in feature server configuration")

except Exception as e:

logger.error(f"Error checking/adding MCP support: {e}")

# Don't fail the entire server if MCP fails to initialize

from .mcp_config import McpFeatureServerConfig

from .mcp_server import add_mcp_support_to_app

__all__ = [

"McpFeatureServerConfig",

"add_mcp_support_to_app",

]

from typing import Literal, Optional

from pydantic import StrictBool, StrictStr

from feast.infra.feature_servers.base_config import BaseFeatureServerConfig

class McpFeatureServerConfig(BaseFeatureServerConfig):

"""MCP (Model Context Protocol) Feature Server configuration."""

# Feature server type selector

type: Literal["mcp"] = "mcp"

# Enable MCP server support - defaults to False as requested

mcp_enabled: StrictBool = False

# MCP server name for identification

mcp_server_name: StrictStr = "feast-mcp-server"

# MCP server version

mcp_server_version: StrictStr = "1.0.0"

# Optional MCP transport configuration

mcp_transport: Optional[StrictStr] = None

# The endpoint definition for transformation_service (inherited from base)

transformation_service_endpoint: StrictStr = "localhost:6566"

import logging

from typing import Optional

from feast.feature_store import FeatureStore

logger = logging.getLogger(__name__)

try:

from fastapi_mcp import FastApiMCP

MCP_AVAILABLE = True

except ImportError:

logger.warning(

"fastapi_mcp is not installed. MCP support will be disabled. "

"Install it with: pip install fastapi_mcp"

)

MCP_AVAILABLE = False

# Create placeholder classes for testing

FastApiMCP = None

def add_mcp_support_to_app(app, store: FeatureStore, config) -> Optional["FastApiMCP"]:

"""Add MCP support to the FastAPI app if enabled in configuration."""

if not MCP_AVAILABLE:

logger.warning("MCP support requested but fastapi_mcp is not available")

return None

try:

# Create MCP server from the FastAPI app

mcp = FastApiMCP(

app,

name=getattr(config, "mcp_server_name", "feast-feature-store"),

description="Feast Feature Store MCP Server - Access feature store data and operations through MCP",

)

# Mount the MCP server to the FastAPI app

mcp.mount()

logger.info(

"MCP support has been enabled for the Feast feature server at /mcp endpoint"

)

logger.info(

f"MCP integration initialized for {getattr(config, 'mcp_server_name', 'feast-feature-store')} "

f"v{getattr(config, 'mcp_server_version', '1.0.0')}"

)

return mcp

except Exception as e:

logger.error(f"Failed to initialize MCP integration: {e}")

return None

.to_arrow()