---
title: "Connect Fishbowl Advanced to Claude: Query Data & Track Production"
slug: connect-fishbowl-advanced-to-claude-query-data-track-production
date: 2026-11-01
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "A technical guide to connecting Fishbowl Advanced to Claude via a managed MCP server. Learn how to configure tools, execute raw SQL queries, and automate manufacturing workflows."
tldr: "Connect Fishbowl Advanced to Claude using Truto's managed MCP server. This guide covers setup via UI and API, Claude configuration, and executing complex workflows like raw SQL queries and inventory management using AI."
canonical: https://truto.one/blog/connect-fishbowl-advanced-to-claude-query-data-track-production/
---

# Connect Fishbowl Advanced to Claude: Query Data & Track Production


If your team needs to connect Fishbowl Advanced to Claude to automate inventory tracking, query custom manufacturing data, or manage purchase orders, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This server acts as the translation layer between Claude's JSON-RPC tool calls and Fishbowl Advanced's REST APIs. You can either [build and maintain this infrastructure yourself](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or use a [managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). If your team uses ChatGPT, check out our guide on [/connect-fishbowl-advanced-to-chatgpt-manage-orders-inventory/](https://truto.one/connect-fishbowl-advanced-to-chatgpt-manage-orders-inventory/) or explore our broader architectural overview on [/connect-fishbowl-advanced-to-ai-agents-automate-sourcing-sales/](https://truto.one/connect-fishbowl-advanced-to-ai-agents-automate-sourcing-sales/).

Giving a Large Language Model (LLM) read and write access to a complex manufacturing and warehouse management system like Fishbowl Advanced is an engineering challenge. You have to map highly nested JSON schemas to MCP tool definitions, deal with Fishbowl's unique data import requirements, and handle complex authentication lifecycles. Every time a new custom field is added to the ERP, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Fishbowl Advanced, connect it natively to Claude Desktop, and execute complex manufacturing workflows using natural language.

> Want to give your AI agents secure, authenticated access to Fishbowl Advanced and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Fishbowl Advanced 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](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/), the reality of implementing it against specialized ERP APIs is painful. Fishbowl Advanced is built to manage deep bills of materials, complex inventory routing, and hybrid on-premise/cloud database architectures. Its API directly reflects that complexity.

If you decide to build a custom Fishbowl Advanced MCP server, here are the specific integration challenges you will face:

**The SQL Query Data Access Pattern**
Unlike standard SaaS applications that expose a distinct REST endpoint for every object type, Fishbowl Advanced relies heavily on direct SQL execution for data retrieval. To read sales orders, customers, or custom tracking values that lack dedicated endpoints, you must execute raw SQL queries via the API. An LLM needs strict schema awareness to generate valid `SELECT` statements for the underlying Firebird or MySQL database. A managed MCP server exposes tools like `list_all_fishbowl_advanced_data_queries` that allow Claude to safely execute these read-only queries while explicitly blocking potentially destructive operations.

**CSV-Formatted JSON Payloads for Data Imports**
Creating or updating core records in Fishbowl Advanced often bypasses standard JSON objects entirely. Instead, the API utilizes a hybrid pattern where data is imported using the `create_a_fishbowl_advanced_import` endpoint. The body of the JSON request requires an array of rows where the first row acts as a strict CSV header. Furthermore, the `import_name` parameter must match case-sensitive internal naming conventions (e.g., `Sales-Order-Details`). Writing custom code to force an LLM to reliably generate this exact structure is tedious and error-prone.

**Strict Rate Limits and Normalization**
Fishbowl Advanced instances can easily be overwhelmed by aggressive polling or rapid LLM tool execution loops. Factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream API returns an 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 - your MCP client or AI agent - is strictly responsible for retry and backoff logic. Do not build an integration expecting the middle tier to absorb these errors.

## Creating the Fishbowl Advanced MCP Server

Truto dynamically generates MCP tools from the Fishbowl Advanced integration's resource definitions and documentation. You can generate an MCP server for a specific Fishbowl Advanced account using either the Truto UI or the API.

### Method 1: Via the Truto UI

For ad-hoc configurations and testing, the UI is the fastest path.

1. Log into your Truto dashboard and navigate to the integrated account page for the connected Fishbowl Advanced instance.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration. You can filter the server to only allow `read` operations, or restrict access using specific tool tags (e.g., `inventory`, `manufacturing`).
5. Copy the generated MCP server URL. It will look like `https://api.truto.one/mcp/a1b2c3d4e5f6...`.

### Method 2: Via the Truto API

For programmatic, multi-tenant deployments, you can generate MCP servers on the fly via REST. This endpoint creates a database record, securely hashes the token, and schedules any requested expiration alarms.

```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": "Fishbowl Production Assistant",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["inventory", "manufacturing"]
    }
  }'
```

The API will return the server details and the authenticated URL:

```json
{
  "id": "mcp-uuid-1234-5678",
  "name": "Fishbowl Production Assistant",
  "config": {
    "methods": ["read", "write", "custom"],
    "tags": ["inventory", "manufacturing"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you can connect it to Claude. Because the URL contains a cryptographic token linked directly to the integrated account, no additional API keys are required on the client side.

### Method A: Via the Claude UI

If you are using the Claude web interface or enterprise workspace that supports native custom connectors:

1. Navigate to **Settings** > **Integrations** (or **Connectors** depending on your plan tier).
2. Click **Add MCP Server** or **Add custom connector**.
3. Paste the Truto MCP URL (`https://api.truto.one/mcp/a1b2c3d4e5f6...`) into the Server URL field.
4. Click **Add**. Claude will perform an initialization handshake (`initialize`), retrieve the tool definitions via `tools/list`, and make them immediately available for use in your chats.

### Method B: Via Manual Configuration File (Claude Desktop)

If you are building custom tooling or running Claude Desktop locally, you must configure the MCP server via the `claude_desktop_config.json` file. Because Truto's MCP servers speak Server-Sent Events (SSE) over HTTP, you will use the official `@modelcontextprotocol/server-sse` package to proxy the connection.

Edit your configuration file (typically found at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):

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

Restart Claude Desktop. The application will execute the `npx` command, establish the SSE connection, and populate the UI with the Fishbowl Advanced tools.

## Security and Access Control

Exposing an ERP to an LLM requires strict boundary controls. Truto enforces security at the token level, ensuring the model can only execute the tools you explicitly authorize.

*   **Method Filtering (`config.methods`)**: Restrict the MCP server to specific operation types. Set `["read"]` to strictly allow `get` and `list` methods. The model will physically not be able to see or call `create`, `update`, or `delete` tools.
*   **Tag Filtering (`config.tags`)**: Group tools by functional area. By setting `["inventory"]`, you isolate the LLM to inventory operations, blocking it from touching HR or accounting modules within Fishbowl.
*   **Expiration (`expires_at`)**: Pass an ISO datetime string when creating the server to generate a short-lived token. Once the timestamp is reached, Cloudflare KV drops the token and a scheduled alarm cleans up the database record, instantly revoking access.
*   **Dual Authentication (`require_api_token_auth`)**: By default, the MCP URL acts as a bearer token. For zero-trust environments, enable `require_api_token_auth: true`. The MCP client must then pass a valid Truto API token in the `Authorization` header on every request, ensuring that URL possession alone is not enough to execute a tool.

## Hero Tools for Fishbowl Advanced

The Truto MCP server dynamically generates tools from the Fishbowl Advanced API schema. Here are the highest-leverage tools available for AI-driven automation.

### list_all_fishbowl_advanced_data_queries

This is the most powerful read tool in the Fishbowl integration. Because Fishbowl lacks REST read endpoints for many core objects, this tool allows Claude to execute raw SQL `SELECT` queries against the database schema.

> "Write a SQL query to retrieve the top 10 most recent sales orders where the statusId is 2, including the id and num columns, and execute it against the Fishbowl database."

### create_a_fishbowl_advanced_import

This tool handles bulk data inserts and updates for objects that lack a standard REST write endpoint. It accepts a JSON array of rows, where the first row is the CSV header. The `import_name` must exactly match Fishbowl's internal case-sensitive import names (e.g., `Sales-Order-Details`).

> "Format a JSON array to update the shipping addresses for customer ID 405 using the 'Customer' import format, and execute the import into Fishbowl."

### list_all_fishbowl_advanced_inventory

Searches the active inventory tables. Truto handles the underlying pagination (using `pageNumber` and `pageSize`), providing a consistent cursor format for Claude to iterate through massive part lists.

> "Pull the current inventory levels for all parts in the 'Main Warehouse' location group and list any items where the available quantity is below the minimum threshold."

### create_a_fishbowl_advanced_inventory_move

Executes an inventory move transaction, transferring stock from one physical location to another within Fishbowl. Requires the specific `part_id` and the origin/destination location IDs.

> "Move 50 units of part ID 8901 from the Receiving Dock location to the Assembly Line location in Fishbowl."

### list_all_fishbowl_advanced_manufacture_orders

Searches and retrieves manufacture orders (MOs). This tool is critical for tracking production progress, understanding raw material commitments, and auditing factory floor operations.

> "List all active manufacture orders scheduled for this week, and extract the MO numbers and their current statuses."

### create_a_fishbowl_advanced_manufacture_order_issue

Issues a specific manufacture order, effectively committing the required raw materials out of inventory and moving the MO into an active production state. Requires the `manufacture_order_id`.

> "Issue the manufacture order with ID 4459 to commit the required inventory for production."

For the complete inventory of available tools, including detailed query and body schemas, visit the [Fishbowl Advanced integration page](https://truto.one/integrations/detail/fishbowl).

## Workflows in Action

With the MCP server connected, Claude can orchestrate complex, multi-step workflows across the Fishbowl Advanced ecosystem. Here are real-world examples of how engineers and floor managers use these tools.

### Scenario 1: Auditing Stalled Sales Orders via Custom SQL

Warehouse managers frequently need to identify sales orders that are stuck in specific statuses but lack an out-of-the-box API endpoint to filter them effectively.

> "Query the Fishbowl database to find all sales orders stuck in statusId 20. Extract the order numbers, then generate a CSV import payload to update their status to 'On Hold' using the Sales-Order import format."

1. **`list_all_fishbowl_advanced_data_queries`**: Claude formulates a `SELECT id, num FROM so WHERE statusId = 20` query and executes it against the database to retrieve the stalled orders.
2. **`create_a_fishbowl_advanced_import`**: Using the retrieved IDs, Claude structures a JSON array with the required CSV headers (e.g., `OrderNumber, Status`) and executes the import using `import_name: "Sales-Order"`.

**Result**: The user receives confirmation that the database was queried successfully, the data was extracted, and the batch update was processed natively by Fishbowl's import engine.

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as "Claude Desktop"
    participant Truto as "Truto MCP Server"
    participant FB as "Fishbowl API"

    User->>Claude: "Find stalled orders and update status."
    Claude->>Truto: Call list_all_fishbowl_advanced_data_queries (SQL SELECT)
    Truto->>FB: Execute Proxy API
    FB-->>Truto: Return SQL ResultSet
    Truto-->>Claude: JSON Array of Orders
    Claude->>Truto: Call create_a_fishbowl_advanced_import (Sales-Order)
    Truto->>FB: Execute Proxy API
    FB-->>Truto: Import Success Status
    Truto-->>Claude: Result Confirmation
    Claude-->>User: "Orders updated to On Hold."
```

### Scenario 2: Orchestrating Manufacturing Execution

Production planners need to ensure raw materials are staged before officially issuing a manufacture order.

> "Check the inventory levels for part ID 8901. If we have at least 100 units, move them from Receiving to the Assembly Line location, then issue manufacture order ID 4459."

1. **`list_all_fishbowl_advanced_inventory`**: Claude queries the inventory tables for `part_id: 8901` to verify sufficient stock exists in the source location.
2. **`create_a_fishbowl_advanced_inventory_move`**: Claude executes the inventory move, transferring the 100 units to the Assembly Line location ID.
3. **`create_a_fishbowl_advanced_manufacture_order_issue`**: With the materials physically staged, Claude issues the MO (`manufacture_order_id: 4459`), committing the stock to the job.

**Result**: The floor manager gets a natural language confirmation that the physical inventory routing is complete and the production job is officially active in the ERP.

```mermaid
flowchart TD
    A["Check Inventory<br>(list_all_..._inventory)"] --> B{"Stock >= 100?"}
    B -->|"Yes"| C["Move Inventory<br>(create_a_..._inventory_move)"]
    B -->|"No"| D["Alert Manager<br>Insufficient Stock"]
    C --> E["Issue MO<br>(create_a_..._manufacture_order_issue)"]```

## Wrap-Up

Connecting Claude to Fishbowl Advanced via MCP transforms a complex, legacy-pattern ERP into an accessible, AI-driven automation engine. By utilizing Truto's dynamic tool generation, you sidestep the massive architectural burden of maintaining OAuth lifecycles, mapping CSV-in-JSON schemas, and managing custom SQL integrations. Your LLM gets immediate, structured access to inventory, manufacturing, and raw data layers, while you retain absolute control over authentication and endpoint security.

Ready to stop hand-coding integration layers and start building agentic workflows? Use Truto to abstract the API complexity.

> Want to give your AI agents secure, authenticated access to Fishbowl Advanced and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)