Model Context Protocol (MCP)

Agent Flow schema and MCP server are preview features

Agent flow schema and hosted MCP servers are preview features that require Prismatic Support to enable the feature for you. Please contact Prismatic Support if you'd like to opt-in to the MCP Preview.

MCP is an open protocol, introduced by Anthropic, that attempts to standardize how LLMs request context from applications. When an LLM connects to an MCP server, it requests a list of tools that the MCP server offers. These tools can do things like "Find people with thus-and-such a name in Hubspot" or "Add an event to my Google Calendar." The MCP server offers a standardized schema, so LLMs know to send a first and last name to the "find people" tool or an event name and date to the "add event" tool.

In the Prismatic MCP Server, the tools are implemented as agent flows. By using agent flows, as your tools you're able to add validation, better error handling using either the Low Code UI or you can leverage the full power of Code Native Integrations to build your flows.

Prismatic offers a built-in MCP server which allows you to connect to all of your agent flows. This will be the best supported way to interact with the Prismatic platform via MCP, but if you have specific use cases you can opt to build your own MCP server and still interact with your Prismatic agent flows.

Before connecting Prismatic's MCP server (or before building your own), ensure that you've created agent flows that have invocation schema, so your LLM has something to query.

Organization team members have access to all agent flows

Note that as an organization team member, when you ask for agent flows you'll receive a list of all agent flows deployed to all customers. A Customer user will only receive agent flows that are deployed for them.

Using Prismatic's MCP service

Prismatic's offers a hosted MCP server can be used to connect to your agent flows. Below are MCP endpoints for Prismatic's public regions. During the preview release we only support the public endpoints, but will be adding support for white labeling. If your organization uses private stack, please contact support for your MCP endpoint.

Region	MCP Endpoint
US Commercial (default)	mcp.prismatic.io/mcp
US GovCloud	mcp.us-gov-west-1.prismatic.io/mcp
Europe (Ireland)	mcp.eu-west-1.prismatic.io/mcp
Europe (London)	mcp.eu-west-2.prismatic.io/mcp
Canada (Central)	mcp.ca-central-1.prismatic.io/mcp
Australia (Sydney)	mcp.ap-southeast-2.prismatic.io/mcp

Prismatic's MCP server uses OAuth (similar to how you log in with the prism CLI tool). When connecting an AI client to Prismatic's MCP server, your client will likely direct you to Prismatic's OAuth 2.0 consent screen in order to connect.

Connect your MCP Client to Prismatic's MCP server

Prismatic's MCP server is designed to be used with any client that supports the current draft of the Model Context Protocol (MCP) specification. Specifically, your client must support the following:

• MCP OAuth as the means to manage authorization between your application and Prismatic, so your client implementation must support provide this support.
• Streamable HTTP transport, not stdio, nor the legacy HTTP SSE.

We'll continue to evaluate the MCP specification as it matures, and make updates as needed.

Connecting Claude Desktop to Prismatic's MCP server

During initial development, it may make sense to test your agent flows outside of your custom client with a tool like Claude Desktop. Here's a sample config file that will connect to Prismatic's MCP server. Currently (as of 2025-05-23; things in the AI space change rapidly!) Claude Desktop expects that you configure MCP servers by editing claude_desktop_config.json. Open your configuration file up, and add this to it:

claude_desktop_config.json

{
  "mcpServers": {
    "prismatic": {
      "command": "npx",
      "args": ["mcp-remote", "https://mcp.prismatic.io/mcp"]
    }
  }
}

This will instruct Claude to use the mcp-remote shim to connect to Prismatic's MCP server. If successful, after editing your config file and restarting Claude you should automatically be directed to an OAuth 2.0 consent screen to grant Claude access to your Prismatic environment.

After authenticating, ask Claude "Who am I?". Claude will use Prismatic's get-me tool (which is a default tool you'll have access to from Prismatic's MCP server).

Connecting your own MCP server to Prismatic

If you'd like to build your own MCP server and instruct it to interact with agent flows in Prismatic, your MCP server must be told which flows are available to be queried. This example code instructs an MCP server to fetch agent flows from Prismatic's API, and creates a resource for each:

import {
  type JSONSchema,
  JSONSchemaToZod,
} from "@dmitryrechkin/json-schema-to-zod";
import {
  McpServer,
  type ToolCallback,
} from "@modelcontextprotocol/sdk/server/mcp.js";
import { gql, request } from "graphql-request";

const STACK_BASE_URL = "https://app.prismatic.io"; // Change this to your own region
const PRISMATIC_API_KEY = "";

interface AgentFlowResponse {
  ai: {
    agentFlows: {
      nodes: {
        id: string;
        name: string;
        description: string;
        webhookUrl: string;
        apiKeys: string[];
        invokeSchema: string;
        resultSchema: string;
      }[];
    };
  };
}

// Query for agentFlows
const result = await request<AgentFlowResponse>(
  new URL("/api", STACK_BASE_URL).toString(),
  gql`
    query agentFlows {
      ai {
        agentFlows {
          nodes {
            id
            name
            description
            webhookUrl
            apiKeys
            invokeSchema
            resultSchema
          }
        }
      }
    }
  `,
  {},
  {
    Authorization: `Bearer ${PRISMATIC_API_KEY}`,
  },
);

// Customize MCP server to allow custom tool registrations, particularly
// for use with JSON Schema (as, by default, only zod schemas are supported).
class DynamicMcpServer extends McpServer {
  jsonSchemaTool(
    name: string,
    description: string,
    schema: JSONSchema,
    cb: ToolCallback,
  ): void {
    const zodSchema = JSONSchemaToZod.convert(schema) as any;
    super.tool(name, description, zodSchema.shape, cb);
  }
}

const server = new DynamicMcpServer({
  name: "person-getter",
  version: "1.0.0",
  capabilities: {
    resources: {},
    tools: {},
  },
});

// For each flow, create a
for (const flow of result.ai.agentFlows.nodes) {
  server.jsonSchemaTool(
    flow.name,
    flow.description,
    JSON.parse(flow.invokeSchema),
    async (args) => {
      console.log("flow invoke", flow.name, args);
      const result = await fetch(flow.webhookUrl, {
        method: "POST",
        body: JSON.stringify(args),
        headers: {
          "Content-Type": "application/json",
          "prismatic-synchronous": "true",
        },
      });
      return { content: [{ type: "text", text: await result.text() }] };
    },
  );
}