Overview

Kumo MCP Server provides a local Model Context Protocol (MCP) adapter that lets developer tools and agent frameworks query KumoRFM — a pretrained Relational Foundation Model — against multi-table relational datasets without any model training. The server builds a graph representation from CSV or Parquet inputs, converts natural language into Predictive Query Language (PQL), and forwards queries to KumoRFM to return predictions, imputations, forecasts, and model explanations.

This server is intended for embedding KumoRFM intelligence into agentic workflows (Claude, LangChain, CrewAI, OpenAI Agents, etc.), notebooks, or developer tools that speak MCP. It exposes a set of tools for data ingestion, graph management, prediction, and explainability so teams can get fast, training-free insights for model-driven decision making.

Features

Build and manage heterogeneous graphs from CSV or Parquet relational data
Natural language to PQL translation for conversational querying
Run training-free RFM predictions: missing value imputation, temporal forecasting, risk / propensity scoring
Explainability outputs (feature attributions and local explanations) alongside predictions
Works as an MCP server for seamless integration with agent frameworks and assistants
MCP Bundle (single-click .dxt) for easy installation into supported clients (e.g., Claude Desktop)
Cross-platform support (Linux, macOS, Windows) — requires a Python 3.10+ runtime

Installation / Configuration

Prerequisites: Python 3.10 or newer and a KUMO_API_KEY (get one from kumorfm.ai).

Install from PyPI:

pip install kumo-rfm-mcp

Run the server directly (example, opens an MCP server using stdio or a port if supported):

# basic start with API key in environment
export KUMO_API_KEY="your_api_key_here"
python -m kumo_rfm_mcp.server

Add the server to an MCP client configuration (example JSON snippet for Claude Desktop or other MCP host):

{
  "mcpServers": {
    "kumo-rfm": {
      "command": "python",
      "args": ["-m", "kumo_rfm_mcp.server", "--port", "8000"],
      "env": {
        "KUMO_API_KEY": "your_api_key_here"
      }
    }
  }
}

One-line add for Claude CLI (example):

claude mcp add --transport stdio kumo-rfm-mcp --env KUMO_API_KEY=<YOUR-API-KEY> -- python -m kumo_rfm_mcp.server --port 8000

MCP Bundle (.dxt): download the distribution file and double-click to install into supported desktop clients. (Bundle creates a venv and registers the server for you.)

Available Resources

Graph Builder: ingest tabular files (CSV/Parquet) and infer multi-table relationships to create a heterogeneous temporal graph.
PQL Translator: turn natural-language questions into Predictive Query Language to specify prediction targets and context.
Prediction API (MCP tools): run predictions (imputation, forecasting, scoring) against graph nodes/edges and retrieve scores and confidence metadata.
Explainability: get local feature attributions and human-readable reasoning that explain each prediction.
Visualization helpers: basic graph and result visualization for inspecting relationships and temporal trends.
Example Notebooks: curated Jupyter examples (ecommerce, insurance, sales agents) in the repository to show end-to-end flows.
GitHub: https://github.com/kumo-ai/kumo-rfm-mcp — source, issues, and examples.

Use Cases

Customer retention scoring: ingest orders, customer, and interaction tables; ask the server to predict churn propensity for the next 90 days and show top contributing features per customer.
Missing-data imputation: supply a dataset with sparse fields; use KumoRFM to impute likely values without retraining a model.
Temporal forecasting: predict future revenue or demand per product using transaction history across related tables; produce confidence intervals and feature attributions.
Agent-driven analytics: wire the server into an agent (Claude, LangChain, CrewAI) so a conversational assistant can answer “Which customers are most likely to purchase in the next month and why?” and produce actionable segments.
Rapid prototyping: analyze relational schemas and generate insights without the overhead of building bespoke ML pipelines.

Example: creating an agent toolset (pseudocode adapted for common MCP clients)

from langchain_mcp_adapter.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "kumo-rfm": {
        "command": "python",
        "args": ["-m", "kumo_rfm_mcp.server"],
        "env": {"KUMO_API_KEY": "YOUR_KEY"}
    }
})

tools = await client.get_tools()  # registers KumoRFM tools with your agent
# Now create an agent that can call the imported tools to build graphs and run predictions

Tips for Developers

Prepare your relational data: include primary/foreign key columns and timestamps where available to improve temporal modeling.
Start with small sample tables to explore PQL and explainability outputs before scaling to full datasets.
Use the example notebooks in the repo to learn how to translate common business questions into PQL queries.
If embedding into a desktop assistant, prefer the MCP Bundle for faster setup; otherwise use the pip package and MCP config.

Links and Further Reading

Repository: https://github.com/kumo-ai/kumo-rfm-mcp
KumoRFM product and docs: https://kumorfm.ai
Example notebooks and agent demos are included in the repository for hands-on learning.

Kumo MCP Server for KumoRFM Predictions