feast-dev · franciscojavierarceo · franciscojavierarceo · YassinNouh21 · redhatHameed · YassinNouh21
@@ -53,6 +53,7 @@
 * [Validating historical features with Great Expectations](tutorials/validating-historical-features.md)
 * [Building streaming features](tutorials/building-streaming-features.md)
 * [Retrieval Augmented Generation (RAG) with Feast](tutorials/rag-with-docling.md)
+* [MCP - AI Agent Example](../examples/mcp_feature_store/README.md)
 
 ## How-to Guides
 
@@ -147,6 +148,7 @@
 * [Feature servers](reference/feature-servers/README.md)
   * [Python feature server](reference/feature-servers/python-feature-server.md)
   * [\[Alpha\] Go feature server](reference/feature-servers/go-feature-server.md)
+  * [MCP Feature Server](reference/feature-servers/mcp-feature-server.md)
   * [Offline Feature Server](reference/feature-servers/offline-feature-server.md)
   * [Registry server](reference/feature-servers/registry-server.md)
 * [\[Beta\] Web UI](reference/alpha-web-ui.md)

@@ -103,13 +103,62 @@ This integration enables:
 - Generating embeddings for millions of text chunks
 - Efficiently materializing features to vector databases
 - Scaling RAG applications to enterprise-level document repositories
+
+## Model Context Protocol (MCP) Support
+
+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.
+
+### Key Benefits of MCP Support
+
+* **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
+
+### Getting Started with MCP
+
+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"
+   ```
+
+### How It Works
+
+The MCP integration uses the `fastapi_mcp` library to automatically transform your Feast feature server's FastAPI endpoints into MCP-compatible tools. When you enable MCP support:
+
+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
+
+### Available MCP Tools
+
+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  
+
+For a complete example, see the [MCP Feature Store Example](../../examples/mcp_feature_store/).
+
 ## Learn More
 
 For more detailed information and examples:
 
 * [Vector Database Reference](../reference/alpha-vector-database.md)
 * [RAG Tutorial with Docling](../tutorials/rag-with-docling.md)
 * [Milvus Quickstart Example](https://github.com/feast-dev/feast/tree/master/examples/rag/milvus-quickstart.ipynb)
+* [MCP Feature Store Example](../../examples/mcp_feature_store/)
+* [MCP Feature Server Reference](../reference/feature-servers/mcp-feature-server.md)
 * [Spark Data Source](../reference/data-sources/spark.md)
 * [Spark Offline Store](../reference/offline-stores/spark.md)
 * [Spark Batch Materialization](../reference/batch-materialization/spark.md)
@@ -0,0 +1,77 @@
+ # Feast MCP Feature Server Example
+
+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.
+
+## Prerequisites
+
+1. Python 3.8+
+2. Feast installed
+3. FastAPI MCP library
+
+## Installation
+
+1. Install Feast with MCP support:
+```bash
+pip install feast[mcp]
+```
+
+Alternatively, you can install the dependencies separately:
+```bash
+pip install feast
+pip install fastapi_mcp
+```
+
+## Setup
+
+1. Navigate to this example directory within your cloned Feast repository:
+```bash
+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:
+```bash
+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:
+```bash
+cd feature_repo 
+feast apply
+cd .. # Go back to examples/mcp_feature_store for the next steps
+```
+
+## Starting the MCP-Enabled Feature Server
+
+Start the Feast feature server with MCP support:
+
+```bash
+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:
+
+```
+INFO:feast.feature_server:MCP support has been enabled for the Feast feature server
+```
+
+## Available MCP Tools
+
+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  
+
+
+## Configuration Details
+
+The key configuration that enables MCP support:
+
+```yaml
+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"
+```
@@ -0,0 +1,22 @@
+project: feast_mcp_example
+registry: data/registry.db
+provider: local
+
+online_store:
+    type: sqlite
+    path: data/online_store.db
+
+offline_store:
+    type: file
+
+# MCP Feature Server Configuration
+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
diff --git a/pyproject.toml b/pyproject.toml
@@ -116,6 +116,7 @@ snowflake = [
     "snowflake-connector-python[pandas]>=3.7,<4",
 ]
 sqlite_vec = ["sqlite-vec==v0.1.6"]
+mcp = ["fastapi_mcp"]
 
 ci = [
     "build",
@@ -162,13 +163,13 @@ ci = [
     "types-setuptools",
     "types-tabulate",
     "virtualenv<20.24.2",
-    "feast[aws, azure, cassandra, clickhouse, couchbase, delta, docling, duckdb, elasticsearch, faiss, gcp, ge, go, grpcio, hazelcast, hbase, ibis, ikv, k8s, milvus, mssql, mysql, opentelemetry, spark, trino, postgres, pytorch, qdrant, redis, singlestore, snowflake, sqlite_vec]"
+    "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]"
 ]
 nlp = ["feast[docling, milvus, pytorch]"]
 dev = ["feast[ci]"]
 docs = ["feast[ci]"]
 # used for the 'feature-server' container image build
-minimal = ["feast[aws, gcp, snowflake, redis, go, mysql, postgres-c, opentelemetry, grpcio, k8s, duckdb, milvus]"]
+minimal = ["feast[aws, gcp, snowflake, redis, go, mysql, postgres-c, opentelemetry, grpcio, k8s, duckdb, mcp, milvus]"]
 minimal-sdist-build = [
     "feast[minimal]",
     "feast[ibis]",

@@ -173,6 +173,8 @@ def get_app(
     - `/materialize-incremental`: Materialize features incrementally
     - `/chat`: Chat UI
     - `/ws/chat`: WebSocket endpoint for chat
+    MCP Support:
+    - If MCP is enabled in feature server configuration, MCP endpoints will be added automatically
     """
     proto_json.patch()
     # Asynchronously refresh registry, notifying shutdown and canceling the active timer if the app is shutting down
@@ -490,9 +492,37 @@ async def websocket_endpoint(websocket: WebSocket):
     with importlib_resources.as_file(static_dir_ref) as static_dir:
         app.mount("/static", StaticFiles(directory=static_dir), name="static")
 
+    # Add MCP support if enabled in feature server configuration
+    _add_mcp_support_if_enabled(app, store)
+
     return app
 
 
+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
+
+
 if sys.platform != "win32":
     import gunicorn.app.base
 

@@ -0,0 +1,9 @@
+# MCP (Model Context Protocol) server implementations for Feast
+
+from .mcp_config import McpFeatureServerConfig
+from .mcp_server import add_mcp_support_to_app
+
+__all__ = [
+    "McpFeatureServerConfig",
+    "add_mcp_support_to_app",
+]
@@ -0,0 +1,27 @@
+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"
@@ -0,0 +1,58 @@
+"""
+MCP (Model Context Protocol) integration for Feast Feature Server.
+
+This module provides MCP support for Feast by integrating with fastapi_mcp
+to expose Feast functionality through the Model Context Protocol.
+"""
+
+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
@@ -96,7 +96,7 @@ def _write_data_source(
             prev_schema = (
                 DeltaTable(file_options.uri, storage_options=storage_options)
                 .schema()
-                .to_pyarrow()
+                .to_arrow()
             )
             table = table.cast(ibis.Schema.from_pyarrow(prev_schema))
             write_mode = "append"

@@ -202,7 +202,7 @@ def get_table_column_names_and_types(
             schema = (
                 DeltaTable(self.path, storage_options=storage_options)
                 .schema()
-                .to_pyarrow()
+                .to_arrow()
             )
         else:
             raise Exception(f"Unknown FileFormat -> {self.file_format}")

@@ -105,6 +105,7 @@
 
 FEATURE_SERVER_CONFIG_CLASS_FOR_TYPE = {
     "local": "feast.infra.feature_servers.local_process.config.LocalFeatureServerConfig",
+    "mcp": "feast.infra.mcp_servers.mcp_config.McpFeatureServerConfig",
 }
 
 ALLOWED_AUTH_TYPES = ["no_auth", "kubernetes", "oidc"]