Connect Epicor Kinetic to ChatGPT: Manage ERP Orders, Jobs, and Parts

If you need to connect Epicor Kinetic to ChatGPT to automate supply chain workflows, manage manufacturing jobs, or orchestrate complex ERP sales orders, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's function calls and Epicor Kinetic's complex OData REST APIs. You can either build and maintain this proxy infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on connecting Epicor Kinetic to Claude or explore our broader architectural overview on connecting Epicor Kinetic to AI Agents.

Giving a Large Language Model (LLM) read and write access to a highly customized, on-premise or cloud-hosted ERP like Epicor Kinetic is a massive engineering challenge. You have to handle rigid relational data payloads, map dynamic Business Activity Queries (BAQs) to MCP tool definitions, and deal with deeply nested Business Object (BO) architectures. Every time an Epicor administrator updates a BAQ or adds a required custom field (UD field) to an order schema, your custom server code must be updated, redeployed, and tested.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Epicor Kinetic, connect it natively to ChatGPT, and execute complex ERP workflows using natural language.

The Engineering Reality of the Epicor Kinetic API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools via JSON-RPC, implementing it against Epicor Kinetic's highly specialized API surface is exceptionally painful.

If you decide to build a custom MCP server for Epicor, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Epicor Kinetic:

The Complexity of Business Objects (Erp.BO)

Epicor Kinetic does not expose flat, simple REST resources. Instead, it exposes Business Objects (e.g., Erp.BO.SalesOrderSvc or Erp.BO.JobEntrySvc). Interacting with these services requires understanding the underlying dataset structures. Creating a sales order isn't just a matter of POSTing a generic JSON object; Epicor expects a structured OrderHed dataset, and any lines attached require referencing the parent key precisely. If your LLM hallucinates the relational mapping between OrderNum and OrderLine, the API will outright reject the payload with cryptic server-side exceptions.

Business Activity Queries (BAQs) and Dynamic Schemas

In the real world, no two Epicor deployments are the same. Companies rely heavily on custom Business Activity Queries (BAQs) to extract specific, joined data sets (e.g., "Get all open jobs for parts containing specific materials"). Standard static MCP tools cannot account for these custom endpoints. Your MCP server must dynamically read the available BAQs (BaqSvc) for the authenticated user and expose them as runnable tools with plain query parameters. Hardcoding standard endpoints guarantees your AI agent will be blind to the company's actual operational data.

OData Syntax and Pagination Constraints

Epicor relies heavily on OData V3 and V4 standards for querying. When an AI agent needs to find a specific vendor, it must generate a syntactically perfect OData $filter string (e.g., VendorNum eq 5000). Furthermore, Epicor restricts the number of returned records, requiring strict adherence to pagination cursors or $top / $skip logic. If you build your own MCP server, you must teach the LLM to paginate accurately or write middleware to abstract the OData complexity away from the model.

Connect Epicor Kinetic to ChatGPT Quickstart Guide

If you just want the fastest path from a fresh Truto account to ChatGPT calling the Epicor Kinetic API, follow these steps. Deeper architecture, security, and lifecycle details live in the sections below.

What you need:

• A Truto account with API access.
• Epicor Kinetic API credentials (ensure REST access is enabled on the Epicor instance).
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available.

Step 1: Connect Epicor Kinetic as an Integrated Account

In the Truto dashboard, open Integrated Accounts -> New Integrated Account, pick Epicor Kinetic, and input the required credentials (Base URL, Username, Password, and Company ID). Truto handles the login token lifecycle (POST TokenResource.svc), generating and refreshing the bearer token every 20 minutes automatically so ChatGPT never encounters an expired credential.

Step 2: Generate an Epicor Kinetic MCP Server

Truto scopes every MCP server to a single integrated account using a cryptographic token. You can generate this URL via the Truto UI or the API.

Method A: Via the Truto UI

1. Navigate to the integrated account page for your Epicor connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., allowing only specific methods like read, or tagging specific resources like sales_orders).
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<token>).

Method B: Via the API If you are programmatically provisioning AI access for your users, you can generate the MCP server via a single API call:

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Epicor for ChatGPT",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'

The response returns a url field containing your secure MCP endpoint.

Step 3: Connect the MCP Server to ChatGPT

With your secure URL in hand, you must register it with your ChatGPT environment. You can do this visually or via a local configuration file.

Method A: Via the ChatGPT UI

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode on.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name: Epicor Kinetic.
5. Server URL: Paste the Truto MCP URL.
6. Click Save.

Method B: Via Manual Config File For developers managing local AI environments, you can configure the connection manually. ChatGPT supports SSE-based (Server-Sent Events) MCP connections. Add the following to your MCP client configuration JSON:

{
  "mcpServers": {
    "epicor-kinetic": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<your_secure_token>"
      ]
    }
  }
}

Once connected, ChatGPT will execute the tools/list JSON-RPC handshake, and Truto will dynamically translate the Epicor Kinetic integration documentation into a list of usable AI tools.

Epicor Kinetic MCP Hero Tools

Truto automatically generates an expansive inventory of MCP tools for Epicor Kinetic. Rather than exposing raw endpoints, these tools are enriched with descriptions and JSON schemas instructing the LLM exactly how to construct queries, apply OData filters, and format ERP payloads. Here are the highest-leverage tools available for AI agents.

Execute Business Activity Queries

Tool: list_all_epicor_kinetic_baq_results

This is arguably the most powerful tool in the Epicor arsenal. It allows ChatGPT to execute custom BAQs configured by the ERP administrator. The LLM passes BAQ parameters as plain query parameters, enabling dynamic execution of complex, pre-joined data views without needing to understand the underlying SQL.

"Run the 'DailyShipments' BAQ for the date range starting on Monday. Give me a summary of total shipped value by customer."

Execute Business Object Methods

Tool: epicor_kinetic_business_object_methods_execute

For complex operations that standard CRUD cannot accomplish, Epicor uses specific business object methods (e.g., GetNewOrderHed, UpdateExt). This tool executes POST /api/v2/odata/<Company>/<service>/<method_name>. The LLM must pass the parameters exactly as named in the instance's REST help.

"Call the Erp.BO.SalesOrderSvc GetNewOrderHed method to instantiate a new sales order header for customer ID 1045."

Manage Sales Orders

Tool: list_all_epicor_kinetic_sales_orders

Queries the Erp.BO.SalesOrderSvc/SalesOrders object. The LLM can pass an OData $filter to isolate specific orders. Truto handles the cursor-based pagination automatically, fetching up to 100 results per page and seamlessly passing the cursor back to the model.

"Find all open sales orders for CustNum 1205 where the total amount is greater than $5,000."

Add Lines to Sales Orders

Tool: create_a_epicor_kinetic_sales_order_line

Creates a line item for an existing order by interacting with Erp.BO.SalesOrderSvc/OrderDtls. The LLM must provide the order_num query parameter and the OrderDtl column payload. Epicor automatically handles default value injection.

"Add a line item to Sales Order 50020 for PartNum 'WIDGET-X', quantity 50. Set the required date to next Friday."

Create Purchase Orders

Tool: create_a_epicor_kinetic_purchase_order

Generates a new PO via POST Erp.BO.POSvc/POes. The LLM sends the POHeader columns (like VendorNum). Epicor assigns the system key and defaults for terms and shipping.

"Draft a new purchase order for VendorNum 7780. Leave the lines empty for now, I just need the PO header created."

Retrieve Manufacturing Jobs

Tool: get_single_epicor_kinetic_job_by_id

Fetches a specific manufacturing job by its ID from Erp.BO.JobEntrySvc/JobEntries. Useful for agentic workflows where customer support needs to check the production status of a backordered item.

"Check the status of manufacturing job 'JOB-99432'. Is the job closed or still in the engineering phase?"

To view the full inventory of tools, including AP/AR invoicing, vendor management, quote generation, and Epicor Functions execution, visit the Epicor Kinetic integration page.

Workflows in Action

When you give ChatGPT access to Epicor Kinetic via an MCP server, it stops being a passive chat interface and becomes a capable ERP operator. Here are two real-world sequences showing how the model chains tools together to solve business problems.

Workflow 1: Customer Order Status Investigation

An account manager needs an immediate update on a delayed customer order to prep for a client call.

"Find the most recent sales order for customer 'Acme Corp'. Check if there are any active manufacturing jobs linked to its parts and tell me the job status."

How ChatGPT executes this:

1. Lookup Customer: Calls list_all_epicor_kinetic_customers using an OData filter Name eq 'Acme Corp' to extract the CustNum.
2. Lookup Orders: Calls list_all_epicor_kinetic_sales_orders filtering by CustNum and ordering by date descending to grab the most recent OrderNum.
3. Inspect Lines: Calls list_all_epicor_kinetic_sales_order_lines passing order_num to extract the PartNums being ordered.
4. Check Jobs: Calls list_all_epicor_kinetic_jobs filtering by PartNum eq '...' and checking the JobClosed and JobComplete flags.

Result: ChatGPT replies: "Acme Corp's most recent order (Order 54099) includes 20 units of part 'BRACKET-A'. There is currently an active manufacturing job (Job 10293) for this part which is marked as open and in the 'Assembly' phase. It is not yet complete."

Workflow 2: Automated Custom Reporting via BAQ

A supply chain analyst wants to run a custom internal query without logging into the Epicor desktop client.

"Run our custom 'LowStockAlert' BAQ for warehouse 'MAIN'. Export the results into a markdown table."

How ChatGPT executes this:

1. Identify BAQs: Calls list_all_epicor_kinetic_baqs (if it needs to verify the exact ID of the query).
2. Execute BAQ: Calls list_all_epicor_kinetic_baq_results passing baq_id: 'LowStockAlert' and providing the custom parameter WarehouseCode: 'MAIN'.
3. Format Output: The LLM receives the JSON array of rows, parses the fields, and formats them into a markdown table.

Result: ChatGPT instantly returns a fully formatted markdown table containing the exact columns designed by the Epicor administrator in the BAQ, saving the user from navigating complex ERP reporting menus.

flowchart TD
    A["ChatGPT Pro<br>(MCP Client)"] -->|"POST /mcp/:token<br>Call BAQ Tool"| B["Truto MCP Server<br>(Stateless Proxy)"]
    B -->|"REST GET<br>/BaqSvc/LowStockAlert/Data"| C["Epicor Kinetic API"]
    C -->|"BAQ JSON Response"| B
    B -->|"JSON-RPC 2.0 Response"| A

Security and Access Control

Giving an LLM access to a mission-critical ERP like Epicor Kinetic requires strict guardrails. Truto's MCP servers are designed with security primitives that keep you in control of what the model can touch.

• Method Filtering: When creating the MCP token, you can restrict the server to specific HTTP verbs. Set "methods": ["read"] to ensure ChatGPT can only query Epicor data (like running BAQs or listing jobs) but can never accidentally execute a POST or PATCH to alter financial records.
• Tag Filtering: Limit the scope of the server to specific operational domains. By applying tags like ["sales", "inventory"], the MCP server will only generate tools related to those specific integration resources, hiding sensitive endpoints like payroll or HR entirely.
• Additional Authentication (require_api_token_auth): By default, the MCP URL acts as a bearer token. If you check this flag during creation, clients hitting the /mcp/:token endpoint must also supply a valid Truto API token in their Authorization header, adding a second layer of identity verification.
• Ephemeral Servers (expires_at): For temporary workflows or contractor access, you can pass an ISO datetime to expires_at. Truto relies on distributed key-value expiration and durable state alarms to permanently destroy the token at the exact second it expires.

A Note on Handling Epicor Rate Limits

When automating workflows at scale, AI agents can generate a significant volume of API requests, especially when paginating through large ERP datasets. It is critical to understand how infrastructure handles throttling.

Truto does not retry, throttle, or apply backoff on rate limit errors. When Epicor Kinetic returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller in the JSON-RPC payload. Truto normalizes the upstream rate limit information into standardized HTTP headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (whether that is ChatGPT or a custom LangGraph agent orchestrator) is strictly responsible for interpreting these headers and implementing its own retry and backoff logic.

Summary

Connecting ChatGPT to Epicor Kinetic via an MCP server bridges the gap between natural language intelligence and rigid ERP operations. Instead of forcing your team to navigate complex desktop clients or write manual OData queries, you can empower AI agents to query BAQs, check job statuses, and draft purchase orders autonomously.

By leveraging an auto-generated, managed MCP layer, engineering teams can bypass the maintenance burden of tracking schema drift, pagination rules, and token refreshes—allowing them to focus strictly on building high-leverage AI workflows.