Every enterprise team faces the same challenge: critical business data lives scattered across multiple systems. Salesforce holds CRM data, NetSuite manages ERP, Zendesk tracks support tickets, and separate databases store product usage, HR records, and marketing metrics. Getting a unified view requires either filing a data engineering ticket and waiting days or exporting CSVs and manually joining them in spreadsheets.
The goal is simple: build a natural-language query interface where any business user can ask "Show me accounts with declining product usage and open support tickets" and get a real-time answer joined across multiple systems. No SQL. No exports. No waiting.
The challenge is that cross-system connectivity typically requires massive engineering effort. Teams need to authenticate with each API, normalize across different schemas, translate queries for each source, and securely manage credentials. Most teams spend months just building the plumbing before they can even start on actual product features. Connect AI MCP changes this equation entirely.
Why Connect AI MCP makes this realistic
Traditional data integrations turn the connectivity layer into the bottleneck. Every SaaS platform has its own authentication flow, rate limits, pagination quirks, and schema inconsistencies. Building custom connectors for even three or four systems can take weeks.
Connect AI handles all of that complexity through two interfaces that make AI-assisted development actually work:
What this means for the build: the application never needs to understand how Salesforce, NetSuite, Zendesk, or other databases work under the hood. It just points at Connect AI, which handles authentication, query translation, and schema normalization for all 350+ connectors it supports. From the application's perspective, every data source looks identical.
The MCP endpoint is what makes AI coding assistance practical here. Instead of writing custom connector logic that an AI tool would struggle to generate correctly, developers can use simple SQL queries that any LLM understands. The AI coding assistant generates the queries, Connect AI executes them, and the results come back ready to use.
What we built and the tools used
The result is a Business Intelligence Command Center: a Next.js application where users type questions in plain English and get live, cross-system answers with AI-generated summaries.
A single engineer, with the help of Claude Code, built the entire application with Connect AI working under the hood. Claude Code is an AI coding assistant that runs in the terminal and can autonomously handle multi-file projects. The tech stack is straightforward: Next.js for the frontend, Connect AI's REST Metadata API for schema discovery, and the Connect AI MCP endpoint for query execution. The AI layer supports multiple providers, including Grok, Gemini, OpenAI, Mistral, and DeepSeek.
The app organizes enterprise data into six categories: CRM, ERP, Support, Product Usage, HRIS, and Marketing. It ships with ten prebuilt query templates for common cross-functional questions like churn risk analysis, pipeline-to-invoice gaps, product adoption tracking, and revenue recognition. Users can also ask ad-hoc questions.
What makes the build fast: Connect AI abstracts away all the connector complexity, so Claude Code can focus entirely on the application logic. No debugging OAuth flows or parsing inconsistent API responses. Just writing prompts and letting the AI assistant generate working code.
The prompts that built this app and how Connect AI made them work
The development process feels fundamentally different when Connect AI handles the connectivity layer. Instead of spending days writing connector code, the entire build becomes a conversation with Claude Code. Here are the actual prompts used and what Connect AI enabled at each step.
Prompt 1: Get me the schema context
The first prompt to Claude Code: "Call the Connect AI REST Metadata API to get the schema for CRM, ERP, and Support categories, then cache the results."
Normally, this step alone would be a multi-day project. You would need to:
Read API documentation for Salesforce, NetSuite, and Zendesk
Figure out their different authentication methods (OAuth 2.0, token-based, session-based)
Build custom logic to query each platform's schema endpoint
Manually map Salesforce "objects" to NetSuite "records" to Zendesk "tickets"
Write code to normalize field names and data types across platforms
Connect AI MCP eliminated all of that. Claude Code generated a single API call that returned normalized schemas for all three systems in one unified response. The schemas came back as standard table and column structures, ready to use. What would have taken days took minutes.
This is the piece that makes AI coding assistance actually viable for cross-system apps. Without Connect AI, Claude Code would struggle to generate correct connector logic for even one platform, let alone six. With Connect AI, the AI assistant just works with clean, normalized metadata.
Prompt 2: Build a query planner
The next prompt: "Build a query planner that takes the user's question and the cached schemas, sends them to the LLM, and gets back a structured JSON plan with SQL queries for each relevant category and join keys."
Claude Code generated the query planning logic in one shot. The code passes the schema context and user question to an LLM, which returns a structured plan identifying which categories to query, the SQL for each source, which queries can run in parallel, and how to join the results.
For example, when a user asks: "Retrieve the top 10 accounts by ARR from CRM, along with their total product usage sessions, count of support tickets, and total recognized revenue from ERP," the LLM generates a plan with four parallel SQL queries across CRM, Usage, Support, and ERP.
What Connect AI enabled here: because the schemas are normalized, the LLM reasons about business concepts like "accounts" and "revenue" rather than platform-specific terminology. It does not need to know that Salesforce calls them "objects" or that NetSuite uses different field names. It just sees consistent table structures and generates standard SQL.
Without schema normalization, this step would require extensive prompt engineering and fallback logic to handle each platform's quirks. Connect AI makes it straightforward.
Prompt 3: Execute the queries
The prompt: "Send each SQL query from the plan to the Connect AI MCP endpoint, run independent queries in parallel, and join the results using the join keys from the query plan."
Connect AI MCP absolutely shines here. Traditionally, query execution against multiple sources means:
Writing platform-specific execution logic (REST calls for Salesforce, SOAP for NetSuite, different endpoints for Zendesk)
Managing separate authentication flows and credential refresh logic
Handling pagination, rate limits, and retries differently per platform
Translating SQL into whatever query language each system expects (SOQL for Salesforce, SuiteQL for NetSuite, Zendesk's query API)
Claude Code generated straightforward code that sends SQL to a single MCP endpoint. The endpoint handles query translation, authentication, execution, and row returns for all sources. No connector-specific logic. No credential management. The AI coding assistant never has to understand how any individual system works.
The security model stays clean, too. LLM credentials never touch the MCP endpoint, and Connect AI credentials never touch the LLM provider. Everything stays properly isolated.
Prompt 4: Turn data into summaries
The final prompt: "Pass the joined results back to the LLM and have it generate an executive summary with key insights and suggested follow-up questions based on the actual data, not the original query."
Claude Code wrote the code to send result rows to the LLM, which produces plain-English summaries. The summary reflects what the data actually shows rather than just restating what the user asks for. This makes the output immediately useful for business users who do not want to parse tables.
The whole pipeline runs in seconds. For questions that used to require a data engineering request and a two-day wait, that execution time matters.
What makes this development experience different
The build feels unusually smooth because Connect AI and Claude Code complement each other perfectly. Connect AI removes the hardest part (connectivity and schema normalization), which means Claude Code can focus on what AI coding assistants excel at: generating application logic, API calls, data processing, and UI components.
The build requires no connector-specific code. No OAuth debugging. No schema inconsistency handling. Connect AI handles all of that, so the prompts stay high-level and business-focused.
The GitHub repository for this project shows the final code, and it is surprisingly clean. That reflects how Connect AI abstracts away all the complexity that would normally make this codebase a mess.
What this means beyond the demo
The BI Command Center is just one application on top of Connect AI. The same data layer can power a CFO copilot, a customer success dashboard, a sales intelligence tool, or any other application that needs live enterprise data access. Set up connectors once in Connect AI, and every application built on top inherits that connectivity immediately.
The reusability is what makes this approach powerful. Once a team configures a Salesforce or NetSuite connection in Connect AI, every future application built with AI assistance inherits that connectivity automatically. Teams stop re-solving authentication and schema mapping for each new project.
The GitHub repository is public with sample Google Sheets data, so anyone can run all ten query templates without connecting any enterprise systems. It offers a fast way to see how the prompts and pipeline work before wiring in production credentials.
Get started with CData Connect AI
Sign up for a 14-day free trial of CData Connect AI and connect your first data source in minutes.
Explore CData Connect AI today
See how CData Connect AI delivers live, governed access to your enterprise data without the complexity.
