---
title: "Connect Aurora Solar to ChatGPT: Automate Project and Design Workflows"
slug: connect-aurora-solar-to-chatgpt-automate-project-and-design-workflows
date: 2026-07-07
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to connect Aurora Solar to ChatGPT using a managed MCP server. Automate project creation, solar design requests, and utility bill workflows without maintaining custom API infrastructure."
tldr: "Connect Aurora Solar to ChatGPT via Truto's managed MCP server to automate solar design requests, project tracking, and utility bill processing without building or hosting custom API integration infrastructure."
canonical: https://truto.one/blog/connect-aurora-solar-to-chatgpt-automate-project-and-design-workflows/
---

# Connect Aurora Solar to ChatGPT: Automate Project and Design Workflows


If you need to connect Aurora Solar to ChatGPT to automate solar project pipelines, trigger remote design requests, or analyze utility bill consumption, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between ChatGPT's tool calls and Aurora Solar's complex REST API ecosystem. If your team uses Claude, check out our guide on [connecting Aurora Solar to Claude](https://truto.one/connect-aurora-solar-to-claude-manage-sales-proposals-and-financing/) or explore our broader architectural overview on [connecting Aurora Solar to AI Agents](https://truto.one/connect-aurora-solar-to-ai-agents-sync-engineering-and-site-surveys/).

Giving a Large Language Model (LLM) read and write access to a specialized solar design and engineering platform is a serious engineering challenge. You have to handle OAuth token lifecycles, map massive JSON schemas to MCP tool definitions, and navigate Aurora Solar's heavy reliance on asynchronous polling mechanisms. Every time an endpoint updates, you have to rewrite your server code, redeploy, and test the integration.

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

## The Engineering Reality of the Aurora Solar 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, the reality of implementing it against Aurora Solar's proprietary API endpoints is painful. If you decide to build a custom MCP server, you own the entire lifecycle of the integration.

Here are the specific integration challenges that break standard CRUD assumptions when working with Aurora Solar:

### Asynchronous Polling Quagmires
Aurora Solar does not execute heavy operations in a single synchronous HTTP request. If you want to convert an order to a project, parse a utility bill via OCR, run an AI roof model, or generate a PDF proposal, the API immediately returns a `202 Accepted` with a `job_id`. Your AI agent cannot simply wait for a response. Your MCP server must expose separate polling tools, and you must explicitly instruct the LLM to use the `job_id` to poll the status endpoint until it hits a `succeeded` or `failed` state. If your MCP tools aren't perfectly mapped to link the creation tool with the status tool, the LLM will hallucinate the outcome.

### Ephemeral Presigned URLs
When an LLM needs to access a generated proposal PDF, a signed contract agreement, or an uploaded utility bill, Aurora Solar does not provide static file links. It generates presigned download URLs that expire quickly. A utility bill link expires in 24 hours. A Docusign agreement PDF link expires in exactly 15 minutes. If your AI agent tries to reference a URL an hour after requesting it, the request will 403. Your MCP architecture must instruct the LLM to dynamically re-request fresh URLs immediately before file ingestion.

### Deeply Nested Data Mutability constraints
Updating Aurora Solar data models requires highly specific payload structures. For example, updating a project's consumption profile strictly requires exactly one of three nested objects: `monthly_bill`, `monthly_energy`, or `interval_data`. Sending more than one throws a validation error. Updating system loss settings requires a partial map of string names to integer percentages. If you do not construct perfect JSON schemas for the LLM to parse, the model will fail to format its write requests correctly.

### Rate Limits and the 429 Reality
Aurora Solar enforces strict rate limits across its tenants. **Factual note on rate limits:** Truto does not retry, throttle, or apply backoff on rate limit errors. When an upstream API returns HTTP 429, Truto passes that error directly to the caller. Truto normalizes upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The caller (or the custom framework orchestrating ChatGPT) is entirely responsible for retry and exponential backoff logic.

## How Truto's Managed MCP Server Works

Instead of forcing your engineering team to build boilerplate API wrappers, Truto dynamically generates an MCP server from your connected Aurora Solar account. 

Truto derives MCP tools dynamically from documentation records and resource configurations. This [auto-generated approach](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide) acts as a quality gate, ensuring LLMs only see well-defined endpoints. Rather than hand-coding tool definitions, Truto cross-references the available Aurora Solar endpoints with structured documentation records containing descriptions, query schemas, and body schemas. If an endpoint is documented, it automatically becomes a tool.

Each MCP server is backed by a secure cryptographic token stored in a distributed edge key-value system. The resulting URL contains everything ChatGPT needs to authenticate and execute API calls via Truto's proxy routing layer. 

## Step 1: Creating the Aurora Solar MCP Server

You can create an MCP server for Aurora Solar using either the Truto UI or programmatically via the Truto API.

### Method 1: Via the Truto UI
1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select your connected Aurora Solar instance.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Configure the server settings (assign a name, optionally filter by specific HTTP methods like `read` or `write`, and apply specific tags).
5. Click save and **copy the generated MCP server URL** (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API
You can dynamically provision MCP servers for your users by sending an authenticated POST request. This is ideal if you are embedding agentic workflows into your own SaaS application.

```bash
curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Aurora Solar Project AI",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'
```

The API will return a database record containing the secure URL:

```json
{
  "id": "aur-123",
  "name": "Aurora Solar Project AI",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

## Step 2: Connecting Aurora Solar to ChatGPT

Once you have the Truto MCP URL, you need to register it as a [custom connector](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto) in your AI framework.

### Method A: Via the ChatGPT UI
If you are using ChatGPT Pro, Plus, Enterprise, or Team accounts, you can add the server directly into the interface.

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Toggle **Developer mode** to ON.
3. Under the **MCP servers / Custom connectors** section, click add.
4. Enter a recognizable name (e.g., "Aurora Solar").
5. Paste the Truto MCP URL into the **Server URL** field.
6. Save the configuration. ChatGPT will immediately perform the initialization handshake and ingest the available tools.

*(Note: For Claude Desktop, navigate to Settings -> Integrations -> Add MCP Server, paste the URL, and click Add).* 

### Method B: Via Manual Config File
If you are running local agents, Claude Desktop (via manual config), or an open-source framework like Cursor, you can route traffic to the Truto MCP URL using the official Server-Sent Events (SSE) transport adapter.

Modify your `mcp_config.json` (or framework equivalent) to point to the remote Truto endpoint:

```json
{
  "mcpServers": {
    "aurora_solar": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f67890"
      ]
    }
  }
}
```

## Hero Tools for Aurora Solar Workflows

When ChatGPT connects to the server, Truto automatically translates the integration's documentation into LLM-ready schemas. Here are the most critical tools available for building automated solar workflows.

### 1. list_all_aurora_solar_tenant_projects
Retrieves a list of Aurora Solar projects for the tenant. The query schema automatically instructs the LLM to utilize the `next_cursor` property exactly as received to handle pagination for large project pipelines.

> "Find the latest 50 solar projects created in the system and return their property addresses and current status."

### 2. get_single_aurora_solar_tenant_project_by_id
Retrieves the full project object including location, owner ID, AHJ ID, and deep customer details. Truto automatically flattens path and query parameters so the LLM simply provides the `id`.

> "Get the full project details for project ID 987654, paying special attention to the Authority Having Jurisdiction (AHJ) ID and project status."

### 3. create_a_aurora_solar_tenant_design_request
Generates a new remote design request for a project. This triggers Aurora Solar's expert design teams to create a 3D model. Requires the `project_id`, address details, and SLA parameters.

> "Create a new priority design request for project ID 987654. Include the roof pitch estimate of 18 degrees and mark it for auto-accept once the design is completed."

### 4. list_all_aurora_solar_project_utility_bills
Lists all utility bills uploaded to a project. Crucially, this returns freshly minted presigned download URLs for the bill files. The LLM must be aware that the returned URL expires in 24 hours.

> "Check the utility bills uploaded for project ID 987654. Retrieve the latest bill and provide the secure download URL so I can extract the PDF contents."

### 5. list_all_aurora_solar_design_pricings
Retrieves the complex financial pricing models applied to an Aurora Solar design, including system price, price per watt, storage pricing methods, and any applied adders or incentives.

> "Pull the pricing summary for design ID 112233. Break down the flat system price versus the storage pricing, and list any discount adders currently applied to the deal."

### 6. create_a_aurora_solar_project_creation_run
Creates a Project from an Aurora Solar Order by triggering an asynchronous creation job. Returns a `job_id` which must be polled.

> "Convert order ID 554433 into a new project. Give me the resulting job ID so we can monitor the creation status."

### 7. list_all_aurora_solar_project_creation_status
Polls the status of the Convert Order to Project job. Requires the `order_id` and the `job_id` returned from the previous run.

> "Check the status of project creation job ID 889900 for order ID 554433. Let me know if it has succeeded or failed."

To view the complete inventory of available tools, required properties, and JSON schemas, visit the [Aurora Solar integration page](https://truto.one/integrations/detail/aurorasolar).

## Workflows in Action

Exposing these tools to ChatGPT enables highly autonomous workflows that drastically reduce manual data entry for sales and engineering teams.

### Workflow 1: The Automated Solar Design Requester
Sales reps often create a project in the CRM and then manually log into Aurora Solar to request a 3D design from the engineering team. An AI agent can fully automate this handover.

> "Check if project 987654 has any active design requests. If not, create a new EagleView design request for it and set the auto_accept flag to true."

**Execution Steps:**
1. ChatGPT calls `list_all_aurora_solar_tenant_design_requests` filtering by `project_id`. 
2. The server returns an empty list, confirming no active requests exist.
3. ChatGPT calls `create_a_aurora_solar_design_requests_eagleview`, passing the `project_id` and setting `auto_accept: true` in the JSON body.
4. The server returns the generated `eagleview_design_request` object, confirming the request was successfully queued.

```mermaid
sequenceDiagram
    participant User
    participant LLM as ChatGPT
    participant MCP as Truto MCP Server
    participant Aurora as Aurora Solar API

    User->>LLM: Check project 987654 for design requests.<br>If none, create EagleView request.
    LLM->>MCP: Call list_all_aurora_solar_tenant_design_requests
    MCP->>Aurora: GET /tenant/design_requests?project_id=987654
    Aurora-->>MCP: 200 OK (Empty array)
    MCP-->>LLM: Result: []
    LLM->>MCP: Call create_a_aurora_solar_design_requests_eagleview
    MCP->>Aurora: POST /design_requests/eagleview<br>{"project_id":"987654", "auto_accept":true}
    Aurora-->>MCP: 201 Created (eagleview_design_request)
    MCP-->>LLM: Result: Request ID 55667
    LLM-->>User: No prior requests found. Created EagleView<br>design request 55667.
```

### Workflow 2: Bill Parsing and Financial Analysis
Analyzing a customer's current energy consumption is the first step in quoting a solar system. An agent can extract the utility bill metadata and ensure the system has valid consumption profiles attached.

> "Find the latest utility bill for project 987654 and get the download URL. Then, check the current consumption profile for the project to see what the monthly energy estimate is."

**Execution Steps:**
1. ChatGPT calls `list_all_aurora_solar_project_utility_bills` passing the `project_id`.
2. The server responds with a list of utility bills, sorted newest first, containing freshly generated presigned URLs.
3. ChatGPT isolates the latest `utility_bill` ID and temporary URL.
4. ChatGPT calls `list_all_aurora_solar_project_consumption_profiles` to retrieve the current baseline estimates.
5. The LLM presents the secure download link and the monthly energy profile to the user.

### Workflow 3: Order to Project Conversion (Async Polling)
When a sales order closes, turning it into a deployable project involves asynchronous backend processing.

> "Convert order 112233 to a project and wait until it finishes processing."

**Execution Steps:**
1. ChatGPT calls `create_a_aurora_solar_project_creation_run` with the order ID.
2. The server returns a `202 Accepted` response with a `job_id` (e.g., `job_9988`).
3. ChatGPT calls `list_all_aurora_solar_project_creation_status` passing the order ID and `job_id`.
4. If the response status is `processing`, the LLM waits a moment and loops back to step 3.
5. Once the response hits `succeeded`, the LLM extracts the newly minted `project_id` and informs the user.

## Security and Access Control

When connecting ChatGPT to a production Aurora Solar environment, security is paramount. The Truto MCP architecture includes several mechanisms to constrain AI agent behavior:

* **Method Filtering:** During token creation, you can specify an allowed methods array (e.g., `methods: ["read"]`). Truto will physically refuse to generate tool definitions for `create`, `update`, or `delete` operations, completely neutralizing the AI's ability to mutate data.
* **Tag Filtering:** You can restrict the MCP server to only expose tools relevant to specific domains (e.g., only `designs` or `orders`), hiding sensitive administrative APIs.
* **Time-to-Live Expiration:** You can set an `expires_at` timestamp. Once the Unix timestamp is breached, the distributed alarm handler immediately purges the token from edge KV storage, terminating access instantly.
* **Secondary Authentication:** Enabling `require_api_token_auth` mandates that the client must pass a valid Truto API token in the `Authorization` header alongside the MCP URL token. This ensures that even if the MCP URL is leaked in a chat log, it cannot be used without valid environment credentials.

## Give ChatGPT a Solar Engineering Degree

Building a custom integration layer between AI frameworks and Aurora Solar requires wrangling asynchronous polling architecture, short-lived security tokens, and deeply nested mutability schemas. By offloading the API execution layer to Truto, you strip away the boilerplate.

You generate an MCP server, pass the URL to ChatGPT, and immediately transition from reading REST documentation to executing natural language engineering workflows.

> Stop spending engineering cycles building custom AI tool integrations for Aurora Solar. Let Truto generate your MCP infrastructure dynamically so you can focus on building AI products.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)