Connect Lone Wolf Back Office to ChatGPT: Manage Transactions & Staff

If you need to connect Lone Wolf Back Office to ChatGPT to automate real estate transaction pipelines, manage agent commissions, or audit your office staff, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and the underlying Lone Wolf Back Office API. You can either spend weeks building, hosting, and securing this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate an authenticated MCP server URL in seconds.

If your team uses Claude, check out our guide on connecting Lone Wolf Back Office to Claude or explore our broader architectural overview on connecting Lone Wolf Back Office to AI Agents.

Giving a Large Language Model (LLM) read and write access to a complex back-office system is a significant engineering challenge. You have to handle intricate relational data payloads, map dynamic resources to MCP tool definitions, and manage strict OAuth token lifecycles. Every time an endpoint changes or you need to expose a new resource, 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 Lone Wolf Back Office, connect it natively to ChatGPT, and execute complex workflows using natural language.

The Engineering Reality of the Lone Wolf Back Office 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 Lone Wolf Back Office's specific Transact API requires handling several unique architectural quirks.

If you decide to build a custom MCP server for Lone Wolf Back Office, you own the entire API lifecycle. Here are the specific integration challenges you will face:

The Custom JWT Exchange Lifecycle

The Lone Wolf Back Office API does not use a standard perpetual bearer token. Instead, it relies on an OAuth client credentials flow that requires exchanging your application's client ID, client secret, and a specific Lone Wolf client GUID for a JWT access token. This exchange happens at the /oauth/token endpoint and results in an access_token and an expires_in value. If your custom MCP server attempts to call an endpoint with an expired token, the request will fail. Your server must track the expiration time, pause incoming tool calls from ChatGPT, perform the token exchange, and resume the request. Truto handles this automatically by running the create_a_lone_wolf_back_office_access_token operation behind the scenes every hour, ensuring ChatGPT never encounters an expired credential.

Strict Pagination Mechanics

When an LLM asks "Get me all the employees in the system," a standard API might return hundreds of records. The Lone Wolf Back Office API strictly enforces pagination using limit and offset parameters, with the limit strictly capped at 100 records per page. Your MCP server must explicitly inform the LLM about these constraints via the tool schemas, otherwise ChatGPT might attempt to pull 1,000 records at once and trigger a 400 Bad Request error. Truto automatically injects these pagination schemas into the generated tools, instructing the model to iterate through pages accurately.

Highly Relational Domain Models

Lone Wolf Back Office data is not flat. A transaction record relies on external references to business contacts, condition types, and specific commission entities. When ChatGPT creates a transaction, it cannot just pass a flat string of data - it must assemble a nested JSON object referencing valid IDs for offices, property types, and contact types. Your MCP server must expose all of these supporting read endpoints so the LLM can look up the correct foreign keys before attempting a write operation.

Quickstart: Creating and Connecting the MCP Server

Truto dynamically generates MCP tools based on the resources available in your connected Lone Wolf Back Office account. Here is how to create the server and connect it to ChatGPT.

Step 1: Create the MCP Server

You can generate the MCP server URL either directly through the Truto dashboard or programmatically via the Truto REST API.

Method A: Via the Truto UI

1. Log into your Truto dashboard and navigate to the Integrated Accounts section.
2. Select your connected Lone Wolf Back Office account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., allow read and write methods, filter by specific tags like transactions or employees).
6. Click Save and copy the generated MCP server URL.

Method B: Via the API If you are provisioning infrastructure programmatically, you can issue a POST request to the Truto API to generate the server. This scopes a secure token specifically to this integrated account.

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": "Lone Wolf Back Office - ChatGPT Server",
    "config": {
      "methods": ["read", "write"],
      "tags": ["transactions", "employees", "commissions"]
    }
  }'

The API returns a JSON response containing the critical url field:

{
  "id": "abc-123-def",
  "name": "Lone Wolf Back Office - ChatGPT Server",
  "config": { 
    "methods": ["read", "write"], 
    "tags": ["transactions", "employees", "commissions"] 
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Treat this URL as a secret. It encodes the routing and authentication required to execute tools against your specific Lone Wolf Back Office instance.

Step 2: Connect to ChatGPT

Once you have your MCP server URL, you must register it with ChatGPT so the LLM can discover the available tools.

Method A: Via the ChatGPT UI (Developer Mode)

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON (this requires a Plus, Pro, Team, or Enterprise account).
3. Under MCP servers / Custom connectors, click Add a new server.
4. Enter a recognizable name (e.g., "Lone Wolf Back Office").
5. Paste the Truto MCP URL into the Server URL field and click Save.

ChatGPT will perform the initial JSON-RPC handshake, pull down the tool definitions, and immediately make them available in your chat sessions.

Method B: Via Manual Config File (SSE Transport) If you are orchestrating local agents or prefer a configuration-as-code approach, you can define the connection in an MCP configuration file using the @modelcontextprotocol/server-sse package to proxy the connection.

{
  "mcpServers": {
    "lone-wolf-back-office": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}

Hero Tools for Lone Wolf Back Office

Truto automatically generates tools for every documented resource on the integration. Instead of listing all operations, here are 6 high-leverage hero tools that unlock the most powerful ChatGPT workflows for Lone Wolf Back Office.

List All Transactions

Tool Name: list_all_lone_wolf_back_office_transactions

This is the core read tool for auditing real estate pipelines. It supports filtering by startDate and endDate, allowing ChatGPT to pull transactions for a specific reporting period. It also utilizes limit and offset for paging through large datasets.

"Pull all transactions that occurred between September 1st and September 30th. Summarize the total number of deals and group them by status."

Create a Transaction

Tool Name: create_a_lone_wolf_back_office_transaction

This write tool allows ChatGPT to initiate new deals directly in the system. Because transactions require valid references to property types and offices, ChatGPT will typically call listing tools first to gather the correct IDs before executing this payload.

"Draft a new transaction for the property at 123 Main Street. Set the property type to Residential and assign it to the Seattle office."

Get Commission Details

Tool Name: get_single_lone_wolf_back_office_commission_by_id

Required parameter: id. Extracts the specific commission structure tied to a transaction or agent. This is critical for end-of-month reconciliations where a broker needs to verify splits, deductions, and final payout numbers.

"Look up the commission record for ID 48291. What was the gross commission, and what percentage was allocated to the external agent?"

List All Employees

Tool Name: list_all_lone_wolf_back_office_employees

Retrieves the directory of staff members and agents. Truto handles the pagination schemas, ensuring ChatGPT knows how to iterate if your organization has more than 100 employees.

"List all active employees in the system. Filter the results to only show agents assigned to the Downtown branch."

Get Deposit Details

Tool Name: get_single_lone_wolf_back_office_deposit_by_id

Required parameter: id. Retrieves the financial specifics of earnest money or escrow deposits. This allows financial controllers to use ChatGPT to audit deposit statuses without logging into the clunky ERP interface.

"Retrieve the deposit record for ID 9931. Verify the deposit amount and check if the funds have cleared."

List All Offices

Tool Name: list_all_lone_wolf_back_office_offices

Returns the structural hierarchy of your brokerage locations. This tool is often used as a prerequisite step so ChatGPT can discover valid office IDs before assigning employees or creating transactions.

"List all configured office locations. I need the internal ID for the Portland office so we can assign a new agent to it."

For the complete inventory of available Lone Wolf Back Office tools, including classifications, contact types, and external agents, view the Lone Wolf Back Office integration page.

Workflows in Action

Exposing individual tools is helpful, but the real power of MCP emerges when ChatGPT chains these tools together to execute multi-step workflows. Here are two concrete examples of how personas interact with Lone Wolf Back Office via ChatGPT.

Scenario 1: End-of-Month Commission Reconciliation

Persona: Brokerage Financial Controller

A financial controller needs to verify that the top-performing agent in a specific office received the correct commission splits for their recent deals.

"Find all transactions closed last month in the Austin office. Identify the top agent by volume, and retrieve their specific commission details to verify the split was calculated correctly."

Execution Steps:

1. ChatGPT calls list_all_lone_wolf_back_office_offices to find the internal ID for the Austin office.
2. ChatGPT calls list_all_lone_wolf_back_office_transactions with startDate and endDate filters, filtering the results in-memory to match the Austin office ID.
3. ChatGPT analyzes the transaction array to identify the agent with the highest aggregate volume.
4. ChatGPT extracts the commission IDs from that agent's transactions and iteratively calls get_single_lone_wolf_back_office_commission_by_id.
5. ChatGPT summarizes the gross commissions, calculated splits, and flags any anomalies to the user.

sequenceDiagram
  participant User as User
  participant ChatGPT as ChatGPT
  participant Truto as Truto MCP Server
  participant API as Lone Wolf Back Office
  
  User->>ChatGPT: "Audit Austin office commissions..."
  ChatGPT->>Truto: call list_all_lone_wolf_back_office_offices
  Truto->>API: GET /offices
  API-->>Truto: [{id: 4, name: "Austin"}]
  Truto-->>ChatGPT: Office ID 4
  
  ChatGPT->>Truto: call list_all_lone_wolf_back_office_transactions
  Truto->>API: GET /transactions?startDate=...&endDate=...
  API-->>Truto: Transaction data array
  Truto-->>ChatGPT: Transaction data array
  
  ChatGPT->>Truto: call get_single_lone_wolf_back_office_commission_by_id (id: 89)
  Truto->>API: GET /commissions/89
  API-->>Truto: Commission details
  Truto-->>ChatGPT: Commission details
  
  ChatGPT-->>User: Top agent summary and split verification

Scenario 2: New Office Setup and Staff Allocation

Persona: Regional Operations Manager

An operations manager is preparing to open a new branch and needs to audit the current employee roster to identify staff members who can be transferred.

"Get a list of all our current offices. Then, pull the full list of employees and tell me how many agents are currently assigned to the North branch vs the South branch."

Execution Steps:

1. ChatGPT calls list_all_lone_wolf_back_office_offices to map the names of the North and South branches to their respective IDs.
2. ChatGPT calls list_all_lone_wolf_back_office_employees. If the roster exceeds 100 employees, the API returns a pagination cursor. ChatGPT automatically calls the tool again using the offset parameter until all pages are retrieved.
3. ChatGPT cross-references the employee array against the office IDs, counting the agents assigned to each branch.
4. ChatGPT returns a formatted breakdown of the staff allocation.

Handling Rate Limits

When connecting AI agents to enterprise APIs, rate limiting is a critical consideration. LLMs can execute tools rapidly, sometimes triggering upstream API throttling.

It is important to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Lone Wolf Back Office 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, the LLM framework or the client orchestrating the agent - is fully responsible for reading these headers, implementing retry logic, and applying exponential backoff.

Do not assume the MCP server will absorb these errors for you. Design your agent prompts or client architecture to handle 429s gracefully.

Security and Access Control

Exposing an ERP system to an AI agent requires strict governance. You should not give ChatGPT unrestricted access to delete transactions or modify commission structures unless explicitly intended. Truto MCP servers provide four layers of security configuration at the token level:

• Method Filtering: Constrain the server by HTTP method. You can configure the MCP server to only expose read operations (get, list), ensuring ChatGPT cannot modify data, even if it tries to hallucinate a write command.
• Tag Filtering: Group tools by functional domains. If you only want an agent to analyze employee data, you can create a server restricted to the employees tag, completely removing transaction and deposit tools from the schema.
• Extra Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. For higher security, enabling this flag forces the client to pass a valid Truto API token in the Authorization header. This ensures only authenticated users can invoke the tools.
• Expiration (expires_at): You can set a strict time-to-live for the MCP server. Once the timestamp passes, the server URL becomes invalid, and Truto automatically destroys the underlying configuration. This is perfect for granting temporary agent access for specific auditing tasks.

Stop Writing Boilerplate Integration Code

Building a custom MCP server for Lone Wolf Back Office requires managing OAuth client credentials, formatting complex JSON payloads, mapping relational entities, and constantly updating schemas when the vendor changes their API.

Truto eliminates this technical debt. By dynamically generating documentation-driven MCP tools from connected integrations, Truto allows your engineering team to focus on building agentic workflows rather than maintaining infrastructure.