Connect Forecast to ChatGPT: Manage Project Teams and Resources

If you need to connect Forecast to ChatGPT to automate project planning, resource allocation, and financial tracking, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Forecast's REST APIs. You can either spend weeks writing custom integration code and managing token refreshes, 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 sibling guide on connecting Forecast to Claude or explore our broader architectural overview on connecting Forecast to AI Agents.

Giving a Large Language Model (LLM) read and write access to a complex professional services automation (PSA) tool like Forecast is a massive engineering challenge. You have to handle legacy versus modern endpoints, custom field mappings, and strict time registration rules. Every time Forecast updates an 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 MCP server for Forecast, connect it natively to ChatGPT, and execute complex resourcing workflows using natural language.

The Engineering Reality of the Forecast 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 Forecast's extensive API surface is exceptionally painful.

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

The Legacy v3 vs v4 Endpoint Split

Forecast is actively migrating its architecture, which means its API surface is split across legacy v3 endpoints and modern v4 endpoints. For example, time registrations have both list_all_forecast_legacy_time_registrations (v3) and list_all_forecast_time_registrations (v4). If you build a static MCP server, you must manually curate which endpoints the LLM can see, or risk the agent hallucinating payloads against deprecated routes. Truto handles this by clearly labeling deprecated resources and automatically pushing the modern schemas to the LLM.

Custom Fields Require Admin-Defined Keys

Forecast relies heavily on custom fields to adapt to different business processes. Unlike systems that return custom data as a simple unstructured object, Forecast's forecast_custom_fields_update_task or forecast_custom_fields_update_phase endpoints require a map of keys to values where the keys must be pre-defined in the Forecast admin UI for that specific entity type. Your LLM needs exact schema context to know which custom keys are valid, otherwise, the API will reject the payload with a validation error.

Complex Utilization and Aggregation Dates

When querying financial numbers or person utilization, Forecast expects highly specific date parameters (often formatted as YYYYMMDD and requiring both start_date and end_date simultaneously). Financial aggregation also requires strict grouping enum values (PROJECT, YEAR, MONTH). Building this into an MCP server requires writing complex input validation logic to ensure the LLM doesn't send mismatched dates or invalid groupings that cause 500 errors.

How Truto's Auto-Generated MCP Servers Work

Truto eliminates these headaches by treating tool generation as a dynamic, documentation-driven process. Rather than writing code for each Forecast endpoint, Truto derives MCP tool definitions directly from the integration's internal schemas and human-readable documentation.

When ChatGPT requests tools via the JSON-RPC tools/list protocol, Truto dynamically compiles the list. If an endpoint lacks proper documentation, it does not become a tool. This acts as a strict quality gate, ensuring the LLM only sees well-defined operations.

flowchart TD
    A["ChatGPT Client"] -->|"JSON-RPC POST"| B["Truto MCP Endpoint<br>(/mcp/:token)"]
    B -->|"Token Validation<br>(Edge KV Storage)"| C["MCP Router"]
    C -->|"Proxy API Handler"| D["Forecast Native API"]
    D -.->|"HTTP 429 Rate Limit<br>(Passed through)"| C
    C -.->|"Normalized Headers<br>(No auto-retry)"| A

The Rate Limit Reality (No Auto-Retries)

It is critical to understand how rate limits function when combining AI agents with third-party APIs. Truto does not retry, throttle, or apply backoff on rate limit errors.

When the upstream Forecast API returns an HTTP 429 (Too Many Requests), Truto passes that exact error back to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification.

It is entirely the responsibility of the caller (your custom agent orchestration layer, or the ChatGPT client) to read these headers, implement exponential backoff, and retry the tool call. Do not assume the infrastructure will magically absorb high-velocity token streams hitting Forecast's API limits.

Step 1: Create the Forecast MCP Server

Before ChatGPT can talk to Forecast, you need an active connection. First, connect your Forecast account in the Truto dashboard via OAuth. Once connected, you will receive an integrated_account_id.

You can generate the MCP Server URL using either the Truto UI or the Truto REST API.

Method A: Via the Truto UI

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select your connected Forecast account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restrict to read methods only, or filter by specific tags like tasks and financials).
6. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<secure-token>).

Method B: Via the Truto API

If you are provisioning infrastructure programmatically, you can create the MCP server via a single API call. This is ideal for multi-tenant architectures where you need to spin up isolated servers for individual customers.

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": "Forecast Resourcing Copilot",
    "config": {
      "methods": ["read", "write"],
      "tags": ["projects", "tasks", "persons", "utilization"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

Truto hashes the token, stores it in a globally distributed key-value store, and returns the endpoint URL. This URL is self-contained - it handles routing, authentication, and schema definition in one endpoint.

Step 2: Connect the MCP Server to ChatGPT

Once you have the Truto MCP URL, you must register it with your LLM client. We will cover both the ChatGPT Desktop UI and the manual configuration file approach for custom server implementations.

Method A: Via the ChatGPT UI

Note: MCP support in ChatGPT requires a Pro, Plus, Business, Enterprise, or Education account with Developer mode enabled.

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode on.
3. Under the MCP servers (or Custom connectors) section, click Add a new server.
4. Give it a label, such as "Forecast (Truto)".
5. Paste the Truto MCP URL into the Server URL field and click Save.

ChatGPT will immediately ping the endpoint, execute an initialize handshake, and call tools/list to populate its context window with the Forecast schema.

Method B: Via Manual Config File (SSE Bridge)

If you are running a custom MCP client setup, LangChain, or using an intermediate CLI layer, you can bridge the Truto HTTP endpoint using the standard @modelcontextprotocol/server-sse package in an mcp.json or claude_desktop_config.json file:

{
  "mcpServers": {
    "forecast-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<your-secure-token>"
      ]
    }
  }
}

Hero Tools for Forecast

Truto exposes dozens of Forecast endpoints, but throwing 100 tools at an LLM wastes context window space. Here are the 6 highest-leverage "hero tools" for building agentic resource and project workflows.

1. list_all_forecast_projects

Retrieves a list of all projects in the Forecast workspace, including their stage, status, budget, and dates. This is the foundation for almost all agentic workflows, as the LLM needs the project_id to query tasks or expenses.

"Give me a list of all active Forecast projects along with their current budget and start dates."

2. create_a_forecast_task

Creates a new task in a specific project. The LLM can set estimates, assigned persons, and labels natively. Because Truto flattens the input namespace, the LLM simply passes a single JSON object containing both path and body parameters.

"Create a new task in the 'Website Overhaul' project called 'Finalize QA'. Assign it an estimate of 4 hours and tag it as high priority."

3. create_a_forecast_time_registration

Logs time against a specific task or project. This is crucial for building slackbots or chat interfaces that allow engineers and creatives to log time conversationally.

"Log 2.5 hours today for me on the 'API Integration' task. Add a note saying I completed the OAuth architecture."

4. get_single_forecast_person_utilization_by_id

Retrieves granular utilization data for a specific team member over a given date range. The agent uses this to prevent overallocation before assigning new work.

"Check Sarah's utilization for next week. If she has more than 15 hours of available time, assign her to the phase 2 design task."

5. forecast_financials_get_financial_numbers

Extracts aggregated financial metrics including revenue recognition, actual costs, and forecast to complete. This tool requires specific startDate, endDate, and groupBy parameters, which the LLM derives from the JSON Schema.

"Pull the aggregated financial numbers for the Q3 marketing campaign. Group the data by month and show me the actual cost versus planned revenue."

6. forecast_custom_fields_update_task

Sets custom field values on a task. The LLM must pass a dictionary of custom-field keys to values. This demonstrates how Truto proxies complex, instance-specific payloads.

"Update the custom fields on task #4592. Set the 'Client_Approval_Status' to 'Pending' and the 'Target_Release_Quarter' to 'Q4'."

For the complete inventory of Forecast tools and detailed schema definitions, visit the Truto Forecast integration page.

Workflows in Action

Exposing tools is only the first step. The true power of an MCP server lies in the LLM's ability to orchestrate multi-step, stateful workflows. Here is how ChatGPT utilizes these tools in practice.

Scenario 1: Intelligent Resource Allocation

Project managers constantly struggle to balance workloads. Instead of clicking through five different screens, a PM can ask ChatGPT to handle the reallocation.

User Prompt:

"Find the 'Enterprise App Migration' project. Check the utilization for John and Emily next week. Assign the 'Database Schema Audit' task to whoever has more available capacity. The task should have a 6-hour estimate."

Agent Execution Sequence:

1. list_all_forecast_projects - The LLM searches for the project named "Enterprise App Migration" and extracts its id.
2. list_all_forecast_persons - The LLM queries the directory to resolve the IDs for "John" and "Emily".
3. get_single_forecast_person_utilization_by_id (Called twice) - The LLM queries the utilization endpoints for both John and Emily, passing next week's date range formatted as YYYYMMDD.
4. Internal Logic - ChatGPT compares minutes_available minus task_minutes_allocated for both users.
5. create_a_forecast_task - The LLM constructs the payload, passing the project_id, the 6-hour estimate, and assigns it to the person with higher capacity.

Result: ChatGPT confirms the task creation and reports back which engineer was assigned based on exact capacity metrics.

Scenario 2: Month-End Financial Audit

Finance teams need to quickly identify discrepancies between logged time and billed revenue.

sequenceDiagram
    participant User
    participant GPT as ChatGPT
    participant Truto as Truto MCP Server
    participant Forecast as Forecast API

    User->>GPT: Audit September financials
    GPT->>Truto: call "forecast_financials_get_financial_numbers"
    Truto->>Forecast: GET /v1/financials
    Forecast-->>Truto: 200 OK (Financial Data)
    Truto-->>GPT: JSON-RPC Result
    GPT->>Truto: call "list_all_forecast_deleted_data"
    Truto->>Forecast: GET /v1/deleted-data
    Forecast-->>Truto: 200 OK (Deleted logs)
    Truto-->>GPT: JSON-RPC Result
    GPT-->>User: "Found a $4,000 discrepancy caused by deleted time registrations."

User Prompt:

"Audit our financial numbers for last month. Group the data by project. Also, check if there are any deleted time registrations from that period that might explain the drop in billable hours for the 'Alpha Redesign' project."

Agent Execution Sequence:

1. forecast_financials_get_financial_numbers - The LLM requests the financials, setting startDate to the beginning of the month, endDate to the end, and groupBy to PROJECT.
2. list_all_forecast_deleted_data - The LLM fetches the log of deleted time registrations, filtering for entries within the target month.
3. Internal Logic - ChatGPT correlates the missing billable minutes from the deleted registrations with the financial shortfall on the "Alpha Redesign" project.

Result: The user receives a concise summary explaining exactly why revenue dipped, backed by audit logs of deleted timesheets.

Security and Access Control

Giving an AI agent raw write access to your PSA platform is inherently risky. Truto provides several architectural guardrails to enforce least privilege at the MCP server level:

• Method Filtering (methods): Restrict an MCP server to only allow read operations (GET, LIST) or block write operations (CREATE, UPDATE, DELETE). If an LLM goes rogue, the server fundamentally rejects mutations.
• Tag Filtering (tags): Scope the server by functional area. You can generate a server that only has tools tagged with financials or tasks, hiding all HR or directory endpoints.
• Dual Authentication (require_api_token_auth): By default, the cryptographically secure MCP URL is the only secret needed. For enterprise deployments, toggle require_api_token_auth: true. The MCP client must then pass a valid Truto API token in the Authorization header, linking the action to a known developer identity.
• Automatic Expiration (expires_at): Schedule the server to self-destruct via durable alarms. This is ideal for granting an external contractor or temporary CI/CD pipeline short-lived agentic access to Forecast.

Final Thoughts

Connecting ChatGPT to Forecast using the Model Context Protocol bridges the gap between unstructured conversation and structured resource planning.

Attempting to build this translation layer yourself means writing endless boilerplate to handle JSON-RPC handshakes, API schema transformations, and legacy endpoint routing. By utilizing Truto's documentation-driven MCP generation, you reduce an entire quarter of integration engineering into a single POST request.

Your AI agents get instant, heavily curated access to Forecast's native capabilities, and your engineering team gets to focus on core product logic instead of maintaining token lifecycles and parsing OpenAPI specs.