---
title: "Connect BQE CORE to ChatGPT: Manage Projects, Time, and Expenses"
slug: connect-bqe-core-to-chatgpt-manage-projects-time-and-expenses
date: 2026-10-31
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: "Learn how to connect BQE CORE to ChatGPT using a managed MCP server. Automate project accounting, time tracking, and expense workflows with AI agents."
tldr: "Discover how to generate a secure, authenticated MCP server for BQE CORE using Truto, and connect it to ChatGPT to orchestrate complex ERP workflows like time tracking and invoicing."
canonical: https://truto.one/blog/connect-bqe-core-to-chatgpt-manage-projects-time-and-expenses/
---

# Connect BQE CORE to ChatGPT: Manage Projects, Time, and Expenses


If you need to connect BQE CORE to ChatGPT to automate project accounting, time tracking, or resource scheduling, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This infrastructure layer acts as a JSON-RPC 2.0 translation layer, converting natural language intent from ChatGPT into structured, authenticated REST calls against the BQE CORE API. 

If your team uses Claude, check out our guide on [connecting BQE CORE to Claude](https://truto.one/connect-bqe-core-to-claude-automate-billing-and-resource-schedules/) or explore our broader architectural overview on [connecting BQE CORE to AI Agents](https://truto.one/connect-bqe-core-to-ai-agents-sync-sales-leads-and-workforce-ops/).

Giving a Large Language Model (LLM) read and write access to a comprehensive professional services automation (PSA) and enterprise resource planning (ERP) platform like BQE CORE is a massive engineering challenge. You must handle deeply nested relational data payloads, map rigid expense and time entry schemas to LLM tool definitions, and deal with strict pagination and validation rules. Every time you want to expose a new endpoint, your custom server code must be updated, redeployed, and tested. 

This guide breaks down exactly how to use Truto to [generate a secure, managed BQE CORE MCP server dynamically](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/), connect it natively to ChatGPT, and execute complex workflows using natural language.

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the BQE CORE 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, implementing it against BQE CORE's highly structured API is exceptionally painful. If you decide to [build a custom BQE CORE MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with BQE CORE:

### Relational Hierarchy and Strict ID Dependencies
Unlike simple SaaS platforms with flat schemas, BQE CORE enforces a strict relational hierarchy. You cannot simply instruct the API to "log two hours for John on the Acme redesign." A valid `create_a_bqe_core_time_entry` request requires exact UUIDs for the `resourceId` (Employee), `projectId` (Project), and `activityId` (Activity code). This means your AI agent must execute a multi-step orchestration: searching for the employee, querying the project list with a `where` filter, finding the correct activity code, and finally executing the POST request. If your MCP server does not expose these underlying lookup endpoints, your LLM will hallucinate UUIDs and fail continuously.

### Complex Pagination and Expansion Limits
BQE CORE employs a rigid pagination scheme utilizing the `page=<number>,<size>` format. By default, you can retrieve up to 1000 records per page. However, BQE CORE supports an `expand` query parameter to pull nested properties (e.g., retrieving client details alongside a project). When `expand` is used, the maximum page size drops to 100. If your LLM attempts to fetch a large list of activities with nested allocations and requests a page size of 500, the API will throw an error. The MCP tool definitions must explicitly document these constraints so the LLM formats its query strings correctly.

### Rate Limiting and Error Handling
Like any enterprise ERP, BQE CORE enforces strict rate limits to protect its infrastructure. When building an integration, it is crucial to understand that **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the upstream BQE CORE API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller (in this case, your custom AI agent framework or ChatGPT) is entirely responsible for reading these headers and executing the appropriate retry and exponential backoff logic.

## Generating a BQE CORE MCP Server

Instead of building a custom Node.js or Python MCP server from scratch, you can use Truto to generate a secure, authenticated MCP server URL. Truto derives the tool definitions dynamically from BQE CORE's API documentation. 

There are two ways to generate this server.

### Method 1: Via the Truto UI

For teams who prefer a visual setup process, you can generate the server directly from the dashboard:

1. Log into your Truto account and navigate to **Integrated Accounts**.
2. Select your connected BQE CORE account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Configure the server (e.g., name it "ChatGPT BQE CORE", filter for specific `methods` or `tags` if you only want read access).
6. Click **Create** and copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/<token>`).

### Method 2: Via the API

For developers building programmatic deployment pipelines, you can generate the MCP server via a single API call. This provisions the server in Truto's Cloudflare KV storage and returns a ready-to-use endpoint.

```bash
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": "ChatGPT BQE CORE Automation",
    "config": {
      "methods": ["read", "write"],
      "tags": ["projects", "time_entries", "expenses", "employees", "activities"]
    }
  }'
```

The JSON response will contain a `url` field. This URL is cryptographically hashed and acts as both the routing layer and the authentication mechanism. Treat this URL as a sensitive secret.

## Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you need to register it with ChatGPT so the LLM can discover and invoke the BQE CORE tools. You can do this visually in ChatGPT or programmatically via a config file if you are using an enterprise setup.

### Method 1: Via the ChatGPT UI

If you are using ChatGPT Plus, Pro, Business, Enterprise, or Education:

1. Open ChatGPT and go to **Settings -> Apps -> Advanced settings**.
2. Ensure **Developer mode** is toggled on.
3. Under **MCP servers / Custom connectors**, click **Add new**.
4. Enter a name (e.g., "BQE CORE (Truto)").
5. Paste your Truto MCP URL into the Server URL field.
6. Click **Save**.

ChatGPT will immediately ping the endpoint, execute the `initialize` and `tools/list` JSON-RPC handshake, and load the BQE CORE tools into its context window.

### Method 2: Via Manual Config File

If you are running a local development agent or [managing a team-wide configuration](https://truto.one/how-to-architect-a-multi-tenant-mcp-server-for-enterprise-b2b-saas/) for an OpenAI-compatible desktop client, you can use the standard MCP configuration file approach. Use the Server-Sent Events (SSE) proxy to route traffic to the Truto URL.

```json
{
  "mcpServers": {
    "bqe-core-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<your-token-here>"
      ]
    }
  }
}
```

## Hero Tools for BQE CORE

Truto exposes over a hundred operations for BQE CORE, covering everything from Accounts and Benefits to Subscriptions and Vendors. Below are the highest-leverage hero tools that enable ChatGPT to handle project management, time tracking, and expense workflows. 

### 1. list_all_bqe_core_projects
Retrieves a paginated list of projects. The LLM relies on this tool to translate a human-readable project name (e.g., "Acme Redesign") into the `id` required for subsequent time and expense entries. You can pass `where` and `orderBy` parameters to filter the results efficiently.

> "Find the project ID for the 'Acme Redesign' project so we can log time against it. Check the active projects list."

### 2. create_a_bqe_core_time_entry
Creates a new time entry. This is the core engine for timesheet automation. It requires a `projectId`, `activityId`, `resourceId`, `date`, and a `description`. The LLM must assemble these required UUIDs before invoking this tool.

> "Log 4 hours of time for today. The project is 'Acme Redesign' and the activity is 'Design Consulting'. Use my employee record."

### 3. list_all_bqe_core_activities
Retrieves the list of billable and non-billable activity codes defined in the ERP. Time entries are strictly validated against these activity codes, making this lookup operation mandatory for automated timesheets.

> "Search our activity codes for anything related to 'Software Engineering' or 'Code Review' and return the ID."

### 4. create_a_bqe_core_expense_entry
Logs a project expense. Similar to time entries, this requires a `projectId`, `expenseId`, `resourceId`, `date`, and `description`. This tool allows AI agents to parse receipts or natural language expenses and inject them directly into BQE CORE.

> "Record a $150 expense for server hosting against the Internal IT project. Tag it under the 'Software Subscriptions' expense code."

### 5. list_all_bqe_core_employees
Retrieves the directory of employees. This tool is essential for mapping a user's natural language identity to their `resourceId` in BQE CORE, which is required for both time and expense assignments.

> "Look up the employee ID for Sarah Jenkins in the directory so I can assign her to the new project allocation."

### 6. create_a_bqe_core_invoice
Generates a new invoice based on tracked time and expenses. This requires a `date`, `invoiceAmount`, and `invoiceNumber`. 

> "Draft a new invoice for $5,000 dated today for the Acme account. We will attach the time entries to it in the next step."

For a complete list of all BQE CORE tools, schemas, required fields, and expansion parameters, visit the [BQE CORE integration page](https://truto.one/integrations/detail/bqecore).

## Workflows in Action

Connecting tools to ChatGPT is only half the battle. The real value of an MCP server lies in how the LLM chains these tools together to execute multi-step workflows. Because Truto flattens the input schemas and handles the API routing, ChatGPT can focus entirely on orchestration.

### Scenario 1: Automated Time Entry Logging

A project manager asks ChatGPT to log time for a specific task. The LLM cannot simply guess the UUIDs; it must query BQE CORE to resolve the natural language names into strict database identifiers before writing the data.

> "Please log 3 hours for today on the 'Mobile App V2' project. The activity is 'Backend Development' and the employee is Michael Scott. Add a note saying we refactored the API routes."

**Tool execution sequence:**
1. `list_all_bqe_core_projects` - The LLM searches for a project where the name contains "Mobile App V2" and extracts the `projectId`.
2. `list_all_bqe_core_employees` - The LLM searches for Michael Scott to retrieve his `resourceId`.
3. `list_all_bqe_core_activities` - The LLM searches for an activity code matching "Backend Development" to get the `activityId`.
4. `create_a_bqe_core_time_entry` - Armed with the exact UUIDs, the LLM constructs the JSON payload and successfully logs the 3 hours.

The user receives a confirmation message: *"I've successfully logged 3 hours for Michael Scott on the Mobile App V2 project under Backend Development. The description has been updated with your notes."*

```mermaid
sequenceDiagram
    participant User as User
    participant GPT as ChatGPT
    participant MCP as Truto MCP Server
    participant BQE as BQE CORE API

    User->>GPT: "Log 3 hours for Michael on Mobile App V2"
    GPT->>MCP: Call list_all_bqe_core_projects
    MCP->>BQE: GET /projects
    BQE-->>MCP: Returns Project ID
    MCP-->>GPT: Project ID
    
    GPT->>MCP: Call list_all_bqe_core_employees
    MCP->>BQE: GET /employees
    BQE-->>MCP: Returns Resource ID
    MCP-->>GPT: Resource ID
    
    GPT->>MCP: Call create_a_bqe_core_time_entry
    MCP->>BQE: POST /timeentries<br>with UUIDs
    BQE-->>MCP: 201 Created
    MCP-->>GPT: Success
    GPT-->>User: "Time entry successfully logged!"
```

### Scenario 2: Project Expense and Invoice Generation

A team lead needs to record a software purchase and immediately generate an invoice for the client.

> "I just bought a $200 SSL certificate for the 'Stark Industries Website' project. Log this as a 'Software' expense for me (Jim Halpert). Once that's done, create an invoice for $200 so we can bill them."

**Tool execution sequence:**
1. `list_all_bqe_core_projects` - Looks up the Stark Industries project ID.
2. `list_all_bqe_core_employees` - Looks up Jim Halpert's ID.
3. `list_all_bqe_core_expenses` - Finds the expense code ID for "Software".
4. `create_a_bqe_core_expense_entry` - Logs the $200 expense using the retrieved IDs.
5. `create_a_bqe_core_invoice` - Drafts the invoice for $200.

The user receives a confirmation: *"I have logged the $200 software expense against the Stark Industries project for Jim Halpert. I have also generated a new invoice for $200 to bill the client."*

## Security and Access Control

Exposing an ERP like BQE CORE to an AI agent requires strict governance. Truto's MCP architecture provides native security controls that limit what the LLM can see and do.

*   **Method Filtering:** When generating the MCP server, you can pass `"methods": ["read"]` to ensure the server only exposes GET and LIST operations. This prevents the LLM from accidentally deleting projects or altering financial records.
*   **Tag Filtering:** Use the `tags` array to scope the tools by domain. Passing `"tags": ["time_entries", "projects"]` hides sensitive tools like payroll, banking, or human resources from the LLM.
*   **Require API Token Auth:** By setting `require_api_token_auth: true`, the bare MCP URL is no longer sufficient for access. The connecting client must also pass a valid Truto API token in the `Authorization` header, providing a second layer of enterprise authentication.
*   **Expiring Servers:** For temporary agent tasks or contractor access, you can pass an `expires_at` ISO datetime. The Truto infrastructure will automatically delete the MCP server and revoke all access from Cloudflare KV precisely at the specified time.

Integrating BQE CORE with ChatGPT manually requires parsing massive API specs, managing OAuth tokens, and writing complex pagination and retry logic. By using Truto to generate a managed MCP server, you turn months of backend engineering into a single API call, empowering your AI agents to safely automate time, expenses, and project lifecycles.