Build agents that anticipate customers, navigate risks, and reason over forecasts, with KumoRFM MCP Server

Introduction: From Reactive to Predictive AI Agents

Today’s AI agents excel at retrieving information, summarizing content, and orchestrating workflows. They can search the web, process business documents, and coordinate tasks across applications. But most agents remain reactive, they respond to what has already happened rather than anticipating what will happen next.

For AI agents to truly transform enterprise productivity, they must leverage an enterprise's vast repositories of relational data to reason about the future. Imagine agents that:

• Optimize equipment maintenance schedules to prevent downtime
• Anticipate customer demand to manage inventory more efficiently
• Spot churn risks before customers leave
• Recommend cross-sell and upsell opportunities proactively

The Challenge of Adding AI Predictions to Agents

Building predictive AI into agents is not trivial. The traditional approach involves standing up custom machine learning models and pipelines, a process that can take months and requires teams of specialists to perform the following iterative tasks:

• Data preparation: Data engineers connect disparate systems (ERP, CRM, SCM, HRM), denormalize tables, and prepare data for downstream modeling.
• Feature engineering: Data scientists transform raw data into machine-learning-ready features by imputing missing values, normalizing scales, encoding categorical variables, vectorizing text, and generating time-series features.
• Model training: Data scientists experiment with algorithms and hyperparameters to identify the best-performing model configuration
• Evaluation: Data scientists assess models against validation metrics on unseen test data, with careful checks to prevent information leakage between training and evaluation.
• Model serving: Machine learning engineers build end-to-end pipelines to deploy models in production, ensuring high availability.
• Model maintenance: All teams contribute to ongoing pipeline monitoring and maintenance, including retraining, adapting schema changes, mitigating feature drift, and addressing downtime. This maintenance effort is continuous and adds significant long-term overhead for every deployed model.

This model-by-model approach doesn’t scale for the diverse predictions modern agents require.

KumoRFM: Foundation Model Intelligence for Relational Data

Enter KumoRFM (Relational Foundation Model), a paradigm shift for enterprise predictions. KumoRFM eliminates feature engineering and model training by extending in-context learning, as used by LLMs, to relational data.

By interpreting multi-table databases as temporal heterogeneous graphs, and leveraging a Graph Transformer architecture, KumoRFM generates predictions directly from existing schemas. That means:

• Zero training required
• Zero feature engineering
• Predictions across many use cases from a single model and relational data input

Instead of dozens of custom machine learning pipelines, agents can now rely on one foundation model to unlock predictive capabilities.

The KumoRFM MCP Server

The Model Context Protocol (MCP) is an open standard that lets AI agents communicate with external tools and data in a structured way. Rather than hard-coding integrations, MCP provides a consistent interface. An MCP server exposes a service’s capabilities to agents as tools, acting as a bridge.

The KumoRFM MCP server brings predictive intelligence to any MCP-compatible agent framework—including LangChain, Crew.AI, SmolAgents, pydantic.ai, and OpenAI Agents SDK.

Available Tools

The KumoRFM MCP server exposes KumoRFM's capabilities through carefully designed tools that map naturally to agent workflows:

🤔Knowledge tools

• get_docs: Retrieves documentation for graph setup and Predictive Query Language (PQL) syntax

📊 I/O Operatins

• find_table_files: Discovers CSV/Parquet files in local directories or S3
• inspect_table_files: Examines schemas and sample data to understand structure

🕸️ Graph Management

• inspect_graph_metadata: Views current graph structure, relationships, and semantic types
• update_graph_metadata: Configures table relationships, primary keys, and time columns
• get_mermaid: Generates visual entity-relationship diagrams
• lookup_table_rows: Retrieves specific rows from tables
• materialize_graph: Builds the graph structure for predictions
• Lookup_table_rows: Lookup rows in the raw data frame of a table for a list of primary keys

🤖 Prediction Execution

• predict: Executes Kumo predictive queries to generate predictions
• evaluate: Assesses prediction quality on holdout data / historical ground truth

This design lets agents build, adjust, and reason about enterprise data, and then generate predictions directly.

Usage Patterns & Examples

Pattern 1: Direct Integration in Claude Desktop

Perhaps the simplest integration example is to connect the KumoRFM MCP server to Claude desktop. To install, simply run:

pip install kumo-rfm-mcp

pip install kumo-rfm-mcp

Add to your MCP configuration file:

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

Now Claude can naturally handle requests like (given that you tell it where it can find your data!):

• "Predict which customers are likely to churn in the next 30 days"
• "What products should we recommend to customer #123?"
• "Analyze the relationship between customer demographics and purchase patterns"

For an even easier setup, we also provide a MCP Bundle (MCPB) for one-click installation and integration with Claude Desktop .

1. Download the dxt file from here
2. Double click to install

Pattern 2: Multi-Agent Orchestration with OpenAI Agents SDK

The openai-agents-sdk makes it very easy to build agentic flows, if you want your application to first verify if a prediction is possible before it executes it, you can define two agentic sub-steps and assessment agent which checks if a prediction is feasible and a prediction agent which actually performs the prediction. The framework also provides dynamic tool filtering, which makes it handy to build such specialized sub-systems.

from agents import Agent
from agents.mcp import MCPServerStdio, ToolFilterContext

async with MCPServerStdio(
    params={
        "command": "python",
        "args": ["-m", "kumo_rfm_mcp.server"],
        "env": {"KUMO_API_KEY": api_key}
    }
) as server:
    
    # Assessment Agent - validates prediction feasibility
    assessment_agent = Agent(
        name="Assessment Agent",
        instructions="Analyze data availability for predictions...",
        mcp_servers=[server],
    )
    
    # Prediction Agent - executes predictions
    prediction_agent = Agent(
        name="Prediction Agent", 
        instructions="Set up graphs and run predictions...",
        mcp_servers=[server],
    )

Visit our official OpenAI Cookbook submission and additional OpenAI sample notebook for further examples for how to use of KumoRFM MCP server with the OpenAI Agents SDK

Pattern 3: Any other agentic framework of your choice!

Listing out all available agentic frameworks in 2025 is a herculean task, suffice it to say that most of them provide some kind of MCP integration support. Take a look at our kumo-rfm repository to find additional examples in LangGraph and Crew.AI, or feel free to contribute your own!

Next Steps

The KumoRFM MCP server bridges the critical gap between reactive information processing and predictive intelligence in AI agents. By providing foundation model capabilities for relational data through a simple MCP interface, it enables a new generation of agents that can anticipate, forecast, and optimize!

Key Takeaways

• Agents need predictions: And they need to be able to ground their predictions in business data
• Zero Training Required: KumoRFM lets your agents predict without training
• Multi-step reasoning: Having the ability to predict without training unlocks chaining several predictions together

Getting Started

1. Install the server: pip install kumo-rfm-mcp
2. Get your API key: Generate a free key at kumorfm.ai
3. Try the examples: Explore our GitHub repository for complete examples and notebooks
4. Join the community: Share your experiences and get help in our Slack channel

What's Next?

We're actively improving our KumoRFM foundation model, developing new capabilities for the KumoRFM MCP server, and building out new examples and applications!

The future of AI agents is predictive. With KumoRFM MCP, that future is available today. Start building agents that don't just understand what happened, but anticipate what happens next.