From raw data to smart decisions with AI Agents

Dashboards Are Great, But Not Always Enough

Dashboards are one of the most powerful ways to track metrics, monitor KPIs, and get a consistent view of your business. At Trupropel, we’ve built a vast amount of high-impact dashboards for clients who depend on real-time visibility to run operations, make forecasts, and align teams.

But what happens when you need to go beyond what’s on the screen?

That’s where AI interfaces come in.

Let’s say your dashboard shows a dip in sales in Atlanta. You want to understand:

• Is this a seasonal trend or specific to a product line?
• Are competitors doing better in that same timeframe?

Is inventory moving slower or are prices mismatched?

You could export data, slice it manually, or create custom filters - but what if you could just ask?

Why are F150s selling slower in Atlanta this quarter compared to last?

‍

That’s where an AI agent steps in, complementing your dashboard by investigating patterns, running dozens of backend queries in the background, and returning insights you might not catch with static filters.

In short: dashboards are your control center. AI agents are your investigative analysts. And when combined, they create a system that’s both responsive and intelligent.

A Real-World Example

Here’s a real request we processed for a client managing regional vehicle inventory. User prompts:

Look at the top vehicles by year, make, and model with high volume and low days on market in Atlanta over the past 90 days. Then find the same vehicles in Miami that are oversupplied and selling slowly. Help me find opportunities within my inventory to move from Miami to Atlanta.

‍

And the AI outputs:

Ford F-150 Miami → Atlanta: Quick Data Points

🎯 Sales Performance

• Atlanta: 69.7% sell within 99 days vs Miami: 49.6%
• +20 more vehicles of your 100 would sell quickly in Atlanta

📊 Market Conditions

• Miami inventory: 4,314 F-150s vs Atlanta: 1,099 F-150s
• You're competing against 3.9x more vehicles in Miami
• Atlanta sold/active ratio: 0.91 vs Miami: 0.76 (stronger demand)

⏰ Time Savings

• 15-25 days faster average sale time in Atlanta
• Miami slow sales (200+ days): 13 of your 100 trucks
• Atlanta slow sales (200+ days): 11 of your 100 trucks

💰 Financial Impact

• Potential annual cash flow improvement: $150K-$375K
• Carrying cost breakdown ($1,500/month per vehicle):
• 25 days faster sale = $1,250 savings per truck
• 100 trucks × $1,250 = $125,000 immediate benefit

🚚 Bottom Line

• Move 100 trucks to a market where 7/10 sell fast vs 5/10 in Miami
• Less competition, stronger demand, faster sales cycle
• Real savings from reduced interest payments and operating costs

Wondering how the AI agent comes up with this? Here's a behind-the-scenes look at the chain of GraphQL calls it executes to analyze, compare, and summarize the data:

The Technology Behind It

This is agentic AI in action: autonomous agents equipped with the intelligence to understand context, plan a data retrieval strategy, and combine API results into meaningful conclusions, all without human assistance at each step.

To enable this, we combine AI agents with GraphQL APIs using a framework called the Model Context Protocol (MCP). It’s an open standard developed by Anthropic to let agents securely connect to tools and systems like yours.

We use:

• The official MCP TypeScript SDK to build powerful AI integrations.
• The new Apollo Server MCP integration, which allows us to expose your GraphQL API directly as an agent toolset—no wrappers needed.

This lets the agent introspect your schema, issue dynamic queries, and pull only the data it needs. The MCP server runs just like any other backend service. It can be deployed securely within your cloud environment or behind your firewall.

We run AI models such as Claude on AWS Bedrock, which ensures enterprise-grade security, privacy, and compliance. No data is shared with the model provider. Everything is handled within a managed and auditable environment designed for production use cases. That means faster, more efficient responses, and no need to upload your full dataset into the AI model.

One of the most critical aspects of this setup is how tools are defined in the MCP server. Tools expose capabilities - like querying data, retrieving metadata, or executing summaries - that the AI agent can reason about and use on its own.

A typical tool definition might look like this:

server.tool("query-graphql", "Query a GraphQL endpoint", {
 query: z.string(),
 variables: z.string().optional(),
}, async ({ query, variables }) => {
 // execute query logic
});

‍

What matters most is the structure:

• Tool name (e.g., query-graphql)
• Description (so the agent knows when to use it)
• Schema validation (using zod, to ensure safe inputs)
• Logic (how it translates to real API calls)

These tools are declared alongside metadata about the server, making it easy for the agent to understand your system's structure, constraints, and available actions.

You can define multiple tools beyond just querying. For example:

server.tool("introspect-schema", "Get GraphQL schema metadata", {}, async () => {
 // returns the current GraphQL schema
});

server.tool("summarize-kpi", "Generate KPI summary over date range", {
 metric: z.string(),
 startDate: z.string(),
 endDate: z.string()
}, async ({ metric, startDate, endDate }) => {
 // logic to retrieve and summarize KPI data
});

Tools like these help agents chain reasoning: introspecting a schema before issuing a query, summarizing results after retrieving raw data, or retrying steps with updated filters.

When something goes wrong, like a malformed query or invalid variable, the agent can access tool metadata (including error messages or schema definitions) and use that context to recover. This ability to debug and retry on its own is what makes the experience feel intelligent and resilient, not brittle or scripted.

We typically wrap this around your existing analytics API, whether it’s a GraphQL service you already maintain or one we help you build and optimize.

An important benefit of this architecture is that your existing authentication and authorization rules remain intact. The AI agent only has access to the data that the current user would have access to, no more, no less. This makes the system secure by design and ensures compliance with privacy and access control standards.

A Glimpse at the Agent’s Brain: Real Queries, Built on Your Schema

While the GraphQL schema gives the agent a structural understanding of your data, that alone is not enough for a great agent experience. Just like when onboarding a new developer, naming conventions, patterns, and clear documentation make a huge difference.

Using consistent, intuitive names and organizing queries and mutations by domain helps the AI reason more efficiently. Queries like ListingVolumeMetric, KpiDaysOnMarket, and VehicleComparison should clearly reflect their purpose and be scoped to business use cases.

Documentation is critical. Every major query should include:

• A plain-English description of what it does
• The expected arguments (and validations, if relevant)
• Edge cases or known limitations
• A real call example and expected response shape

Providing these details helps the agent:

• Choose the right tool/query for the job
• Avoid invalid combinations or unsupported filters
• Save context by requiring fewer exploratory queries

Think of it as documenting your API for an intelligent developer who has never seen your backend before - but is capable of solving complex problems if given the right structure.

One of the most impressive aspects of this system is how the AI agent builds its own GraphQL queries dynamically - based entirely on your schema.

Here is an actual query and result for a histogram of days on market in Atlanta:

query AtlantaF150DaysOnMarketHistogram {
 listingDaysOnMarketHistogram(
   interval: 5
   filters: [
     {
       makeModelFilter: {
         combinations: [{ make: "Ford", model: ["F150"] }]
       }
     },
     {
       geoFilter: {
         operator: {
           distance: {
             distance: 15
             location: {
               latitude: 33.7501275,
               longitude: -84.3885209
             }
             unit: Miles
           }
         }
         place: { postalCode: "", address: "Atlanta" }
       }
     }
   ]
   dateRange: { from: "2025-03-08", to: "2025-06-05" }
   country: US
   kpiLevel: VIN
 ) {
   average
   histogram {
     count
     key {
       from
       to
     }
   }
 }
}

Response excerpt:

• Average days on market: 232
• Vehicles sold in 0–99 days: 1,455
• Vehicles in 200+ days: 226

This shows the level of detail the AI can access, process, and summarize in just one of many calls. Multiply this by 10–50 calls per user request, and you get insight that’s both rich and highly contextual, generated instantly.

Wrapping It Up

AI agents aren’t here to replace dashboards — they’re here to unlock what dashboards can’t always show. When a new question arises and the right view doesn’t exist yet, these agents step in, leveraging your existing data and APIs to deliver answers in real time.

At Trupropel, we design these intelligent interfaces to work with the systems you already have. No retraining. No new tooling. Just deeper insights, faster — even when the dashboard hasn’t caught up yet.

‍